@tangle-network/agent-integrations 0.52.0 → 0.53.1

package/dist/{chunk-XEJKVCXB.js → chunk-5QWQFX2Q.js}

@@ -14,7 +14,7 @@ import {
   TangleIdentityUnreachableError,
   createTangleIdentityClient,
   tangleIdentity
-} from "./chunk-UWF33ESC.js";
+} from "./chunk-PDV6QQTH.js";
 import {
   __export
 } from "./chunk-PZ5AY32C.js";
@@ -32,6 +32,7 @@ __export(adapters_exports, {
   acumbamailConnector: () => acumbamailConnector,
   adobeCreativeCloudConnector: () => adobeCreativeCloudConnector,
   adpConnector: () => adpConnector,
+  affinityConnector: () => affinityConnector,
   afforaiConnector: () => afforaiConnector,
   agentxConnector: () => agentxConnector,
   aidbaseConnector: () => aidbaseConnector,
@@ -44,6 +45,7 @@ __export(adapters_exports, {
   altTextAiConnector: () => altTextAiConnector,
   alttextifyConnector: () => alttextifyConnector,
   amazonBedrockConnector: () => amazonBedrockConnector,
+  amazonS3Connector: () => amazonS3Connector,
   amazonSecretsManagerConnector: () => amazonSecretsManagerConnector,
   amazonSesConnector: () => amazonSesConnector,
   amazonSnsConnector: () => amazonSnsConnector,
@@ -263,6 +265,7 @@ __export(adapters_exports, {
   heyreachConnector: () => heyreachConnector,
   hightouchConnector: () => hightouchConnector,
   housecallProConnector: () => housecallProConnector,
+  httpConnector: () => httpConnector,
   hubspot: () => hubspot,
   huggingFaceConnector: () => huggingFaceConnector,
   huggingfaceConnector: () => huggingfaceConnector,
@@ -443,6 +446,7 @@ __export(adapters_exports, {
   ringcentralConnector: () => ringcentralConnector,
   ripplingConnector: () => ripplingConnector,
   robollyConnector: () => robollyConnector,
+  rssConnector: () => rssConnector,
   runwareConnector: () => runwareConnector,
   saasticConnector: () => saasticConnector,
   saleorConnector: () => saleorConnector,
@@ -568,6 +572,7 @@ __export(adapters_exports, {
   zohoBookingsConnector: () => zohoBookingsConnector,
   zohoCrmConnector: () => zohoCrmConnector,
   zohoDeskConnector: () => zohoDeskConnector,
+  zoomConnector: () => zoomConnector,
   zoominfoConnector: () => zoominfoConnector,
   zuoraConnector: () => zuoraConnector
 });
@@ -999,6 +1004,19 @@ function declarativeRestConnector(spec) {
     async executeRead(inv) {
       const op = readOperation(spec, inv.capabilityName, "read");
       const response = await executeRestRequest(spec, op.request, inv, requiredArgsOf(op.parameters));
+      if (response.outcome === "rate-limited") {
+        const retryAfterMs = response.retryAfterMs ?? DEFAULT_RETRY_AFTER_MS;
+        throw new ProviderRateLimited(
+          `${spec.displayName} ${inv.capabilityName} rate limit (429); retry after ${retryAfterMs}ms`,
+          inv.source.id,
+          { status: 429, body: response.data, retryAfterMs }
+        );
+      }
+      if (response.outcome === "conflict") {
+        throw new Error(
+          `${spec.kind} ${op.request.method} ${op.request.path} HTTP ${response.status ?? 409}: ${(response.message ?? "").slice(0, 300)}`
+        );
+      }
       return {
         data: response.data,
         etag: response.etag,
@@ -1008,31 +1026,7 @@ function declarativeRestConnector(spec) {
     async executeMutation(inv) {
       const op = readOperation(spec, inv.capabilityName, "mutation");
       const response = await executeRestRequest(spec, op.request, inv, requiredArgsOf(op.parameters));
-      if (response.outcome === "conflict") {
-        return {
-          status: "conflict",
-          alternatives: [],
-          // The upstream's parsed body — the contract calls this "the current
-          // authoritative state", so it must be what the provider returned,
-          // not the transport's own wrapper.
-          currentState: response.data,
-          message: response.message || `${spec.displayName} rejected the write on a state conflict`
-        };
-      }
-      if (response.outcome === "rate-limited") {
-        return {
-          status: "rate-limited",
-          retryAfterMs: response.retryAfterMs ?? DEFAULT_RETRY_AFTER_MS,
-          message: response.message || `${spec.displayName} throttled the write`
-        };
-      }
-      return {
-        status: "committed",
-        data: response.data,
-        etagAfter: response.etag,
-        committedAt: Date.now(),
-        idempotentReplay: false
-      };
+      return mutationResultFromTransport(spec.displayName, response);
     },
     async test(source) {
       if (!spec.test) return { ok: true };
@@ -1043,6 +1037,12 @@ function declarativeRestConnector(spec) {
           args: {},
           idempotencyKey: "test"
         });
+        if (response.outcome) {
+          return {
+            ok: false,
+            reason: response.message || `${spec.displayName} test request was ${response.outcome}`
+          };
+        }
         validateTestResponse(spec, spec.test, response.data);
         return { ok: true };
       } catch (error) {
@@ -1099,6 +1099,33 @@ function requiredArgsOf(parameters) {
   const required = parameters.required;
   return Array.isArray(required) ? required.filter((entry) => typeof entry === "string") : void 0;
 }
+function mutationResultFromTransport(displayName, response) {
+  if (response.outcome === "conflict") {
+    return {
+      status: "conflict",
+      alternatives: [],
+      // The upstream's parsed body — the contract calls this "the current
+      // authoritative state", so it must be what the provider returned,
+      // not the transport's own wrapper.
+      currentState: response.data,
+      message: response.message || `${displayName} rejected the write on a state conflict`
+    };
+  }
+  if (response.outcome === "rate-limited") {
+    return {
+      status: "rate-limited",
+      retryAfterMs: response.retryAfterMs ?? DEFAULT_RETRY_AFTER_MS,
+      message: response.message || `${displayName} throttled the write`
+    };
+  }
+  return {
+    status: "committed",
+    data: response.data,
+    etagAfter: response.etag,
+    committedAt: Date.now(),
+    idempotentReplay: false
+  };
+}
 async function executeRestRequest(spec, request, inv, requiredArgs) {
   const placement = spec.credentialPlacement ?? { kind: "bearer" };
   const aws = placement.kind === "aws-sigv4" ? parseAwsCredentialBundle(inv.source.credentials) : void 0;
@@ -1153,6 +1180,7 @@ async function executeRestRequest(spec, request, inv, requiredArgs) {
     return {
       data: parseBodyText(text2),
       outcome: "conflict",
+      status: res.status,
       message: text2,
       etag: res.headers.get("etag") ?? void 0
     };
@@ -1162,6 +1190,7 @@ async function executeRestRequest(spec, request, inv, requiredArgs) {
     return {
       data: parseBodyText(text2),
       outcome: "rate-limited",
+      status: res.status,
       message: text2,
       retryAfterMs: retryAfterMsFromHeader(res.headers.get("retry-after"))
     };
@@ -7398,13 +7427,7 @@ async function databasesUpdate(inv) {
     { method: "PATCH", path: "/databases/{databaseId}", body },
     inv
   );
-  return {
-    status: "committed",
-    data: response.data,
-    etagAfter: response.etag,
-    committedAt: Date.now(),
-    idempotentReplay: false
-  };
+  return mutationResultFromTransport(NOTION_SPEC.displayName, response);
 }
 function withNotionOverrides(base) {
   return {
@@ -14008,6 +14031,910 @@ function signHeaders(creds, body, idempotencyKey) {
   return headers;
 }
 
+// src/connectors/adapters/public-http-target.ts
+function assertPublicHttpTarget(url, label) {
+  const hostname = url.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (hostname === "localhost" || hostname.endsWith(".localhost") || hostname.endsWith(".local") || hostname === "metadata.google.internal") {
+    throw new Error(`${label} host is not a public network target`);
+  }
+  if (isPrivateIpv4(hostname) || isPrivateIpv6(hostname)) {
+    throw new Error(`${label} host is not a public network target`);
+  }
+}
+function isPrivateIpv4(hostname) {
+  const parts = hostname.split(".");
+  if (parts.length !== 4 || parts.some((part) => !/^\d{1,3}$/.test(part))) return false;
+  const octets = parts.map(Number);
+  if (octets.some((octet) => octet > 255)) return false;
+  const [a, b] = octets;
+  return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 198 && (b === 18 || b === 19) || a >= 224;
+}
+function isPrivateIpv6(hostname) {
+  const normalized = hostname.toLowerCase();
+  if (normalized === "::" || normalized === "::1") return true;
+  if (/^f[cd]/.test(normalized) || /^fe[89ab]/.test(normalized)) return true;
+  const mapped = normalized.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/);
+  return mapped ? isPrivateIpv4(mapped[1]) : false;
+}
+
+// src/connectors/adapters/http.ts
+var ALLOWED_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:"]);
+var READ_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+var MUTATION_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var MAX_TIMEOUT_MS = 6e4;
+var DEFAULT_TIMEOUT_MS = 15e3;
+var httpConnector = {
+  manifest: {
+    kind: "http",
+    displayName: "HTTP Request",
+    description: "Send an arbitrary HTTP request to any http(s) URL. Useful for hitting one-off APIs, probes, public JSON feeds, or operator-controlled webhooks. No shared auth \u2014 the agent supplies the full URL, method, headers, and body at invocation time.",
+    auth: { kind: "none" },
+    category: "webhook",
+    defaultConsistencyModel: "advisory",
+    capabilities: [
+      {
+        name: "request.fetch",
+        class: "read",
+        description: "Issue a GET/HEAD/OPTIONS request to a URL. Returns the parsed JSON body if the response Content-Type is application/json, otherwise the raw text. The `etag` of the response (when present) is exposed for downstream conditional reads.",
+        parameters: {
+          type: "object",
+          properties: {
+            url: { type: "string", description: "Absolute http(s) URL to fetch." },
+            method: {
+              type: "string",
+              enum: ["GET", "HEAD", "OPTIONS"],
+              description: "HTTP verb. Defaults to GET."
+            },
+            headers: {
+              type: "object",
+              description: "Optional request headers. Header names are lower-cased before send.",
+              additionalProperties: { type: "string" }
+            },
+            query: {
+              type: "object",
+              description: "Optional query-string parameters. Values are coerced to string; arrays become repeated keys.",
+              additionalProperties: true
+            },
+            timeoutMs: {
+              type: "number",
+              description: `Per-request timeout in milliseconds. Defaults to ${DEFAULT_TIMEOUT_MS}, capped at ${MAX_TIMEOUT_MS}.`
+            }
+          },
+          required: ["url"]
+        }
+      },
+      {
+        name: "request.send",
+        class: "mutation",
+        description: "Issue a POST/PUT/PATCH/DELETE request to a URL. The agent supplies the body verbatim \u2014 pass an object for JSON, a string for raw text. The idempotency key is forwarded as the `Idempotency-Key` header; receivers that honour it (Stripe, Square, many SaaS APIs) dedupe automatically.",
+        parameters: {
+          type: "object",
+          properties: {
+            url: { type: "string", description: "Absolute http(s) URL to call." },
+            method: {
+              type: "string",
+              enum: ["POST", "PUT", "PATCH", "DELETE"],
+              description: "HTTP verb. Defaults to POST."
+            },
+            headers: {
+              type: "object",
+              description: "Optional request headers. Header names are lower-cased before send.",
+              additionalProperties: { type: "string" }
+            },
+            query: {
+              type: "object",
+              description: "Optional query-string parameters appended to the URL.",
+              additionalProperties: true
+            },
+            body: {
+              description: "Request body. Objects are JSON-encoded with `content-type: application/json`; strings are sent verbatim with the caller-supplied content-type (defaulting to text/plain)."
+            },
+            timeoutMs: {
+              type: "number",
+              description: `Per-request timeout in milliseconds. Defaults to ${DEFAULT_TIMEOUT_MS}, capped at ${MAX_TIMEOUT_MS}.`
+            }
+          },
+          required: ["url"]
+        },
+        cas: "none",
+        externalEffect: true
+      }
+    ]
+  },
+  async executeRead(inv) {
+    const args = inv.args ?? {};
+    const method = readMethod(args.method, "GET", READ_METHODS, "request.fetch");
+    const url = buildUrl(readUrl(args.url), args.query);
+    const headers = mergeHeaders(args.headers, inv.idempotencyKey, false, void 0);
+    const res = await fetch(url.toString(), {
+      method,
+      headers,
+      signal: AbortSignal.timeout(readTimeout(args.timeoutMs))
+    });
+    const data = await parseResponse(res, method);
+    if (!res.ok) {
+      throw new Error(`http ${method} ${url.toString()} failed: ${res.status} ${truncate(stringify(data), 200)}`);
+    }
+    return {
+      data,
+      etag: res.headers.get("etag") ?? void 0,
+      fetchedAt: Date.now()
+    };
+  },
+  async executeMutation(inv) {
+    const args = inv.args ?? {};
+    const method = readMethod(args.method, "POST", MUTATION_METHODS, "request.send");
+    const url = buildUrl(readUrl(args.url), args.query);
+    const { body, contentType } = encodeBody(args.body);
+    const headers = mergeHeaders(args.headers, inv.idempotencyKey, true, contentType);
+    const res = await fetch(url.toString(), {
+      method,
+      headers,
+      body,
+      signal: AbortSignal.timeout(readTimeout(args.timeoutMs))
+    });
+    const data = await parseResponse(res, method);
+    if (res.status === 409) {
+      const message = typeof data === "object" && data !== null && "message" in data && typeof data.message === "string" ? data.message : `http ${method} ${url.toString()} returned 409`;
+      const alternatives = typeof data === "object" && data !== null && Array.isArray(data.alternatives) ? data.alternatives : [];
+      return { status: "conflict", alternatives, message, currentState: data };
+    }
+    if (res.status === 429) {
+      const retryAfter = parseRetryAfterMs(res.headers.get("retry-after"));
+      return {
+        status: "rate-limited",
+        retryAfterMs: retryAfter,
+        message: `http ${method} ${url.toString()} rate-limited; retry after ${retryAfter}ms`
+      };
+    }
+    if (!res.ok) {
+      throw new Error(`http ${method} ${url.toString()} failed: ${res.status} ${truncate(stringify(data), 200)}`);
+    }
+    return {
+      status: "committed",
+      data,
+      etagAfter: res.headers.get("etag") ?? void 0,
+      committedAt: Date.now(),
+      idempotentReplay: false
+    };
+  },
+  async test() {
+    return { ok: true };
+  }
+};
+function readUrl(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error("http.url is required");
+  }
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw new Error(`http.url is not a valid absolute URL: ${value}`);
+  }
+  if (!ALLOWED_SCHEMES.has(parsed.protocol)) {
+    throw new Error(`http.url scheme not allowed: ${parsed.protocol} (only http: and https: are accepted)`);
+  }
+  assertPublicHttpTarget(parsed, "http.url");
+  return parsed;
+}
+function readMethod(value, fallback, allowed, capability) {
+  if (value === void 0 || value === null) return fallback;
+  if (typeof value !== "string") {
+    throw new Error(`http.method must be a string for ${capability}`);
+  }
+  const upper = value.toUpperCase();
+  if (!allowed.has(upper)) {
+    throw new Error(
+      `http.method ${upper} not allowed for ${capability} (allowed: ${[...allowed].sort().join(", ")})`
+    );
+  }
+  return upper;
+}
+function readTimeout(value) {
+  if (value === void 0 || value === null) return DEFAULT_TIMEOUT_MS;
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    throw new Error("http.timeoutMs must be a positive finite number");
+  }
+  return Math.min(Math.floor(value), MAX_TIMEOUT_MS);
+}
+function buildUrl(base, query) {
+  if (query === void 0 || query === null) return base;
+  if (typeof query !== "object") {
+    throw new Error("http.query must be an object of string/number/boolean values (or arrays of those)");
+  }
+  const url = new URL(base.toString());
+  for (const [key, raw] of Object.entries(query)) {
+    if (raw === void 0 || raw === null) continue;
+    if (Array.isArray(raw)) {
+      for (const entry of raw) url.searchParams.append(key, scalarToString(entry, key));
+      continue;
+    }
+    url.searchParams.set(key, scalarToString(raw, key));
+  }
+  return url;
+}
+function scalarToString(value, key) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  throw new Error(`http.query.${key} must be string, number, boolean, or an array of those`);
+}
+function mergeHeaders(raw, idempotencyKey, isMutation, bodyContentType) {
+  const headers = new Headers();
+  headers.set("accept", "application/json, */*;q=0.1");
+  if (raw !== void 0 && raw !== null) {
+    if (typeof raw !== "object") {
+      throw new Error("http.headers must be an object of string values");
+    }
+    for (const [name, value] of Object.entries(raw)) {
+      if (value === void 0 || value === null) continue;
+      if (typeof value !== "string") {
+        throw new Error(`http.headers.${name} must be a string`);
+      }
+      headers.set(name.toLowerCase(), value);
+    }
+  }
+  if (isMutation) {
+    if (bodyContentType && !headers.has("content-type")) {
+      headers.set("content-type", bodyContentType);
+    }
+    if (!headers.has("idempotency-key")) {
+      headers.set("idempotency-key", idempotencyKey);
+    }
+  }
+  return headers;
+}
+function encodeBody(raw) {
+  if (raw === void 0 || raw === null) return { body: void 0, contentType: void 0 };
+  if (typeof raw === "string") return { body: raw, contentType: "text/plain;charset=utf-8" };
+  if (typeof raw === "number" || typeof raw === "boolean") {
+    return { body: String(raw), contentType: "text/plain;charset=utf-8" };
+  }
+  if (raw instanceof ArrayBuffer) return { body: raw, contentType: "application/octet-stream" };
+  if (typeof raw === "object") {
+    return { body: JSON.stringify(raw), contentType: "application/json" };
+  }
+  throw new Error(`http.body must be string, number, boolean, object, or ArrayBuffer (got ${typeof raw})`);
+}
+async function parseResponse(res, method) {
+  if (method === "HEAD") return null;
+  const contentType = res.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json") || contentType.includes("+json")) {
+    const text = await res.text();
+    if (text.length === 0) return null;
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  return await res.text();
+}
+function parseRetryAfterMs(header2) {
+  if (!header2) return 1e3;
+  const seconds = Number(header2);
+  if (Number.isFinite(seconds) && seconds >= 0) return Math.floor(seconds * 1e3);
+  const date = Date.parse(header2);
+  if (!Number.isFinite(date)) return 1e3;
+  return Math.max(0, date - Date.now());
+}
+function stringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function truncate(value, limit) {
+  return value.length > limit ? `${value.slice(0, limit)}\u2026` : value;
+}
+
+// src/connectors/adapters/rss.ts
+var ALLOWED_SCHEMES2 = /* @__PURE__ */ new Set(["http:", "https:"]);
+var DEFAULT_LIMIT = 20;
+var MAX_LIMIT = 200;
+var DEFAULT_TIMEOUT_MS2 = 15e3;
+var MAX_BODY_BYTES = 5 * 1024 * 1024;
+var READ_CAPABILITIES = [
+  {
+    name: "feed.fetch",
+    class: "read",
+    description: "Fetch and parse the RSS/Atom feed URL pinned in DataSource.metadata.feedUrl. Returns normalized entries newest-first. Forwards the upstream ETag/Last-Modified so downstream conditional reads can avoid re-parsing unchanged feeds.",
+    parameters: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: `Maximum entries to return, newest first. Defaults to ${DEFAULT_LIMIT}, capped at ${MAX_LIMIT}.`
+        },
+        since: {
+          type: "string",
+          description: "ISO-8601 timestamp. When set, entries with `published` (or `updated` for Atom) strictly older than this are dropped."
+        }
+      }
+    }
+  },
+  {
+    name: "feed.lookup",
+    class: "read",
+    description: "Fetch and parse an arbitrary RSS/Atom feed URL the agent constructs at request time (e.g. search-result feeds, comment streams). Same normalization as `feed.fetch`.",
+    parameters: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "Absolute http(s) URL of the feed to fetch." },
+        limit: {
+          type: "number",
+          description: `Maximum entries to return, newest first. Defaults to ${DEFAULT_LIMIT}, capped at ${MAX_LIMIT}.`
+        },
+        since: {
+          type: "string",
+          description: "ISO-8601 timestamp. When set, entries with `published` (or `updated` for Atom) strictly older than this are dropped."
+        }
+      },
+      required: ["url"]
+    }
+  }
+];
+var rssConnector = {
+  manifest: {
+    kind: "rss",
+    displayName: "RSS / Atom Feed",
+    description: "Pull entries from any public RSS 2.0 or Atom 1.0 feed. No auth required \u2014 the operator pins one feed URL at connect time (`feed.fetch`), and the agent can also resolve ad-hoc feed URLs at request time (`feed.lookup`). The connector parses both formats and emits a normalized entry shape so downstream tools do not have to branch on the feed dialect.",
+    auth: { kind: "none" },
+    category: "webhook",
+    defaultConsistencyModel: "cache",
+    capabilities: READ_CAPABILITIES
+  },
+  async executeRead(inv) {
+    const args = inv.args ?? {};
+    const url = inv.capabilityName === "feed.lookup" ? readUrl2(args.url, "feed.lookup.url") : readUrl2(readPinnedFeedUrl(inv.source), "DataSource.metadata.feedUrl");
+    const limit = clampLimit2(args.limit);
+    const since = readSinceMs(args.since);
+    const res = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        accept: "application/rss+xml, application/atom+xml, application/xml;q=0.9, text/xml;q=0.8, */*;q=0.1",
+        "user-agent": "tangle-agent-integrations-rss/1.0"
+      },
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS2)
+    });
+    if (!res.ok) {
+      throw new Error(`rss fetch ${res.status} ${res.statusText} for ${url.toString()}`);
+    }
+    const body = await readBoundedText(res, MAX_BODY_BYTES);
+    const parsed = parseFeed(body, url.toString());
+    const filtered = filterAndLimit(parsed.entries, since, limit);
+    const data = {
+      feedTitle: parsed.feedTitle,
+      feedUrl: url.toString(),
+      feedUpdated: parsed.feedUpdated,
+      entries: filtered,
+      format: parsed.format
+    };
+    return {
+      data,
+      etag: res.headers.get("etag") ?? res.headers.get("last-modified") ?? void 0,
+      fetchedAt: Date.now()
+    };
+  },
+  async test(source) {
+    const raw = source.metadata?.feedUrl;
+    if (typeof raw !== "string" || raw.length === 0) {
+      return { ok: true };
+    }
+    let url;
+    try {
+      url = new URL(raw);
+    } catch {
+      return { ok: false, reason: `feedUrl is not a valid absolute URL: ${raw}` };
+    }
+    if (!ALLOWED_SCHEMES2.has(url.protocol)) {
+      return { ok: false, reason: `feedUrl scheme not allowed: ${url.protocol}` };
+    }
+    try {
+      const res = await fetch(url.toString(), {
+        method: "HEAD",
+        headers: { "user-agent": "tangle-agent-integrations-rss/1.0" },
+        signal: AbortSignal.timeout(8e3)
+      });
+      if (res.status >= 500) return { ok: false, reason: `feedUrl returned ${res.status}` };
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, reason: err instanceof Error ? err.message : String(err) };
+    }
+  }
+};
+function readPinnedFeedUrl(source) {
+  return source.metadata?.feedUrl;
+}
+function readUrl2(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${label} is required`);
+  }
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw new Error(`${label} is not a valid absolute URL: ${value}`);
+  }
+  if (!ALLOWED_SCHEMES2.has(parsed.protocol)) {
+    throw new Error(`${label} scheme not allowed: ${parsed.protocol} (only http: and https: are accepted)`);
+  }
+  assertPublicHttpTarget(parsed, label);
+  return parsed;
+}
+function clampLimit2(value) {
+  if (value === void 0 || value === null) return DEFAULT_LIMIT;
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    throw new Error("rss.limit must be a positive finite number");
+  }
+  return Math.min(Math.floor(value), MAX_LIMIT);
+}
+function readSinceMs(value) {
+  if (value === void 0 || value === null) return null;
+  if (typeof value !== "string") {
+    throw new Error("rss.since must be an ISO-8601 string");
+  }
+  const ms = Date.parse(value);
+  if (!Number.isFinite(ms)) {
+    throw new Error(`rss.since is not a valid date: ${value}`);
+  }
+  return ms;
+}
+async function readBoundedText(res, maxBytes) {
+  const reader = res.body?.getReader();
+  if (!reader) return await res.text();
+  const decoder = new TextDecoder("utf-8", { fatal: false });
+  let out = "";
+  let total = 0;
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    total += value.byteLength;
+    if (total > maxBytes) {
+      try {
+        await reader.cancel();
+      } catch {
+      }
+      throw new Error(`rss feed body exceeded ${maxBytes} bytes`);
+    }
+    out += decoder.decode(value, { stream: true });
+  }
+  out += decoder.decode();
+  return out;
+}
+function filterAndLimit(entries, sinceMs, limit) {
+  let filtered = entries;
+  if (sinceMs !== null) {
+    filtered = entries.filter((entry) => {
+      const ts = entry.published ?? entry.updated;
+      if (!ts) return true;
+      const ms = Date.parse(ts);
+      if (!Number.isFinite(ms)) return true;
+      return ms >= sinceMs;
+    });
+  }
+  return filtered.slice(0, limit);
+}
+function parseFeed(body, feedUrl) {
+  const text = body.replace(/^/, "").trimStart();
+  const rssIdx = text.search(/<rss\b/i);
+  const atomIdx = text.search(/<feed\b/i);
+  if (rssIdx === -1 && atomIdx === -1) {
+    return { feedTitle: null, feedUpdated: null, entries: [], format: "unknown" };
+  }
+  if (atomIdx !== -1 && (rssIdx === -1 || atomIdx < rssIdx)) {
+    return parseAtom(text, feedUrl);
+  }
+  return parseRss(text);
+}
+function parseRss(text) {
+  const channelOuter = extractFirstElement(text, "channel");
+  if (!channelOuter) {
+    return { feedTitle: null, feedUpdated: null, entries: [], format: "rss" };
+  }
+  const channelInner = stripAllElements(channelOuter, "item");
+  const feedTitle = decodeXml(firstTagText(channelInner, "title"));
+  const items = collectElements(channelOuter, "item");
+  const entries = items.map((item) => {
+    const guid = firstTagText(item, "guid");
+    const link = firstTagText(item, "link");
+    const title = firstTagText(item, "title");
+    const description = firstTagText(item, "description");
+    const contentEncoded = firstTagText(item, "content:encoded");
+    const pubDate = firstTagText(item, "pubDate");
+    const author = firstTagText(item, "author") ?? firstTagText(item, "dc:creator");
+    const categories = collectElements(item, "category").map((cat) => decodeXml(stripTags(cat)) ?? "").filter(Boolean);
+    const id = decodeXml(guid) ?? decodeXml(link) ?? hash(item);
+    return {
+      id,
+      title: decodeXml(title),
+      link: decodeXml(link),
+      summary: decodeXml(description),
+      content: decodeXml(contentEncoded),
+      published: normalizeDate(decodeXml(pubDate)),
+      updated: null,
+      author: decodeXml(author),
+      categories
+    };
+  });
+  return { feedTitle, feedUpdated: null, entries, format: "rss" };
+}
+function parseAtom(text, feedUrl) {
+  const feedOuter = extractFirstElement(text, "feed") ?? text;
+  const feedInner = stripAllElements(feedOuter, "entry");
+  const feedTitle = decodeXml(firstTagText(feedInner, "title"));
+  const feedUpdated = normalizeDate(decodeXml(firstTagText(feedInner, "updated")));
+  const items = collectElements(feedOuter, "entry");
+  const entries = items.map((item) => {
+    const id = decodeXml(firstTagText(item, "id"));
+    const title = decodeXml(firstTagText(item, "title"));
+    const summary = decodeXml(firstTagText(item, "summary"));
+    const contentNode = firstTagText(item, "content");
+    const published = normalizeDate(decodeXml(firstTagText(item, "published")));
+    const updated = normalizeDate(decodeXml(firstTagText(item, "updated")));
+    const author = decodeXml(firstTagText(extractFirstElement(item, "author") ?? "", "name")) ?? decodeXml(firstTagText(item, "author"));
+    const link = pickAtomLink(item);
+    const categories = collectAtomCategories(item);
+    return {
+      id: id ?? link ?? hash(item),
+      title,
+      link,
+      summary,
+      content: decodeXml(contentNode),
+      published,
+      updated,
+      author,
+      categories
+    };
+  });
+  return { feedTitle, feedUpdated, entries, format: "atom" };
+}
+function extractFirstElement(text, tag) {
+  const escaped = escapeRegex(tag);
+  const openRe = new RegExp(`<${escaped}\\b([^>]*)>`, "i");
+  const m = openRe.exec(text);
+  if (!m) return null;
+  const openEnd = m.index + m[0].length;
+  if (m[0].endsWith("/>")) return m[0];
+  const closeRe = new RegExp(`</${escaped}\\s*>`, "gi");
+  closeRe.lastIndex = openEnd;
+  const close = closeRe.exec(text);
+  if (!close) return text.slice(m.index);
+  return text.slice(m.index, close.index + close[0].length);
+}
+function collectElements(text, tag) {
+  const escaped = escapeRegex(tag);
+  const out = [];
+  const openRe = new RegExp(`<${escaped}\\b([^>]*)>`, "gi");
+  let m;
+  while ((m = openRe.exec(text)) !== null) {
+    const start = m.index;
+    if (m[0].endsWith("/>")) {
+      out.push(m[0]);
+      continue;
+    }
+    const after = m.index + m[0].length;
+    const closeRe = new RegExp(`</${escaped}\\s*>`, "gi");
+    closeRe.lastIndex = after;
+    const close = closeRe.exec(text);
+    if (!close) break;
+    out.push(text.slice(start, close.index + close[0].length));
+    openRe.lastIndex = close.index + close[0].length;
+  }
+  return out;
+}
+function stripAllElements(text, tag) {
+  const escaped = escapeRegex(tag);
+  let out = text;
+  const re = new RegExp(`<${escaped}\\b[^>]*>[\\s\\S]*?</${escaped}\\s*>`, "gi");
+  out = out.replace(re, "");
+  const selfRe = new RegExp(`<${escaped}\\b[^>]*/>`, "gi");
+  out = out.replace(selfRe, "");
+  return out;
+}
+function firstTagText(text, tag) {
+  const escaped = escapeRegex(tag);
+  const re = new RegExp(`<${escaped}\\b([^>]*)>([\\s\\S]*?)</${escaped}\\s*>`, "i");
+  const m = re.exec(text);
+  if (m) return unwrapCdata(m[2]);
+  const selfRe = new RegExp(`<${escaped}\\b([^>]*)/>`, "i");
+  const sm = selfRe.exec(text);
+  if (sm) return null;
+  return null;
+}
+function pickAtomLink(entryOuter) {
+  const linkRe = /<link\b([^>]*)\/?>(?:([\s\S]*?)<\/link\s*>)?/gi;
+  let bestHref = null;
+  let fallback = null;
+  let m;
+  while ((m = linkRe.exec(entryOuter)) !== null) {
+    const attrs = m[1] ?? "";
+    const href = readAttr(attrs, "href");
+    if (!href) continue;
+    const rel = readAttr(attrs, "rel");
+    if (!fallback) fallback = href;
+    if (!rel || rel === "alternate") {
+      bestHref = href;
+      break;
+    }
+  }
+  return bestHref ?? fallback;
+}
+function collectAtomCategories(entryOuter) {
+  const out = [];
+  const re = /<category\b([^>]*)(?:\/>|>([\s\S]*?)<\/category\s*>)/gi;
+  let m;
+  while ((m = re.exec(entryOuter)) !== null) {
+    const term = readAttr(m[1] ?? "", "term");
+    if (term) out.push(decodeXml(term) ?? "");
+    else if (m[2]) {
+      const inner = decodeXml(stripTags(m[2]));
+      if (inner) out.push(inner);
+    }
+  }
+  return out.filter(Boolean);
+}
+function readAttr(attrs, name) {
+  const re = new RegExp(`\\b${escapeRegex(name)}\\s*=\\s*("([^"]*)"|'([^']*)')`, "i");
+  const m = re.exec(attrs);
+  if (!m) return null;
+  return m[2] ?? m[3] ?? null;
+}
+function stripTags(value) {
+  return value.replace(/<[^>]*>/g, "");
+}
+function unwrapCdata(value) {
+  const cdata = /<!\[CDATA\[([\s\S]*?)\]\]>/g;
+  let out = "";
+  let lastIdx = 0;
+  let m;
+  while ((m = cdata.exec(value)) !== null) {
+    out += value.slice(lastIdx, m.index);
+    out += m[1];
+    lastIdx = m.index + m[0].length;
+  }
+  out += value.slice(lastIdx);
+  return out;
+}
+function decodeXml(value) {
+  if (value === null) return null;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return null;
+  return trimmed.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&#(\d+);/g, (_, d) => {
+    const code = Number(d);
+    return Number.isFinite(code) ? String.fromCodePoint(code) : _;
+  }).replace(/&#x([0-9a-fA-F]+);/g, (_, h) => {
+    const code = parseInt(h, 16);
+    return Number.isFinite(code) ? String.fromCodePoint(code) : _;
+  }).replace(/&amp;/g, "&");
+}
+function normalizeDate(value) {
+  if (!value) return null;
+  const ms = Date.parse(value);
+  if (!Number.isFinite(ms)) return null;
+  return new Date(ms).toISOString();
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hash(value) {
+  let h = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    h ^= value.charCodeAt(i);
+    h = h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24)) >>> 0;
+  }
+  return `rss-${h.toString(16).padStart(8, "0")}`;
+}
+
+// src/connectors/adapters/amazon-s3.ts
+var amazonS3Connector = declarativeRestConnector({
+  kind: "amazon-s3",
+  displayName: "Amazon S3",
+  description: "Scalable storage in the cloud. Read, upload, delete, and manage files in S3 buckets.",
+  auth: {
+    kind: "api-key",
+    hint: 'AWS credentials as JSON: {"accessKeyId":"AKIA\u2026","secretAccessKey":"\u2026","region":"us-east-1"} for an IAM principal with S3 permissions. Optional "sessionToken" and "endpoint" (S3-compatible stores). Requests are signed with AWS Signature V4; the region selects the s3.<region>.amazonaws.com endpoint.'
+  },
+  category: "storage",
+  defaultConsistencyModel: "authoritative",
+  // S3 REST API, path-style. Each request is signed with AWS Signature V4
+  // (service `s3`, which signs the request path verbatim); the bundle's region
+  // is substituted into the `{region}` host template.
+  credentialPlacement: { kind: "aws-sigv4", service: "s3" },
+  baseUrl: "https://s3.{region}.amazonaws.com",
+  test: { method: "GET", path: "/" },
+  capabilities: [
+    {
+      name: "files.list",
+      class: "read",
+      description: "List files in an S3 bucket folder.",
+      parameters: {
+        type: "object",
+        properties: {
+          prefix: { type: "string", description: "Folder path to filter results (e.g., docs/)" },
+          maxKeys: { type: "integer", description: "Maximum number of files to return (1\u20131000)" }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/",
+        query: { prefix: "{prefix}", "max-keys": "{maxKeys}" }
+      }
+    },
+    {
+      name: "files.read",
+      class: "read",
+      description: "Read a file from S3.",
+      parameters: {
+        type: "object",
+        properties: {
+          key: { type: "string", description: "The full path to the file in S3" }
+        },
+        required: ["key"]
+      },
+      request: {
+        method: "GET",
+        path: "/{key}"
+      }
+    },
+    {
+      name: "files.upload",
+      class: "mutation",
+      description: "Upload a file to S3.",
+      parameters: {
+        type: "object",
+        properties: {
+          key: { type: "string", description: "The file path and name in S3" },
+          contentType: { type: "string", description: "MIME type of the file" }
+        },
+        required: ["key"]
+      },
+      request: {
+        method: "PUT",
+        path: "/{key}",
+        headers: { "Content-Type": "{contentType}" }
+      },
+      cas: "native-idempotency"
+    },
+    {
+      name: "files.delete",
+      class: "mutation",
+      description: "Delete a file from S3.",
+      parameters: {
+        type: "object",
+        properties: {
+          key: { type: "string", description: "The full path to the file to delete" }
+        },
+        required: ["key"]
+      },
+      request: {
+        method: "DELETE",
+        path: "/{key}"
+      },
+      cas: "optimistic-read-verify"
+    },
+    {
+      name: "files.generateSignedUrl",
+      class: "read",
+      description: "Generate a signed URL for temporary access to a file.",
+      parameters: {
+        type: "object",
+        properties: {
+          key: { type: "string", description: "The file path in S3" },
+          expiresIn: { type: "integer", description: "URL validity duration in minutes" }
+        },
+        required: ["key", "expiresIn"]
+      },
+      request: {
+        method: "GET",
+        path: "/{key}",
+        query: { "X-Amz-Expires": "{expiresIn}" }
+      }
+    },
+    {
+      name: "files.moveFile",
+      class: "mutation",
+      description: "Move a file to a different location in S3.",
+      parameters: {
+        type: "object",
+        properties: {
+          sourceKey: { type: "string", description: "Current file path" },
+          destinationKey: { type: "string", description: "New file path" }
+        },
+        required: ["sourceKey", "destinationKey"]
+      },
+      request: {
+        method: "PUT",
+        path: "/{destinationKey}",
+        headers: { "x-amz-copy-source": "{sourceKey}" }
+      },
+      cas: "optimistic-read-verify"
+    },
+    {
+      name: "files.copyFile",
+      class: "mutation",
+      description: "Server-side copy of an object to a new key. Source is left in place.",
+      parameters: {
+        type: "object",
+        properties: {
+          sourceKey: {
+            type: "string",
+            description: "Existing object identifier as {bucket}/{key}."
+          },
+          destinationKey: {
+            type: "string",
+            description: "New object key (relative to the destination bucket)."
+          }
+        },
+        required: ["sourceKey", "destinationKey"]
+      },
+      request: {
+        method: "PUT",
+        path: "/{destinationKey}",
+        headers: { "x-amz-copy-source": "{sourceKey}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "files.setMetadata",
+      class: "mutation",
+      description: "Replace object metadata in place via the S3 copy-self pattern (x-amz-metadata-directive: REPLACE).",
+      parameters: {
+        type: "object",
+        properties: {
+          key: { type: "string", description: "Object key whose metadata should be replaced." },
+          contentType: { type: "string", description: "New Content-Type for the object." },
+          metadata: {
+            type: "string",
+            description: "Serialized x-amz-meta-* JSON forwarded as the x-amz-meta-user header (caller-controlled)."
+          }
+        },
+        required: ["key"]
+      },
+      request: {
+        method: "PUT",
+        path: "/{key}",
+        headers: {
+          "x-amz-copy-source": "{key}",
+          "x-amz-metadata-directive": "REPLACE",
+          "Content-Type": "{contentType}",
+          "x-amz-meta-user": "{metadata}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "files.createBucket",
+      class: "mutation",
+      description: "Create a new bucket in the configured region. Request is a PUT against the bucket name path.",
+      parameters: {
+        type: "object",
+        properties: {
+          bucket: { type: "string", description: "Bucket name to create." },
+          region: {
+            type: "string",
+            description: "AWS region for the bucket (sent via x-amz-bucket-region)."
+          }
+        },
+        required: ["bucket"]
+      },
+      request: {
+        method: "PUT",
+        path: "/{bucket}",
+        headers: { "x-amz-bucket-region": "{region}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
 // src/connectors/adapters/stripe-webhook-receiver.ts
 var stripeWebhookReceiverConnector = {
   manifest: {
@@ -93359,6 +94286,881 @@ var granolaConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/zoom.ts
+var zoomConnector = declarativeRestConnector({
+  kind: "zoom",
+  displayName: "Zoom",
+  description: "Create and manage Zoom meetings, webinars, users, and cloud recordings via the Zoom API v2.",
+  auth: {
+    kind: "oauth2",
+    authorizationUrl: "https://zoom.us/oauth/authorize",
+    tokenUrl: "https://zoom.us/oauth/token",
+    scopes: [
+      "user:read:user",
+      "user:write:user",
+      "meeting:read:meeting",
+      "meeting:write:meeting",
+      "meeting:update:meeting",
+      "meeting:delete:meeting",
+      "webinar:read:webinar",
+      "webinar:write:webinar",
+      "webinar:update:webinar",
+      "webinar:delete:webinar",
+      "recording:read:recording",
+      "recording:write:recording"
+    ],
+    clientIdEnv: "ZOOM_OAUTH_CLIENT_ID",
+    clientSecretEnv: "ZOOM_OAUTH_CLIENT_SECRET"
+  },
+  category: "calendar",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.zoom.us",
+  test: { method: "GET", path: "/v2/users/me" },
+  capabilities: [
+    {
+      name: "users.get",
+      class: "read",
+      description: 'Read a Zoom user by id, email, or the "me" alias for the authenticated user.',
+      parameters: {
+        type: "object",
+        properties: {
+          userId: { type: "string", description: 'User id, email address, or "me".' }
+        },
+        required: ["userId"]
+      },
+      request: { method: "GET", path: "/v2/users/{userId}" },
+      requiredScopes: ["user:read:user"]
+    },
+    {
+      name: "users.list",
+      class: "read",
+      description: "List users on the Zoom account.",
+      parameters: {
+        type: "object",
+        properties: {
+          status: { type: "string", enum: ["active", "inactive", "pending"] },
+          page_size: { type: "integer", minimum: 1, maximum: 300 },
+          next_page_token: { type: "string" },
+          role_id: { type: "string" }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/v2/users",
+        query: {
+          status: "{status}",
+          page_size: "{page_size}",
+          next_page_token: "{next_page_token}",
+          role_id: "{role_id}"
+        }
+      },
+      requiredScopes: ["user:read:user"]
+    },
+    {
+      name: "meetings.list",
+      class: "read",
+      description: "List meetings for a user (scheduled, live, or upcoming).",
+      parameters: {
+        type: "object",
+        properties: {
+          userId: { type: "string", description: 'User id, email, or "me".' },
+          type: {
+            type: "string",
+            enum: ["scheduled", "live", "upcoming", "upcoming_meetings", "previous_meetings"],
+            description: "Subset of meetings to return; defaults to scheduled."
+          },
+          page_size: { type: "integer", minimum: 1, maximum: 300 },
+          next_page_token: { type: "string" }
+        },
+        required: ["userId"]
+      },
+      request: {
+        method: "GET",
+        path: "/v2/users/{userId}/meetings",
+        query: {
+          type: "{type}",
+          page_size: "{page_size}",
+          next_page_token: "{next_page_token}"
+        }
+      },
+      requiredScopes: ["meeting:read:meeting"]
+    },
+    {
+      name: "meetings.get",
+      class: "read",
+      description: "Read a Zoom meeting by numeric meeting id.",
+      parameters: {
+        type: "object",
+        properties: {
+          meetingId: { type: "string", description: "Numeric Zoom meeting id." },
+          occurrence_id: { type: "string", description: "Optional recurring-meeting occurrence id." }
+        },
+        required: ["meetingId"]
+      },
+      request: {
+        method: "GET",
+        path: "/v2/meetings/{meetingId}",
+        query: { occurrence_id: "{occurrence_id}" }
+      },
+      requiredScopes: ["meeting:read:meeting"]
+    },
+    {
+      name: "meetings.create",
+      class: "mutation",
+      description: "Schedule a Zoom meeting for a user. Body follows the v2 meetings contract (topic, start_time, duration, type, settings, ...).",
+      parameters: {
+        type: "object",
+        properties: {
+          userId: { type: "string", description: 'User id, email, or "me".' },
+          topic: { type: "string" },
+          type: {
+            type: "integer",
+            enum: [1, 2, 3, 8],
+            description: "1=instant, 2=scheduled, 3=recurring no fixed time, 8=recurring with fixed time."
+          },
+          start_time: { type: "string", description: "ISO-8601 start time (UTC or with offset)." },
+          duration: { type: "integer", description: "Meeting length in minutes." },
+          timezone: { type: "string" },
+          password: { type: "string" },
+          agenda: { type: "string" },
+          settings: { type: "object" },
+          recurrence: { type: "object" },
+          tracking_fields: { type: "array", items: { type: "object" } }
+        },
+        required: ["userId", "topic"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/users/{userId}/meetings",
+        body: {
+          topic: "{topic}",
+          type: "{type}",
+          start_time: "{start_time}",
+          duration: "{duration}",
+          timezone: "{timezone}",
+          password: "{password}",
+          agenda: "{agenda}",
+          settings: "{settings}",
+          recurrence: "{recurrence}",
+          tracking_fields: "{tracking_fields}"
+        }
+      },
+      cas: "none",
+      externalEffect: true,
+      requiredScopes: ["meeting:write:meeting"]
+    },
+    {
+      name: "meetings.update",
+      class: "mutation",
+      description: "Update a scheduled Zoom meeting in place.",
+      parameters: {
+        type: "object",
+        properties: {
+          meetingId: { type: "string" },
+          occurrence_id: { type: "string" },
+          topic: { type: "string" },
+          start_time: { type: "string" },
+          duration: { type: "integer" },
+          timezone: { type: "string" },
+          password: { type: "string" },
+          agenda: { type: "string" },
+          settings: { type: "object" },
+          recurrence: { type: "object" }
+        },
+        required: ["meetingId"]
+      },
+      request: {
+        method: "PATCH",
+        path: "/v2/meetings/{meetingId}",
+        query: { occurrence_id: "{occurrence_id}" },
+        body: {
+          topic: "{topic}",
+          start_time: "{start_time}",
+          duration: "{duration}",
+          timezone: "{timezone}",
+          password: "{password}",
+          agenda: "{agenda}",
+          settings: "{settings}",
+          recurrence: "{recurrence}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["meeting:update:meeting"]
+    },
+    {
+      name: "meetings.delete",
+      class: "mutation",
+      description: "Delete a Zoom meeting. Optionally notify hosts/registrants and scope to a single occurrence.",
+      parameters: {
+        type: "object",
+        properties: {
+          meetingId: { type: "string" },
+          occurrence_id: { type: "string" },
+          schedule_for_reminder: { type: "boolean" },
+          cancel_meeting_reminder: { type: "boolean" }
+        },
+        required: ["meetingId"]
+      },
+      request: {
+        method: "DELETE",
+        path: "/v2/meetings/{meetingId}",
+        query: {
+          occurrence_id: "{occurrence_id}",
+          schedule_for_reminder: "{schedule_for_reminder}",
+          cancel_meeting_reminder: "{cancel_meeting_reminder}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: true,
+      requiredScopes: ["meeting:delete:meeting"]
+    },
+    {
+      name: "meetings.list-registrants",
+      class: "read",
+      description: "List registrants for a Zoom meeting.",
+      parameters: {
+        type: "object",
+        properties: {
+          meetingId: { type: "string" },
+          occurrence_id: { type: "string" },
+          status: { type: "string", enum: ["pending", "approved", "denied"] },
+          page_size: { type: "integer", minimum: 1, maximum: 300 },
+          next_page_token: { type: "string" }
+        },
+        required: ["meetingId"]
+      },
+      request: {
+        method: "GET",
+        path: "/v2/meetings/{meetingId}/registrants",
+        query: {
+          occurrence_id: "{occurrence_id}",
+          status: "{status}",
+          page_size: "{page_size}",
+          next_page_token: "{next_page_token}"
+        }
+      },
+      requiredScopes: ["meeting:read:meeting"]
+    },
+    {
+      name: "meetings.add-registrant",
+      class: "mutation",
+      description: "Register a participant for a Zoom meeting that requires registration.",
+      parameters: {
+        type: "object",
+        properties: {
+          meetingId: { type: "string" },
+          occurrence_ids: { type: "string", description: "Comma-separated occurrence ids for recurring meetings." },
+          email: { type: "string" },
+          first_name: { type: "string" },
+          last_name: { type: "string" },
+          address: { type: "string" },
+          city: { type: "string" },
+          country: { type: "string" },
+          zip: { type: "string" },
+          state: { type: "string" },
+          phone: { type: "string" },
+          industry: { type: "string" },
+          org: { type: "string" },
+          job_title: { type: "string" },
+          purchasing_time_frame: { type: "string" },
+          role_in_purchase_process: { type: "string" },
+          no_of_employees: { type: "string" },
+          comments: { type: "string" },
+          custom_questions: { type: "array", items: { type: "object" } },
+          language: { type: "string" },
+          auto_approve: { type: "boolean" }
+        },
+        required: ["meetingId", "email", "first_name"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/meetings/{meetingId}/registrants",
+        query: { occurrence_ids: "{occurrence_ids}" },
+        body: {
+          email: "{email}",
+          first_name: "{first_name}",
+          last_name: "{last_name}",
+          address: "{address}",
+          city: "{city}",
+          country: "{country}",
+          zip: "{zip}",
+          state: "{state}",
+          phone: "{phone}",
+          industry: "{industry}",
+          org: "{org}",
+          job_title: "{job_title}",
+          purchasing_time_frame: "{purchasing_time_frame}",
+          role_in_purchase_process: "{role_in_purchase_process}",
+          no_of_employees: "{no_of_employees}",
+          comments: "{comments}",
+          custom_questions: "{custom_questions}",
+          language: "{language}",
+          auto_approve: "{auto_approve}"
+        }
+      },
+      cas: "native-idempotency",
+      requiredScopes: ["meeting:write:meeting"]
+    },
+    {
+      name: "webinars.list",
+      class: "read",
+      description: "List webinars for a user.",
+      parameters: {
+        type: "object",
+        properties: {
+          userId: { type: "string" },
+          page_size: { type: "integer", minimum: 1, maximum: 300 },
+          next_page_token: { type: "string" }
+        },
+        required: ["userId"]
+      },
+      request: {
+        method: "GET",
+        path: "/v2/users/{userId}/webinars",
+        query: {
+          page_size: "{page_size}",
+          next_page_token: "{next_page_token}"
+        }
+      },
+      requiredScopes: ["webinar:read:webinar"]
+    },
+    {
+      name: "webinars.get",
+      class: "read",
+      description: "Read a Zoom webinar by id.",
+      parameters: {
+        type: "object",
+        properties: {
+          webinarId: { type: "string" },
+          occurrence_id: { type: "string" }
+        },
+        required: ["webinarId"]
+      },
+      request: {
+        method: "GET",
+        path: "/v2/webinars/{webinarId}",
+        query: { occurrence_id: "{occurrence_id}" }
+      },
+      requiredScopes: ["webinar:read:webinar"]
+    },
+    {
+      name: "webinars.create",
+      class: "mutation",
+      description: "Schedule a Zoom webinar for a user.",
+      parameters: {
+        type: "object",
+        properties: {
+          userId: { type: "string" },
+          topic: { type: "string" },
+          type: {
+            type: "integer",
+            enum: [5, 6, 9],
+            description: "5=scheduled, 6=recurring no fixed time, 9=recurring with fixed time."
+          },
+          start_time: { type: "string" },
+          duration: { type: "integer" },
+          timezone: { type: "string" },
+          password: { type: "string" },
+          agenda: { type: "string" },
+          settings: { type: "object" },
+          recurrence: { type: "object" }
+        },
+        required: ["userId", "topic"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/users/{userId}/webinars",
+        body: {
+          topic: "{topic}",
+          type: "{type}",
+          start_time: "{start_time}",
+          duration: "{duration}",
+          timezone: "{timezone}",
+          password: "{password}",
+          agenda: "{agenda}",
+          settings: "{settings}",
+          recurrence: "{recurrence}"
+        }
+      },
+      cas: "none",
+      externalEffect: true,
+      requiredScopes: ["webinar:write:webinar"]
+    },
+    {
+      name: "recordings.list",
+      class: "read",
+      description: "List cloud recordings for a user.",
+      parameters: {
+        type: "object",
+        properties: {
+          userId: { type: "string", description: 'User id, email, or "me".' },
+          from: { type: "string", description: "YYYY-MM-DD lower bound." },
+          to: { type: "string", description: "YYYY-MM-DD upper bound." },
+          page_size: { type: "integer", minimum: 1, maximum: 300 },
+          next_page_token: { type: "string" },
+          mc: { type: "string" },
+          trash: { type: "boolean" },
+          trash_type: { type: "string", enum: ["meeting_recordings", "recording_file"] }
+        },
+        required: ["userId"]
+      },
+      request: {
+        method: "GET",
+        path: "/v2/users/{userId}/recordings",
+        query: {
+          from: "{from}",
+          to: "{to}",
+          page_size: "{page_size}",
+          next_page_token: "{next_page_token}",
+          mc: "{mc}",
+          trash: "{trash}",
+          trash_type: "{trash_type}"
+        }
+      },
+      requiredScopes: ["recording:read:recording"]
+    },
+    {
+      // Zoom does not expose a DELETE /meetings/{id}/live; ending an in-flight
+      // meeting is modeled as a status PUT with `action: "end"`. The endpoint
+      // is idempotent — repeating it on an already-ended meeting returns 204.
+      name: "meetings.end",
+      class: "mutation",
+      description: 'End a live Zoom meeting via the status endpoint (PUT /meetings/{id}/status, action="end").',
+      parameters: {
+        type: "object",
+        properties: {
+          meetingId: { type: "string", description: "Numeric Zoom meeting id of the live meeting to end." }
+        },
+        required: ["meetingId"]
+      },
+      request: {
+        method: "PUT",
+        path: "/v2/meetings/{meetingId}/status",
+        body: { action: "end" }
+      },
+      cas: "native-idempotency",
+      externalEffect: true,
+      requiredScopes: ["meeting:update:meeting"]
+    },
+    {
+      // Mirrors the meeting update contract: a PATCH against the webinar
+      // record. Zoom returns 204 on success and rejects with 300/400 on
+      // schedule conflicts; the declarative-rest layer surfaces both.
+      name: "webinars.update",
+      class: "mutation",
+      description: "Update a scheduled Zoom webinar in place.",
+      parameters: {
+        type: "object",
+        properties: {
+          webinarId: { type: "string" },
+          occurrence_id: { type: "string" },
+          topic: { type: "string" },
+          start_time: { type: "string" },
+          duration: { type: "integer" },
+          timezone: { type: "string" },
+          password: { type: "string" },
+          agenda: { type: "string" },
+          settings: { type: "object" },
+          recurrence: { type: "object" }
+        },
+        required: ["webinarId"]
+      },
+      request: {
+        // Optional-field forest: any of topic/start_time/duration/etc. may be
+        // absent, and the bare {x} body template requires every placeholder.
+        // body: 'args' passes the resolved arg bag through verbatim, dropping
+        // webinarId-on-path duplication via Zoom's lenient PATCH (extra
+        // fields are ignored). Keeps the caller's optional-field semantics
+        // exact instead of forcing them to send every field.
+        method: "PATCH",
+        path: "/v2/webinars/{webinarId}",
+        query: { occurrence_id: "{occurrence_id}" },
+        body: "args"
+      },
+      cas: "native-idempotency",
+      externalEffect: true,
+      requiredScopes: ["webinar:update:webinar"]
+    },
+    {
+      name: "webinars.delete",
+      class: "mutation",
+      description: "Delete a Zoom webinar. Optionally scope to a single occurrence and toggle host/panelist cancellation notifications.",
+      parameters: {
+        type: "object",
+        properties: {
+          webinarId: { type: "string" },
+          occurrence_id: { type: "string" },
+          cancel_webinar_reminder: { type: "boolean" }
+        },
+        required: ["webinarId"]
+      },
+      request: {
+        method: "DELETE",
+        path: "/v2/webinars/{webinarId}",
+        query: {
+          occurrence_id: "{occurrence_id}",
+          cancel_webinar_reminder: "{cancel_webinar_reminder}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: true,
+      requiredScopes: ["webinar:delete:webinar"]
+    },
+    {
+      // `action=trash` moves the recording to the cloud trash (recoverable for
+      // 30 days); `action=delete` permanently deletes. The caller picks the
+      // mode — we won't default to one because the destructive variant is
+      // unrecoverable and the safe variant breaks downstream search indexes
+      // that watch the trash queue.
+      name: "recordings.delete",
+      class: "mutation",
+      description: 'Delete (or trash) a cloud recording for a meeting. action="trash" is recoverable; action="delete" is permanent.',
+      parameters: {
+        type: "object",
+        properties: {
+          meetingId: { type: "string", description: "Meeting id or recording UUID." },
+          action: { type: "string", enum: ["trash", "delete"], description: "trash (default, recoverable) or delete (permanent)." }
+        },
+        required: ["meetingId"]
+      },
+      request: {
+        method: "DELETE",
+        path: "/v2/meetings/{meetingId}/recordings",
+        query: { action: "{action}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: true,
+      requiredScopes: ["recording:write:recording"]
+    },
+    {
+      // Zoom user provisioning is a single POST with an `action` discriminator:
+      // create (manual invite), autoCreate (provision into the account), or
+      // custCreate (custom-managed user). The user_info sub-object carries
+      // email/type/first_name/last_name. We expose `action` + `user_info`
+      // verbatim so callers can hit any of the three provisioning modes.
+      name: "users.create",
+      class: "mutation",
+      description: "Create a user in the Zoom account. `action` selects the provisioning mode; user_info carries the user payload.",
+      parameters: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["create", "autoCreate", "custCreate", "ssoCreate"],
+            description: "Provisioning mode: create (invite), autoCreate (provision), custCreate (custom-managed), ssoCreate (SSO)."
+          },
+          user_info: {
+            type: "object",
+            description: "User payload (email, type, first_name, last_name, password for custCreate, etc.)."
+          }
+        },
+        required: ["action", "user_info"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/users",
+        body: { action: "{action}", user_info: "{user_info}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: true,
+      requiredScopes: ["user:write:user"]
+    },
+    {
+      name: "recordings.get",
+      class: "read",
+      description: 'List recording files for a meeting or recording id (use a double-encoded UUID if it begins with "/" or contains "//").',
+      parameters: {
+        type: "object",
+        properties: {
+          meetingId: { type: "string", description: "Meeting id or recording UUID." },
+          include_fields: { type: "string", description: "Comma-separated extra fields to include (e.g. download_access_token)." },
+          ttl: { type: "integer", description: "TTL in seconds for download_access_token (max 604800)." }
+        },
+        required: ["meetingId"]
+      },
+      request: {
+        method: "GET",
+        path: "/v2/meetings/{meetingId}/recordings",
+        query: {
+          include_fields: "{include_fields}",
+          ttl: "{ttl}"
+        }
+      },
+      requiredScopes: ["recording:read:recording"]
+    }
+  ]
+});
+
+// src/connectors/adapters/affinity.ts
+var affinityConnector = declarativeRestConnector({
+  kind: "affinity",
+  displayName: "Affinity",
+  description: "Synchronize Affinity people, organizations, opportunities, lists, notes, interactions, and field values.",
+  auth: {
+    kind: "api-key",
+    hint: "Affinity API key from Settings > API. Availability depends on the workspace plan and key owner permissions."
+  },
+  category: "crm",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.affinity.co",
+  test: { method: "GET", path: "/auth/whoami" },
+  capabilities: [
+    collectionRead("people.list", "List or search people.", "/persons", "person"),
+    entityRead("people.get", "Read one person, including current organizations and opportunities.", "/persons/{personId}", "personId"),
+    entityCreate("people.create", "Create a person.", "/persons"),
+    entityUpdate("people.update", "Update a person.", "/persons/{personId}", "personId"),
+    entityDelete("people.delete", "Delete a person.", "/persons/{personId}", "personId"),
+    collectionRead("organizations.list", "List or search organizations.", "/organizations", "organization"),
+    entityRead("organizations.get", "Read one organization.", "/organizations/{organizationId}", "organizationId"),
+    entityCreate("organizations.create", "Create an organization.", "/organizations"),
+    entityUpdate("organizations.update", "Update an organization.", "/organizations/{organizationId}", "organizationId"),
+    entityDelete("organizations.delete", "Delete an organization.", "/organizations/{organizationId}", "organizationId"),
+    collectionRead("opportunities.list", "List or search opportunities.", "/opportunities", "opportunity"),
+    entityRead("opportunities.get", "Read one opportunity.", "/opportunities/{opportunityId}", "opportunityId"),
+    entityCreate("opportunities.create", "Create an opportunity.", "/opportunities"),
+    entityUpdate("opportunities.update", "Update an opportunity.", "/opportunities/{opportunityId}", "opportunityId"),
+    entityDelete("opportunities.delete", "Delete an opportunity.", "/opportunities/{opportunityId}", "opportunityId"),
+    collectionRead("lists.list", "List CRM lists.", "/lists", "list"),
+    entityRead("lists.get", "Read one CRM list and its field definitions.", "/lists/{listId}", "listId"),
+    {
+      name: "list-entries.list",
+      class: "read",
+      description: "List entries in an Affinity list.",
+      parameters: {
+        type: "object",
+        properties: {
+          listId: { type: "integer" },
+          page_size: { type: "integer", minimum: 1, maximum: 500 },
+          page_token: { type: "string" }
+        },
+        required: ["listId"]
+      },
+      request: {
+        method: "GET",
+        path: "/lists/{listId}/list-entries",
+        query: { page_size: "{page_size}", page_token: "{page_token}" }
+      }
+    },
+    {
+      name: "list-entries.create",
+      class: "mutation",
+      description: "Add an entity to an Affinity list.",
+      parameters: {
+        type: "object",
+        properties: {
+          listId: { type: "integer" },
+          entity_id: { type: "integer" }
+        },
+        required: ["listId", "entity_id"]
+      },
+      request: { method: "POST", path: "/lists/{listId}/list-entries", body: { entity_id: "{entity_id}" } },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "list-entries.delete",
+      class: "mutation",
+      description: "Remove a list entry.",
+      parameters: idParameters("listEntryId"),
+      request: { method: "DELETE", path: "/list-entries/{listEntryId}" },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "field-values.list",
+      class: "read",
+      description: "Read mapped custom-field values for one person, organization, opportunity, or list entry.",
+      parameters: {
+        type: "object",
+        properties: {
+          person_id: { type: "integer" },
+          organization_id: { type: "integer" },
+          opportunity_id: { type: "integer" },
+          list_entry_id: { type: "integer" }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/field-values",
+        query: {
+          person_id: "{person_id}",
+          organization_id: "{organization_id}",
+          opportunity_id: "{opportunity_id}",
+          list_entry_id: "{list_entry_id}"
+        }
+      }
+    },
+    entityCreate("field-values.create", "Create a custom-field value.", "/field-values"),
+    entityUpdate("field-values.update", "Update a custom-field value.", "/field-values/{fieldValueId}", "fieldValueId"),
+    entityDelete("field-values.delete", "Delete a custom-field value.", "/field-values/{fieldValueId}", "fieldValueId"),
+    {
+      name: "field-value-changes.list",
+      class: "read",
+      description: "Read custom-field change history for synchronization and evidence.",
+      parameters: {
+        type: "object",
+        properties: {
+          field_id: { type: "integer" },
+          action_type: { type: "integer" },
+          page_size: { type: "integer", minimum: 1, maximum: 500 },
+          page_token: { type: "string" }
+        },
+        required: ["field_id"]
+      },
+      request: {
+        method: "GET",
+        path: "/field-value-changes",
+        query: {
+          field_id: "{field_id}",
+          action_type: "{action_type}",
+          page_size: "{page_size}",
+          page_token: "{page_token}"
+        }
+      }
+    },
+    {
+      name: "interactions.list",
+      class: "read",
+      description: "List email, meeting, call, and chat interactions for a person or organization.",
+      parameters: {
+        type: "object",
+        properties: {
+          person_id: { type: "integer" },
+          organization_id: { type: "integer" },
+          type: { type: "integer" },
+          start_time: { type: "string" },
+          end_time: { type: "string" },
+          page_size: { type: "integer", minimum: 1, maximum: 500 },
+          page_token: { type: "string" }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/interactions",
+        query: {
+          person_id: "{person_id}",
+          organization_id: "{organization_id}",
+          type: "{type}",
+          start_time: "{start_time}",
+          end_time: "{end_time}",
+          page_size: "{page_size}",
+          page_token: "{page_token}"
+        }
+      }
+    },
+    {
+      name: "notes.list",
+      class: "read",
+      description: "List notes linked to people, organizations, or opportunities.",
+      parameters: {
+        type: "object",
+        properties: {
+          person_id: { type: "integer" },
+          organization_id: { type: "integer" },
+          opportunity_id: { type: "integer" },
+          page_size: { type: "integer", minimum: 1, maximum: 500 },
+          page_token: { type: "string" }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/notes",
+        query: {
+          person_id: "{person_id}",
+          organization_id: "{organization_id}",
+          opportunity_id: "{opportunity_id}",
+          page_size: "{page_size}",
+          page_token: "{page_token}"
+        }
+      }
+    },
+    entityCreate("notes.create", "Create a note linked to CRM records.", "/notes"),
+    entityUpdate("notes.update", "Update a note.", "/notes/{noteId}", "noteId"),
+    entityDelete("notes.delete", "Delete a note.", "/notes/{noteId}", "noteId")
+  ]
+});
+function collectionRead(name, description, path, entity) {
+  return {
+    name,
+    class: "read",
+    description,
+    parameters: {
+      type: "object",
+      properties: {
+        term: { type: "string", description: `Search ${entity} names and identifiers.` },
+        page_size: { type: "integer", minimum: 1, maximum: 500 },
+        page_token: { type: "string" }
+      }
+    },
+    request: {
+      method: "GET",
+      path,
+      query: { term: "{term}", page_size: "{page_size}", page_token: "{page_token}" }
+    }
+  };
+}
+function entityRead(name, description, path, id) {
+  return {
+    name,
+    class: "read",
+    description,
+    parameters: idParameters(id),
+    request: { method: "GET", path }
+  };
+}
+function entityCreate(name, description, path) {
+  return {
+    name,
+    class: "mutation",
+    description,
+    parameters: arbitraryBodyParameters(),
+    request: { method: "POST", path, body: "args" },
+    cas: "native-idempotency",
+    externalEffect: true
+  };
+}
+function entityUpdate(name, description, path, id) {
+  return {
+    name,
+    class: "mutation",
+    description,
+    parameters: {
+      type: "object",
+      properties: { [id]: { type: "integer" } },
+      required: [id],
+      additionalProperties: true
+    },
+    request: { method: "PUT", path, body: "args" },
+    cas: "optimistic-read-verify",
+    externalEffect: true
+  };
+}
+function entityDelete(name, description, path, id) {
+  return {
+    name,
+    class: "mutation",
+    description,
+    parameters: idParameters(id),
+    request: { method: "DELETE", path },
+    cas: "native-idempotency",
+    externalEffect: true
+  };
+}
+function idParameters(id) {
+  return {
+    type: "object",
+    properties: { [id]: { type: "integer" } },
+    required: [id]
+  };
+}
+function arbitraryBodyParameters() {
+  return {
+    type: "object",
+    additionalProperties: true,
+    properties: {}
+  };
+}
+
 // src/connectors/adapters/griptape.ts
 var griptapeConnector = declarativeRestConnector({
   kind: "griptape",
@@ -125448,6 +127250,9 @@ export {
   phonyConnector,
   stripePackConnector,
   webhookConnector,
+  httpConnector,
+  rssConnector,
+  amazonS3Connector,
   stripeWebhookReceiverConnector,
   slackEventsConnector,
   githubConnector,
@@ -125769,6 +127574,8 @@ export {
   gptzeroDetectAiConnector,
   gristConnector,
   granolaConnector,
+  zoomConnector,
+  affinityConnector,
   griptapeConnector,
   heartbeatConnector,
   hedyConnector,
@@ -125956,4 +127763,4 @@ export {
   demandbaseConnector,
   adapters_exports
 };
-//# sourceMappingURL=chunk-XEJKVCXB.js.map
+//# sourceMappingURL=chunk-5QWQFX2Q.js.map