@tangle-network/agent-integrations 0.53.32 → 0.53.34

package/dist/{chunk-FOIC32DF.js → chunk-XGKE6JW4.js}

@@ -182,9 +182,12 @@ __export(adapters_exports, {
   copyAiConnector: () => copyAiConnector,
   couchbaseConnector: () => couchbaseConnector,
   createKafkaConnector: () => createKafkaConnector,
+  createMongoDbConnector: () => createMongoDbConnector,
   createMySqlConnector: () => createMySqlConnector,
+  createPostgresConnector: () => createPostgresConnector,
   createRabbitMqConnector: () => createRabbitMqConnector,
   createRedisConnector: () => createRedisConnector,
+  createRedshiftConnector: () => createRedshiftConnector,
   createSftpConnector: () => createSftpConnector,
   createTangleIdentityClient: () => createTangleIdentityClient,
   crispConnector: () => crispConnector,
@@ -446,6 +449,7 @@ __export(adapters_exports, {
   n8nConnector: () => n8nConnector,
   netlifyConnector: () => netlifyConnector,
   netsuiteConnector: () => netsuiteConnector,
+  neverbounceConnector: () => neverbounceConnector,
   niftyConnector: () => niftyConnector,
   ninjapipeConnector: () => ninjapipeConnector,
   nocodbConnector: () => nocodbConnector,
@@ -522,6 +526,7 @@ __export(adapters_exports, {
   recurlyConnector: () => recurlyConnector,
   redditConnector: () => redditConnector,
   redisConnector: () => redisConnector,
+  redshiftConnector: () => redshiftConnector,
   reoonVerifierConnector: () => reoonVerifierConnector,
   replyIoConnector: () => replyIoConnector,
   resolveConnectorAdapterFactoryOptions: () => resolveConnectorAdapterFactoryOptions,
@@ -39205,6 +39210,628 @@ var mollieConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/miro.ts
+var miroConnector = declarativeRestConnector({
+  kind: "miro",
+  displayName: "Miro",
+  description: "Read and edit Miro boards: list and search boards, read board items (sticky notes, shapes, text, cards, images, frames, connectors), create and update items, and post board content back into the source of truth.",
+  auth: {
+    kind: "oauth2",
+    authorizationUrl: "https://miro.com/oauth/authorize",
+    tokenUrl: "https://api.miro.com/v1/oauth/token",
+    scopes: [
+      "boards:read",
+      "boards:write",
+      "identity:read"
+    ],
+    clientIdEnv: "MIRO_OAUTH_CLIENT_ID",
+    clientSecretEnv: "MIRO_OAUTH_CLIENT_SECRET"
+  },
+  category: "doc",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.miro.com",
+  defaultHeaders: { accept: "application/json" },
+  // GET /v2/me returns the authenticated user — Miro's documented health probe.
+  test: { method: "GET", path: "/v2/me" },
+  capabilities: [
+    {
+      name: "me.get",
+      class: "read",
+      description: "Return the authenticated Miro user.",
+      parameters: { type: "object", properties: {} },
+      request: { method: "GET", path: "/v2/me" },
+      requiredScopes: ["identity:read"]
+    },
+    {
+      name: "boards.list",
+      class: "read",
+      description: "List boards accessible to the authenticated user. Supports cursor pagination via `cursor` and team / sort filters.",
+      parameters: {
+        type: "object",
+        properties: {
+          team_id: { type: "string", description: "Filter to a single team id." },
+          query: { type: "string", description: "Free-text board name filter." },
+          owner: { type: "string", description: "Filter by owner user id." },
+          limit: { type: "integer", minimum: 1, maximum: 50 },
+          offset: { type: "integer", minimum: 0 },
+          sort: {
+            type: "string",
+            enum: ["default", "last_modified", "last_opened", "last_created", "alphabetically"]
+          }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/v2/boards",
+        query: {
+          team_id: "{team_id}",
+          query: "{query}",
+          owner: "{owner}",
+          limit: "{limit}",
+          offset: "{offset}",
+          sort: "{sort}"
+        }
+      },
+      requiredScopes: ["boards:read"]
+    },
+    {
+      name: "boards.get",
+      class: "read",
+      description: "Fetch a single Miro board by id.",
+      parameters: {
+        type: "object",
+        properties: { board_id: { type: "string" } },
+        required: ["board_id"]
+      },
+      request: { method: "GET", path: "/v2/boards/{board_id}" },
+      requiredScopes: ["boards:read"]
+    },
+    {
+      name: "boards.members.list",
+      class: "read",
+      description: "List members (collaborators) of a Miro board.",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          limit: { type: "integer", minimum: 1, maximum: 50 },
+          offset: { type: "integer", minimum: 0 }
+        },
+        required: ["board_id"]
+      },
+      request: {
+        method: "GET",
+        path: "/v2/boards/{board_id}/members",
+        query: { limit: "{limit}", offset: "{offset}" }
+      },
+      requiredScopes: ["boards:read"]
+    },
+    {
+      name: "items.list",
+      class: "read",
+      description: "List all items on a board, optionally filtered by item type (sticky_note, text, shape, card, image, frame, connector, embed, app_card, document).",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          type: {
+            type: "string",
+            enum: [
+              "sticky_note",
+              "text",
+              "shape",
+              "card",
+              "image",
+              "frame",
+              "connector",
+              "embed",
+              "app_card",
+              "document",
+              "preview"
+            ]
+          },
+          limit: { type: "integer", minimum: 1, maximum: 50 },
+          cursor: { type: "string" }
+        },
+        required: ["board_id"]
+      },
+      request: {
+        method: "GET",
+        path: "/v2/boards/{board_id}/items",
+        query: { type: "{type}", limit: "{limit}", cursor: "{cursor}" }
+      },
+      requiredScopes: ["boards:read"]
+    },
+    {
+      name: "items.get",
+      class: "read",
+      description: "Fetch a single board item by id.",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          item_id: { type: "string" }
+        },
+        required: ["board_id", "item_id"]
+      },
+      request: { method: "GET", path: "/v2/boards/{board_id}/items/{item_id}" },
+      requiredScopes: ["boards:read"]
+    },
+    {
+      name: "connectors.list",
+      class: "read",
+      description: "List connector lines on a board (arrows / lines between items).",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          limit: { type: "integer", minimum: 1, maximum: 50 },
+          cursor: { type: "string" }
+        },
+        required: ["board_id"]
+      },
+      request: {
+        method: "GET",
+        path: "/v2/boards/{board_id}/connectors",
+        query: { limit: "{limit}", cursor: "{cursor}" }
+      },
+      requiredScopes: ["boards:read"]
+    },
+    {
+      name: "tags.list",
+      class: "read",
+      description: "List tags defined on a board.",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          limit: { type: "integer", minimum: 1, maximum: 50 },
+          offset: { type: "integer", minimum: 0 }
+        },
+        required: ["board_id"]
+      },
+      request: {
+        method: "GET",
+        path: "/v2/boards/{board_id}/tags",
+        query: { limit: "{limit}", offset: "{offset}" }
+      },
+      requiredScopes: ["boards:read"]
+    },
+    {
+      name: "boards.create",
+      class: "mutation",
+      description: "Create a new Miro board. Accepts an optional name, description, team_id, and sharing policy. Returns the new board id used by every items.* endpoint.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string", maxLength: 60 },
+          description: { type: "string", maxLength: 300 },
+          team_id: { type: "string" },
+          policy: {
+            type: "object",
+            description: "Permissions + sharing policy. See https://developers.miro.com/reference/create-board for the full PolicyChange shape."
+          }
+        },
+        required: ["name"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards",
+        body: {
+          name: "{name}",
+          description: "{description}",
+          teamId: "{team_id}",
+          policy: "{policy}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "boards.update",
+      class: "mutation",
+      description: "Update a Miro board (name, description, team, or sharing policy).",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          name: { type: "string", maxLength: 60 },
+          description: { type: "string", maxLength: 300 },
+          team_id: { type: "string" },
+          policy: { type: "object" }
+        },
+        required: ["board_id"]
+      },
+      request: {
+        method: "PATCH",
+        path: "/v2/boards/{board_id}",
+        body: {
+          name: "{name}",
+          description: "{description}",
+          teamId: "{team_id}",
+          policy: "{policy}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "boards.delete",
+      class: "mutation",
+      description: "Delete a Miro board (irreversible).",
+      parameters: {
+        type: "object",
+        properties: { board_id: { type: "string" } },
+        required: ["board_id"]
+      },
+      request: { method: "DELETE", path: "/v2/boards/{board_id}" },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "sticky_notes.create",
+      class: "mutation",
+      description: "Create a sticky note on a board. `data.content` accepts plain text; `style.fillColor` is a Miro sticky-note color keyword (e.g. yellow, light_yellow, pink).",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          data: {
+            type: "object",
+            properties: {
+              content: { type: "string" },
+              shape: { type: "string", enum: ["square", "rectangle"] }
+            },
+            required: ["content"]
+          },
+          style: {
+            type: "object",
+            properties: {
+              fillColor: { type: "string" },
+              textAlign: { type: "string", enum: ["left", "center", "right"] },
+              textAlignVertical: { type: "string", enum: ["top", "middle", "bottom"] }
+            }
+          },
+          position: {
+            type: "object",
+            properties: {
+              x: { type: "number" },
+              y: { type: "number" },
+              origin: { type: "string", enum: ["center"] }
+            }
+          },
+          geometry: {
+            type: "object",
+            properties: {
+              width: { type: "number" },
+              height: { type: "number" }
+            }
+          },
+          parent: {
+            type: "object",
+            description: "Attach the sticky note to a frame: { id: <frame_item_id> }.",
+            properties: { id: { type: "string" } }
+          }
+        },
+        required: ["board_id", "data"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards/{board_id}/sticky_notes",
+        body: {
+          data: "{data}",
+          style: "{style}",
+          position: "{position}",
+          geometry: "{geometry}",
+          parent: "{parent}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "sticky_notes.update",
+      class: "mutation",
+      description: "Update a sticky note (content, style, position, geometry, or parent frame).",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          item_id: { type: "string" },
+          data: { type: "object" },
+          style: { type: "object" },
+          position: { type: "object" },
+          geometry: { type: "object" },
+          parent: { type: "object" }
+        },
+        required: ["board_id", "item_id"]
+      },
+      request: {
+        method: "PATCH",
+        path: "/v2/boards/{board_id}/sticky_notes/{item_id}",
+        body: {
+          data: "{data}",
+          style: "{style}",
+          position: "{position}",
+          geometry: "{geometry}",
+          parent: "{parent}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "text.create",
+      class: "mutation",
+      description: "Create a text item on a board.",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          data: {
+            type: "object",
+            properties: { content: { type: "string" } },
+            required: ["content"]
+          },
+          style: { type: "object" },
+          position: { type: "object" },
+          geometry: { type: "object" },
+          parent: { type: "object" }
+        },
+        required: ["board_id", "data"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards/{board_id}/texts",
+        body: {
+          data: "{data}",
+          style: "{style}",
+          position: "{position}",
+          geometry: "{geometry}",
+          parent: "{parent}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "shapes.create",
+      class: "mutation",
+      description: "Create a shape item on a board. `data.shape` selects the geometric primitive (rectangle, round_rectangle, circle, triangle, rhombus, etc.).",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          data: {
+            type: "object",
+            properties: {
+              shape: {
+                type: "string",
+                description: "Miro shape kind; full enum at https://developers.miro.com/reference/create-shape-item."
+              },
+              content: { type: "string" }
+            },
+            required: ["shape"]
+          },
+          style: { type: "object" },
+          position: { type: "object" },
+          geometry: { type: "object" },
+          parent: { type: "object" }
+        },
+        required: ["board_id", "data"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards/{board_id}/shapes",
+        body: {
+          data: "{data}",
+          style: "{style}",
+          position: "{position}",
+          geometry: "{geometry}",
+          parent: "{parent}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "cards.create",
+      class: "mutation",
+      description: "Create a card item (title + description + assignee + due-date) on a board.",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          data: {
+            type: "object",
+            properties: {
+              title: { type: "string" },
+              description: { type: "string" },
+              dueDate: { type: "string", format: "date-time" },
+              assigneeId: { type: "string" }
+            },
+            required: ["title"]
+          },
+          style: { type: "object" },
+          position: { type: "object" },
+          geometry: { type: "object" },
+          parent: { type: "object" }
+        },
+        required: ["board_id", "data"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards/{board_id}/cards",
+        body: {
+          data: "{data}",
+          style: "{style}",
+          position: "{position}",
+          geometry: "{geometry}",
+          parent: "{parent}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "frames.create",
+      class: "mutation",
+      description: "Create a frame on a board. Frames group items; child items can be attached via `parent.id` on item creation.",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          data: {
+            type: "object",
+            properties: {
+              title: { type: "string" },
+              format: { type: "string", enum: ["custom"] },
+              type: { type: "string", enum: ["freeform"] }
+            }
+          },
+          style: { type: "object" },
+          position: { type: "object" },
+          geometry: { type: "object" }
+        },
+        required: ["board_id"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards/{board_id}/frames",
+        body: {
+          data: "{data}",
+          style: "{style}",
+          position: "{position}",
+          geometry: "{geometry}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "images.create.by_url",
+      class: "mutation",
+      description: "Create an image item from a public URL (Miro fetches the image server-side).",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          data: {
+            type: "object",
+            properties: {
+              url: { type: "string", format: "uri" },
+              title: { type: "string" }
+            },
+            required: ["url"]
+          },
+          position: { type: "object" },
+          geometry: { type: "object" },
+          parent: { type: "object" }
+        },
+        required: ["board_id", "data"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards/{board_id}/images",
+        body: {
+          data: "{data}",
+          position: "{position}",
+          geometry: "{geometry}",
+          parent: "{parent}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "connectors.create",
+      class: "mutation",
+      description: "Create a connector line between two items on the board. `startItem.id` and `endItem.id` reference existing item ids.",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          startItem: {
+            type: "object",
+            properties: { id: { type: "string" } },
+            required: ["id"]
+          },
+          endItem: {
+            type: "object",
+            properties: { id: { type: "string" } },
+            required: ["id"]
+          },
+          captions: {
+            type: "array",
+            items: { type: "object", properties: { content: { type: "string" } } }
+          },
+          style: { type: "object" },
+          shape: { type: "string", enum: ["straight", "elbowed", "curved"] }
+        },
+        required: ["board_id", "startItem", "endItem"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards/{board_id}/connectors",
+        body: {
+          startItem: "{startItem}",
+          endItem: "{endItem}",
+          captions: "{captions}",
+          style: "{style}",
+          shape: "{shape}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "items.delete",
+      class: "mutation",
+      description: "Delete an item from a board (works across all item types).",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          item_id: { type: "string" }
+        },
+        required: ["board_id", "item_id"]
+      },
+      request: { method: "DELETE", path: "/v2/boards/{board_id}/items/{item_id}" },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    },
+    {
+      name: "boards.share",
+      class: "mutation",
+      description: "Invite users to a Miro board by email. Roles: viewer, commenter, editor, coowner.",
+      parameters: {
+        type: "object",
+        properties: {
+          board_id: { type: "string" },
+          emails: { type: "array", items: { type: "string", format: "email" } },
+          role: {
+            type: "string",
+            enum: ["viewer", "commenter", "editor", "coowner"]
+          },
+          message: { type: "string" }
+        },
+        required: ["board_id", "emails", "role"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/boards/{board_id}/members",
+        body: {
+          emails: "{emails}",
+          role: "{role}",
+          message: "{message}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["boards:write"]
+    }
+  ]
+});
+
 // src/connectors/adapters/monday.ts
 var BOARD_FRAGMENT = `
   id
@@ -39329,7 +39956,7 @@ var mondayConnector = declarativeRestConnector({
   auth: {
     kind: "oauth2",
     authorizationUrl: "https://auth.monday.com/oauth2/authorize",
-    tokenUrl: "https://auth.monday.com/oauth2/token",
+    tokenUrl: "https://auth.monday.com/oauth_ms/oauth/token",
     scopes: [
       "me:read",
       "boards:read",
@@ -39719,6 +40346,475 @@ var mondayConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/mongodb.ts
+import { isIP as isIP3 } from "net";
+import { createSecureContext } from "tls";
+import {
+  BSON,
+  MongoClient
+} from "mongodb";
+var MAX_NAME_BYTES = 120;
+var MAX_FIELD_BYTES = 256;
+var MAX_FILTERS = 20;
+var MAX_PROJECTION_FIELDS = 64;
+var MAX_SORT_FIELDS = 8;
+var MAX_COLLECTIONS = 1e3;
+var MAX_INDEXES = 200;
+var MAX_DOCUMENTS = 1e3;
+var MAX_RESULT_BYTES2 = 10 * 1024 * 1024;
+var MAX_FILTER_BYTES = 1024 * 1024;
+var MAX_SCALAR_STRING_BYTES = 64 * 1024;
+var MAX_TLS_CA_BYTES = 256 * 1024;
+function createMongoDbConnector(options = {}) {
+  const createClient = options.createClient ?? defaultCreateClient;
+  const resolveHost = options.resolveHost ?? resolvePublicHostAddresses;
+  return {
+    manifest: {
+      kind: "mongodb",
+      displayName: "MongoDB",
+      description: "Inspect MongoDB collections and indexes and run bounded structured document reads over a verified TLS connection.",
+      auth: {
+        kind: "api-key",
+        hint: "JSON with a public MongoDB host, database, user, password, optional port/auth source, and optional TLS CA. Verified TLS is mandatory."
+      },
+      category: "database",
+      defaultConsistencyModel: "authoritative",
+      rateLimit: { requests: 120, windowMs: 6e4, scope: "data-source" },
+      capabilities: [
+        readCapability6("mongodb.collections.list", "List collections visible in the configured database.", {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }),
+        readCapability6("mongodb.collections.describe", "Read options and metadata for one collection.", collectionSchema()),
+        readCapability6("mongodb.indexes.list", "List bounded index metadata for one collection.", collectionSchema()),
+        readCapability6("mongodb.documents.find", "Read bounded documents using fixed scalar predicates, projection, and sort fields.", {
+          type: "object",
+          properties: {
+            collection: nameParameter("Collection name."),
+            filters: filterArraySchema(),
+            fields: {
+              type: "array",
+              minItems: 1,
+              maxItems: MAX_PROJECTION_FIELDS,
+              uniqueItems: true,
+              items: fieldParameter()
+            },
+            includeId: { type: "boolean", default: true },
+            sort: {
+              type: "array",
+              maxItems: MAX_SORT_FIELDS,
+              items: {
+                type: "object",
+                properties: {
+                  field: fieldParameter(),
+                  direction: { type: "string", enum: ["asc", "desc"], default: "asc" }
+                },
+                required: ["field"],
+                additionalProperties: false
+              }
+            },
+            limit: { type: "integer", minimum: 1, maximum: MAX_DOCUMENTS, default: 100 },
+            skip: { type: "integer", minimum: 0, maximum: 1e6, default: 0 }
+          },
+          required: ["collection"],
+          additionalProperties: false
+        }),
+        readCapability6("mongodb.documents.count", "Count documents matching fixed scalar predicates within a bounded server execution time.", {
+          type: "object",
+          properties: {
+            collection: nameParameter("Collection name."),
+            filters: filterArraySchema()
+          },
+          required: ["collection"],
+          additionalProperties: false
+        })
+      ]
+    },
+    async test(source) {
+      try {
+        await withClient(source, createClient, resolveHost, async (client, credentials) => {
+          const response = await client.db(credentials.database).command(
+            { ping: 1 },
+            { maxTimeMS: credentials.commandTimeoutMs }
+          );
+          if (response.ok !== 1) throw new Error("MongoDB ping returned an unexpected response");
+        });
+        return { ok: true };
+      } catch (error) {
+        return { ok: false, reason: safeErrorMessage(error, credentialSecrets(source)) };
+      }
+    },
+    async executeRead(invocation) {
+      const request4 = prepareRead(invocation);
+      const data4 = await withClient(invocation.source, createClient, resolveHost, async (client, credentials) => {
+        return executeRead(request4, client.db(credentials.database), credentials.commandTimeoutMs);
+      });
+      return { data: data4, fetchedAt: Date.now() };
+    }
+  };
+}
+var mongodbConnector = createMongoDbConnector();
+function defaultCreateClient(uri, options) {
+  return new MongoClient(uri, options);
+}
+async function withClient(source, createClient, resolveHost, run) {
+  const credentials = readCredentials2(source);
+  const addresses = await resolveHost(credentials.host);
+  if (addresses.length === 0) throw new Error("MongoDB host did not resolve");
+  const uriHost = isIP3(credentials.host) === 6 ? `[${credentials.host}]` : credentials.host;
+  const client = createClient(`mongodb://${uriHost}:${credentials.port}/`, {
+    appName: "tangle-integration-hub",
+    auth: { username: credentials.user, password: credentials.password },
+    authSource: credentials.authSource,
+    connectTimeoutMS: credentials.connectTimeoutMs,
+    directConnection: true,
+    lookup: pinnedLookup(addresses[0]),
+    maxIdleTimeMS: 5e3,
+    maxPoolSize: 1,
+    minPoolSize: 0,
+    rejectUnauthorized: true,
+    retryReads: true,
+    retryWrites: false,
+    serverSelectionTimeoutMS: credentials.connectTimeoutMs,
+    servername: isIP3(credentials.host) === 0 ? credentials.host : void 0,
+    secureContext: createSecureContext({ ca: credentials.tlsCa, minVersion: "TLSv1.2" }),
+    socketTimeoutMS: credentials.commandTimeoutMs,
+    tls: true
+  });
+  try {
+    await client.connect();
+    return await run(client, credentials);
+  } catch (error) {
+    throw new Error(safeErrorMessage(error, credentials.secrets));
+  } finally {
+    await client.close().catch(() => void 0);
+  }
+}
+async function executeRead(request4, database, commandTimeoutMs) {
+  if (request4.kind === "collections.list") {
+    const collections = await readCursor(
+      database.listCollections({}, { nameOnly: true, maxTimeMS: commandTimeoutMs }),
+      MAX_COLLECTIONS,
+      "MongoDB collection list"
+    );
+    return boundedResult({ collections }, "MongoDB collection list");
+  }
+  if (request4.kind === "collections.describe") {
+    const matches = await readCursor(
+      database.listCollections({ name: request4.collection }, { nameOnly: false, maxTimeMS: commandTimeoutMs }),
+      1,
+      "MongoDB collection description"
+    );
+    return boundedResult({ collection: matches[0] ?? null }, "MongoDB collection description");
+  }
+  if (request4.kind === "indexes.list") {
+    const indexes = await readCursor(
+      database.collection(request4.collection).listIndexes({ maxTimeMS: commandTimeoutMs }),
+      MAX_INDEXES,
+      "MongoDB index list"
+    );
+    return boundedResult({ collection: request4.collection, indexes }, "MongoDB index list");
+  }
+  if (request4.kind === "documents.find") {
+    const cursor = database.collection(request4.collection).find(request4.filter, {
+      ...request4.projection ? { projection: request4.projection } : {},
+      maxTimeMS: commandTimeoutMs
+    });
+    if (Object.keys(request4.sort).length > 0) cursor.sort(request4.sort);
+    cursor.skip(request4.skip).limit(request4.limit);
+    const documents = await readCursor(cursor, request4.limit, "MongoDB document result");
+    return boundedResult({ collection: request4.collection, documents }, "MongoDB document result");
+  }
+  if (request4.kind === "documents.count") {
+    const count = await database.collection(request4.collection).countDocuments(request4.filter, { maxTimeMS: commandTimeoutMs });
+    if (!Number.isSafeInteger(count) || count < 0) throw new Error("MongoDB returned a malformed document count");
+    return { collection: request4.collection, count };
+  }
+}
+function prepareRead(invocation) {
+  if (invocation.capabilityName === "mongodb.collections.list") return { kind: "collections.list" };
+  if (invocation.capabilityName === "mongodb.collections.describe") {
+    return { kind: "collections.describe", collection: readCollectionName(invocation.args.collection) };
+  }
+  if (invocation.capabilityName === "mongodb.indexes.list") {
+    return { kind: "indexes.list", collection: readCollectionName(invocation.args.collection) };
+  }
+  if (invocation.capabilityName === "mongodb.documents.find") {
+    return {
+      kind: "documents.find",
+      collection: readCollectionName(invocation.args.collection),
+      filter: readFilters(invocation.args.filters),
+      projection: readProjection(invocation.args.fields, invocation.args.includeId),
+      sort: readSort(invocation.args.sort),
+      limit: readBoundedInteger(invocation.args.limit, 100, 1, MAX_DOCUMENTS, "limit"),
+      skip: readBoundedInteger(invocation.args.skip, 0, 0, 1e6, "skip")
+    };
+  }
+  if (invocation.capabilityName === "mongodb.documents.count") {
+    return {
+      kind: "documents.count",
+      collection: readCollectionName(invocation.args.collection),
+      filter: readFilters(invocation.args.filters)
+    };
+  }
+  throw new Error(`Unknown MongoDB read capability: ${invocation.capabilityName}`);
+}
+async function readCursor(cursor, maximum, label) {
+  const entries = [];
+  let serializedBytes = 2;
+  try {
+    while (entries.length < maximum) {
+      const entry = await cursor.next();
+      if (entry === null) return entries;
+      serializedBytes += Buffer.byteLength(
+        JSON.stringify(BSON.EJSON.serialize(entry, { relaxed: true })),
+        "utf8"
+      ) + 1;
+      if (serializedBytes > MAX_RESULT_BYTES2) {
+        throw new Error(`${label} exceeds the ${MAX_RESULT_BYTES2}-byte limit`);
+      }
+      entries.push(entry);
+    }
+    if (await cursor.next() !== null) throw new Error(`${label} exceeds ${maximum} entries`);
+    return entries;
+  } finally {
+    await cursor.close().catch(() => void 0);
+  }
+}
+function readCredentials2(source) {
+  let raw;
+  if (source.credentials.kind === "custom") raw = source.credentials.values;
+  else if (source.credentials.kind === "api-key") {
+    try {
+      raw = JSON.parse(source.credentials.apiKey);
+    } catch {
+      throw new Error("MongoDB credential must be valid JSON");
+    }
+  } else {
+    throw new Error("MongoDB requires a structured credential bundle");
+  }
+  if (!isPlainRecord(raw)) throw new Error("MongoDB credential must be a JSON object");
+  const host = readHost(raw.host);
+  const database = readDatabaseName(raw.database, "database");
+  const user = readCredentialString(raw.user ?? raw.username, "user", 128);
+  const password = readCredentialString(raw.password, "password", 4096);
+  const authSource = raw.authSource === void 0 ? "admin" : readDatabaseName(raw.authSource, "authSource");
+  const tlsCa = readOptionalString(raw.tlsCa, "tlsCa");
+  if (tlsCa && Buffer.byteLength(tlsCa, "utf8") > MAX_TLS_CA_BYTES) {
+    throw new Error(`MongoDB tlsCa exceeds the ${MAX_TLS_CA_BYTES}-byte limit`);
+  }
+  return {
+    host,
+    port: readBoundedInteger(raw.port, 27017, 1, 65535, "port"),
+    database,
+    user,
+    password,
+    authSource,
+    tlsCa,
+    connectTimeoutMs: readBoundedInteger(raw.connectTimeoutMs, 1e4, 1e3, 3e4, "connectTimeoutMs"),
+    commandTimeoutMs: readBoundedInteger(raw.commandTimeoutMs, 3e4, 1e3, 6e4, "commandTimeoutMs"),
+    secrets: [password]
+  };
+}
+function readFilters(value) {
+  if (value === void 0 || value === null) return {};
+  if (!Array.isArray(value) || value.length > MAX_FILTERS) {
+    throw new Error(`filters must contain at most ${MAX_FILTERS} entries`);
+  }
+  const predicates = value.map((entry, index) => {
+    if (!isPlainRecord(entry)) throw new Error(`filters[${index}] must be an object`);
+    const field = readField(entry.field, `filters[${index}].field`);
+    const operator = entry.operator;
+    if (!["eq", "ne", "lt", "lte", "gt", "gte"].includes(String(operator))) {
+      throw new Error(`filters[${index}].operator is unsupported`);
+    }
+    const scalar = readScalar(entry.value, `filters[${index}].value`);
+    return { [field]: { [mongoOperator(String(operator))]: scalar } };
+  });
+  const filter = predicates.length === 0 ? {} : { $and: predicates };
+  if (Buffer.byteLength(JSON.stringify(filter), "utf8") > MAX_FILTER_BYTES) {
+    throw new Error(`MongoDB filters exceed the ${MAX_FILTER_BYTES}-byte limit`);
+  }
+  return filter;
+}
+function readProjection(fieldsValue, includeIdValue) {
+  const includeId = includeIdValue === void 0 || includeIdValue === null ? true : readBoolean2(includeIdValue, "includeId");
+  if (fieldsValue === void 0 || fieldsValue === null) return includeId ? void 0 : { _id: 0 };
+  const fields = readFieldArray(fieldsValue, "fields", MAX_PROJECTION_FIELDS, true);
+  return Object.fromEntries([
+    ...fields.map((field) => [field, 1]),
+    ...!includeId && !fields.includes("_id") ? [["_id", 0]] : []
+  ]);
+}
+function readSort(value) {
+  if (value === void 0 || value === null) return {};
+  if (!Array.isArray(value) || value.length > MAX_SORT_FIELDS) {
+    throw new Error(`sort must contain at most ${MAX_SORT_FIELDS} entries`);
+  }
+  const entries = value.map((entry, index) => {
+    if (!isPlainRecord(entry)) throw new Error(`sort[${index}] must be an object`);
+    const field = readField(entry.field, `sort[${index}].field`);
+    const direction = entry.direction ?? "asc";
+    if (direction !== "asc" && direction !== "desc") {
+      throw new Error(`sort[${index}].direction must be asc or desc`);
+    }
+    return [field, direction === "asc" ? 1 : -1];
+  });
+  if (new Set(entries.map(([field]) => field)).size !== entries.length) {
+    throw new Error("sort must not contain duplicate fields");
+  }
+  return Object.fromEntries(entries);
+}
+function readFieldArray(value, label, maximum, required) {
+  if (!Array.isArray(value) || required && value.length === 0 || value.length > maximum) {
+    throw new Error(`${label} must contain ${required ? "1-" : "0-"}${maximum} fields`);
+  }
+  const fields = value.map((entry, index) => readField(entry, `${label}[${index}]`));
+  if (new Set(fields).size !== fields.length) throw new Error(`${label} must not contain duplicates`);
+  return fields;
+}
+function readScalar(value, label) {
+  if (value === null || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error(`${label} must be finite`);
+    return value;
+  }
+  if (typeof value === "string") {
+    if (Buffer.byteLength(value, "utf8") > MAX_SCALAR_STRING_BYTES) {
+      throw new Error(`${label} exceeds the ${MAX_SCALAR_STRING_BYTES}-byte limit`);
+    }
+    return value;
+  }
+  throw new Error(`${label} must be a JSON scalar or null`);
+}
+function mongoOperator(value) {
+  return { eq: "$eq", ne: "$ne", lt: "$lt", lte: "$lte", gt: "$gt", gte: "$gte" }[value];
+}
+function boundedResult(value, label) {
+  const serialized = BSON.EJSON.serialize(value, { relaxed: true });
+  if (Buffer.byteLength(JSON.stringify(serialized), "utf8") > MAX_RESULT_BYTES2) {
+    throw new Error(`${label} exceeds the ${MAX_RESULT_BYTES2}-byte limit`);
+  }
+  return serialized;
+}
+function readHost(value) {
+  const host = readCredentialString(value, "host", 253);
+  const ipVersion = isIP3(host);
+  if (ipVersion !== 0) {
+    if (!isPublicNetworkAddress(host)) throw new Error("MongoDB host is not a public network target");
+    return host;
+  }
+  const normalized = host.toLowerCase();
+  if (normalized === "localhost" || normalized.endsWith(".localhost") || normalized.endsWith(".local") || /[\s/@:\[\]]/.test(host)) {
+    throw new Error("MongoDB host must be a public hostname or IP address without a scheme or port");
+  }
+  return host;
+}
+function readName(value, label) {
+  if (typeof value !== "string" || value.length === 0 || Buffer.byteLength(value, "utf8") > MAX_NAME_BYTES || /[\u0000-\u001f\u007f/\\]/.test(value)) {
+    throw new Error(`${label} must be a non-empty MongoDB name under ${MAX_NAME_BYTES} bytes`);
+  }
+  return value;
+}
+function readCollectionName(value) {
+  const collection = readName(value, "collection");
+  if (collection.startsWith("system.") || collection.includes("$")) {
+    throw new Error("collection must not target MongoDB system or command namespaces");
+  }
+  return collection;
+}
+function readDatabaseName(value, label) {
+  const database = readName(value, label);
+  if (Buffer.byteLength(database, "utf8") > 63 || !/^[A-Za-z0-9_-]+$/.test(database)) {
+    throw new Error(`${label} must use only letters, numbers, underscores, or hyphens and stay under 63 bytes`);
+  }
+  return database;
+}
+function readField(value, label) {
+  if (typeof value !== "string" || value.length === 0 || Buffer.byteLength(value, "utf8") > MAX_FIELD_BYTES || !/^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(value)) {
+    throw new Error(`${label} must be a dotted MongoDB field path under ${MAX_FIELD_BYTES} bytes`);
+  }
+  return value;
+}
+function readCredentialString(value, label, maximum) {
+  if (typeof value !== "string" || value.length === 0 || value.length > maximum || label !== "password" && /[\u0000-\u001f\u007f]/.test(value)) {
+    throw new Error(`MongoDB credential ${label} must be a non-empty string under ${maximum} characters`);
+  }
+  return value;
+}
+function readBoolean2(value, label) {
+  if (typeof value !== "boolean") throw new Error(`${label} must be a boolean`);
+  return value;
+}
+function pinnedLookup(address) {
+  const family = isIP3(address);
+  return (_hostname, options, callback) => {
+    const normalizedOptions = typeof options === "number" ? { family: options } : options;
+    if (normalizedOptions?.family && normalizedOptions.family !== family) {
+      callback(new Error("MongoDB pinned address does not match the requested network family"), "", 0);
+      return;
+    }
+    if (normalizedOptions?.all) {
+      callback(null, [{ address, family }], void 0);
+      return;
+    }
+    callback(null, address, family);
+  };
+}
+function safeErrorMessage(error, secrets) {
+  let message = error instanceof Error ? error.message : String(error);
+  for (const secret of secrets) {
+    if (secret.length >= 4) message = message.replaceAll(secret, "[REDACTED]");
+  }
+  return message;
+}
+function credentialSecrets(source) {
+  try {
+    return readCredentials2(source).secrets;
+  } catch {
+    return [];
+  }
+}
+function collectionSchema() {
+  return {
+    type: "object",
+    properties: { collection: nameParameter("Collection name.") },
+    required: ["collection"],
+    additionalProperties: false
+  };
+}
+function filterArraySchema() {
+  return {
+    type: "array",
+    maxItems: MAX_FILTERS,
+    items: {
+      type: "object",
+      properties: {
+        field: fieldParameter(),
+        operator: { type: "string", enum: ["eq", "ne", "lt", "lte", "gt", "gte"] },
+        value: { type: ["string", "number", "boolean", "null"] }
+      },
+      required: ["field", "operator", "value"],
+      additionalProperties: false
+    }
+  };
+}
+function nameParameter(description) {
+  return { type: "string", minLength: 1, maxLength: MAX_NAME_BYTES, description };
+}
+function fieldParameter() {
+  return {
+    type: "string",
+    minLength: 1,
+    maxLength: MAX_FIELD_BYTES,
+    pattern: "^[A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)*$"
+  };
+}
+function readCapability6(name, description, parameters) {
+  return { name, class: "read", description, parameters };
+}
+
 // src/connectors/adapters/mycase.ts
 var pageProperties = {
   page: { type: "integer", minimum: 1 },
@@ -44747,12 +45843,12 @@ var quickbooksConnector = declarativeRestConnector({
 
 // src/connectors/adapters/rabbitmq.ts
 import { createHash as createHash7 } from "crypto";
-import { isIP as isIP3 } from "net";
+import { isIP as isIP4 } from "net";
 import {
   connect as amqpConnect
 } from "amqplib";
 var MAX_MESSAGE_BYTES3 = 1024 * 1024;
-var MAX_NAME_BYTES = 255;
+var MAX_NAME_BYTES2 = 255;
 var MAX_PEM_BYTES = 64 * 1024;
 var MAX_CA_CERTIFICATES = 16;
 var MAX_CA_BYTES = 256 * 1024;
@@ -44772,13 +45868,13 @@ function createRabbitMqConnector(options = {}) {
       category: "webhook",
       rateLimit: { requests: 120, windowMs: 6e4, scope: "data-source" },
       capabilities: [
-        readCapability6("rabbitmq.queues.inspect", "Check a queue and return its current message and consumer counts.", {
+        readCapability7("rabbitmq.queues.inspect", "Check a queue and return its current message and consumer counts.", {
           type: "object",
           properties: { queue: nameSchema("queue") },
           required: ["queue"],
           additionalProperties: false
         }),
-        readCapability6("rabbitmq.exchanges.inspect", "Check whether a named exchange exists and is visible to the connection.", {
+        readCapability7("rabbitmq.exchanges.inspect", "Check whether a named exchange exists and is visible to the connection.", {
           type: "object",
           properties: { exchange: nameSchema("exchange") },
           required: ["exchange"],
@@ -44800,7 +45896,7 @@ function createRabbitMqConnector(options = {}) {
           type: "object",
           properties: {
             exchange: nameSchema("exchange"),
-            routingKey: { type: "string", maxLength: MAX_NAME_BYTES, default: "" },
+            routingKey: { type: "string", maxLength: MAX_NAME_BYTES2, default: "" },
             data: {},
             persistent: { type: "boolean", default: true },
             expirationMs: { type: "integer", minimum: 1, maximum: 6048e5 },
@@ -44813,7 +45909,7 @@ function createRabbitMqConnector(options = {}) {
     },
     async executeRead({ source, capabilityName, args }) {
       if (capabilityName === "rabbitmq.queues.inspect") {
-        const queue = readName(args.queue, "queue");
+        const queue = readName2(args.queue, "queue");
         const data4 = await withChannel(source, connect, resolveHost, async (channel) => {
           const details = await channel.checkQueue(queue);
           return { queue: details.queue, messageCount: details.messageCount, consumerCount: details.consumerCount };
@@ -44821,7 +45917,7 @@ function createRabbitMqConnector(options = {}) {
         return { data: data4, fetchedAt: Date.now() };
       }
       if (capabilityName === "rabbitmq.exchanges.inspect") {
-        const exchange = readName(args.exchange, "exchange");
+        const exchange = readName2(args.exchange, "exchange");
         const data4 = await withChannel(source, connect, resolveHost, async (channel) => {
           await channel.checkExchange(exchange);
           return { exchange, exists: true };
@@ -44833,7 +45929,7 @@ function createRabbitMqConnector(options = {}) {
     async executeMutation({ source, capabilityName, args, idempotencyKey }) {
       let data4;
       if (capabilityName === "send.message.to.queue") {
-        const queue = readName(args.queue, "queue");
+        const queue = readName2(args.queue, "queue");
         const body = readJsonMessage(args.data);
         const publishOptions = readPublishOptions(args, idempotencyKey);
         data4 = await withConfirmChannel(source, connect, resolveHost, async (channel) => {
@@ -44842,7 +45938,7 @@ function createRabbitMqConnector(options = {}) {
           return { queue, confirmed: true, messageId: publishOptions.messageId, byteLength: body.byteLength };
         });
       } else if (capabilityName === "send.message.to.exchange") {
-        const exchange = readName(args.exchange, "exchange");
+        const exchange = readName2(args.exchange, "exchange");
         const routingKey = readRoutingKey(args.routingKey);
         const body = readJsonMessage(args.data);
         const publishOptions = readPublishOptions(args, idempotencyKey);
@@ -44858,20 +45954,20 @@ function createRabbitMqConnector(options = {}) {
     },
     async test(source) {
       try {
-        const credentials = readCredentials2(source);
+        const credentials = readCredentials3(source);
         await resolveHost(credentials.host);
         const model2 = await connect(credentials.connectOptions, credentials.socketOptions);
         await model2.close();
         return { ok: true };
       } catch (error) {
-        return { ok: false, reason: safeErrorMessage(error, credentialSecrets(source)) };
+        return { ok: false, reason: safeErrorMessage2(error, credentialSecrets2(source)) };
       }
     }
   };
 }
 var rabbitMqConnector = createRabbitMqConnector();
 async function withChannel(source, connect, resolveHost, run) {
-  const credentials = readCredentials2(source);
+  const credentials = readCredentials3(source);
   await resolveHost(credentials.host);
   let model2;
   let channel;
@@ -44880,14 +45976,14 @@ async function withChannel(source, connect, resolveHost, run) {
     channel = await model2.createChannel();
     return await run(channel);
   } catch (error) {
-    throw new Error(safeErrorMessage(error, credentials.secrets));
+    throw new Error(safeErrorMessage2(error, credentials.secrets));
   } finally {
     await channel?.close().catch(() => void 0);
     await model2?.close().catch(() => void 0);
   }
 }
 async function withConfirmChannel(source, connect, resolveHost, run) {
-  const credentials = readCredentials2(source);
+  const credentials = readCredentials3(source);
   await resolveHost(credentials.host);
   let model2;
   let channel;
@@ -44896,7 +45992,7 @@ async function withConfirmChannel(source, connect, resolveHost, run) {
     channel = await model2.createConfirmChannel();
     return await run(channel);
   } catch (error) {
-    throw new Error(safeErrorMessage(error, credentials.secrets));
+    throw new Error(safeErrorMessage2(error, credentials.secrets));
   } finally {
     await channel?.close().catch(() => void 0);
     await model2?.close().catch(() => void 0);
@@ -44916,7 +46012,7 @@ async function publishConfirmed(channel, publishOptions, publish) {
     channel.removeListener("return", onReturn);
   }
 }
-function readCredentials2(source) {
+function readCredentials3(source) {
   let raw;
   if (source.credentials.kind === "custom") raw = source.credentials.values;
   else if (source.credentials.kind === "api-key") {
@@ -44929,13 +46025,13 @@ function readCredentials2(source) {
     throw new Error("RabbitMQ requires a structured credential bundle");
   }
   if (!isPlainRecord(raw)) throw new Error("RabbitMQ credential must be a JSON object");
-  const host = readHost(raw.host);
+  const host = readHost2(raw.host);
   const port = readBoundedInteger(raw.port, 5671, 1, 65535, "port");
   const username = readRequiredString(raw.username, "username", 1024);
   const password = readRequiredString(raw.password, "password", 4096);
   const vhost = readOptionalString(raw.vhost, "vhost") ?? "/";
-  if (Buffer.byteLength(vhost, "utf8") > MAX_NAME_BYTES || /[\u0000-\u001f\u007f]/.test(vhost)) {
-    throw new Error(`vhost must be at most ${MAX_NAME_BYTES} bytes without control characters`);
+  if (Buffer.byteLength(vhost, "utf8") > MAX_NAME_BYTES2 || /[\u0000-\u001f\u007f]/.test(vhost)) {
+    throw new Error(`vhost must be at most ${MAX_NAME_BYTES2} bytes without control characters`);
   }
   const ca = readPem(raw.tlsCa, "tlsCa", true);
   const cert = readPem(raw.tlsCert, "tlsCert", false);
@@ -44957,7 +46053,7 @@ function readCredentials2(source) {
     socketOptions: {
       minVersion: "TLSv1.2",
       rejectUnauthorized: true,
-      servername: isIP3(host) === 0 ? host : void 0,
+      servername: isIP4(host) === 0 ? host : void 0,
       lookup: publicDnsLookup,
       timeout: readBoundedInteger(raw.connectionTimeoutMs, 1e4, 1e3, 3e4, "connectionTimeoutMs"),
       noDelay: true,
@@ -44971,9 +46067,9 @@ function readCredentials2(source) {
     secrets: [password, ...cert ? [cert] : [], ...key ? [key] : [], ...passphrase ? [passphrase] : []]
   };
 }
-function readHost(value) {
+function readHost2(value) {
   const host = readRequiredString(value, "host", 253);
-  const ipVersion = isIP3(host);
+  const ipVersion = isIP4(host);
   if (ipVersion !== 0) {
     if (!isPublicNetworkAddress(host)) throw new Error("RabbitMQ host is not a public network target");
     return host;
@@ -45012,16 +46108,16 @@ function readJsonMessage(value) {
   if (body.byteLength > MAX_MESSAGE_BYTES3) throw new Error(`data exceeds the ${MAX_MESSAGE_BYTES3}-byte limit`);
   return body;
 }
-function readName(value, label) {
-  const name = readRequiredString(value, label, MAX_NAME_BYTES);
-  if (Buffer.byteLength(name, "utf8") > MAX_NAME_BYTES || /[\u0000-\u001f\u007f]/.test(name)) {
-    throw new Error(`${label} must be at most ${MAX_NAME_BYTES} bytes without control characters`);
+function readName2(value, label) {
+  const name = readRequiredString(value, label, MAX_NAME_BYTES2);
+  if (Buffer.byteLength(name, "utf8") > MAX_NAME_BYTES2 || /[\u0000-\u001f\u007f]/.test(name)) {
+    throw new Error(`${label} must be at most ${MAX_NAME_BYTES2} bytes without control characters`);
   }
   return name;
 }
 function readRoutingKey(value) {
   if (value === void 0 || value === null || value === "") return "";
-  return readName(value, "routingKey");
+  return readName2(value, "routingKey");
 }
 function readRequiredString(value, label, maxLength) {
   if (typeof value !== "string" || value.length === 0 || value.length > maxLength) {
@@ -45039,32 +46135,32 @@ function readPem(value, label, allowArray) {
   }
   return allowArray ? values : values[0];
 }
-function credentialSecrets(source) {
+function credentialSecrets2(source) {
   try {
-    return readCredentials2(source).secrets;
+    return readCredentials3(source).secrets;
   } catch {
     return [];
   }
 }
-function safeErrorMessage(error, secrets) {
+function safeErrorMessage2(error, secrets) {
   let message = error instanceof Error ? error.message : String(error);
   for (const secret of secrets) {
     if (secret.length >= 4) message = message.replaceAll(secret, "[REDACTED]");
   }
   return message;
 }
-function readCapability6(name, description, parameters) {
+function readCapability7(name, description, parameters) {
   return { name, class: "read", description, parameters };
 }
 function mutationCapability6(name, description, parameters) {
   return { name, class: "mutation", description, parameters, cas: "none", externalEffect: true };
 }
 function nameSchema(label) {
-  return { type: "string", minLength: 1, maxLength: MAX_NAME_BYTES, description: `Existing RabbitMQ ${label} name.` };
+  return { type: "string", minLength: 1, maxLength: MAX_NAME_BYTES2, description: `Existing RabbitMQ ${label} name.` };
 }
 
 // src/connectors/adapters/redis.ts
-import { isIP as isIP4 } from "net";
+import { isIP as isIP5 } from "net";
 import {
   createClient as createRedisClient
 } from "redis";
@@ -45073,7 +46169,7 @@ var MAX_PATTERN_BYTES = 4096;
 var MAX_VALUE_BYTES = 1024 * 1024;
 var MAX_SCAN_KEYS = 1e3;
 var MAX_SCAN_BYTES = 1024 * 1024;
-var MAX_TLS_CA_BYTES = 256 * 1024;
+var MAX_TLS_CA_BYTES2 = 256 * 1024;
 var MAX_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 var SCAN_SCRIPT = `
 local page
@@ -45123,7 +46219,7 @@ if redis.call('GET', KEYS[1]) ~= ARGV[1] then return 0 end
 return redis.call('DEL', KEYS[1])
 `;
 function createRedisConnector(options = {}) {
-  const createClient = options.createClient ?? defaultCreateClient;
+  const createClient = options.createClient ?? defaultCreateClient2;
   const resolveHost = options.resolveHost ?? resolvePublicHostAddresses;
   return {
     manifest: {
@@ -45138,7 +46234,7 @@ function createRedisConnector(options = {}) {
       category: "database",
       rateLimit: { requests: 120, windowMs: 6e4, scope: "data-source" },
       capabilities: [
-        readCapability7("redis.keys.scan", "Read one bounded SCAN page without blocking the server with KEYS.", {
+        readCapability8("redis.keys.scan", "Read one bounded SCAN page without blocking the server with KEYS.", {
           type: "object",
           properties: {
             cursor: { type: "string", pattern: "^[0-9]+$", default: "0" },
@@ -45148,8 +46244,8 @@ function createRedisConnector(options = {}) {
           },
           additionalProperties: false
         }),
-        readCapability7("redis.key.inspect", "Read a key type and remaining expiry atomically.", keySchema()),
-        readCapability7("redis.string.get", "Read one bounded string value, type, and remaining expiry atomically.", keySchema()),
+        readCapability8("redis.key.inspect", "Read a key type and remaining expiry atomically.", keySchema()),
+        readCapability8("redis.string.get", "Read one bounded string value, type, and remaining expiry atomically.", keySchema()),
         mutationCapability7("redis.string.set", "Set a bounded string only when the key is absent, present, or matches an expected value.", {
           type: "object",
           properties: {
@@ -45176,22 +46272,22 @@ function createRedisConnector(options = {}) {
     },
     async test(source) {
       try {
-        await withClient(source, createClient, resolveHost, async (client) => {
+        await withClient2(source, createClient, resolveHost, async (client) => {
           const response = await client.ping();
           if (response !== "PONG") throw new Error("Redis PING returned an unexpected response");
         });
         return { ok: true };
       } catch (error) {
-        return { ok: false, reason: safeErrorMessage2(error, credentialSecrets2(source)) };
+        return { ok: false, reason: safeErrorMessage3(error, credentialSecrets3(source)) };
       }
     },
     async executeRead({ source, capabilityName, args }) {
       if (capabilityName === "redis.keys.scan") {
-        const cursor = readCursor(args.cursor);
+        const cursor = readCursor2(args.cursor);
         const match = readPattern(args.match);
         const count = readBoundedInteger(args.count, 100, 1, MAX_SCAN_KEYS, "count");
         const type = readScanType(args.type);
-        const data4 = await withClient(source, createClient, resolveHost, async (client) => {
+        const data4 = await withClient2(source, createClient, resolveHost, async (client) => {
           const reply = readArrayReply(await client.eval(SCAN_SCRIPT, {
             keys: [],
             arguments: [
@@ -45206,13 +46302,13 @@ function createRedisConnector(options = {}) {
           }), "scan");
           const keys = readStringArray(reply[1], "scan keys");
           assertScanPage(keys);
-          return { cursor: readCursor(readReplyString(reply[0], "cursor")), keys };
+          return { cursor: readCursor2(readReplyString(reply[0], "cursor")), keys };
         });
         return { data: data4, fetchedAt: Date.now() };
       }
       if (capabilityName === "redis.key.inspect") {
         const key = readKey(args.key);
-        const data4 = await withClient(source, createClient, resolveHost, async (client) => {
+        const data4 = await withClient2(source, createClient, resolveHost, async (client) => {
           const reply = readArrayReply(await client.eval(INSPECT_SCRIPT, { keys: [key], arguments: [] }), "inspect");
           const type = readReplyString(reply[0], "type");
           return { key, exists: type !== "none", type, ttlMs: normalizeTtl(reply[1]) };
@@ -45221,7 +46317,7 @@ function createRedisConnector(options = {}) {
       }
       if (capabilityName === "redis.string.get") {
         const key = readKey(args.key);
-        const data4 = await withClient(source, createClient, resolveHost, async (client) => {
+        const data4 = await withClient2(source, createClient, resolveHost, async (client) => {
           const reply = readArrayReply(await client.eval(READ_STRING_SCRIPT, {
             keys: [key],
             arguments: [String(MAX_VALUE_BYTES)]
@@ -45248,7 +46344,7 @@ function createRedisConnector(options = {}) {
     async executeMutation({ source, capabilityName, args }) {
       if (capabilityName === "redis.string.set") {
         const input = readSetInput(args);
-        return withClient(source, createClient, resolveHost, async (client) => {
+        return withClient2(source, createClient, resolveHost, async (client) => {
           let committed;
           if (input.condition === "matches") {
             committed = readReplyInteger(await client.eval(COMPARE_SET_SCRIPT, {
@@ -45269,7 +46365,7 @@ function createRedisConnector(options = {}) {
       if (capabilityName === "redis.string.delete") {
         const key = readKey(args.key);
         const expectedValue = readValue(args.expectedValue, "expectedValue");
-        return withClient(source, createClient, resolveHost, async (client) => {
+        return withClient2(source, createClient, resolveHost, async (client) => {
           const deleted = readReplyInteger(await client.eval(COMPARE_DELETE_SCRIPT, {
             keys: [key],
             arguments: [expectedValue]
@@ -45283,11 +46379,11 @@ function createRedisConnector(options = {}) {
   };
 }
 var redisConnector = createRedisConnector();
-function defaultCreateClient(options) {
+function defaultCreateClient2(options) {
   return createRedisClient(options);
 }
-async function withClient(source, createClient, resolveHost, run) {
-  const credentials = readCredentials3(source);
+async function withClient2(source, createClient, resolveHost, run) {
+  const credentials = readCredentials4(source);
   const addresses = await resolveHost(credentials.host);
   if (addresses.length === 0) throw new Error("Redis host did not resolve");
   let client;
@@ -45305,7 +46401,7 @@ async function withClient(source, createClient, resolveHost, run) {
         host: addresses[0],
         port: credentials.port,
         tls: true,
-        servername: isIP4(credentials.host) === 0 ? credentials.host : void 0,
+        servername: isIP5(credentials.host) === 0 ? credentials.host : void 0,
         minVersion: "TLSv1.2",
         rejectUnauthorized: true,
         ca: credentials.tlsCa,
@@ -45318,13 +46414,13 @@ async function withClient(source, createClient, resolveHost, run) {
     await client.connect();
     return await run(client);
   } catch (error) {
-    throw new Error(safeErrorMessage2(error, credentials.secrets));
+    throw new Error(safeErrorMessage3(error, credentials.secrets));
   } finally {
     if (client?.isOpen) await client.close().catch(() => client?.destroy());
     else client?.destroy();
   }
 }
-function readCredentials3(source) {
+function readCredentials4(source) {
   let raw;
   if (source.credentials.kind === "custom") raw = source.credentials.values;
   else if (source.credentials.kind === "api-key") {
@@ -45337,15 +46433,15 @@ function readCredentials3(source) {
     throw new Error("Redis requires a structured credential bundle");
   }
   if (!isPlainRecord(raw)) throw new Error("Redis credential must be a JSON object");
-  const host = readHost2(raw.host);
+  const host = readHost3(raw.host);
   const username = readOptionalString(raw.username, "username");
   if (username && (username.length > 128 || /[\u0000-\u001f\u007f]/.test(username))) {
     throw new Error("Redis username must be at most 128 characters without control characters");
   }
   const password = readRequiredString2(raw.password, "password", 4096);
   const tlsCa = readOptionalString(raw.tlsCa, "tlsCa");
-  if (tlsCa && Buffer.byteLength(tlsCa, "utf8") > MAX_TLS_CA_BYTES) {
-    throw new Error(`Redis tlsCa exceeds the ${MAX_TLS_CA_BYTES}-byte limit`);
+  if (tlsCa && Buffer.byteLength(tlsCa, "utf8") > MAX_TLS_CA_BYTES2) {
+    throw new Error(`Redis tlsCa exceeds the ${MAX_TLS_CA_BYTES2}-byte limit`);
   }
   return {
     host,
@@ -45359,9 +46455,9 @@ function readCredentials3(source) {
     secrets: [password]
   };
 }
-function readHost2(value) {
+function readHost3(value) {
   const host = readRequiredString2(value, "host", 253);
-  const ipVersion = isIP4(host);
+  const ipVersion = isIP5(host);
   if (ipVersion !== 0) {
     if (!isPublicNetworkAddress(host)) throw new Error("Redis host is not a public network target");
     return host;
@@ -45387,7 +46483,7 @@ function readSetInput(args) {
   if (ttlMs !== void 0 && keepTtl) throw new Error("ttlMs and keepTtl cannot be used together");
   return { key, value, condition, expectedValue, ttlMs, keepTtl };
 }
-function readCursor(value) {
+function readCursor2(value) {
   if (value === void 0 || value === null || value === "") return "0";
   if (typeof value !== "string" || !/^[0-9]+$/.test(value) || value.length > 32) {
     throw new Error("cursor must be a Redis numeric cursor string");
@@ -45460,16 +46556,16 @@ function normalizeTtl(value) {
   const ttl = readReplyInteger(value, "ttlMs");
   return ttl >= 0 ? ttl : null;
 }
-function safeErrorMessage2(error, secrets) {
+function safeErrorMessage3(error, secrets) {
   let message = error instanceof Error ? error.message : String(error);
   for (const secret of secrets) {
     if (secret.length >= 4) message = message.replaceAll(secret, "[REDACTED]");
   }
   return message;
 }
-function credentialSecrets2(source) {
+function credentialSecrets3(source) {
   try {
-    return readCredentials3(source).secrets;
+    return readCredentials4(source).secrets;
   } catch {
     return [];
   }
@@ -45480,7 +46576,7 @@ function committedResult(data4) {
 function conflict(message) {
   return { status: "conflict", alternatives: [], currentState: null, message };
 }
-function readCapability7(name, description, parameters) {
+function readCapability8(name, description, parameters) {
   return { name, class: "read", description, parameters };
 }
 function mutationCapability7(name, description, parameters) {
@@ -45498,6 +46594,390 @@ function keySchema() {
   };
 }
 
+// src/connectors/adapters/redshift.ts
+import { isIP as isIP6 } from "net";
+import {
+  Client as PgClient
+} from "pg";
+var MAX_IDENTIFIER_BYTES = 127;
+var MAX_COLUMNS5 = 64;
+var MAX_FILTERS2 = 20;
+var MAX_ORDER_COLUMNS = 8;
+var MAX_PARAMETERS_BYTES = 10 * 1024 * 1024;
+var MAX_RESULT_ROWS = 1e4;
+var MAX_RESULT_BYTES3 = 10 * 1024 * 1024;
+var MAX_TLS_CA_BYTES3 = 256 * 1024;
+var REDSHIFT_PROVIDER = {
+  kind: "redshift",
+  displayName: "Amazon Redshift",
+  description: "Inspect Redshift schemas and tables and run bounded structured row reads over the verified PostgreSQL wire protocol.",
+  authHint: "JSON with a public Redshift host, database, user, password, optional port, and optional TLS CA. Verified TLS is mandatory.",
+  defaultPort: 5439
+};
+function createRedshiftConnector(options = {}) {
+  return createPostgresWireReadConnector(REDSHIFT_PROVIDER, options);
+}
+function createPostgresWireReadConnector(provider2, options = {}) {
+  const createClient = options.createClient ?? defaultCreateClient3;
+  const resolveHost = options.resolveHost ?? resolvePublicHostAddresses;
+  return {
+    manifest: {
+      kind: provider2.kind,
+      displayName: provider2.displayName,
+      description: provider2.description,
+      auth: {
+        kind: "api-key",
+        hint: provider2.authHint
+      },
+      defaultConsistencyModel: "authoritative",
+      category: "database",
+      rateLimit: { requests: 120, windowMs: 6e4, scope: "data-source" },
+      capabilities: [
+        readCapability9(`${provider2.kind}.schemas.list`, `List schemas visible to the connected ${provider2.displayName} user.`, emptySchema2()),
+        readCapability9(`${provider2.kind}.tables.list`, "List tables and views in one schema.", {
+          type: "object",
+          properties: { schema: identifierSchema("Schema name; defaults to public.") },
+          additionalProperties: false
+        }),
+        readCapability9(`${provider2.kind}.tables.describe`, "Read ordered column metadata for one table or view.", {
+          type: "object",
+          properties: {
+            schema: identifierSchema("Schema name; defaults to public."),
+            table: identifierSchema("Table or view name.")
+          },
+          required: ["table"],
+          additionalProperties: false
+        }),
+        readCapability9(`${provider2.kind}.rows.select`, "Read bounded rows using an identifier-safe query builder with scalar predicates.", {
+          type: "object",
+          properties: {
+            schema: identifierSchema("Schema name; defaults to public."),
+            table: identifierSchema("Table or view name."),
+            columns: {
+              type: "array",
+              minItems: 1,
+              maxItems: MAX_COLUMNS5,
+              uniqueItems: true,
+              items: identifierSchema("Column name.")
+            },
+            filters: {
+              type: "array",
+              maxItems: MAX_FILTERS2,
+              items: {
+                type: "object",
+                properties: {
+                  column: identifierSchema("Column name."),
+                  operator: { type: "string", enum: ["eq", "ne", "lt", "lte", "gt", "gte", "like", "is-null", "not-null"] },
+                  value: { type: ["string", "number", "boolean", "null"] }
+                },
+                required: ["column", "operator"],
+                additionalProperties: false
+              }
+            },
+            orderBy: {
+              type: "array",
+              maxItems: MAX_ORDER_COLUMNS,
+              items: {
+                type: "object",
+                properties: {
+                  column: identifierSchema("Column name."),
+                  direction: { type: "string", enum: ["asc", "desc"], default: "asc" }
+                },
+                required: ["column"],
+                additionalProperties: false
+              }
+            },
+            limit: { type: "integer", minimum: 1, maximum: MAX_RESULT_ROWS, default: 100 },
+            offset: { type: "integer", minimum: 0, maximum: 1e6, default: 0 }
+          },
+          required: ["table", "columns"],
+          additionalProperties: false
+        })
+      ]
+    },
+    async test(source) {
+      try {
+        await withClient3(source, provider2, createClient, resolveHost, async (client) => {
+          await client.query({ text: "SELECT current_database() AS database_name, current_user AS user_name", values: [] });
+        });
+        return { ok: true };
+      } catch (error) {
+        return { ok: false, reason: safeErrorMessage4(error, credentialSecrets4(source, provider2)) };
+      }
+    },
+    async executeRead(inv) {
+      const query2 = buildQuery(inv, provider2);
+      const data4 = await withClient3(inv.source, provider2, createClient, resolveHost, async (client) => {
+        await client.query({ text: "BEGIN READ ONLY", values: [] });
+        try {
+          const result = await client.query(query2);
+          return boundedResult2(result, provider2.displayName);
+        } finally {
+          await client.query({ text: "ROLLBACK", values: [] }).catch(() => void 0);
+        }
+      });
+      return { data: data4, fetchedAt: Date.now() };
+    }
+  };
+}
+var redshiftConnector = createRedshiftConnector();
+function defaultCreateClient3(config) {
+  return new PgClient(config);
+}
+async function withClient3(source, provider2, createClient, resolveHost, run) {
+  const credentials = readCredentials5(source, provider2);
+  const addresses = await resolveHost(credentials.host);
+  if (addresses.length === 0) throw new Error(`${provider2.displayName} host did not resolve`);
+  let client;
+  try {
+    client = createClient({
+      host: addresses[0],
+      port: credentials.port,
+      user: credentials.user,
+      password: credentials.password,
+      database: credentials.database,
+      application_name: "tangle-integration-hub",
+      connectionTimeoutMillis: credentials.connectTimeoutMs,
+      query_timeout: credentials.queryTimeoutMs,
+      statement_timeout: credentials.queryTimeoutMs,
+      lock_timeout: credentials.queryTimeoutMs,
+      keepAlive: true,
+      keepAliveInitialDelayMillis: 6e4,
+      ssl: {
+        servername: isIP6(credentials.host) === 0 ? credentials.host : void 0,
+        minVersion: "TLSv1.2",
+        rejectUnauthorized: true,
+        ca: credentials.tlsCa
+      }
+    });
+    client.on("error", () => void 0);
+    await client.connect();
+    return await run(client);
+  } catch (error) {
+    throw new Error(safeErrorMessage4(error, credentials.secrets));
+  } finally {
+    await client?.end().catch(() => void 0);
+  }
+}
+function readCredentials5(source, provider2) {
+  let raw;
+  if (source.credentials.kind === "custom") raw = source.credentials.values;
+  else if (source.credentials.kind === "api-key") {
+    try {
+      raw = JSON.parse(source.credentials.apiKey);
+    } catch {
+      throw new Error(`${provider2.displayName} credential must be valid JSON`);
+    }
+  } else {
+    throw new Error(`${provider2.displayName} requires a structured credential bundle`);
+  }
+  if (!isPlainRecord(raw)) throw new Error(`${provider2.displayName} credential must be a JSON object`);
+  const host = readHost4(raw.host, provider2.displayName);
+  const user = readCredentialString2(raw.user ?? raw.username, "user", 128, provider2.displayName);
+  const password = readCredentialString2(raw.password, "password", 4096, provider2.displayName);
+  const database = readCredentialString2(raw.database, "database", MAX_IDENTIFIER_BYTES, provider2.displayName);
+  const tlsCa = readOptionalString(raw.tlsCa, "tlsCa");
+  if (tlsCa && Buffer.byteLength(tlsCa, "utf8") > MAX_TLS_CA_BYTES3) {
+    throw new Error(`${provider2.displayName} tlsCa exceeds the ${MAX_TLS_CA_BYTES3}-byte limit`);
+  }
+  return {
+    host,
+    port: readBoundedInteger(raw.port, provider2.defaultPort, 1, 65535, "port"),
+    user,
+    password,
+    database,
+    tlsCa,
+    connectTimeoutMs: readBoundedInteger(raw.connectTimeoutMs, 1e4, 1e3, 3e4, "connectTimeoutMs"),
+    queryTimeoutMs: readBoundedInteger(raw.queryTimeoutMs, 3e4, 1e3, 6e4, "queryTimeoutMs"),
+    secrets: [password]
+  };
+}
+function buildQuery(inv, provider2) {
+  if (inv.capabilityName === `${provider2.kind}.schemas.list`) {
+    return {
+      text: `SELECT schema_name AS "schemaName", schema_owner AS "schemaOwner" FROM information_schema.schemata WHERE schema_name NOT LIKE 'pg_%' AND schema_name <> 'information_schema' ORDER BY schema_name LIMIT ${MAX_RESULT_ROWS + 1}`,
+      values: []
+    };
+  }
+  if (inv.capabilityName === `${provider2.kind}.tables.list`) {
+    return {
+      text: `SELECT table_schema AS "schemaName", table_name AS "tableName", table_type AS "tableType" FROM information_schema.tables WHERE table_schema = $1 ORDER BY table_name LIMIT ${MAX_RESULT_ROWS + 1}`,
+      values: [readSchema(inv.args.schema)]
+    };
+  }
+  if (inv.capabilityName === `${provider2.kind}.tables.describe`) {
+    return {
+      text: `SELECT table_schema AS "schemaName", table_name AS "tableName", column_name AS "columnName", ordinal_position AS "ordinalPosition", column_default AS "columnDefault", is_nullable AS "isNullable", data_type AS "dataType", character_maximum_length AS "characterMaximumLength", numeric_precision AS "numericPrecision", numeric_scale AS "numericScale" FROM information_schema.columns WHERE table_schema = $1 AND table_name = $2 ORDER BY ordinal_position LIMIT ${MAX_RESULT_ROWS + 1}`,
+      values: [readSchema(inv.args.schema), readIdentifier(inv.args.table, "table")]
+    };
+  }
+  if (inv.capabilityName === `${provider2.kind}.rows.select`) return buildRowSelect(inv.args, provider2.displayName);
+  throw new Error(`Unknown ${provider2.displayName} read capability: ${inv.capabilityName}`);
+}
+function buildRowSelect(args, providerLabel) {
+  const schema = readSchema(args.schema);
+  const table = readIdentifier(args.table, "table");
+  const columns = readIdentifierArray(args.columns, "columns", MAX_COLUMNS5, true);
+  const filters = readFilters2(args.filters);
+  const orderBy = readOrderBy(args.orderBy);
+  const limit = readBoundedInteger(args.limit, 100, 1, MAX_RESULT_ROWS, "limit");
+  const offset = readBoundedInteger(args.offset, 0, 0, 1e6, "offset");
+  const values = [];
+  const predicates = filters.map((filter) => {
+    const column = quoteIdentifier2(filter.column);
+    if (filter.operator === "is-null") return `${column} IS NULL`;
+    if (filter.operator === "not-null") return `${column} IS NOT NULL`;
+    values.push(filter.value);
+    return `${column} ${sqlOperator(filter.operator)} $${values.length}`;
+  });
+  assertParameterBytes(values, providerLabel);
+  const where = predicates.length > 0 ? ` WHERE ${predicates.join(" AND ")}` : "";
+  const order = orderBy.length > 0 ? ` ORDER BY ${orderBy.map((entry) => `${quoteIdentifier2(entry.column)} ${entry.direction.toUpperCase()}`).join(", ")}` : "";
+  return {
+    text: `SELECT ${columns.map(quoteIdentifier2).join(", ")} FROM ${quoteIdentifier2(schema)}.${quoteIdentifier2(table)}${where}${order} LIMIT ${limit} OFFSET ${offset}`,
+    values
+  };
+}
+function readFilters2(value) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value) || value.length > MAX_FILTERS2) throw new Error(`filters must contain at most ${MAX_FILTERS2} entries`);
+  return value.map((entry, index) => {
+    if (!isPlainRecord(entry)) throw new Error(`filters[${index}] must be an object`);
+    const column = readIdentifier(entry.column, `filters[${index}].column`);
+    const operator = entry.operator;
+    if (!["eq", "ne", "lt", "lte", "gt", "gte", "like", "is-null", "not-null"].includes(String(operator))) {
+      throw new Error(`filters[${index}].operator is unsupported`);
+    }
+    const valueRequired = !["is-null", "not-null"].includes(String(operator));
+    if (valueRequired) assertScalar(entry.value, `filters[${index}].value`);
+    else if (entry.value !== void 0) throw new Error(`filters[${index}].value is not valid for ${operator}`);
+    if (valueRequired && entry.value === null) throw new Error(`filters[${index}] must use is-null or not-null for null values`);
+    if (operator === "like" && typeof entry.value !== "string") throw new Error(`filters[${index}].value must be a string for like`);
+    return { column, operator: String(operator), value: entry.value };
+  });
+}
+function readOrderBy(value) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value) || value.length > MAX_ORDER_COLUMNS) throw new Error(`orderBy must contain at most ${MAX_ORDER_COLUMNS} entries`);
+  return value.map((entry, index) => {
+    if (!isPlainRecord(entry)) throw new Error(`orderBy[${index}] must be an object`);
+    const column = readIdentifier(entry.column, `orderBy[${index}].column`);
+    const direction = entry.direction ?? "asc";
+    if (direction !== "asc" && direction !== "desc") throw new Error(`orderBy[${index}].direction must be asc or desc`);
+    return { column, direction };
+  });
+}
+function readIdentifierArray(value, label, max, required) {
+  if (!Array.isArray(value) || required && value.length === 0 || value.length > max) {
+    throw new Error(`${label} must contain ${required ? "1-" : "0-"}${max} identifiers`);
+  }
+  const identifiers = value.map((entry, index) => readIdentifier(entry, `${label}[${index}]`));
+  if (new Set(identifiers).size !== identifiers.length) throw new Error(`${label} must not contain duplicates`);
+  return identifiers;
+}
+function boundedResult2(result, providerLabel) {
+  if (!Array.isArray(result.rows) || result.rows.length > MAX_RESULT_ROWS) {
+    throw new Error(`${providerLabel} result exceeds ${MAX_RESULT_ROWS} rows`);
+  }
+  if (result.rowCount !== null && (!Number.isSafeInteger(result.rowCount) || result.rowCount < 0 || result.rowCount > MAX_RESULT_ROWS)) {
+    throw new Error(`${providerLabel} result returned a malformed row count`);
+  }
+  const data4 = {
+    rows: jsonSafe(result.rows),
+    columns: result.fields.map((field) => ({
+      name: field.name,
+      tableId: field.tableID,
+      columnId: field.columnID,
+      dataTypeId: field.dataTypeID
+    })),
+    rowCount: result.rowCount ?? result.rows.length
+  };
+  const serialized = JSON.stringify(data4);
+  if (Buffer.byteLength(serialized, "utf8") > MAX_RESULT_BYTES3) {
+    throw new Error(`${providerLabel} result exceeds the ${MAX_RESULT_BYTES3}-byte limit`);
+  }
+  return data4;
+}
+function assertParameterBytes(values, providerLabel) {
+  if (Buffer.byteLength(JSON.stringify(values), "utf8") > MAX_PARAMETERS_BYTES) {
+    throw new Error(`${providerLabel} filter values exceed the ${MAX_PARAMETERS_BYTES}-byte limit`);
+  }
+}
+function assertScalar(value, label) {
+  if (value !== null && !["string", "number", "boolean"].includes(typeof value)) throw new Error(`${label} must be a JSON scalar or null`);
+  if (typeof value === "number" && !Number.isFinite(value)) throw new Error(`${label} must be finite`);
+}
+function sqlOperator(value) {
+  return { eq: "=", ne: "<>", lt: "<", lte: "<=", gt: ">", gte: ">=", like: "LIKE" }[value];
+}
+function readSchema(value) {
+  return value === void 0 || value === null ? "public" : readIdentifier(value, "schema");
+}
+function readIdentifier(value, label) {
+  if (typeof value !== "string" || value.length === 0 || Buffer.byteLength(value, "utf8") > MAX_IDENTIFIER_BYTES || !/^[A-Za-z_][A-Za-z0-9_$]*$/.test(value)) {
+    throw new Error(`${label} must be a SQL identifier under ${MAX_IDENTIFIER_BYTES} bytes`);
+  }
+  return value;
+}
+function quoteIdentifier2(value) {
+  return `"${value.replaceAll('"', '""')}"`;
+}
+function readHost4(value, providerLabel) {
+  const host = readCredentialString2(value, "host", 253, providerLabel);
+  const ipVersion = isIP6(host);
+  if (ipVersion !== 0) {
+    if (!isPublicNetworkAddress(host)) throw new Error(`${providerLabel} host is not a public network target`);
+    return host;
+  }
+  const normalized = host.toLowerCase();
+  if (normalized === "localhost" || normalized.endsWith(".localhost") || normalized.endsWith(".local") || /[\s/@:\[\]]/.test(host)) {
+    throw new Error(`${providerLabel} host must be a public hostname or IP address without a scheme or port`);
+  }
+  return host;
+}
+function readCredentialString2(value, label, maxLength, providerLabel) {
+  if (typeof value !== "string" || value.length === 0 || value.length > maxLength || label !== "password" && /[\u0000-\u001f\u007f]/.test(value)) {
+    throw new Error(`${providerLabel} credential ${label} must be a non-empty string under ${maxLength} characters`);
+  }
+  return value;
+}
+function safeErrorMessage4(error, secrets) {
+  let message = error instanceof Error ? error.message : String(error);
+  for (const secret of secrets) {
+    if (secret.length >= 4) message = message.replaceAll(secret, "[REDACTED]");
+  }
+  return message;
+}
+function credentialSecrets4(source, provider2) {
+  try {
+    return readCredentials5(source, provider2).secrets;
+  } catch {
+    return [];
+  }
+}
+function emptySchema2() {
+  return { type: "object", properties: {}, additionalProperties: false };
+}
+function identifierSchema(description) {
+  return { type: "string", minLength: 1, maxLength: MAX_IDENTIFIER_BYTES, pattern: "^[A-Za-z_][A-Za-z0-9_$]*$", description };
+}
+function readCapability9(name, description, parameters) {
+  return { name, class: "read", description, parameters };
+}
+
+// src/connectors/adapters/postgres.ts
+var POSTGRES_PROVIDER = {
+  kind: "postgres",
+  displayName: "PostgreSQL",
+  description: "Inspect PostgreSQL schemas and tables and run bounded structured row reads over a verified TLS connection.",
+  authHint: "JSON with a public PostgreSQL host, database, user, password, optional port, and optional TLS CA. Verified TLS is mandatory.",
+  defaultPort: 5432
+};
+function createPostgresConnector(options = {}) {
+  return createPostgresWireReadConnector(POSTGRES_PROVIDER, options);
+}
+var postgresConnector = createPostgresConnector();
+
 // src/connectors/adapters/recall-ai.ts
 var recallAiRegions = [
   "https://us-east-1.recall.ai",
@@ -46434,7 +47914,7 @@ function createSftpConnector(options = {}) {
       ]
     },
     async executeRead({ source, capabilityName, args }) {
-      const credentials = readCredentials4(source);
+      const credentials = readCredentials6(source);
       if (capabilityName === "sftp.list") {
         const path = resolveRemotePath(credentials.rootPath, args.path ?? "/");
         const limit = readBoundedInteger(args.limit, MAX_LIST_ENTRIES, 1, MAX_LIST_ENTRIES, "limit");
@@ -46467,7 +47947,7 @@ function createSftpConnector(options = {}) {
       throw new Error(`Unknown SFTP read capability: ${capabilityName}`);
     },
     async executeMutation({ source, capabilityName, args }) {
-      const credentials = readCredentials4(source);
+      const credentials = readCredentials6(source);
       const prepared = prepareMutation(capabilityName, args, credentials.rootPath);
       return withSftp(credentials, createClient, lookupHost, async (client) => {
         let data4;
@@ -46501,7 +47981,7 @@ function createSftpConnector(options = {}) {
     },
     async test(source) {
       try {
-        const credentials = readCredentials4(source);
+        const credentials = readCredentials6(source);
         await withSftp(credentials, createClient, lookupHost, (client) => client.cwd());
         return { ok: true };
       } catch (error) {
@@ -46569,7 +48049,7 @@ async function withSftp(credentials, createClient, lookupHost, run) {
     await client.end().catch(() => false);
   }
 }
-function readCredentials4(source) {
+function readCredentials6(source) {
   let raw;
   if (source.credentials.kind === "custom") raw = source.credentials.values;
   else if (source.credentials.kind === "api-key") {
@@ -49918,7 +51398,15 @@ var squareConnector = declarativeRestConnector({
     kind: "oauth2",
     authorizationUrl: "https://connect.squareup.com/oauth2/authorize",
     tokenUrl: "https://connect.squareup.com/oauth2/token",
-    scopes: ["CUSTOMERS_READ", "CUSTOMERS_WRITE", "PAYMENTS_READ", "PAYMENTS_WRITE", "INVOICES_READ", "INVOICES_WRITE"],
+    scopes: [
+      "CUSTOMERS_READ",
+      "CUSTOMERS_WRITE",
+      "PAYMENTS_READ",
+      "PAYMENTS_WRITE",
+      "INVOICES_READ",
+      "INVOICES_WRITE",
+      "ITEMS_WRITE"
+    ],
     clientIdEnv: "SQUARE_OAUTH_CLIENT_ID",
     clientSecretEnv: "SQUARE_OAUTH_CLIENT_SECRET"
   },
@@ -56272,17 +57760,17 @@ var zohoBookingsConnector = {
     category: "calendar",
     defaultConsistencyModel: "authoritative",
     capabilities: [
-      readCapability8("workspaces.list", "List Zoho Bookings workspaces.", {}),
-      readCapability8("services.list", "List services, optionally within one workspace.", {
+      readCapability10("workspaces.list", "List Zoho Bookings workspaces.", {}),
+      readCapability10("services.list", "List services, optionally within one workspace.", {
         workspace_id: { type: "string" }
       }),
-      readCapability8("resources.list", "List bookable resources, optionally for one service.", {
+      readCapability10("resources.list", "List bookable resources, optionally for one service.", {
         service_id: { type: "string" }
       }),
-      readCapability8("staff.list", "List staff, optionally for one service.", {
+      readCapability10("staff.list", "List staff, optionally for one service.", {
         service_id: { type: "string" }
       }),
-      readCapability8("appointments.list", "List appointments from a required start time.", {
+      readCapability10("appointments.list", "List appointments from a required start time.", {
         from_time: {
           type: "string",
           description: "Zoho timestamp in dd-MMM-yyyy HH:mm:ss format."
@@ -56292,10 +57780,10 @@ var zohoBookingsConnector = {
         staff_id: { type: "string" },
         status: { type: "string" }
       }, ["from_time"]),
-      readCapability8("appointments.get", "Read one appointment by booking id.", {
+      readCapability10("appointments.get", "Read one appointment by booking id.", {
         booking_id: { type: "string" }
       }, ["booking_id"]),
-      readCapability8("availability.fetch", "Fetch open time slots for a service and date.", {
+      readCapability10("availability.fetch", "Fetch open time slots for a service and date.", {
         service_id: { type: "string" },
         selected_date: { type: "string", description: "Date in YYYY-MM-DD format." },
         staff_id: { type: "string" },
@@ -56441,7 +57929,7 @@ var zohoBookingsConnector = {
     }
   }
 };
-function readCapability8(name, description, properties, required = []) {
+function readCapability10(name, description, properties, required = []) {
   return {
     name,
     class: "read",
@@ -63795,14 +65283,14 @@ var metabaseConnector = declarativeRestConnector({
 });
 
 // src/connectors/adapters/mysql.ts
-import { connect as createSocket, isIP as isIP5 } from "net";
+import { connect as createSocket, isIP as isIP7 } from "net";
 import {
   createConnection as createMysqlConnection
 } from "mysql2/promise";
 var MAX_PARAMETERS = 1e3;
 var MAX_PARAMETER_BYTES = 10 * 1024 * 1024;
-var MAX_RESULT_ROWS = 1e4;
-var MAX_RESULT_BYTES2 = 10 * 1024 * 1024;
+var MAX_RESULT_ROWS2 = 1e4;
+var MAX_RESULT_BYTES4 = 10 * 1024 * 1024;
 var DEFAULT_QUERY_TIMEOUT_MS = 3e4;
 function createMySqlConnector(options = {}) {
   const createConnection = options.createConnection ?? defaultCreateConnection;
@@ -63824,7 +65312,7 @@ function createMySqlConnector(options = {}) {
           name: "mysql.databases.list",
           class: "read",
           description: "List databases visible to the connected MySQL user.",
-          parameters: emptySchema2()
+          parameters: emptySchema3()
         },
         {
           name: "mysql.tables.list",
@@ -63832,7 +65320,7 @@ function createMySqlConnector(options = {}) {
           description: "List base tables and views in one database.",
           parameters: {
             type: "object",
-            properties: { database: identifierSchema("Database name; defaults to the connection database.") },
+            properties: { database: identifierSchema2("Database name; defaults to the connection database.") },
             additionalProperties: false
           }
         },
@@ -63843,8 +65331,8 @@ function createMySqlConnector(options = {}) {
           parameters: {
             type: "object",
             properties: {
-              database: identifierSchema("Database name; defaults to the connection database."),
-              table: identifierSchema("Table name.")
+              database: identifierSchema2("Database name; defaults to the connection database."),
+              table: identifierSchema2("Table name.")
             },
             required: ["table"],
             additionalProperties: false
@@ -63873,7 +65361,7 @@ function createMySqlConnector(options = {}) {
         });
         return { ok: true };
       } catch (error) {
-        return { ok: false, reason: safeErrorMessage3(error) };
+        return { ok: false, reason: safeErrorMessage5(error) };
       }
     },
     async executeRead(inv) {
@@ -63887,7 +65375,7 @@ function createMySqlConnector(options = {}) {
         try {
           const [rows, fields] = await executeStatement(connection, query2, queryTimeout(inv.source));
           if (!Array.isArray(rows)) throw new Error("MySQL read returned a non-row result");
-          return boundedResult(rows, fields);
+          return boundedResult3(rows, fields);
         } finally {
           await connection.rollback().catch(() => void 0);
         }
@@ -63904,7 +65392,7 @@ function createMySqlConnector(options = {}) {
         inv.args.expectedAffectedRows,
         -1,
         0,
-        MAX_RESULT_ROWS,
+        MAX_RESULT_ROWS2,
         "expectedAffectedRows"
       );
       if (expectedAffectedRows < 0) throw new Error("expectedAffectedRows is required");
@@ -63937,7 +65425,7 @@ async function defaultCreateConnection(config) {
   return createMysqlConnection(config);
 }
 async function withConnection(source, createConnection, resolveHost, run) {
-  const credentials = readCredentials5(source);
+  const credentials = readCredentials7(source);
   const addresses = await resolveHost(credentials.host);
   if (addresses.length === 0) throw new Error("MySQL host did not resolve");
   const address = addresses[0];
@@ -63973,7 +65461,7 @@ async function withConnection(source, createConnection, resolveHost, run) {
     if (connection) await connection.end().catch(() => void 0);
   }
 }
-function readCredentials5(source) {
+function readCredentials7(source) {
   let raw;
   if (source.credentials.kind === "custom") raw = source.credentials.values;
   else if (source.credentials.kind === "api-key") {
@@ -64023,7 +65511,7 @@ function readQuery2(inv) {
   }
   if (inv.capabilityName === "mysql.tables.describe") {
     const database = readDatabase(inv.args.database, inv.source);
-    const table = readIdentifier(inv.args.table, "table");
+    const table = readIdentifier2(inv.args.table, "table");
     return {
       statement: "SELECT COLUMN_NAME AS columnName, ORDINAL_POSITION AS ordinalPosition, COLUMN_DEFAULT AS columnDefault, IS_NULLABLE AS isNullable, DATA_TYPE AS dataType, COLUMN_TYPE AS columnType, COLUMN_KEY AS columnKey, EXTRA AS extra FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? ORDER BY ORDINAL_POSITION",
       parameters: [database, table]
@@ -64074,8 +65562,8 @@ function leadingKeyword(statement) {
 async function executeStatement(connection, query2, timeout) {
   return connection.execute({ sql: query2.statement, values: query2.parameters, timeout });
 }
-function boundedResult(rows, fields) {
-  if (rows.length > MAX_RESULT_ROWS) throw new Error(`MySQL result exceeds ${MAX_RESULT_ROWS} rows`);
+function boundedResult3(rows, fields) {
+  if (rows.length > MAX_RESULT_ROWS2) throw new Error(`MySQL result exceeds ${MAX_RESULT_ROWS2} rows`);
   const data4 = {
     rows: jsonSafe(rows),
     columns: fields.map((field) => ({
@@ -64087,8 +65575,8 @@ function boundedResult(rows, fields) {
     rowCount: rows.length
   };
   const serialized = JSON.stringify(data4);
-  if (Buffer.byteLength(serialized, "utf8") > MAX_RESULT_BYTES2) {
-    throw new Error(`MySQL result exceeds the ${MAX_RESULT_BYTES2}-byte limit`);
+  if (Buffer.byteLength(serialized, "utf8") > MAX_RESULT_BYTES4) {
+    throw new Error(`MySQL result exceeds the ${MAX_RESULT_BYTES4}-byte limit`);
   }
   return data4;
 }
@@ -64115,14 +65603,14 @@ function committedMutation(result, affectedRows) {
   };
 }
 function readDatabase(value, source) {
-  const explicit = value === void 0 ? void 0 : readIdentifier(value, "database");
+  const explicit = value === void 0 ? void 0 : readIdentifier2(value, "database");
   if (explicit) return explicit;
-  const credentials = readCredentials5(source);
+  const credentials = readCredentials7(source);
   if (!credentials.database) throw new Error("database is required when the connection has no default database");
   return credentials.database;
 }
 function queryTimeout(source) {
-  return readCredentials5(source).queryTimeoutMs;
+  return readCredentials7(source).queryTimeoutMs;
 }
 function requiredString7(value, label) {
   const parsed = readOptionalString(value, label);
@@ -64135,21 +65623,21 @@ function requiredCredentialString3(value, label, maxLength) {
   if (parsed.length > maxLength) throw new Error(`MySQL credential ${label} exceeds ${maxLength} characters`);
   return parsed;
 }
-function readIdentifier(value, label) {
+function readIdentifier2(value, label) {
   const parsed = requiredString7(value, label);
   if (parsed.length > 64) throw new Error(`${label} exceeds 64 characters`);
   return parsed;
 }
 function validateHost(host) {
   const normalized = host.toLowerCase();
-  if (host.length > 253 || host.includes("://") || /[\s/@]/.test(host) || normalized === "localhost" || normalized.endsWith(".localhost") || normalized.endsWith(".local") || isIP5(host) === 0 && !/^[A-Za-z0-9.-]+$/.test(host) || host.split(".").some((label) => !label || label.startsWith("-") || label.endsWith("-"))) {
+  if (host.length > 253 || host.includes("://") || /[\s/@]/.test(host) || normalized === "localhost" || normalized.endsWith(".localhost") || normalized.endsWith(".local") || isIP7(host) === 0 && !/^[A-Za-z0-9.-]+$/.test(host) || host.split(".").some((label) => !label || label.startsWith("-") || label.endsWith("-"))) {
     throw new Error("MySQL host must be a public hostname or IP address without a scheme");
   }
 }
-function emptySchema2() {
+function emptySchema3() {
   return { type: "object", properties: {}, additionalProperties: false };
 }
-function identifierSchema(description) {
+function identifierSchema2(description) {
   return { type: "string", minLength: 1, maxLength: 64, description };
 }
 function statementSchema(mutation) {
@@ -64166,7 +65654,7 @@ function statementSchema(mutation) {
     properties.expectedAffectedRows = {
       type: "integer",
       minimum: 0,
-      maximum: MAX_RESULT_ROWS,
+      maximum: MAX_RESULT_ROWS2,
       description: "Commit only when MySQL reports exactly this many affected rows."
     };
   }
@@ -64177,7 +65665,7 @@ function statementSchema(mutation) {
     additionalProperties: false
   };
 }
-function safeErrorMessage3(error) {
+function safeErrorMessage5(error) {
   return error instanceof Error && error.message ? error.message : "MySQL connection failed";
 }
 
@@ -64612,41 +66100,28 @@ var supabaseConnector = declarativeRestConnector({
   displayName: "Supabase",
   description: "Inspect Supabase projects, run SQL against the Postgres database, and manage secrets via the Management API.",
   auth: {
-    kind: "oauth2",
-    authorizationUrl: "https://api.supabase.com/v1/oauth/authorize",
-    tokenUrl: "https://api.supabase.com/v1/oauth/token",
-    scopes: [
-      "organizations:read",
-      "projects:read",
-      "projects:write",
-      "database:read",
-      "database:write",
-      "secrets:read",
-      "secrets:write"
-    ],
-    clientIdEnv: "SUPABASE_OAUTH_CLIENT_ID",
-    clientSecretEnv: "SUPABASE_OAUTH_CLIENT_SECRET"
+    kind: "api-key",
+    hint: "Supabase Management API personal access token (Dashboard > Account > Access Tokens). Sent as an Authorization: Bearer token."
   },
   category: "other",
   defaultConsistencyModel: "authoritative",
   baseUrl: "https://api.supabase.com",
+  credentialPlacement: { kind: "bearer" },
   test: { method: "GET", path: "/v1/organizations" },
   capabilities: [
     {
       name: "organizations.list",
       class: "read",
-      description: "List Supabase organizations the authorizing user belongs to.",
+      description: "List Supabase organizations available to the personal access token.",
       parameters: { type: "object", properties: {} },
-      request: { method: "GET", path: "/v1/organizations" },
-      requiredScopes: ["organizations:read"]
+      request: { method: "GET", path: "/v1/organizations" }
     },
     {
       name: "projects.list",
       class: "read",
-      description: "List Supabase projects across the authorized organizations.",
+      description: "List Supabase projects available to the personal access token.",
       parameters: { type: "object", properties: {} },
-      request: { method: "GET", path: "/v1/projects" },
-      requiredScopes: ["projects:read"]
+      request: { method: "GET", path: "/v1/projects" }
     },
     {
       name: "projects.get",
@@ -64657,18 +66132,17 @@ var supabaseConnector = declarativeRestConnector({
         properties: { ref: { type: "string", description: "Project ref (e.g. abcdefghijklmnop)." } },
         required: ["ref"]
       },
-      request: { method: "GET", path: "/v1/projects/{ref}" },
-      requiredScopes: ["projects:read"]
+      request: { method: "GET", path: "/v1/projects/{ref}" }
     },
     {
       name: "database.query",
-      class: "read",
-      description: "Run a read-only SQL query against the project Postgres database.",
+      class: "mutation",
+      description: "Run SQL against the project Postgres database. This requires normal write approval because a Management API personal access token does not distinguish read-only SQL from writes.",
       parameters: {
         type: "object",
         properties: {
           ref: { type: "string" },
-          query: { type: "string", description: "SQL statement. Mutations are rejected unless database:write is granted." }
+          query: { type: "string", description: "SQL statement." }
         },
         required: ["ref", "query"]
       },
@@ -64677,7 +66151,8 @@ var supabaseConnector = declarativeRestConnector({
         path: "/v1/projects/{ref}/database/query",
         body: { query: "{query}" }
       },
-      requiredScopes: ["database:read"]
+      cas: "native-idempotency",
+      externalEffect: true
     },
     {
       name: "database.execute",
@@ -64696,8 +66171,7 @@ var supabaseConnector = declarativeRestConnector({
         path: "/v1/projects/{ref}/database/query",
         body: { query: "{query}" }
       },
-      cas: "native-idempotency",
-      requiredScopes: ["database:write"]
+      cas: "native-idempotency"
     },
     {
       name: "projects.create",
@@ -64715,8 +66189,7 @@ var supabaseConnector = declarativeRestConnector({
         required: ["organization_id", "name", "region", "db_pass"]
       },
       request: { method: "POST", path: "/v1/projects", body: "args" },
-      cas: "native-idempotency",
-      requiredScopes: ["projects:write"]
+      cas: "native-idempotency"
     },
     {
       name: "secrets.list",
@@ -64727,8 +66200,7 @@ var supabaseConnector = declarativeRestConnector({
         properties: { ref: { type: "string" } },
         required: ["ref"]
       },
-      request: { method: "GET", path: "/v1/projects/{ref}/secrets" },
-      requiredScopes: ["secrets:read"]
+      request: { method: "GET", path: "/v1/projects/{ref}/secrets" }
     },
     {
       name: "secrets.upsert",
@@ -64754,8 +66226,7 @@ var supabaseConnector = declarativeRestConnector({
         path: "/v1/projects/{ref}/secrets",
         body: "{secrets}"
       },
-      cas: "native-idempotency",
-      requiredScopes: ["secrets:write"]
+      cas: "native-idempotency"
     },
     {
       name: "projects.delete",
@@ -64768,8 +66239,7 @@ var supabaseConnector = declarativeRestConnector({
       },
       request: { method: "DELETE", path: "/v1/projects/{ref}" },
       cas: "native-idempotency",
-      externalEffect: true,
-      requiredScopes: ["projects:write"]
+      externalEffect: true
     },
     {
       name: "branches.create",
@@ -64791,8 +66261,7 @@ var supabaseConnector = declarativeRestConnector({
         body: "args"
       },
       cas: "native-idempotency",
-      externalEffect: true,
-      requiredScopes: ["projects:write"]
+      externalEffect: true
     },
     {
       name: "branches.delete",
@@ -64805,8 +66274,7 @@ var supabaseConnector = declarativeRestConnector({
       },
       request: { method: "DELETE", path: "/v1/branches/{branch_id}" },
       cas: "native-idempotency",
-      externalEffect: true,
-      requiredScopes: ["projects:write"]
+      externalEffect: true
     },
     {
       name: "secrets.delete",
@@ -64826,8 +66294,7 @@ var supabaseConnector = declarativeRestConnector({
         query: { name: "{name}" }
       },
       cas: "native-idempotency",
-      externalEffect: true,
-      requiredScopes: ["secrets:write"]
+      externalEffect: true
     },
     {
       name: "storage.upload",
@@ -64849,8 +66316,7 @@ var supabaseConnector = declarativeRestConnector({
         body: "{content}"
       },
       cas: "native-idempotency",
-      externalEffect: true,
-      requiredScopes: ["projects:write"]
+      externalEffect: true
     }
   ]
 });
@@ -65325,6 +66791,49 @@ var hunterConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/neverbounce.ts
+var neverbounceConnector = declarativeRestConnector({
+  kind: "neverbounce",
+  displayName: "NeverBounce",
+  description: "Verify email deliverability with the NeverBounce API.",
+  auth: {
+    kind: "api-key",
+    hint: "NeverBounce API key from Apps > API in the NeverBounce dashboard."
+  },
+  category: "crm",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.neverbounce.com/v4.2",
+  credentialPlacement: { kind: "query", parameter: "key" },
+  test: {
+    method: "GET",
+    path: "/account/info"
+  },
+  capabilities: [
+    {
+      name: "verify.email.address",
+      class: "mutation",
+      description: "Verify one email address and return deliverability status such as valid, invalid, disposable, catch-all, or unknown.",
+      parameters: {
+        type: "object",
+        properties: {
+          email: {
+            type: "string",
+            description: "Email address to verify."
+          }
+        },
+        required: ["email"]
+      },
+      request: {
+        method: "GET",
+        path: "/single/check",
+        query: { email: "{email}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
 // src/connectors/adapters/theirstack.ts
 var theirstackConnector = declarativeRestConnector({
   kind: "theirstack",
@@ -65622,10 +67131,7 @@ var CONNECTOR_ADAPTER_FACTORIES = [
       "GOOGLE_OAUTH_CLIENT_SECRET"
     ]
   }),
-  defineFactoryAdapter(() => supabaseConnector, {
-    clientId: "SUPABASE_OAUTH_CLIENT_ID",
-    clientSecret: "SUPABASE_OAUTH_CLIENT_SECRET"
-  }),
+  defineFactoryAdapter(() => supabaseConnector, {}),
   defineFactoryAdapter(() => airtableConnector, {}),
   defineFactoryAdapter(() => baserowConnector, {}),
   defineFactoryAdapter(() => actualbudgetConnector, {}),
@@ -65738,6 +67244,9 @@ var CONNECTOR_ADAPTER_FACTORIES = [
   defineFactoryAdapter(() => duckdbConnector, {}),
   defineFactoryAdapter(() => rabbitMqConnector, {}),
   defineFactoryAdapter(() => redisConnector, {}),
+  defineFactoryAdapter(() => redshiftConnector, {}),
+  defineFactoryAdapter(() => postgresConnector, {}),
+  defineFactoryAdapter(() => mongodbConnector, {}),
   defineFactoryAdapter(() => csvFilesConnector, {}),
   defineFactoryAdapter(() => excelFilesConnector, {}),
   defineFactoryAdapter(() => parquetFilesConnector, {}),
@@ -65806,6 +67315,10 @@ var CONNECTOR_ADAPTER_FACTORIES = [
     clientId: "LINEAR_OAUTH_CLIENT_ID",
     clientSecret: "LINEAR_OAUTH_CLIENT_SECRET"
   }),
+  defineFactoryAdapter(() => miroConnector, {
+    clientId: "MIRO_OAUTH_CLIENT_ID",
+    clientSecret: "MIRO_OAUTH_CLIENT_SECRET"
+  }),
   defineFactoryAdapter(() => mondayConnector, {
     clientId: "MONDAY_OAUTH_CLIENT_ID",
     clientSecret: "MONDAY_OAUTH_CLIENT_SECRET"
@@ -66032,6 +67545,7 @@ var CONNECTOR_ADAPTER_FACTORIES = [
   defineFactoryAdapter(() => builtwithConnector, {}),
   defineFactoryAdapter(() => fullenrichConnector, {}),
   defineFactoryAdapter(() => hunterConnector, {}),
+  defineFactoryAdapter(() => neverbounceConnector, {}),
   defineFactoryAdapter(() => theirstackConnector, {}),
   defineFactoryAdapter(() => zerobounceConnector, {})
 ];
@@ -72417,677 +73931,6 @@ var figjamConnector = declarativeRestConnector({
   ]
 });
 
-// src/connectors/adapters/miro.ts
-var miroConnector = declarativeRestConnector({
-  kind: "miro",
-  displayName: "Miro",
-  description: "Read and edit Miro boards: list and search boards, read board items (sticky notes, shapes, text, cards, images, frames, connectors), create and update items, and post board content back into the source of truth.",
-  auth: {
-    kind: "oauth2",
-    authorizationUrl: "https://miro.com/oauth/authorize",
-    tokenUrl: "https://api.miro.com/v1/oauth/token",
-    scopes: [
-      "boards:read",
-      "boards:write",
-      "identity:read",
-      "team:read",
-      "organizations:read"
-    ],
-    clientIdEnv: "MIRO_OAUTH_CLIENT_ID",
-    clientSecretEnv: "MIRO_OAUTH_CLIENT_SECRET"
-  },
-  category: "doc",
-  defaultConsistencyModel: "authoritative",
-  baseUrl: "https://api.miro.com",
-  defaultHeaders: { accept: "application/json" },
-  // GET /v2/me returns the authenticated user — Miro's documented health probe.
-  test: { method: "GET", path: "/v2/me" },
-  capabilities: [
-    {
-      name: "me.get",
-      class: "read",
-      description: "Return the authenticated Miro user.",
-      parameters: { type: "object", properties: {} },
-      request: { method: "GET", path: "/v2/me" },
-      requiredScopes: ["identity:read"]
-    },
-    {
-      name: "boards.list",
-      class: "read",
-      description: "List boards accessible to the authenticated user. Supports cursor pagination via `cursor` and team / sort filters.",
-      parameters: {
-        type: "object",
-        properties: {
-          team_id: { type: "string", description: "Filter to a single team id." },
-          query: { type: "string", description: "Free-text board name filter." },
-          owner: { type: "string", description: "Filter by owner user id." },
-          limit: { type: "integer", minimum: 1, maximum: 50 },
-          offset: { type: "integer", minimum: 0 },
-          sort: {
-            type: "string",
-            enum: ["default", "last_modified", "last_opened", "last_created", "alphabetically"]
-          }
-        }
-      },
-      request: {
-        method: "GET",
-        path: "/v2/boards",
-        query: {
-          team_id: "{team_id}",
-          query: "{query}",
-          owner: "{owner}",
-          limit: "{limit}",
-          offset: "{offset}",
-          sort: "{sort}"
-        }
-      },
-      requiredScopes: ["boards:read"]
-    },
-    {
-      name: "boards.get",
-      class: "read",
-      description: "Fetch a single Miro board by id.",
-      parameters: {
-        type: "object",
-        properties: { board_id: { type: "string" } },
-        required: ["board_id"]
-      },
-      request: { method: "GET", path: "/v2/boards/{board_id}" },
-      requiredScopes: ["boards:read"]
-    },
-    {
-      name: "boards.members.list",
-      class: "read",
-      description: "List members (collaborators) of a Miro board.",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          limit: { type: "integer", minimum: 1, maximum: 50 },
-          offset: { type: "integer", minimum: 0 }
-        },
-        required: ["board_id"]
-      },
-      request: {
-        method: "GET",
-        path: "/v2/boards/{board_id}/members",
-        query: { limit: "{limit}", offset: "{offset}" }
-      },
-      requiredScopes: ["boards:read"]
-    },
-    {
-      name: "items.list",
-      class: "read",
-      description: "List all items on a board, optionally filtered by item type (sticky_note, text, shape, card, image, frame, connector, embed, app_card, document).",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          type: {
-            type: "string",
-            enum: [
-              "sticky_note",
-              "text",
-              "shape",
-              "card",
-              "image",
-              "frame",
-              "connector",
-              "embed",
-              "app_card",
-              "document",
-              "preview"
-            ]
-          },
-          limit: { type: "integer", minimum: 1, maximum: 50 },
-          cursor: { type: "string" }
-        },
-        required: ["board_id"]
-      },
-      request: {
-        method: "GET",
-        path: "/v2/boards/{board_id}/items",
-        query: { type: "{type}", limit: "{limit}", cursor: "{cursor}" }
-      },
-      requiredScopes: ["boards:read"]
-    },
-    {
-      name: "items.get",
-      class: "read",
-      description: "Fetch a single board item by id.",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          item_id: { type: "string" }
-        },
-        required: ["board_id", "item_id"]
-      },
-      request: { method: "GET", path: "/v2/boards/{board_id}/items/{item_id}" },
-      requiredScopes: ["boards:read"]
-    },
-    {
-      name: "connectors.list",
-      class: "read",
-      description: "List connector lines on a board (arrows / lines between items).",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          limit: { type: "integer", minimum: 1, maximum: 50 },
-          cursor: { type: "string" }
-        },
-        required: ["board_id"]
-      },
-      request: {
-        method: "GET",
-        path: "/v2/boards/{board_id}/connectors",
-        query: { limit: "{limit}", cursor: "{cursor}" }
-      },
-      requiredScopes: ["boards:read"]
-    },
-    {
-      name: "tags.list",
-      class: "read",
-      description: "List tags defined on a board.",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          limit: { type: "integer", minimum: 1, maximum: 50 },
-          offset: { type: "integer", minimum: 0 }
-        },
-        required: ["board_id"]
-      },
-      request: {
-        method: "GET",
-        path: "/v2/boards/{board_id}/tags",
-        query: { limit: "{limit}", offset: "{offset}" }
-      },
-      requiredScopes: ["boards:read"]
-    },
-    {
-      name: "organizations.get",
-      class: "read",
-      description: "Read an organization (Enterprise plan).",
-      parameters: {
-        type: "object",
-        properties: { org_id: { type: "string" } },
-        required: ["org_id"]
-      },
-      request: { method: "GET", path: "/v2/orgs/{org_id}" },
-      requiredScopes: ["organizations:read"]
-    },
-    {
-      name: "organizations.teams.list",
-      class: "read",
-      description: "List teams in an organization (Enterprise plan).",
-      parameters: {
-        type: "object",
-        properties: {
-          org_id: { type: "string" },
-          limit: { type: "integer", minimum: 1, maximum: 100 },
-          cursor: { type: "string" }
-        },
-        required: ["org_id"]
-      },
-      request: {
-        method: "GET",
-        path: "/v2/orgs/{org_id}/teams",
-        query: { limit: "{limit}", cursor: "{cursor}" }
-      },
-      requiredScopes: ["organizations:read"]
-    },
-    {
-      name: "teams.get",
-      class: "read",
-      description: "Fetch a single team by id.",
-      parameters: {
-        type: "object",
-        properties: {
-          org_id: { type: "string" },
-          team_id: { type: "string" }
-        },
-        required: ["org_id", "team_id"]
-      },
-      request: { method: "GET", path: "/v2/orgs/{org_id}/teams/{team_id}" },
-      requiredScopes: ["team:read"]
-    },
-    {
-      name: "boards.create",
-      class: "mutation",
-      description: "Create a new Miro board. Accepts an optional name, description, team_id, and sharing policy. Returns the new board id used by every items.* endpoint.",
-      parameters: {
-        type: "object",
-        properties: {
-          name: { type: "string", maxLength: 60 },
-          description: { type: "string", maxLength: 300 },
-          team_id: { type: "string" },
-          policy: {
-            type: "object",
-            description: "Permissions + sharing policy. See https://developers.miro.com/reference/create-board for the full PolicyChange shape."
-          }
-        },
-        required: ["name"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards",
-        body: {
-          name: "{name}",
-          description: "{description}",
-          teamId: "{team_id}",
-          policy: "{policy}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "boards.update",
-      class: "mutation",
-      description: "Update a Miro board (name, description, team, or sharing policy).",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          name: { type: "string", maxLength: 60 },
-          description: { type: "string", maxLength: 300 },
-          team_id: { type: "string" },
-          policy: { type: "object" }
-        },
-        required: ["board_id"]
-      },
-      request: {
-        method: "PATCH",
-        path: "/v2/boards/{board_id}",
-        body: {
-          name: "{name}",
-          description: "{description}",
-          teamId: "{team_id}",
-          policy: "{policy}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "boards.delete",
-      class: "mutation",
-      description: "Delete a Miro board (irreversible).",
-      parameters: {
-        type: "object",
-        properties: { board_id: { type: "string" } },
-        required: ["board_id"]
-      },
-      request: { method: "DELETE", path: "/v2/boards/{board_id}" },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "sticky_notes.create",
-      class: "mutation",
-      description: "Create a sticky note on a board. `data.content` accepts plain text; `style.fillColor` is a Miro sticky-note color keyword (e.g. yellow, light_yellow, pink).",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          data: {
-            type: "object",
-            properties: {
-              content: { type: "string" },
-              shape: { type: "string", enum: ["square", "rectangle"] }
-            },
-            required: ["content"]
-          },
-          style: {
-            type: "object",
-            properties: {
-              fillColor: { type: "string" },
-              textAlign: { type: "string", enum: ["left", "center", "right"] },
-              textAlignVertical: { type: "string", enum: ["top", "middle", "bottom"] }
-            }
-          },
-          position: {
-            type: "object",
-            properties: {
-              x: { type: "number" },
-              y: { type: "number" },
-              origin: { type: "string", enum: ["center"] }
-            }
-          },
-          geometry: {
-            type: "object",
-            properties: {
-              width: { type: "number" },
-              height: { type: "number" }
-            }
-          },
-          parent: {
-            type: "object",
-            description: "Attach the sticky note to a frame: { id: <frame_item_id> }.",
-            properties: { id: { type: "string" } }
-          }
-        },
-        required: ["board_id", "data"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards/{board_id}/sticky_notes",
-        body: {
-          data: "{data}",
-          style: "{style}",
-          position: "{position}",
-          geometry: "{geometry}",
-          parent: "{parent}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "sticky_notes.update",
-      class: "mutation",
-      description: "Update a sticky note (content, style, position, geometry, or parent frame).",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          item_id: { type: "string" },
-          data: { type: "object" },
-          style: { type: "object" },
-          position: { type: "object" },
-          geometry: { type: "object" },
-          parent: { type: "object" }
-        },
-        required: ["board_id", "item_id"]
-      },
-      request: {
-        method: "PATCH",
-        path: "/v2/boards/{board_id}/sticky_notes/{item_id}",
-        body: {
-          data: "{data}",
-          style: "{style}",
-          position: "{position}",
-          geometry: "{geometry}",
-          parent: "{parent}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "text.create",
-      class: "mutation",
-      description: "Create a text item on a board.",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          data: {
-            type: "object",
-            properties: { content: { type: "string" } },
-            required: ["content"]
-          },
-          style: { type: "object" },
-          position: { type: "object" },
-          geometry: { type: "object" },
-          parent: { type: "object" }
-        },
-        required: ["board_id", "data"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards/{board_id}/texts",
-        body: {
-          data: "{data}",
-          style: "{style}",
-          position: "{position}",
-          geometry: "{geometry}",
-          parent: "{parent}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "shapes.create",
-      class: "mutation",
-      description: "Create a shape item on a board. `data.shape` selects the geometric primitive (rectangle, round_rectangle, circle, triangle, rhombus, etc.).",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          data: {
-            type: "object",
-            properties: {
-              shape: {
-                type: "string",
-                description: "Miro shape kind; full enum at https://developers.miro.com/reference/create-shape-item."
-              },
-              content: { type: "string" }
-            },
-            required: ["shape"]
-          },
-          style: { type: "object" },
-          position: { type: "object" },
-          geometry: { type: "object" },
-          parent: { type: "object" }
-        },
-        required: ["board_id", "data"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards/{board_id}/shapes",
-        body: {
-          data: "{data}",
-          style: "{style}",
-          position: "{position}",
-          geometry: "{geometry}",
-          parent: "{parent}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "cards.create",
-      class: "mutation",
-      description: "Create a card item (title + description + assignee + due-date) on a board.",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          data: {
-            type: "object",
-            properties: {
-              title: { type: "string" },
-              description: { type: "string" },
-              dueDate: { type: "string", format: "date-time" },
-              assigneeId: { type: "string" }
-            },
-            required: ["title"]
-          },
-          style: { type: "object" },
-          position: { type: "object" },
-          geometry: { type: "object" },
-          parent: { type: "object" }
-        },
-        required: ["board_id", "data"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards/{board_id}/cards",
-        body: {
-          data: "{data}",
-          style: "{style}",
-          position: "{position}",
-          geometry: "{geometry}",
-          parent: "{parent}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "frames.create",
-      class: "mutation",
-      description: "Create a frame on a board. Frames group items; child items can be attached via `parent.id` on item creation.",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          data: {
-            type: "object",
-            properties: {
-              title: { type: "string" },
-              format: { type: "string", enum: ["custom"] },
-              type: { type: "string", enum: ["freeform"] }
-            }
-          },
-          style: { type: "object" },
-          position: { type: "object" },
-          geometry: { type: "object" }
-        },
-        required: ["board_id"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards/{board_id}/frames",
-        body: {
-          data: "{data}",
-          style: "{style}",
-          position: "{position}",
-          geometry: "{geometry}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "images.create.by_url",
-      class: "mutation",
-      description: "Create an image item from a public URL (Miro fetches the image server-side).",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          data: {
-            type: "object",
-            properties: {
-              url: { type: "string", format: "uri" },
-              title: { type: "string" }
-            },
-            required: ["url"]
-          },
-          position: { type: "object" },
-          geometry: { type: "object" },
-          parent: { type: "object" }
-        },
-        required: ["board_id", "data"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards/{board_id}/images",
-        body: {
-          data: "{data}",
-          position: "{position}",
-          geometry: "{geometry}",
-          parent: "{parent}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "connectors.create",
-      class: "mutation",
-      description: "Create a connector line between two items on the board. `startItem.id` and `endItem.id` reference existing item ids.",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          startItem: {
-            type: "object",
-            properties: { id: { type: "string" } },
-            required: ["id"]
-          },
-          endItem: {
-            type: "object",
-            properties: { id: { type: "string" } },
-            required: ["id"]
-          },
-          captions: {
-            type: "array",
-            items: { type: "object", properties: { content: { type: "string" } } }
-          },
-          style: { type: "object" },
-          shape: { type: "string", enum: ["straight", "elbowed", "curved"] }
-        },
-        required: ["board_id", "startItem", "endItem"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards/{board_id}/connectors",
-        body: {
-          startItem: "{startItem}",
-          endItem: "{endItem}",
-          captions: "{captions}",
-          style: "{style}",
-          shape: "{shape}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "items.delete",
-      class: "mutation",
-      description: "Delete an item from a board (works across all item types).",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          item_id: { type: "string" }
-        },
-        required: ["board_id", "item_id"]
-      },
-      request: { method: "DELETE", path: "/v2/boards/{board_id}/items/{item_id}" },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    },
-    {
-      name: "boards.share",
-      class: "mutation",
-      description: "Invite users to a Miro board by email. Roles: viewer, commenter, editor, coowner.",
-      parameters: {
-        type: "object",
-        properties: {
-          board_id: { type: "string" },
-          emails: { type: "array", items: { type: "string", format: "email" } },
-          role: {
-            type: "string",
-            enum: ["viewer", "commenter", "editor", "coowner"]
-          },
-          message: { type: "string" }
-        },
-        required: ["board_id", "emails", "role"]
-      },
-      request: {
-        method: "POST",
-        path: "/v2/boards/{board_id}/members",
-        body: {
-          emails: "{emails}",
-          role: "{role}",
-          message: "{message}"
-        }
-      },
-      cas: "native-idempotency",
-      requiredScopes: ["boards:write"]
-    }
-  ]
-});
-
 // src/connectors/adapters/canva.ts
 var canvaConnector = declarativeRestConnector({
   kind: "canva",
@@ -120704,309 +121547,6 @@ var mindStudioConnector = declarativeRestConnector({
   ]
 });
 
-// src/connectors/adapters/mongodb.ts
-var mongodbConnector = declarativeRestConnector({
-  kind: "mongodb",
-  displayName: "MongoDB",
-  description: "Query, insert, update, and delete MongoDB documents via the Data API.",
-  auth: { kind: "api-key", hint: "MongoDB Data API key." },
-  category: "database",
-  defaultConsistencyModel: "authoritative",
-  baseUrl: "https://data.mongodb-api.com/app",
-  test: { method: "POST", path: "/{appId}/endpoint/data/v1/action/findOne" },
-  capabilities: [
-    {
-      name: "documents.find",
-      class: "read",
-      description: "Query documents in a collection.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: 'Data source name (e.g., "Cluster0").' },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          filter: { type: "object", description: 'Query filter (e.g., { "status": "active" }).' },
-          projection: { type: "object", description: "Fields to include/exclude." },
-          sort: { type: "object", description: "Sort criteria." },
-          limit: { type: "integer", description: "Maximum documents to return." },
-          skip: { type: "integer", description: "Documents to skip." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/find",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          filter: "{filter}",
-          projection: "{projection}",
-          sort: "{sort}",
-          limit: "{limit}",
-          skip: "{skip}"
-        }
-      }
-    },
-    {
-      name: "documents.findOne",
-      class: "read",
-      description: "Find a single document matching a filter.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          filter: { type: "object", description: "Query filter." },
-          projection: { type: "object", description: "Fields to include/exclude." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/findOne",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          filter: "{filter}",
-          projection: "{projection}"
-        }
-      }
-    },
-    {
-      name: "documents.insertOne",
-      class: "mutation",
-      description: "Insert a single document into a collection.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          document: { type: "object", description: "Document to insert." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName", "document"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/insertOne",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          document: "{document}"
-        }
-      },
-      cas: "native-idempotency"
-    },
-    {
-      name: "documents.insertMany",
-      class: "mutation",
-      description: "Insert multiple documents into a collection.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          documents: { type: "array", items: { type: "object" }, description: "Array of documents to insert." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName", "documents"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/insertMany",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          documents: "{documents}"
-        }
-      },
-      cas: "native-idempotency"
-    },
-    {
-      name: "documents.updateOne",
-      class: "mutation",
-      description: "Update a single document matching a filter.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          filter: { type: "object", description: "Query filter." },
-          update: { type: "object", description: 'Update operations (e.g., { "$set": { "status": "inactive" } }).' },
-          upsert: { type: "boolean", description: "Insert if no match found." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName", "filter", "update"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/updateOne",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          filter: "{filter}",
-          update: "{update}",
-          upsert: "{upsert}"
-        }
-      },
-      cas: "optimistic-read-verify"
-    },
-    {
-      name: "documents.updateMany",
-      class: "mutation",
-      description: "Update multiple documents matching a filter.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          filter: { type: "object", description: "Query filter." },
-          update: { type: "object", description: "Update operations." },
-          upsert: { type: "boolean", description: "Insert if no match found." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName", "filter", "update"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/updateMany",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          filter: "{filter}",
-          update: "{update}",
-          upsert: "{upsert}"
-        }
-      },
-      cas: "optimistic-read-verify"
-    },
-    {
-      name: "documents.replaceOne",
-      class: "mutation",
-      description: "Replace a single document entirely.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          filter: { type: "object", description: "Query filter." },
-          replacement: { type: "object", description: "Replacement document." },
-          upsert: { type: "boolean", description: "Insert if no match found." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName", "filter", "replacement"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/replaceOne",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          filter: "{filter}",
-          replacement: "{replacement}",
-          upsert: "{upsert}"
-        }
-      },
-      cas: "etag-if-match"
-    },
-    {
-      name: "documents.deleteOne",
-      class: "mutation",
-      description: "Delete a single document matching a filter.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          filter: { type: "object", description: "Query filter." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName", "filter"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/deleteOne",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          filter: "{filter}"
-        }
-      },
-      cas: "native-idempotency"
-    },
-    {
-      name: "documents.deleteMany",
-      class: "mutation",
-      description: "Delete multiple documents matching a filter.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          filter: { type: "object", description: "Query filter." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName", "filter"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/deleteMany",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          filter: "{filter}"
-        }
-      },
-      cas: "native-idempotency"
-    },
-    {
-      name: "documents.aggregate",
-      class: "read",
-      description: "Run an aggregation pipeline over a collection.",
-      parameters: {
-        type: "object",
-        properties: {
-          appId: { type: "string", description: "MongoDB Data API application ID." },
-          dataSourceName: { type: "string", description: "Data source name." },
-          databaseName: { type: "string", description: "Database name." },
-          collectionName: { type: "string", description: "Collection name." },
-          pipeline: { type: "array", items: { type: "object" }, description: "Aggregation stages." }
-        },
-        required: ["appId", "dataSourceName", "databaseName", "collectionName", "pipeline"]
-      },
-      request: {
-        method: "POST",
-        path: "/{appId}/endpoint/data/v1/action/aggregate",
-        body: {
-          dataSource: "{dataSourceName}",
-          database: "{databaseName}",
-          collection: "{collectionName}",
-          pipeline: "{pipeline}"
-        }
-      }
-    }
-  ]
-});
-
 // src/connectors/adapters/nifty.ts
 var niftyConnector = declarativeRestConnector({
   kind: "nifty",
@@ -125588,45 +126128,6 @@ var pollybotAiConnector = declarativeRestConnector({
   ]
 });
 
-// src/connectors/adapters/postgres.ts
-var postgresConnector = declarativeRestConnector({
-  kind: "postgres",
-  displayName: "PostgreSQL",
-  description: "Execute queries and monitor PostgreSQL databases.",
-  auth: { kind: "api-key", hint: "PostgreSQL connection credentials." },
-  category: "database",
-  defaultConsistencyModel: "authoritative",
-  baseUrl: "postgresql://",
-  test: { method: "GET", path: "/" },
-  capabilities: [
-    {
-      name: "query.execute",
-      class: "read",
-      description: "Execute a SQL query against the database.",
-      parameters: {
-        type: "object",
-        properties: {
-          host: { type: "string", description: "PostgreSQL server hostname" },
-          port: { type: "integer", description: "PostgreSQL server port" },
-          user: { type: "string", description: "Database user" },
-          password: { type: "string", description: "Database password" },
-          database: { type: "string", description: "Database name" },
-          query: { type: "string", description: "SQL query to execute" },
-          args: { type: "array", description: "Query arguments for parameterized queries" },
-          query_timeout: { type: "integer", description: "Query timeout in milliseconds" },
-          connection_timeout_ms: { type: "integer", description: "Connection timeout in milliseconds" },
-          application_name: { type: "string", description: "Application name for the connection" },
-          enable_ssl: { type: "boolean", description: "Enable SSL connection" },
-          reject_unauthorized: { type: "boolean", description: "Verify server certificate" },
-          certificate: { type: "string", description: "CA certificate for SSL verification" }
-        },
-        required: ["host", "port", "user", "password", "database", "query"]
-      },
-      request: { method: "POST", path: "/query", body: "{query}" }
-    }
-  ]
-});
-
 // src/connectors/adapters/postiz.ts
 var postizConnector = declarativeRestConnector({
   kind: "postiz",
@@ -145721,7 +146222,10 @@ export {
   mastodonConnector,
   meetgeekAiConnector,
   mollieConnector,
+  miroConnector,
   mondayConnector,
+  createMongoDbConnector,
+  mongodbConnector,
   mycaseConnector,
   notionConnector,
   notion,
@@ -145743,6 +146247,10 @@ export {
   rabbitMqConnector,
   createRedisConnector,
   redisConnector,
+  createRedshiftConnector,
+  redshiftConnector,
+  createPostgresConnector,
+  postgresConnector,
   recallAiConnector,
   rampConnector,
   ringcentralConnector,
@@ -145817,6 +146325,7 @@ export {
   builtwithConnector,
   fullenrichConnector,
   hunterConnector,
+  neverbounceConnector,
   theirstackConnector,
   zerobounceConnector,
   CONNECTOR_ADAPTER_FACTORIES,
@@ -145842,7 +146351,6 @@ export {
   sanityConnector,
   figmaConnector,
   figjamConnector,
-  miroConnector,
   canvaConnector,
   adobeCreativeCloudConnector,
   clioConnector,
@@ -146062,7 +146570,6 @@ export {
   mailchainConnector,
   medullarConnector,
   mindStudioConnector,
-  mongodbConnector,
   niftyConnector,
   nocodbConnector,
   ntfyConnector,
@@ -146088,7 +146595,6 @@ export {
   plausibleConnector,
   pocketbaseConnector,
   pollybotAiConnector,
-  postgresConnector,
   postizConnector,
   posthogConnector,
   predictLeadsConnector,
@@ -146203,4 +146709,4 @@ export {
   demandbaseConnector,
   adapters_exports
 };
-//# sourceMappingURL=chunk-FOIC32DF.js.map
+//# sourceMappingURL=chunk-XGKE6JW4.js.map