@tangle-network/agent-integrations 0.41.0 → 0.43.0

package/dist/{chunk-COKK7BOH.js → chunk-HRPCFEGL.js}

@@ -48,6 +48,7 @@ __export(adapters_exports, {
   amazonTextractConnector: () => amazonTextractConnector,
   aminosConnector: () => aminosConnector,
   ampecoConnector: () => ampecoConnector,
+  amplemarketConnector: () => amplemarketConnector,
   anthropicConnector: () => anthropicConnector,
   apitableConnector: () => apitableConnector,
   apitemplateIoConnector: () => apitemplateIoConnector,
@@ -59,6 +60,7 @@ __export(adapters_exports, {
   assemblyaiConnector: () => assemblyaiConnector,
   attioConnector: () => attioConnector,
   auth0Connector: () => auth0Connector,
+  autoboundConnector: () => autoboundConnector,
   autocallsConnector: () => autocallsConnector,
   avianConnector: () => avianConnector,
   avomaConnector: () => avomaConnector,
@@ -71,6 +73,7 @@ __export(adapters_exports, {
   baremetricsConnector: () => baremetricsConnector,
   basecampConnector: () => basecampConnector,
   beamerConnector: () => beamerConnector,
+  bettercontactConnector: () => bettercontactConnector,
   bettermodeConnector: () => bettermodeConnector,
   bexioConnector: () => bexioConnector,
   bigcommerceConnector: () => bigcommerceConnector,
@@ -85,8 +88,10 @@ __export(adapters_exports, {
   boxConnector: () => boxConnector,
   braveSearchConnector: () => braveSearchConnector,
   brazeConnector: () => brazeConnector,
+  brightdataConnector: () => brightdataConnector,
   brilliantDirectoriesConnector: () => brilliantDirectoriesConnector,
   browseAiConnector: () => browseAiConnector,
+  builtwithConnector: () => builtwithConnector,
   calComConnector: () => calComConnector,
   calendlyConnector: () => calendlyConnector,
   campaignMonitorConnector: () => campaignMonitorConnector,
@@ -124,14 +129,17 @@ __export(adapters_exports, {
   cohereConnector: () => cohereConnector,
   cometapiConnector: () => cometapiConnector,
   comfyicuConnector: () => comfyicuConnector,
+  commonRoomConnector: () => commonRoomConnector,
   confluenceConnector: () => confluenceConnector,
   constantContactConnector: () => constantContactConnector,
+  contactoutConnector: () => contactoutConnector,
   contentfulConnector: () => contentfulConnector,
   convertkitConnector: () => convertkitConnector,
   copperConnector: () => copperConnector,
   copyAiConnector: () => copyAiConnector,
   createTangleIdentityClient: () => createTangleIdentityClient,
   crispConnector: () => crispConnector,
+  crustdataConnector: () => crustdataConnector,
   cryptolensConnector: () => cryptolensConnector,
   customerIoConnector: () => customerIoConnector,
   customgptConnector: () => customgptConnector,
@@ -141,9 +149,11 @@ __export(adapters_exports, {
   datocmsConnector: () => datocmsConnector,
   declarativeRestConnector: () => declarativeRestConnector,
   deepseekConnector: () => deepseekConnector,
+  demandbaseConnector: () => demandbaseConnector,
   denserAiConnector: () => denserAiConnector,
   descriptConnector: () => descriptConnector,
   devinConnector: () => devinConnector,
+  dialpadConnector: () => dialpadConnector,
   discordConnector: () => discordConnector,
   dittofeedConnector: () => dittofeedConnector,
   doctlyConnector: () => doctlyConnector,
@@ -167,11 +177,13 @@ __export(adapters_exports, {
   exaConnector: () => exaConnector,
   facebookLeadsConnector: () => facebookLeadsConnector,
   facebookPagesConnector: () => facebookPagesConnector,
+  factorsAiConnector: () => factorsAiConnector,
   fathomAnalyticsConnector: () => fathomAnalyticsConnector,
   fathomConnector: () => fathomConnector,
   figjamConnector: () => figjamConnector,
   figmaConnector: () => figmaConnector,
   filloutFormsConnector: () => filloutFormsConnector,
+  findymailConnector: () => findymailConnector,
   firebaseConnector: () => firebaseConnector,
   fireberryConnector: () => fireberryConnector,
   firecrawlConnector: () => firecrawlConnector,
@@ -190,8 +202,10 @@ __export(adapters_exports, {
   freshsalesConnector: () => freshsalesConnector,
   freshserviceConnector: () => freshserviceConnector,
   frontConnector: () => frontConnector,
+  fullenrichConnector: () => fullenrichConnector,
   gameballConnector: () => gameballConnector,
   geminiConnector: () => geminiConnector,
+  getresponseConnector: () => getresponseConnector,
   ghostcmsConnector: () => ghostcmsConnector,
   gistlyConnector: () => gistlyConnector,
   giteaConnector: () => giteaConnector,
@@ -199,6 +213,7 @@ __export(adapters_exports, {
   gitlabConnector: () => gitlabConnector,
   glideConnector: () => glideConnector,
   gmail: () => gmail,
+  gongConnector: () => gongConnector,
   googleAnalyticsConnector: () => googleAnalyticsConnector,
   googleBigqueryConnector: () => googleBigqueryConnector,
   googleCalendar: () => googleCalendar,
@@ -237,6 +252,8 @@ __export(adapters_exports, {
   helpscoutConnector: () => helpscoutConnector,
   heygenConnector: () => heygenConnector,
   heymarketSmsConnector: () => heymarketSmsConnector,
+  heyreachConnector: () => heyreachConnector,
+  hightouchConnector: () => hightouchConnector,
   housecallProConnector: () => housecallProConnector,
   hubspot: () => hubspot,
   huggingFaceConnector: () => huggingFaceConnector,
@@ -261,6 +278,7 @@ __export(adapters_exports, {
   joggAiConnector: () => joggAiConnector,
   jotformConnector: () => jotformConnector,
   justInvoiceConnector: () => justInvoiceConnector,
+  justcallConnector: () => justcallConnector,
   kallabotAiConnector: () => kallabotAiConnector,
   kapsoConnector: () => kapsoConnector,
   kimaiConnector: () => kimaiConnector,
@@ -274,7 +292,10 @@ __export(adapters_exports, {
   kommoConnector: () => kommoConnector,
   kudosityConnector: () => kudosityConnector,
   kustomerConnector: () => kustomerConnector,
+  lagrowthmachineConnector: () => lagrowthmachineConnector,
   leadConnectorConnector: () => leadConnectorConnector,
+  leadfeederConnector: () => leadfeederConnector,
+  leadmagicConnector: () => leadmagicConnector,
   leapAiConnector: () => leapAiConnector,
   leexiConnector: () => leexiConnector,
   lemlistConnector: () => lemlistConnector,
@@ -335,6 +356,7 @@ __export(adapters_exports, {
   missiveConnector: () => missiveConnector,
   mixmaxConnector: () => mixmaxConnector,
   mixpanelConnector: () => mixpanelConnector,
+  modjoConnector: () => modjoConnector,
   mollieConnector: () => mollieConnector,
   mondayConnector: () => mondayConnector,
   mongodbConnector: () => mongodbConnector,
@@ -343,9 +365,11 @@ __export(adapters_exports, {
   niftyConnector: () => niftyConnector,
   ninjapipeConnector: () => ninjapipeConnector,
   nocodbConnector: () => nocodbConnector,
+  nooksConnector: () => nooksConnector,
   notion: () => notion,
   notionConnector: () => notionConnector,
   ntfyConnector: () => ntfyConnector,
+  oceanIoConnector: () => oceanIoConnector,
   odooConnector: () => odooConnector,
   omniCoConnector: () => omniCoConnector,
   omnihrConnector: () => omnihrConnector,
@@ -360,6 +384,7 @@ __export(adapters_exports, {
   oracleDatabaseConnector: () => oracleDatabaseConnector,
   orimonConnector: () => orimonConnector,
   outlookMail: () => outlookMail,
+  outreachConnector: () => outreachConnector,
   paddleConnector: () => paddleConnector,
   pagerdutyConnector: () => pagerdutyConnector,
   pandadoc: () => pandadoc,
@@ -372,6 +397,7 @@ __export(adapters_exports, {
   peekshotConnector: () => peekshotConnector,
   perplexityAiConnector: () => perplexityAiConnector,
   personalAiConnector: () => personalAiConnector,
+  phantombusterConnector: () => phantombusterConnector,
   phonyConnector: () => phonyConnector,
   pinchPaymentsConnector: () => pinchPaymentsConnector,
   pineconeConnector: () => pineconeConnector,
@@ -381,6 +407,7 @@ __export(adapters_exports, {
   plausibleConnector: () => plausibleConnector,
   pocketbaseConnector: () => pocketbaseConnector,
   pollybotAiConnector: () => pollybotAiConnector,
+  polytomicConnector: () => polytomicConnector,
   postgresConnector: () => postgresConnector,
   posthogConnector: () => posthogConnector,
   postizConnector: () => postizConnector,
@@ -404,17 +431,21 @@ __export(adapters_exports, {
   replyIoConnector: () => replyIoConnector,
   retableConnector: () => retableConnector,
   retellAiConnector: () => retellAiConnector,
+  ringcentralConnector: () => ringcentralConnector,
   ripplingConnector: () => ripplingConnector,
   robollyConnector: () => robollyConnector,
   runwareConnector: () => runwareConnector,
   saasticConnector: () => saasticConnector,
   saleorConnector: () => saleorConnector,
   salesforceConnector: () => salesforceConnector,
+  saleshandyConnector: () => saleshandyConnector,
+  salesloftConnector: () => salesloftConnector,
   sanityConnector: () => sanityConnector,
   sardisConnector: () => sardisConnector,
   savvycalConnector: () => savvycalConnector,
   scrapegraphaiConnector: () => scrapegraphaiConnector,
   scrapelessConnector: () => scrapelessConnector,
+  seamlessAiConnector: () => seamlessAiConnector,
   seekTableConnector: () => seekTableConnector,
   semrushConnector: () => semrushConnector,
   sendgridConnector: () => sendgridConnector,
@@ -422,6 +453,7 @@ __export(adapters_exports, {
   sendpulseConnector: () => sendpulseConnector,
   senjaConnector: () => senjaConnector,
   sentryConnector: () => sentryConnector,
+  serperConnector: () => serperConnector,
   serpstatConnector: () => serpstatConnector,
   serviceNowConnector: () => serviceNowConnector,
   sharepoint: () => sharepoint,
@@ -430,6 +462,7 @@ __export(adapters_exports, {
   shortIoConnector: () => shortIoConnector,
   signNowConnector: () => signNowConnector,
   signrequestConnector: () => signrequestConnector,
+  signwellConnector: () => signwellConnector,
   similarwebConnector: () => similarwebConnector,
   simplirouteConnector: () => simplirouteConnector,
   simplybookmeConnector: () => simplybookmeConnector,
@@ -441,6 +474,7 @@ __export(adapters_exports, {
   smartsuiteConnector: () => smartsuiteConnector,
   smooveConnector: () => smooveConnector,
   smsmodeConnector: () => smsmodeConnector,
+  snovIoConnector: () => snovIoConnector,
   snowflakeConnector: () => snowflakeConnector,
   socialkitConnector: () => socialkitConnector,
   squareConnector: () => squareConnector,
@@ -460,6 +494,7 @@ __export(adapters_exports, {
   telnyxConnector: () => telnyxConnector,
   tenzoConnector: () => tenzoConnector,
   textcortexAiConnector: () => textcortexAiConnector,
+  theirstackConnector: () => theirstackConnector,
   ticktickConnector: () => ticktickConnector,
   timeOpsConnector: () => timeOpsConnector,
   timelinesAiConnector: () => timelinesAiConnector,
@@ -479,6 +514,7 @@ __export(adapters_exports, {
   umamiConnector: () => umamiConnector,
   upgradechatConnector: () => upgradechatConnector,
   uscreenConnector: () => uscreenConnector,
+  usergemsConnector: () => usergemsConnector,
   validatedmailsConnector: () => validatedmailsConnector,
   vapiConnector: () => vapiConnector,
   vboutConnector: () => vboutConnector,
@@ -490,6 +526,7 @@ __export(adapters_exports, {
   vtexConnector: () => vtexConnector,
   vtigerConnector: () => vtigerConnector,
   wafeqConnector: () => wafeqConnector,
+  warmlyConnector: () => warmlyConnector,
   weaviateConnector: () => weaviateConnector,
   webflowConnector: () => webflowConnector,
   webhookConnector: () => webhookConnector,
@@ -498,6 +535,7 @@ __export(adapters_exports, {
   whatsappBusiness: () => whatsappBusiness,
   whatsappConnector: () => whatsappConnector,
   whatsscaleConnector: () => whatsscaleConnector,
+  wizaConnector: () => wizaConnector,
   wonderchatConnector: () => wonderchatConnector,
   woocommerceConnector: () => woocommerceConnector,
   woodpeckerConnector: () => woodpeckerConnector,
@@ -515,6 +553,7 @@ __export(adapters_exports, {
   zapierConnector: () => zapierConnector,
   zendeskConnector: () => zendeskConnector,
   zendeskSellConnector: () => zendeskSellConnector,
+  zenrowsConnector: () => zenrowsConnector,
   zeplinConnector: () => zeplinConnector,
   zerobounceConnector: () => zerobounceConnector,
   zohoBookingsConnector: () => zohoBookingsConnector,
@@ -2281,7 +2320,7 @@ function declarativeRestConnector(spec) {
     },
     async executeRead(inv) {
       const op = readOperation(spec, inv.capabilityName, "read");
-      const response = await executeRestRequest(spec, op.request, inv);
+      const response = await executeRestRequest(spec, op.request, inv, requiredArgsOf(op.parameters));
       return {
         data: response.data,
         etag: response.etag,
@@ -2290,7 +2329,7 @@ function declarativeRestConnector(spec) {
     },
     async executeMutation(inv) {
       const op = readOperation(spec, inv.capabilityName, "mutation");
-      const response = await executeRestRequest(spec, op.request, inv);
+      const response = await executeRestRequest(spec, op.request, inv, requiredArgsOf(op.parameters));
       return {
         status: "committed",
         data: response.data,
@@ -2360,7 +2399,11 @@ function readOperation(spec, name, expected) {
   }
   return op;
 }
-async function executeRestRequest(spec, request, inv) {
+function requiredArgsOf(parameters) {
+  const required = parameters.required;
+  return Array.isArray(required) ? required.filter((entry) => typeof entry === "string") : void 0;
+}
+async function executeRestRequest(spec, request, inv, requiredArgs) {
   const baseUrl = resolveBaseUrl(spec.baseUrl, inv.source.metadata);
   const renderedPath = interpolate(request.path, inv.args).replace(/^\/+/, "");
   const baseWithSlash = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
@@ -2376,13 +2419,14 @@ async function executeRestRequest(spec, request, inv) {
   };
   applyCredentials(headers, url, spec.credentialPlacement ?? { kind: "bearer" }, inv.source.credentials);
   if (inv.expectedEtag) headers["if-match"] = inv.expectedEtag;
-  if (request.method !== "GET" && request.method !== "DELETE") {
+  const sendsBody = request.method !== "GET" && (request.method !== "DELETE" || request.body !== void 0);
+  if (sendsBody) {
     headers["content-type"] = headers["content-type"] ?? "application/json";
   }
   const res = await fetch(url, {
     method: request.method,
     headers,
-    body: request.method === "GET" || request.method === "DELETE" ? void 0 : JSON.stringify(resolveBody(request.body, inv.args)),
+    body: sendsBody ? JSON.stringify(resolveBody(request.body, inv.args, requiredArgs)) : void 0,
     signal: AbortSignal.timeout(2e4)
   });
   if (res.status === 401 || res.status === 403) {
@@ -2410,7 +2454,14 @@ async function executeRestRequest(spec, request, inv) {
     throw new Error(`${spec.kind} ${request.method} ${url.pathname} HTTP ${res.status}: ${(await safeErrorText(res)).slice(0, 300)}`);
   }
   const text = await res.text();
-  const data = text ? JSON.parse(text) : null;
+  let data = null;
+  if (text) {
+    try {
+      data = JSON.parse(text);
+    } catch {
+      data = { raw: text };
+    }
+  }
   return { data, etag: res.headers.get("etag") ?? void 0 };
 }
 function resolveBaseUrl(baseUrl, metadata) {
@@ -2431,28 +2482,47 @@ function credentialToken(credentials) {
   if (credentials.kind === "api-key") return credentials.apiKey;
   throw new Error(`declarative REST connectors require oauth2 or api-key credentials, got ${credentials.kind}`);
 }
-function resolveBody(body, args) {
+function resolveBody(body, args, requiredArgs) {
   if (!body || body === "args") return args;
-  if (typeof body === "string") return renderValue(body, args);
-  return renderObject(body, args);
+  if (typeof body === "string") return renderValue(body, args, requiredArgs);
+  return renderObject(body, args, requiredArgs);
 }
 function renderHeaders(headers, args) {
   return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, interpolate(value, args)]));
 }
-function renderObject(input, args) {
-  return Object.fromEntries(Object.entries(input).map(([key, value]) => [key, renderValue(value, args)]));
+function renderObject(input, args, requiredArgs) {
+  const out = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (typeof value === "string") {
+      const exact = value.match(/^\{([a-zA-Z0-9_.-]+)\}$/);
+      if (exact) {
+        const name = exact[1];
+        const resolved = readPath(args, name);
+        if (resolved === void 0 || resolved === null) {
+          if (requiredArgs?.includes(name)) {
+            throw new Error(`missing required argument: ${name}`);
+          }
+          continue;
+        }
+        out[key] = resolved;
+        continue;
+      }
+    }
+    out[key] = renderValue(value, args, requiredArgs);
+  }
+  return out;
 }
-function renderValue(value, args) {
+function renderValue(value, args, requiredArgs) {
   if (typeof value === "string") {
     const exact = value.match(/^\{([a-zA-Z0-9_.-]+)\}$/);
     if (exact) return readRequiredPath(args, exact[1]);
     return interpolate(value, args);
   }
   if (Array.isArray(value)) {
-    return value.map((entry) => renderValue(entry, args));
+    return value.map((entry) => renderValue(entry, args, requiredArgs));
   }
   if (value && typeof value === "object") {
-    return renderObject(value, args);
+    return renderObject(value, args, requiredArgs);
   }
   return value;
 }
@@ -120259,6 +120329,4262 @@ var pipedreamConnector = declarativeRestConnector({
   ]
 });
 
+// src/connectors/adapters/amplemarket.ts
+var amplemarketConnector = declarativeRestConnector({
+  kind: "amplemarket",
+  displayName: "Amplemarket",
+  description: "Sales intelligence and outbound platform: search and enrich people and companies, validate emails, and add leads to sequences.",
+  auth: {
+    kind: "api-key",
+    hint: "Generate an API key in the Amplemarket dashboard (Settings -> API). Sent as the Authorization: Bearer header."
+  },
+  category: "crm",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.amplemarket.com",
+  credentialPlacement: { kind: "bearer" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/account-info" },
+  capabilities: [
+    {
+      name: "people.search",
+      class: "read",
+      description: "Search for people by job function, company, industry and other filters.",
+      parameters: {
+        type: "object",
+        properties: {
+          page: { type: "integer", description: "Page number." },
+          page_size: { type: "integer", description: "Results per page." },
+          job_functions: {
+            type: "array",
+            items: { type: "string" },
+            description: "Job functions to filter by."
+          },
+          industries: {
+            type: "array",
+            items: { type: "string" },
+            description: "Industries to filter by."
+          }
+        },
+        required: []
+      },
+      request: {
+        method: "POST",
+        path: "/people/search",
+        body: {
+          page: "{page}",
+          page_size: "{page_size}",
+          job_functions: "{job_functions}",
+          industries: "{industries}"
+        }
+      }
+    },
+    {
+      name: "people.find",
+      class: "mutation",
+      description: "Enrich a single person by LinkedIn URL, email, or full name plus company. Consumes credits when contact data is revealed.",
+      parameters: {
+        type: "object",
+        properties: {
+          linkedin_url: { type: "string", description: "LinkedIn profile URL." },
+          email: { type: "string", description: "Known email address." },
+          full_name: { type: "string", description: "Person's full name." },
+          company_name: { type: "string", description: "Company name (use with full_name)." }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/people/find",
+        query: {
+          linkedin_url: "{linkedin_url}",
+          email: "{email}",
+          full_name: "{full_name}",
+          company_name: "{company_name}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "companies.find",
+      class: "read",
+      description: "Enrich a single company by LinkedIn URL, domain, or name.",
+      parameters: {
+        type: "object",
+        properties: {
+          linkedin_url: { type: "string", description: "Company LinkedIn URL." },
+          domain: { type: "string", description: "Company domain." },
+          name: { type: "string", description: "Company name." }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/companies/find",
+        query: { linkedin_url: "{linkedin_url}", domain: "{domain}", name: "{name}" }
+      }
+    },
+    {
+      name: "email.validate",
+      class: "mutation",
+      description: "Start a batch email validation job. Consumes one email credit per validated address.",
+      parameters: {
+        type: "object",
+        properties: {
+          emails: {
+            type: "array",
+            items: { type: "object", properties: { email: { type: "string" } } },
+            description: "List of email objects to validate."
+          }
+        },
+        required: ["emails"]
+      },
+      request: { method: "POST", path: "/email-validations", body: { emails: "{emails}" } },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "sequence.add_leads",
+      class: "mutation",
+      description: "Add one or more leads to an existing Amplemarket sequence.",
+      parameters: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Sequence ID." },
+          leads: {
+            type: "array",
+            items: { type: "object" },
+            description: "Array of lead objects to enroll."
+          }
+        },
+        required: ["id", "leads"]
+      },
+      request: { method: "POST", path: "/sequences/{id}/leads", body: { leads: "{leads}" } },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
+// src/connectors/adapters/heyreach.ts
+var heyreachConnector = declarativeRestConnector({
+  kind: "heyreach",
+  displayName: "HeyReach",
+  description: "LinkedIn outreach automation at agency scale. List campaigns and lists, add leads to campaigns, look up leads, and read inbox conversations.",
+  auth: {
+    kind: "api-key",
+    hint: "Generate an API key in HeyReach (Settings -> Integrations -> Public API). Sent as the X-API-KEY header."
+  },
+  category: "crm",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.heyreach.io/api/public",
+  credentialPlacement: { kind: "header", header: "X-API-KEY" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/auth/CheckApiKey" },
+  capabilities: [
+    {
+      name: "campaign.list",
+      class: "read",
+      description: "List campaigns in the workspace with pagination.",
+      parameters: {
+        type: "object",
+        properties: {
+          offset: { type: "integer", description: "Number of records to skip." },
+          limit: { type: "integer", description: "Maximum records to return." }
+        },
+        required: ["offset", "limit"]
+      },
+      request: {
+        method: "POST",
+        path: "/campaign/GetAll",
+        body: { offset: "{offset}", limit: "{limit}" }
+      }
+    },
+    {
+      name: "list.list",
+      class: "read",
+      description: "List lead lists in the workspace with pagination.",
+      parameters: {
+        type: "object",
+        properties: {
+          offset: { type: "integer", description: "Number of records to skip." },
+          limit: { type: "integer", description: "Maximum records to return." }
+        },
+        required: ["offset", "limit"]
+      },
+      request: {
+        method: "POST",
+        path: "/list/GetAll",
+        body: { offset: "{offset}", limit: "{limit}" }
+      }
+    },
+    {
+      name: "lead.get",
+      class: "read",
+      description: "Get details for a lead by their LinkedIn profile URL.",
+      parameters: {
+        type: "object",
+        properties: {
+          profileUrl: { type: "string", description: "LinkedIn profile URL of the lead." }
+        },
+        required: ["profileUrl"]
+      },
+      request: {
+        method: "POST",
+        path: "/lead/GetLead",
+        body: { profileUrl: "{profileUrl}" }
+      }
+    },
+    {
+      name: "campaign.add_leads",
+      class: "mutation",
+      description: "Add leads (LinkedIn profiles) to an active campaign, assigned to specific sender accounts.",
+      parameters: {
+        type: "object",
+        properties: {
+          campaignId: {
+            type: "integer",
+            description: "Target campaign ID (must be ACTIVE or IN_PROGRESS)."
+          },
+          accountLeadPairs: {
+            type: "array",
+            description: "Array of pairs, each with an optional linkedInAccountId (sender) and a lead object (profileUrl, firstName, lastName, companyName, position, location, emailAddress).",
+            items: { type: "object" }
+          }
+        },
+        required: ["campaignId", "accountLeadPairs"]
+      },
+      request: {
+        method: "POST",
+        path: "/campaign/AddLeadsToCampaignV2",
+        body: { campaignId: "{campaignId}", accountLeadPairs: "{accountLeadPairs}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "inbox.get_conversations",
+      class: "read",
+      description: "Retrieve inbox conversations with filtering and pagination.",
+      parameters: {
+        type: "object",
+        properties: {
+          offset: { type: "integer", description: "Number of records to skip." },
+          limit: { type: "integer", description: "Maximum records to return." },
+          filters: { type: "object", description: "Optional conversation filters." }
+        },
+        required: ["offset", "limit"]
+      },
+      request: {
+        method: "POST",
+        path: "/inbox/GetConversationsV2",
+        body: { offset: "{offset}", limit: "{limit}", filters: "{filters}" }
+      }
+    }
+  ]
+});
+
+// src/connectors/adapters/lagrowthmachine.ts
+var lagrowthmachineConnector = declarativeRestConnector({
+  kind: "lagrowthmachine",
+  displayName: "LaGrowthMachine",
+  description: "Multichannel sales automation (LinkedIn, email, Twitter). Create or update leads in audiences, list campaigns and audiences, and read campaign stats.",
+  auth: {
+    kind: "api-key",
+    hint: "Get your API key at app.lagrowthmachine.com/settings/api. Sent as the 'apikey' query parameter on every request."
+  },
+  category: "crm",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://apiv2.lagrowthmachine.com",
+  credentialPlacement: { kind: "query", parameter: "apikey" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/flow/audiences" },
+  capabilities: [
+    {
+      name: "campaigns.list",
+      class: "read",
+      description: "List campaigns with pagination.",
+      parameters: {
+        type: "object",
+        properties: {
+          skip: { type: "integer", description: "Pagination offset." },
+          limit: { type: "integer", description: "Maximum results to return." }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/flow/campaigns",
+        query: { skip: "{skip}", limit: "{limit}" }
+      }
+    },
+    {
+      name: "audiences.list",
+      class: "read",
+      description: "List the audiences in the workspace.",
+      parameters: { type: "object", properties: {}, required: [] },
+      request: { method: "GET", path: "/flow/audiences" }
+    },
+    {
+      name: "campaign.get_stats",
+      class: "read",
+      description: "Get engagement statistics for a campaign.",
+      parameters: {
+        type: "object",
+        properties: { campaignId: { type: "string", description: "Campaign ID." } },
+        required: ["campaignId"]
+      },
+      request: { method: "GET", path: "/flow/campaigns/{campaignId}/stats" }
+    },
+    {
+      name: "lead.create_or_update",
+      class: "mutation",
+      description: "Create or update a lead in an audience, which starts it through the audience's workflow.",
+      parameters: {
+        type: "object",
+        properties: {
+          audience: { type: "string", description: "Audience name or identifier." },
+          proEmail: { type: "string", description: "Professional email." },
+          persoEmail: { type: "string", description: "Personal email." },
+          linkedinUrl: { type: "string", description: "LinkedIn profile URL." },
+          firstname: { type: "string", description: "First name." },
+          lastname: { type: "string", description: "Last name." },
+          companyName: { type: "string", description: "Company name." },
+          jobTitle: { type: "string", description: "Job title." }
+        },
+        required: ["audience"]
+      },
+      request: {
+        method: "POST",
+        path: "/flow/leads",
+        body: {
+          audience: "{audience}",
+          proEmail: "{proEmail}",
+          persoEmail: "{persoEmail}",
+          linkedinUrl: "{linkedinUrl}",
+          firstname: "{firstname}",
+          lastname: "{lastname}",
+          companyName: "{companyName}",
+          jobTitle: "{jobTitle}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
+// src/connectors/adapters/saleshandy.ts
+var saleshandyConnector = declarativeRestConnector({
+  kind: "saleshandy",
+  displayName: "Saleshandy",
+  description: "Cold email outreach platform: manage prospects, build sequences, add prospects to sequence steps, and control sequence status.",
+  auth: {
+    kind: "api-key",
+    hint: "Generate an API key in company Settings -> API Settings. Sent as the x-api-key header."
+  },
+  category: "crm",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://open-api.saleshandy.com",
+  credentialPlacement: { kind: "header", header: "x-api-key" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/v1/user/team-member-list" },
+  capabilities: [
+    {
+      name: "sequences.list",
+      class: "read",
+      description: "List sequences and their steps.",
+      parameters: {
+        type: "object",
+        properties: {
+          sequenceName: { type: "string", description: "Filter by sequence name." },
+          page: { type: "integer", description: "Page number." },
+          pageSize: { type: "integer", description: "Results per page." }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/v1/sequences",
+        query: { sequenceName: "{sequenceName}", page: "{page}", pageSize: "{pageSize}" }
+      }
+    },
+    {
+      name: "prospects.list",
+      class: "read",
+      description: "List all prospects with pagination and search.",
+      parameters: {
+        type: "object",
+        properties: {
+          search: { type: "string", description: "Search term." },
+          page: { type: "integer", description: "Page number." },
+          pageSize: { type: "integer", description: "Results per page." }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/v1/prospects",
+        query: { search: "{search}", page: "{page}", pageSize: "{pageSize}" }
+      }
+    },
+    {
+      name: "sequence.import_prospects",
+      class: "mutation",
+      description: "Import prospects (keyed by field name) into a sequence at a given step.",
+      parameters: {
+        type: "object",
+        properties: {
+          prospectList: {
+            type: "array",
+            description: "Array of prospect objects keyed by field name (e.g. Email, First Name).",
+            items: { type: "object" }
+          },
+          stepId: { type: "integer", description: "Sequence step ID to add prospects to." },
+          conflictAction: {
+            type: "string",
+            description: "How to handle duplicates (e.g. skip, update)."
+          },
+          verifyProspects: { type: "boolean", description: "Verify emails on import." },
+          tags: { type: "array", items: { type: "string" }, description: "Tags to apply." }
+        },
+        required: ["prospectList", "stepId", "conflictAction"]
+      },
+      request: {
+        method: "POST",
+        path: "/v1/sequences/prospects/import-with-field-name",
+        body: {
+          prospectList: "{prospectList}",
+          stepId: "{stepId}",
+          conflictAction: "{conflictAction}",
+          verifyProspects: "{verifyProspects}",
+          tags: "{tags}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "sequence.set_status",
+      class: "mutation",
+      description: "Activate or pause one or more sequences.",
+      parameters: {
+        type: "object",
+        properties: {
+          sequenceIds: {
+            type: "array",
+            items: { type: "string" },
+            description: "Sequence IDs to update."
+          },
+          status: { type: "string", description: "Target status (e.g. ACTIVE, PAUSED)." }
+        },
+        required: ["sequenceIds", "status"]
+      },
+      request: {
+        method: "POST",
+        path: "/v1/sequences/status",
+        body: { sequenceIds: "{sequenceIds}", status: "{status}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
+// src/connectors/adapters/bettercontact.ts
+var bettercontactConnector = declarativeRestConnector({
+  kind: "bettercontact",
+  displayName: "BetterContact",
+  description: "Waterfall email and phone enrichment that queries 20+ data providers to find a contact's work email and direct phone number.",
+  auth: {
+    kind: "api-key",
+    hint: "API key from the BetterContact dashboard (Settings -> API). Sent as the X-API-Key header."
+  },
+  category: "crm",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://app.bettercontact.rocks/api/v2",
+  credentialPlacement: { kind: "header", header: "X-API-Key" },
+  defaultHeaders: { "content-type": "application/json" },
+  capabilities: [
+    {
+      name: "enrichment.create",
+      class: "mutation",
+      description: "Start an asynchronous waterfall enrichment for 1-100 contacts to find work emails and/or direct phone numbers. Consumes credits per found data point.",
+      parameters: {
+        type: "object",
+        properties: {
+          data: {
+            type: "array",
+            description: "Array of 1-100 lead objects to enrich; each supports first_name, last_name, company, company_domain, linkedin_url, and custom_fields.",
+            items: { type: "object" }
+          },
+          enrich_email_address: { type: "boolean", description: "If true, enrich the work email address." },
+          enrich_phone_number: { type: "boolean", description: "If true, enrich the direct phone number." },
+          webhook: {
+            type: "string",
+            description: "Optional URL to which results are pushed when enrichment completes."
+          }
+        },
+        required: ["data", "enrich_email_address", "enrich_phone_number"]
+      },
+      request: {
+        method: "POST",
+        path: "/async",
+        body: {
+          data: "{data}",
+          enrich_email_address: "{enrich_email_address}",
+          enrich_phone_number: "{enrich_phone_number}",
+          webhook: "{webhook}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "enrichment.get",
+      class: "read",
+      description: "Retrieve the status and enriched results of a previously submitted enrichment request by its request id.",
+      parameters: {
+        type: "object",
+        properties: {
+          request_id: { type: "string", description: "The id returned by enrichment.create." }
+        },
+        required: ["request_id"]
+      },
+      request: { method: "GET", path: "/async/{request_id}" }
+    }
+  ]
+});
+
+// src/connectors/adapters/contactout.ts
+var contactoutConnector = declarativeRestConnector({
+  kind: "contactout",
+  displayName: "ContactOut",
+  description: "Find and enrich professional and personal emails, phone numbers, and LinkedIn data for prospects.",
+  auth: {
+    kind: "api-key",
+    hint: "API token from your ContactOut account. Sent as the 'token' header."
+  },
+  category: "crm",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.contactout.com",
+  credentialPlacement: { kind: "header", header: "token" },
+  defaultHeaders: { "content-type": "application/json" },
+  capabilities: [
+    {
+      name: "people.search",
+      class: "read",
+      description: "Search for people profiles matching criteria such as name, job title, company, and location.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          job_title: { type: "array", items: { type: "string" } },
+          company: { type: "array", items: { type: "string" } },
+          location: { type: "array", items: { type: "string" } },
+          page: { type: "integer", description: "Result page number." },
+          reveal_info: {
+            type: "boolean",
+            description: "Include contact data (consumes email/phone credits)."
+          }
+        },
+        required: []
+      },
+      request: {
+        method: "POST",
+        path: "/v1/people/search",
+        body: {
+          name: "{name}",
+          job_title: "{job_title}",
+          company: "{company}",
+          location: "{location}",
+          page: "{page}",
+          reveal_info: "{reveal_info}"
+        }
+      }
+    },
+    {
+      name: "linkedin.enrich",
+      class: "mutation",
+      description: "Look up a LinkedIn profile URL and return contact data including emails and phones. Consumes credits when contact info is found.",
+      parameters: {
+        type: "object",
+        properties: {
+          profile: { type: "string", description: "URL-encoded LinkedIn profile URL." },
+          profile_only: {
+            type: "boolean",
+            description: "If true, return profile data without contact info."
+          }
+        },
+        required: ["profile"]
+      },
+      request: {
+        method: "GET",
+        path: "/v1/linkedin/enrich",
+        query: { profile: "{profile}", profile_only: "{profile_only}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "people.enrich",
+      class: "mutation",
+      description: "Enrich a person from a LinkedIn URL, email, or name plus company. Returns work/personal emails and phones; consumes credits when found.",
+      parameters: {
+        type: "object",
+        properties: {
+          linkedin_url: { type: "string" },
+          email: { type: "string" },
+          full_name: { type: "string" },
+          company: { type: "string" },
+          company_domain: { type: "string" },
+          include: {
+            type: "array",
+            description: "Data types to include, e.g. work_email, personal_email, phone.",
+            items: { type: "string" }
+          }
+        },
+        required: []
+      },
+      request: {
+        method: "POST",
+        path: "/v1/people/enrich",
+        body: {
+          linkedin_url: "{linkedin_url}",
+          email: "{email}",
+          full_name: "{full_name}",
+          company: "{company}",
+          company_domain: "{company_domain}",
+          include: "{include}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "email.verify",
+      class: "mutation",
+      description: "Verify the deliverability of an email address. Consumes a verifier credit for definitive results.",
+      parameters: {
+        type: "object",
+        properties: { email: { type: "string" } },
+        required: ["email"]
+      },
+      request: { method: "GET", path: "/v1/email/verify", query: { email: "{email}" } },
+      cas: "native-idempotency",
+      externalEffect: false
+    }
+  ]
+});
+
+// src/connectors/adapters/findymail.ts
+var findymailConnector = declarativeRestConnector({
+  kind: "findymail",
+  displayName: "Findymail",
+  description: "Find verified work email addresses by name and company domain, verify deliverability, and discover emails across a domain.",
+  auth: {
+    kind: "api-key",
+    hint: "API key from your Findymail dashboard. Sent as the Authorization: Bearer header."
+  },
+  category: "crm",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://app.findymail.com",
+  credentialPlacement: { kind: "bearer" },
+  defaultHeaders: { "content-type": "application/json", accept: "application/json" },
+  test: { method: "GET", path: "/api/credits" },
+  capabilities: [
+    {
+      name: "email.find",
+      class: "mutation",
+      description: "Find a person's verified work email from their full name and company domain. Consumes a credit when an email is found.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Full name of the person." },
+          domain: { type: "string", description: "Company domain." }
+        },
+        required: ["name", "domain"]
+      },
+      request: {
+        method: "POST",
+        path: "/api/search/name",
+        body: { name: "{name}", domain: "{domain}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "email.verify",
+      class: "mutation",
+      description: "Verify the deliverability of an email address and return the email provider. Consumes a verification credit.",
+      parameters: {
+        type: "object",
+        properties: { email: { type: "string" } },
+        required: ["email"]
+      },
+      request: { method: "POST", path: "/api/verify", body: { email: "{email}" } },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "email.find_by_domain",
+      class: "mutation",
+      description: "Find email addresses associated with a company domain. Consumes credits per email returned.",
+      parameters: {
+        type: "object",
+        properties: { domain: { type: "string", description: "Company domain to search." } },
+        required: ["domain"]
+      },
+      request: { method: "POST", path: "/api/search/domain", body: { domain: "{domain}" } },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "credits.get",
+      class: "read",
+      description: "Retrieve the remaining credit balance for the account.",
+      parameters: { type: "object", properties: {}, required: [] },
+      request: { method: "GET", path: "/api/credits" }
+    }
+  ]
+});
+
+// src/connectors/adapters/snov-io.ts
+var snovIoConnector = declarativeRestConnector({
+  kind: "snov-io",
+  displayName: "Snov.io",
+  description: "Find and verify B2B email addresses by domain or by name, and enrich profiles from an email address.",
+  auth: {
+    kind: "api-key",
+    hint: "Exchange your API User ID and Secret (account Settings -> API) for an access token via POST /v1/oauth/access_token, then paste the access token here. Sent as the Authorization: Bearer header."
+  },
+  category: "crm",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.snov.io",
+  credentialPlacement: { kind: "bearer" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/v2/sender-accounts/emails" },
+  capabilities: [
+    {
+      name: "domain_search.start",
+      class: "mutation",
+      description: "Start an asynchronous search for email addresses belonging to a company domain. Returns a task to poll for results.",
+      parameters: {
+        type: "object",
+        properties: { domain: { type: "string", description: "Company domain to search." } },
+        required: ["domain"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/domain-search/start",
+        body: { domain: "{domain}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "email_finder.start",
+      class: "mutation",
+      description: "Start finding email addresses for one or more people by first name, last name, and company domain. Returns a task to poll; consumes credits when emails are found.",
+      parameters: {
+        type: "object",
+        properties: {
+          rows: {
+            type: "array",
+            description: "Array of objects each with first_name, last_name, and domain.",
+            items: { type: "object" }
+          }
+        },
+        required: ["rows"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/emails-by-domain-by-name/start",
+        body: { rows: "{rows}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "email_verification.start",
+      class: "mutation",
+      description: "Start verification of up to 10 email addresses. Returns a task to poll for deliverability results. Consumes credits.",
+      parameters: {
+        type: "object",
+        properties: {
+          emails: {
+            type: "array",
+            description: "Array of email addresses to verify (max 10).",
+            items: { type: "string" }
+          }
+        },
+        required: ["emails"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/email-verification/start",
+        body: { emails: "{emails}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "profile.get_by_email",
+      class: "mutation",
+      description: "Enrich a social/professional profile from an email address. Consumes a credit.",
+      parameters: {
+        type: "object",
+        properties: { email: { type: "string" } },
+        required: ["email"]
+      },
+      request: {
+        method: "POST",
+        path: "/v1/get-profile-by-email",
+        body: { email: "{email}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "domain_emails_count.get",
+      class: "read",
+      description: "Get the count of email addresses available for a domain (free, does not consume credits).",
+      parameters: {
+        type: "object",
+        properties: { domain: { type: "string" } },
+        required: ["domain"]
+      },
+      request: {
+        method: "POST",
+        path: "/v1/get-domain-emails-count",
+        body: { domain: "{domain}" }
+      }
+    }
+  ]
+});
+
+// src/connectors/adapters/wiza.ts
+var wizaConnector = declarativeRestConnector({
+  kind: "wiza",
+  displayName: "Wiza",
+  description: "Real-time contact enrichment that reveals a person's work/personal email and phone from a LinkedIn URL, email, or name plus company.",
+  auth: {
+    kind: "api-key",
+    hint: "API key from Wiza account settings. Sent as the Authorization: Bearer header."
+  },
+  category: "crm",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://wiza.co/api",
+  credentialPlacement: { kind: "bearer" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/meta/credits" },
+  capabilities: [
+    {
+      name: "individual_reveal.create",
+      class: "mutation",
+      description: "Start a real-time individual reveal to enrich one contact's email and phone from a LinkedIn URL, email, or name plus company/domain. Consumes credits.",
+      parameters: {
+        type: "object",
+        properties: {
+          individual_reveal: {
+            type: "object",
+            description: "Contact identifiers: full_name + company or domain, OR email, OR linkedin (profile URL)."
+          },
+          enrichment_level: { type: "string", description: "One of none, partial, phone, or full." },
+          email_options: {
+            type: "object",
+            description: "Object with accept_work and accept_personal booleans."
+          },
+          phone_options: { type: "object", description: "Phone enrichment options." }
+        },
+        required: ["individual_reveal", "enrichment_level"]
+      },
+      request: {
+        method: "POST",
+        path: "/individual_reveals",
+        body: {
+          individual_reveal: "{individual_reveal}",
+          enrichment_level: "{enrichment_level}",
+          email_options: "{email_options}",
+          phone_options: "{phone_options}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "individual_reveal.get",
+      class: "read",
+      description: "Retrieve the status and revealed contact data of an individual reveal by its id.",
+      parameters: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "The individual reveal id returned by individual_reveal.create."
+          }
+        },
+        required: ["id"]
+      },
+      request: { method: "GET", path: "/individual_reveals/{id}" }
+    },
+    {
+      name: "list.create",
+      class: "mutation",
+      description: "Create a list to enrich up to 2500 profiles in bulk with email and phone data. Consumes credits.",
+      parameters: {
+        type: "object",
+        properties: {
+          list: {
+            type: "object",
+            description: "List config including name, enrichment_level, email_options, and items (array of up to 2500 profiles)."
+          }
+        },
+        required: ["list"]
+      },
+      request: { method: "POST", path: "/lists", body: { list: "{list}" } },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "credits.get",
+      class: "read",
+      description: "Get the account's remaining email, phone, export, and API credit balances.",
+      parameters: { type: "object", properties: {}, required: [] },
+      request: { method: "GET", path: "/meta/credits" }
+    }
+  ]
+});
+
+// src/connectors/adapters/builtwith.ts
+var builtwithConnector = declarativeRestConnector({
+  kind: "builtwith",
+  displayName: "BuiltWith",
+  description: "Look up the technology stack, analytics, hosting, and metadata detected on any website.",
+  auth: {
+    kind: "api-key",
+    hint: "API key (a UUID) from your BuiltWith account dashboard under My Account -> API Access. Sent as the KEY query parameter."
+  },
+  category: "market-intelligence",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.builtwith.com/v22",
+  credentialPlacement: { kind: "query", parameter: "KEY" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/free1/api.json", query: { LOOKUP: "builtwith.com" } },
+  capabilities: [
+    {
+      name: "domain.lookup",
+      class: "read",
+      description: "Return the full set of detected technologies and metadata for one or more root domains.",
+      parameters: {
+        type: "object",
+        properties: {
+          lookup: {
+            type: "string",
+            description: "Root domain to analyze, e.g. stripe.com. Up to 16 domains may be passed as a comma-separated list."
+          }
+        },
+        required: ["lookup"]
+      },
+      request: { method: "GET", path: "/api.json", query: { LOOKUP: "{lookup}" } }
+    },
+    {
+      name: "domain.free",
+      class: "read",
+      description: "Free-tier lookup returning the most popular detected technology groups for a single domain.",
+      parameters: {
+        type: "object",
+        properties: { lookup: { type: "string", description: "Root domain to analyze." } },
+        required: ["lookup"]
+      },
+      request: { method: "GET", path: "/free1/api.json", query: { LOOKUP: "{lookup}" } }
+    },
+    {
+      name: "domain.relationships",
+      class: "read",
+      description: "Return domains that share relationships (e.g. analytics IDs, ad networks) with the given domain.",
+      parameters: {
+        type: "object",
+        properties: {
+          lookup: { type: "string", description: "Root domain to find related domains for." }
+        },
+        required: ["lookup"]
+      },
+      request: { method: "GET", path: "/rv2/api.json", query: { LOOKUP: "{lookup}" } }
+    },
+    {
+      name: "company.to_url",
+      class: "read",
+      description: "Resolve a company name to its most likely website domain.",
+      parameters: {
+        type: "object",
+        properties: {
+          company: { type: "string", description: "Company name to resolve to a domain." }
+        },
+        required: ["company"]
+      },
+      request: { method: "GET", path: "/ctu1/api.json", query: { COMPANY: "{company}" } }
+    }
+  ]
+});
+
+// src/connectors/adapters/common-room.ts
+var commonRoomConnector = declarativeRestConnector({
+  kind: "common-room",
+  displayName: "Common Room",
+  description: "Look up community and customer contacts, their activity, segments, and tags from your Common Room workspace.",
+  auth: {
+    kind: "api-key",
+    hint: "Core API token from Common Room Settings -> API tokens (created by a workspace Admin). Sent as the Authorization: Bearer header."
+  },
+  category: "sales-intelligence",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.commonroom.io/community/v1",
+  credentialPlacement: { kind: "bearer" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/api-token-status" },
+  capabilities: [
+    {
+      name: "contact.get_by_email",
+      class: "read",
+      description: "Return a contact's full Common Room profile given their email address.",
+      parameters: {
+        type: "object",
+        properties: {
+          email: { type: "string", description: "Email address of the contact to look up." }
+        },
+        required: ["email"]
+      },
+      request: { method: "GET", path: "/user/{email}" }
+    },
+    {
+      name: "contact.search",
+      class: "read",
+      description: "Find contacts by email or linked social handles (Twitter, GitHub, LinkedIn).",
+      parameters: {
+        type: "object",
+        properties: {
+          email: { type: "string", description: "Email address to search by." },
+          github: { type: "string", description: "GitHub username to search by." },
+          twitter: { type: "string", description: "Twitter/X handle to search by." },
+          linkedin: {
+            type: "string",
+            description: "LinkedIn profile URL or handle to search by."
+          }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/members",
+        query: {
+          email: "{email}",
+          github: "{github}",
+          twitter: "{twitter}",
+          linkedin: "{linkedin}"
+        }
+      }
+    },
+    {
+      name: "activity_types.list",
+      class: "read",
+      description: "List the activity types available in the workspace.",
+      parameters: { type: "object", properties: {}, required: [] },
+      request: { method: "GET", path: "/activityTypes" }
+    },
+    {
+      name: "segments.list",
+      class: "read",
+      description: "List the segments defined in the workspace.",
+      parameters: { type: "object", properties: {}, required: [] },
+      request: { method: "GET", path: "/segments" }
+    },
+    {
+      name: "contact.upsert",
+      class: "mutation",
+      description: "Create or update a contact in a destination source, optionally setting fields and custom fields.",
+      parameters: {
+        type: "object",
+        properties: {
+          destinationSourceId: {
+            type: "string",
+            description: "ID of the destination source to write the contact into."
+          },
+          fullName: { type: "string", description: "Full name of the contact." },
+          email: { type: "string", description: "Email address of the contact." }
+        },
+        required: ["destinationSourceId"]
+      },
+      request: {
+        method: "POST",
+        path: "/source/{destinationSourceId}/user",
+        body: { fullName: "{fullName}", email: "{email}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
+// src/connectors/adapters/leadfeeder.ts
+var leadfeederConnector = declarativeRestConnector({
+  kind: "leadfeeder",
+  displayName: "Leadfeeder",
+  description: "Identify the company behind a website-visitor IP address, returning firmographic details and a confidence score.",
+  auth: {
+    kind: "api-key",
+    hint: "API key from Leadfeeder (Dealfront) Settings -> API keys. Sent in the X-API-KEY request header."
+  },
+  category: "sales-intelligence",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.lf-discover.com",
+  credentialPlacement: { kind: "header", header: "X-API-KEY" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/companies", query: { ip: "185.70.216.139" } },
+  capabilities: [
+    {
+      name: "ip.enrich",
+      class: "read",
+      description: "Resolve an IPv4 or IPv6 address to the company that owns it, including name, domain, industry, size, revenue, location, and confidence.",
+      parameters: {
+        type: "object",
+        properties: {
+          ip: {
+            type: "string",
+            description: "Valid IPv4 or shortened IPv6 address to enrich, e.g. 185.70.216.139."
+          }
+        },
+        required: ["ip"]
+      },
+      request: { method: "GET", path: "/companies", query: { ip: "{ip}" } }
+    }
+  ]
+});
+
+// src/connectors/adapters/serper.ts
+var serperConnector = declarativeRestConnector({
+  kind: "serper",
+  displayName: "Serper",
+  description: "Run fast Google searches (web, news, images, places, and scholar) and get structured SERP results as JSON.",
+  auth: {
+    kind: "api-key",
+    hint: "API key from your serper.dev dashboard. Sent in the X-API-KEY request header."
+  },
+  category: "market-intelligence",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://google.serper.dev",
+  credentialPlacement: { kind: "header", header: "X-API-KEY" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "POST", path: "/search", body: { q: "OpenAI" } },
+  capabilities: [
+    {
+      name: "search.web",
+      class: "read",
+      description: "Run a Google web search and return organic results, knowledge graph, answer box, and related searches.",
+      parameters: {
+        type: "object",
+        properties: {
+          q: { type: "string", description: "The search query." },
+          gl: {
+            type: "string",
+            description: "Two-letter country code for geo-targeting, e.g. us."
+          },
+          hl: { type: "string", description: "Two-letter language code, e.g. en." },
+          num: { type: "integer", description: "Number of results to return." },
+          page: { type: "integer", description: "Results page number." }
+        },
+        required: ["q"]
+      },
+      request: {
+        method: "POST",
+        path: "/search",
+        body: { q: "{q}", gl: "{gl}", hl: "{hl}", num: "{num}", page: "{page}" }
+      }
+    },
+    {
+      name: "search.news",
+      class: "read",
+      description: "Run a Google News search and return structured news results.",
+      parameters: {
+        type: "object",
+        properties: {
+          q: { type: "string", description: "The news search query." },
+          gl: { type: "string", description: "Two-letter country code." },
+          hl: { type: "string", description: "Two-letter language code." }
+        },
+        required: ["q"]
+      },
+      request: { method: "POST", path: "/news", body: { q: "{q}", gl: "{gl}", hl: "{hl}" } }
+    },
+    {
+      name: "search.places",
+      class: "read",
+      description: "Run a Google Maps/Places search and return structured place results.",
+      parameters: {
+        type: "object",
+        properties: {
+          q: { type: "string", description: "The places search query." },
+          gl: { type: "string", description: "Two-letter country code." }
+        },
+        required: ["q"]
+      },
+      request: { method: "POST", path: "/places", body: { q: "{q}", gl: "{gl}" } }
+    },
+    {
+      name: "search.scholar",
+      class: "read",
+      description: "Run a Google Scholar search and return structured academic results.",
+      parameters: {
+        type: "object",
+        properties: { q: { type: "string", description: "The scholar search query." } },
+        required: ["q"]
+      },
+      request: { method: "POST", path: "/scholar", body: { q: "{q}" } }
+    },
+    {
+      name: "search.images",
+      class: "read",
+      description: "Run a Google Images search and return structured image results.",
+      parameters: {
+        type: "object",
+        properties: {
+          q: { type: "string", description: "The image search query." },
+          gl: { type: "string", description: "Two-letter country code." }
+        },
+        required: ["q"]
+      },
+      request: { method: "POST", path: "/images", body: { q: "{q}", gl: "{gl}" } }
+    }
+  ]
+});
+
+// src/connectors/adapters/warmly.ts
+var warmlyConnector = declarativeRestConnector({
+  kind: "warmly",
+  displayName: "Warmly",
+  description: "List identified website visitors and visiting accounts from your Warmly workspace via its agent-tools API.",
+  auth: {
+    kind: "api-key",
+    hint: "Per-organization API key from the Warmly admin UI. Sent as the Authorization: Bearer header; organizationId must be included in each request body."
+  },
+  category: "sales-intelligence",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://opps-api.getwarmly.com/api",
+  credentialPlacement: { kind: "bearer" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/agent-tools/tools" },
+  capabilities: [
+    {
+      name: "tools.list",
+      class: "read",
+      description: "Discover the available agent tools and their input JSON schemas for your workspace.",
+      parameters: { type: "object", properties: {}, required: [] },
+      request: { method: "GET", path: "/agent-tools/tools" }
+    },
+    {
+      name: "visitors.list",
+      class: "mutation",
+      description: "List identified people who visited your website, with optional filters and pagination. This is a billed read executed via the tool-execution endpoint.",
+      parameters: {
+        type: "object",
+        properties: {
+          organizationId: { type: "string", description: "The organization the API key is issued for." },
+          timeWindow: {
+            type: "string",
+            description: "Lookback window: past_day (default) or past_week."
+          },
+          take: {
+            type: "integer",
+            description: "Number of results to return, 1-500 (default 25)."
+          },
+          offset: { type: "integer", description: "Pagination offset." },
+          searchTerm: { type: "string", description: "Substring match on name, email, or company." }
+        },
+        required: ["organizationId"]
+      },
+      request: {
+        method: "POST",
+        path: "/agent-tools/execute",
+        body: {
+          toolName: "list_warm_visitors",
+          organizationId: "{organizationId}",
+          input: {
+            timeWindow: "{timeWindow}",
+            take: "{take}",
+            offset: "{offset}",
+            searchTerm: "{searchTerm}"
+          }
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "accounts.list",
+      class: "mutation",
+      description: "List company-level aggregations of accounts that visited your website. Billed read executed via the tool-execution endpoint.",
+      parameters: {
+        type: "object",
+        properties: {
+          organizationId: { type: "string", description: "The organization the API key is issued for." },
+          timeWindow: {
+            type: "string",
+            description: "Lookback window: past_day (default) or past_week."
+          },
+          take: { type: "integer", description: "Number of results to return, 1-500." }
+        },
+        required: ["organizationId"]
+      },
+      request: {
+        method: "POST",
+        path: "/agent-tools/execute",
+        body: {
+          toolName: "list_warm_accounts",
+          organizationId: "{organizationId}",
+          input: { timeWindow: "{timeWindow}", take: "{take}" }
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    }
+  ]
+});
+
+// src/connectors/adapters/autobound.ts
+var autoboundConnector = declarativeRestConnector({
+  kind: "autobound",
+  displayName: "Autobound",
+  description: "AI sales-intelligence API that enriches companies and contacts with buyer-intent signals for personalized outreach.",
+  auth: {
+    kind: "api-key",
+    hint: "API key from your Autobound account (Developer Hub). Sent as the X-API-KEY header. Base host is the Signals API at signals.autobound.ai."
+  },
+  category: "sales-intelligence",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://signals.autobound.ai/v1",
+  credentialPlacement: { kind: "header", header: "X-API-KEY" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/account" },
+  capabilities: [
+    {
+      name: "account.get",
+      class: "read",
+      description: "Return account details and rate limits. Consumes no credits.",
+      parameters: { type: "object", properties: {}, required: [] },
+      request: { method: "GET", path: "/account" }
+    },
+    {
+      name: "company.enrich",
+      class: "mutation",
+      description: "Enrich a company with intent and news signals by domain (billed per returned signal).",
+      parameters: {
+        type: "object",
+        properties: {
+          domain: { type: "string" },
+          signal_types: { type: "array", items: { type: "string" } },
+          limit: { type: "integer" }
+        },
+        required: ["domain"]
+      },
+      request: {
+        method: "POST",
+        path: "/companies/enrich",
+        body: { domain: "{domain}", signal_types: "{signal_types}", limit: "{limit}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "company.search",
+      class: "read",
+      description: "Search companies aggregated by entity, filtered by signal type and firmographics.",
+      parameters: {
+        type: "object",
+        properties: {
+          signal_types: { type: "array", items: { type: "string" } },
+          company_domains: { type: "array", items: { type: "string" } },
+          limit: { type: "integer" }
+        },
+        required: ["signal_types"]
+      },
+      request: {
+        method: "POST",
+        path: "/companies/search",
+        body: {
+          signal_types: "{signal_types}",
+          company_domains: "{company_domains}",
+          limit: "{limit}"
+        }
+      }
+    },
+    {
+      name: "contact.enrich",
+      class: "mutation",
+      description: "Enrich a contact with personal signals by email or LinkedIn URL (billed per returned signal).",
+      parameters: {
+        type: "object",
+        properties: {
+          contact_email: { type: "string" },
+          contact_linkedin_url: { type: "string" },
+          signal_types: { type: "array", items: { type: "string" } },
+          limit: { type: "integer" }
+        },
+        required: ["contact_email"]
+      },
+      request: {
+        method: "POST",
+        path: "/contacts/enrich",
+        body: {
+          contact_email: "{contact_email}",
+          contact_linkedin_url: "{contact_linkedin_url}",
+          signal_types: "{signal_types}",
+          limit: "{limit}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "contact.search",
+      class: "read",
+      description: "Search contacts aggregated by entity, filtered by signal type.",
+      parameters: {
+        type: "object",
+        properties: {
+          signal_types: { type: "array", items: { type: "string" } },
+          limit: { type: "integer" }
+        },
+        required: ["signal_types"]
+      },
+      request: {
+        method: "POST",
+        path: "/contacts/search",
+        body: { signal_types: "{signal_types}", limit: "{limit}" }
+      }
+    }
+  ]
+});
+
+// src/connectors/adapters/crustdata.ts
+var crustdataConnector = declarativeRestConnector({
+  kind: "crustdata",
+  displayName: "Crustdata",
+  description: "Real-time B2B company and people data API for enriching, identifying, and searching companies and professional profiles.",
+  auth: {
+    kind: "api-key",
+    hint: "API key (token) from the Crustdata dashboard. Sent as the Authorization: Bearer header. Requests also send the x-api-version: 2025-11-01 header."
+  },
+  category: "sales-intelligence",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.crustdata.com",
+  credentialPlacement: { kind: "bearer" },
+  defaultHeaders: { "content-type": "application/json", "x-api-version": "2025-11-01" },
+  capabilities: [
+    {
+      name: "company.identify",
+      class: "read",
+      description: "Resolve company domains to Crustdata company records.",
+      parameters: {
+        type: "object",
+        properties: { domains: { type: "array", items: { type: "string" } } },
+        required: ["domains"]
+      },
+      request: { method: "POST", path: "/company/identify", body: { domains: "{domains}" } }
+    },
+    {
+      name: "company.enrich",
+      class: "read",
+      description: "Retrieve full company profiles for one or more domains.",
+      parameters: {
+        type: "object",
+        properties: {
+          domains: { type: "array", items: { type: "string" } },
+          fields: { type: "array", items: { type: "string" } }
+        },
+        required: ["domains"]
+      },
+      request: {
+        method: "POST",
+        path: "/company/enrich",
+        body: { domains: "{domains}", fields: "{fields}" }
+      }
+    },
+    {
+      name: "company.search",
+      class: "read",
+      description: "Search companies with filters and sorting.",
+      parameters: {
+        type: "object",
+        properties: { filters: { type: "object" }, page: { type: "integer" } },
+        required: ["filters"]
+      },
+      request: {
+        method: "POST",
+        path: "/company/search",
+        body: { filters: "{filters}", page: "{page}" }
+      }
+    },
+    {
+      name: "person.enrich",
+      class: "read",
+      description: "Enrich people by LinkedIn profile URL or business email; optionally select returned fields.",
+      parameters: {
+        type: "object",
+        properties: {
+          professional_network_profile_urls: { type: "array", items: { type: "string" } },
+          business_emails: { type: "array", items: { type: "string" } },
+          fields: { type: "array", items: { type: "string" } }
+        },
+        required: ["professional_network_profile_urls"]
+      },
+      request: {
+        method: "POST",
+        path: "/person/enrich",
+        body: {
+          professional_network_profile_urls: "{professional_network_profile_urls}",
+          business_emails: "{business_emails}",
+          fields: "{fields}"
+        }
+      }
+    },
+    {
+      name: "person.search",
+      class: "read",
+      description: "Search people with filters and sorting.",
+      parameters: {
+        type: "object",
+        properties: { filters: { type: "object" }, page: { type: "integer" } },
+        required: ["filters"]
+      },
+      request: {
+        method: "POST",
+        path: "/person/search",
+        body: { filters: "{filters}", page: "{page}" }
+      }
+    }
+  ]
+});
+
+// src/connectors/adapters/fullenrich.ts
+var fullenrichConnector = declarativeRestConnector({
+  kind: "fullenrich",
+  displayName: "FullEnrich",
+  description: "Waterfall B2B contact enrichment API that finds work emails and phone numbers for a contact from name, company, or LinkedIn URL.",
+  auth: {
+    kind: "api-key",
+    hint: "API key from the FullEnrich dashboard (app.fullenrich.com/app/api). Sent as the Authorization: Bearer header."
+  },
+  category: "sales-intelligence",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://app.fullenrich.com/api/v2",
+  credentialPlacement: { kind: "bearer" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/account/credits" },
+  capabilities: [
+    {
+      name: "account.credits",
+      class: "read",
+      description: "Return the current credit balance for the account.",
+      parameters: { type: "object", properties: {}, required: [] },
+      request: { method: "GET", path: "/account/credits" }
+    },
+    {
+      name: "contact.enrich.start",
+      class: "mutation",
+      description: "Start an async waterfall enrichment for up to 100 contacts; returns an enrichment id and bills per found data point.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          data: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                first_name: { type: "string" },
+                last_name: { type: "string" },
+                domain: { type: "string" },
+                company_name: { type: "string" },
+                linkedin_url: { type: "string" },
+                enrich_fields: { type: "array", items: { type: "string" } }
+              }
+            }
+          },
+          webhook_url: { type: "string" }
+        },
+        required: ["name", "data"]
+      },
+      request: {
+        method: "POST",
+        path: "/contact/enrich/bulk",
+        body: { name: "{name}", data: "{data}", webhook_url: "{webhook_url}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "contact.enrich.result",
+      class: "read",
+      description: "Retrieve the result of a previously started bulk enrichment by its id.",
+      parameters: {
+        type: "object",
+        properties: { enrichment_id: { type: "string" } },
+        required: ["enrichment_id"]
+      },
+      request: { method: "GET", path: "/contact/enrich/bulk/{enrichment_id}" }
+    },
+    {
+      name: "contact.reverse_email.start",
+      class: "mutation",
+      description: "Start an async reverse-email lookup to find profiles/identities behind email addresses.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          data: {
+            type: "array",
+            items: { type: "object", properties: { email: { type: "string" } } }
+          },
+          webhook_url: { type: "string" }
+        },
+        required: ["name", "data"]
+      },
+      request: {
+        method: "POST",
+        path: "/contact/reverse/email/bulk",
+        body: { name: "{name}", data: "{data}", webhook_url: "{webhook_url}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    }
+  ]
+});
+
+// src/connectors/adapters/leadmagic.ts
+var leadmagicConnector = declarativeRestConnector({
+  kind: "leadmagic",
+  displayName: "LeadMagic",
+  description: "B2B data enrichment API for finding and validating work emails, mobile numbers, and enriching people and company profiles.",
+  auth: {
+    kind: "api-key",
+    hint: "API key from LeadMagic Settings -> API. Sent as the X-API-Key header."
+  },
+  category: "sales-intelligence",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.leadmagic.io",
+  credentialPlacement: { kind: "header", header: "X-API-Key" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/v1/credits" },
+  capabilities: [
+    {
+      name: "credits.get",
+      class: "read",
+      description: "Return the current API key credit balance. Free, no credits consumed.",
+      parameters: { type: "object", properties: {}, required: [] },
+      request: { method: "GET", path: "/v1/credits" }
+    },
+    {
+      name: "email.find",
+      class: "mutation",
+      description: "Find a verified work email from a person's name and company (charged only when an email is found).",
+      parameters: {
+        type: "object",
+        properties: {
+          first_name: { type: "string" },
+          last_name: { type: "string" },
+          domain: { type: "string" },
+          company_name: { type: "string" }
+        },
+        required: ["first_name", "last_name", "domain"]
+      },
+      request: {
+        method: "POST",
+        path: "/v1/people/email-finder",
+        body: {
+          first_name: "{first_name}",
+          last_name: "{last_name}",
+          domain: "{domain}",
+          company_name: "{company_name}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "email.validate",
+      class: "mutation",
+      description: "Validate an email address and return valid/invalid/unknown (charged only for definitive results).",
+      parameters: {
+        type: "object",
+        properties: { email: { type: "string" } },
+        required: ["email"]
+      },
+      request: {
+        method: "POST",
+        path: "/v1/people/email-validation",
+        body: { email: "{email}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "profile.search",
+      class: "read",
+      description: "Enrich a B2B profile from a profile URL or username.",
+      parameters: {
+        type: "object",
+        properties: { profile_url: { type: "string" } },
+        required: ["profile_url"]
+      },
+      request: {
+        method: "POST",
+        path: "/v1/people/profile-search",
+        body: { profile_url: "{profile_url}" }
+      }
+    },
+    {
+      name: "mobile.find",
+      class: "mutation",
+      description: "Find a mobile phone number from a profile URL or email (charged only on a successful match).",
+      parameters: {
+        type: "object",
+        properties: {
+          profile_url: { type: "string" },
+          work_email: { type: "string" },
+          personal_email: { type: "string" }
+        },
+        required: ["profile_url"]
+      },
+      request: {
+        method: "POST",
+        path: "/v1/people/mobile-finder",
+        body: {
+          profile_url: "{profile_url}",
+          work_email: "{work_email}",
+          personal_email: "{personal_email}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "company.search",
+      class: "mutation",
+      description: "Enrich a company's firmographics from its domain, name, or profile URL (charged per company found).",
+      parameters: {
+        type: "object",
+        properties: {
+          company_domain: { type: "string" },
+          company_name: { type: "string" },
+          profile_url: { type: "string" }
+        },
+        required: ["company_domain"]
+      },
+      request: {
+        method: "POST",
+        path: "/v1/companies/company-search",
+        body: {
+          company_domain: "{company_domain}",
+          company_name: "{company_name}",
+          profile_url: "{profile_url}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    }
+  ]
+});
+
+// src/connectors/adapters/brightdata.ts
+var brightdataConnector = declarativeRestConnector({
+  kind: "brightdata",
+  displayName: "Bright Data",
+  description: "Scrape any website at scale using Bright Data's Web Unlocker (bypasses anti-bot protection) and Web Scraper API (structured dataset collection jobs).",
+  auth: {
+    kind: "api-key",
+    hint: "API token from your Bright Data dashboard (Account settings -> API tokens). Sent as the Authorization: Bearer header."
+  },
+  category: "other",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.brightdata.com",
+  credentialPlacement: { kind: "bearer" },
+  defaultHeaders: { "content-type": "application/json" },
+  capabilities: [
+    {
+      name: "unlocker.request",
+      class: "read",
+      description: "Fetch a target URL through the Web Unlocker, returning the page content with anti-bot bypass, CAPTCHA solving, and JS rendering handled.",
+      parameters: {
+        type: "object",
+        properties: {
+          zone: { type: "string", description: "Your Web Unlocker API zone name." },
+          url: { type: "string", description: "Target URL to fetch." },
+          format: {
+            type: "string",
+            description: "Response format, e.g. 'raw' for the unmodified site response or 'json'."
+          },
+          body: {
+            type: "string",
+            description: "Optional raw POST payload to send to the target URL."
+          }
+        },
+        required: ["zone", "url"]
+      },
+      request: {
+        method: "POST",
+        path: "/request",
+        body: { zone: "{zone}", url: "{url}", format: "{format}", body: "{body}" }
+      }
+    },
+    {
+      name: "scraper.trigger",
+      class: "mutation",
+      description: "Trigger an asynchronous Web Scraper data collection job for a given dataset, returning a snapshot_id used to poll progress and download results.",
+      parameters: {
+        type: "object",
+        properties: {
+          dataset_id: {
+            type: "string",
+            description: "Scraper dataset id, e.g. gd_xxxxxxxxxxxxxxxxx."
+          },
+          format: { type: "string", description: "Delivery format of results, e.g. json." },
+          include_errors: { type: "boolean", description: "Include error records in the result set." },
+          inputs: {
+            type: "array",
+            description: "Array of input objects, each typically containing a url to scrape.",
+            items: { type: "object" }
+          }
+        },
+        required: ["dataset_id", "inputs"]
+      },
+      request: {
+        method: "POST",
+        path: "/datasets/v3/trigger",
+        query: {
+          dataset_id: "{dataset_id}",
+          format: "{format}",
+          include_errors: "{include_errors}"
+        },
+        body: "{inputs}"
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "scraper.progress",
+      class: "read",
+      description: "Check the status of a Web Scraper collection job (starting, running, ready, or failed) by its snapshot_id.",
+      parameters: {
+        type: "object",
+        properties: {
+          snapshot_id: { type: "string", description: "Snapshot id returned by scraper.trigger." }
+        },
+        required: ["snapshot_id"]
+      },
+      request: { method: "GET", path: "/datasets/v3/progress/{snapshot_id}" }
+    },
+    {
+      name: "scraper.snapshot",
+      class: "read",
+      description: "Download the collected records for a completed Web Scraper snapshot in the requested format.",
+      parameters: {
+        type: "object",
+        properties: {
+          snapshot_id: { type: "string", description: "Snapshot id returned by scraper.trigger." },
+          format: {
+            type: "string",
+            description: "Output format, e.g. json, ndjson, jsonl, or csv."
+          }
+        },
+        required: ["snapshot_id"]
+      },
+      request: {
+        method: "GET",
+        path: "/datasets/v3/snapshot/{snapshot_id}",
+        query: { format: "{format}" }
+      }
+    }
+  ]
+});
+
+// src/connectors/adapters/phantombuster.ts
+var phantombusterConnector = declarativeRestConnector({
+  kind: "phantombuster",
+  displayName: "PhantomBuster",
+  description: "Launch PhantomBuster Phantoms (automation agents) that scrape and extract data from sites like LinkedIn, then retrieve their output and results.",
+  auth: {
+    kind: "api-key",
+    hint: "API key from your PhantomBuster dashboard (Workspace settings -> API key). Sent in the X-Phantombuster-Key header."
+  },
+  category: "other",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.phantombuster.com/api/v2",
+  credentialPlacement: { kind: "header", header: "X-Phantombuster-Key" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/agents/fetch-all" },
+  capabilities: [
+    {
+      name: "agents.fetch_all",
+      class: "read",
+      description: "List all Phantoms (agents) in the current organization.",
+      parameters: { type: "object", properties: {}, required: [] },
+      request: { method: "GET", path: "/agents/fetch-all" }
+    },
+    {
+      name: "agents.fetch",
+      class: "read",
+      description: "Fetch the configuration and metadata of a single Phantom by its agent id.",
+      parameters: {
+        type: "object",
+        properties: { id: { type: "string", description: "Id of the agent (Phantom) to fetch." } },
+        required: ["id"]
+      },
+      request: { method: "GET", path: "/agents/fetch", query: { id: "{id}" } }
+    },
+    {
+      name: "agents.launch",
+      class: "mutation",
+      description: "Launch a Phantom (agent), optionally passing arguments, and start a new run (container).",
+      parameters: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Id of the agent (Phantom) to launch." },
+          argument: {
+            type: "object",
+            description: "JSON object of arguments overriding the Phantom's saved configuration for this run."
+          },
+          bonusArgument: {
+            type: "object",
+            description: "Additional one-off arguments merged for this launch only."
+          },
+          saveArgument: {
+            type: "boolean",
+            description: "Persist the provided argument as the Phantom's default configuration."
+          },
+          manualLaunch: { type: "boolean", description: "Mark the launch as manual." }
+        },
+        required: ["id"]
+      },
+      request: {
+        method: "POST",
+        path: "/agents/launch",
+        body: {
+          id: "{id}",
+          argument: "{argument}",
+          bonusArgument: "{bonusArgument}",
+          saveArgument: "{saveArgument}",
+          manualLaunch: "{manualLaunch}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "agents.fetch_output",
+      class: "read",
+      description: "Retrieve the console output and most recent container status of a Phantom's run by agent id.",
+      parameters: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Id of the agent to fetch output from." },
+          fromOutputPos: {
+            type: "number",
+            description: "Position from which to start returning output."
+          }
+        },
+        required: ["id"]
+      },
+      request: {
+        method: "GET",
+        path: "/agents/fetch-output",
+        query: { id: "{id}", fromOutputPos: "{fromOutputPos}" }
+      }
+    },
+    {
+      name: "containers.fetch_output",
+      class: "read",
+      description: "Retrieve the console output of a specific Phantom run (container) by its container id.",
+      parameters: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "Id of the container (run) to fetch output from."
+          }
+        },
+        required: ["id"]
+      },
+      request: { method: "GET", path: "/containers/fetch-output", query: { id: "{id}" } }
+    }
+  ]
+});
+
+// src/connectors/adapters/zenrows.ts
+var zenrowsConnector = declarativeRestConnector({
+  kind: "zenrows",
+  displayName: "ZenRows",
+  description: "Render and scrape any web page through ZenRows' Universal Scraper API, handling proxy rotation, headless browsers, and anti-bot bypass.",
+  auth: {
+    kind: "api-key",
+    hint: "API key from your ZenRows dashboard. Sent as the apikey query parameter."
+  },
+  category: "other",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.zenrows.com/v1/",
+  credentialPlacement: { kind: "query", parameter: "apikey" },
+  capabilities: [
+    {
+      name: "page.scrape",
+      class: "read",
+      description: "Fetch a URL and return its HTML, optionally rendering JavaScript and routing through premium residential proxies.",
+      parameters: {
+        type: "object",
+        properties: {
+          url: { type: "string", description: "Target URL to scrape." },
+          js_render: { type: "boolean", description: "Render the page with a headless browser." },
+          premium_proxy: {
+            type: "boolean",
+            description: "Route the request through residential proxies."
+          },
+          proxy_country: {
+            type: "string",
+            description: "Two-letter country code for proxy geolocation."
+          },
+          wait: {
+            type: "integer",
+            description: "Fixed delay in milliseconds after page load."
+          },
+          wait_for: {
+            type: "string",
+            description: "CSS selector to wait for in the DOM before returning."
+          }
+        },
+        required: ["url"]
+      },
+      request: {
+        method: "GET",
+        path: "/",
+        query: {
+          url: "{url}",
+          js_render: "{js_render}",
+          premium_proxy: "{premium_proxy}",
+          proxy_country: "{proxy_country}",
+          wait: "{wait}",
+          wait_for: "{wait_for}"
+        }
+      }
+    },
+    {
+      name: "page.extract",
+      class: "read",
+      description: "Scrape a URL and return structured data extracted via CSS selectors or ZenRows' automatic parser.",
+      parameters: {
+        type: "object",
+        properties: {
+          url: { type: "string", description: "Target URL to scrape." },
+          css_extractor: {
+            type: "string",
+            description: "JSON string mapping output keys to CSS selectors."
+          },
+          autoparse: {
+            type: "boolean",
+            description: "Automatically extract structured data from supported sites."
+          },
+          js_render: { type: "boolean", description: "Render the page with a headless browser." }
+        },
+        required: ["url"]
+      },
+      request: {
+        method: "GET",
+        path: "/",
+        query: {
+          url: "{url}",
+          css_extractor: "{css_extractor}",
+          autoparse: "{autoparse}",
+          js_render: "{js_render}"
+        }
+      }
+    },
+    {
+      name: "page.markdown",
+      class: "read",
+      description: "Fetch a URL and return its content converted to Markdown, plaintext, or PDF.",
+      parameters: {
+        type: "object",
+        properties: {
+          url: { type: "string", description: "Target URL to scrape." },
+          response_type: {
+            type: "string",
+            description: "Output conversion type, e.g. markdown, plaintext, or pdf."
+          },
+          js_render: { type: "boolean", description: "Render the page with a headless browser." }
+        },
+        required: ["url"]
+      },
+      request: {
+        method: "GET",
+        path: "/",
+        query: { url: "{url}", response_type: "{response_type}", js_render: "{js_render}" }
+      }
+    }
+  ]
+});
+
+// src/connectors/adapters/ocean-io.ts
+var oceanIoConnector = declarativeRestConnector({
+  kind: "ocean-io",
+  displayName: "Ocean.io",
+  description: "Lookalike B2B company and people search plus firmographic and contact enrichment. Build target lists from an ideal customer profile and enrich records.",
+  auth: {
+    kind: "api-key",
+    hint: "API token from Settings -> API tokens. Sent as the X-Api-Token header."
+  },
+  category: "sales-intelligence",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.ocean.io",
+  credentialPlacement: { kind: "header", header: "X-Api-Token" },
+  defaultHeaders: { "content-type": "application/json" },
+  capabilities: [
+    {
+      name: "companies.search",
+      class: "read",
+      description: "Search/lookalike companies by filters (location, size, industry, technologies) and/or seed lookalike domains.",
+      parameters: {
+        type: "object",
+        properties: {
+          companiesFilters: { type: "object" },
+          lookalikeDomains: { type: "array", items: { type: "string" } },
+          size: { type: "integer" },
+          searchAfter: { type: "string" }
+        },
+        required: ["size"]
+      },
+      request: {
+        method: "POST",
+        path: "/v3/search/companies",
+        body: {
+          companiesFilters: "{companiesFilters}",
+          lookalikeDomains: "{lookalikeDomains}",
+          size: "{size}",
+          searchAfter: "{searchAfter}"
+        }
+      }
+    },
+    {
+      name: "people.search",
+      class: "read",
+      description: "Search people by persona filters (seniority, department) optionally scoped by company filters.",
+      parameters: {
+        type: "object",
+        properties: {
+          peopleFilters: { type: "object" },
+          companiesFilters: { type: "object" },
+          size: { type: "integer" },
+          searchAfter: { type: "string" }
+        },
+        required: ["size"]
+      },
+      request: {
+        method: "POST",
+        path: "/v3/search/people",
+        body: {
+          peopleFilters: "{peopleFilters}",
+          companiesFilters: "{companiesFilters}",
+          size: "{size}",
+          searchAfter: "{searchAfter}"
+        }
+      }
+    },
+    {
+      name: "companies.enrich",
+      class: "mutation",
+      description: "Match one company against Ocean's database and return firmographic, technographic, and funding data. Costs 0.1 credits per result.",
+      parameters: {
+        type: "object",
+        properties: { company: { type: "object" } },
+        required: ["company"]
+      },
+      request: { method: "POST", path: "/v2/enrich/company", body: { company: "{company}" } },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "people.enrich",
+      class: "mutation",
+      description: "Match one person against Ocean's database and return profile data; optionally trigger asynchronous email/phone reveal via webhook. Costs 0.1 credits per result.",
+      parameters: {
+        type: "object",
+        properties: { person: { type: "object" }, revealEmails: { type: "object" } },
+        required: ["person"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/enrich/person",
+        body: { person: "{person}", revealEmails: "{revealEmails}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "companies.autocomplete",
+      class: "read",
+      description: "Type-ahead autocomplete for company name or domain, useful for picking seed companies for a lookalike search.",
+      parameters: {
+        type: "object",
+        properties: { name: { type: "string" } },
+        required: ["name"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/autocomplete/companies",
+        body: { name: "{name}" }
+      }
+    }
+  ]
+});
+
+// src/connectors/adapters/seamless-ai.ts
+var seamlessAiConnector = declarativeRestConnector({
+  kind: "seamless-ai",
+  displayName: "Seamless.ai",
+  description: "Search and enrich B2B contact and company data, including verified emails, phone numbers, and job-change signals, for go-to-market prospecting.",
+  auth: {
+    kind: "api-key",
+    hint: "API key from Settings -> API Key (Create New Connection). Sent as the Token header."
+  },
+  category: "sales-intelligence",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.seamless.ai/api/client/v1",
+  credentialPlacement: { kind: "header", header: "Token" },
+  defaultHeaders: { "content-type": "application/json" },
+  capabilities: [
+    {
+      name: "contacts.search",
+      class: "read",
+      description: "Search for contacts by company, location, department, job title, seniority, and technologies. Returns search result ids used for research/enrichment.",
+      parameters: {
+        type: "object",
+        properties: {
+          jobTitle: { type: "array", items: { type: "string" } },
+          seniority: { type: "array", items: { type: "string" } },
+          companyDomain: { type: "array", items: { type: "string" } },
+          industry: { type: "array", items: { type: "string" } },
+          limit: { type: "integer" },
+          nextToken: { type: "string" }
+        },
+        required: []
+      },
+      request: {
+        method: "POST",
+        path: "/search/contacts",
+        body: {
+          jobTitle: "{jobTitle}",
+          seniority: "{seniority}",
+          companyDomain: "{companyDomain}",
+          industry: "{industry}",
+          limit: "{limit}",
+          nextToken: "{nextToken}"
+        }
+      }
+    },
+    {
+      name: "companies.search",
+      class: "read",
+      description: "Search for companies by name, domain, location, industry, size, revenue, and technologies. Returns search result ids used for research/enrichment.",
+      parameters: {
+        type: "object",
+        properties: {
+          companyName: { type: "array", items: { type: "string" } },
+          companyDomain: { type: "array", items: { type: "string" } },
+          industry: { type: "array", items: { type: "string" } },
+          companySize: { type: "array", items: { type: "string" } },
+          technologies: { type: "array", items: { type: "string" } },
+          limit: { type: "integer" },
+          nextToken: { type: "string" }
+        },
+        required: []
+      },
+      request: {
+        method: "POST",
+        path: "/search/companies",
+        body: {
+          companyName: "{companyName}",
+          companyDomain: "{companyDomain}",
+          industry: "{industry}",
+          companySize: "{companySize}",
+          technologies: "{technologies}",
+          limit: "{limit}",
+          nextToken: "{nextToken}"
+        }
+      }
+    },
+    {
+      name: "contacts.research",
+      class: "mutation",
+      description: "Research (enrich) contacts asynchronously by searchResultIds from a contact search, or by explicit contact identifiers, to reveal full profile, email, and phone.",
+      parameters: {
+        type: "object",
+        properties: {
+          searchResultIds: { type: "array", items: { type: "string" } },
+          contacts: { type: "array", items: { type: "object" } },
+          isJobChange: { type: "boolean" },
+          skipDeduplicationCheck: { type: "boolean" }
+        },
+        required: []
+      },
+      request: {
+        method: "POST",
+        path: "/contacts/research",
+        body: {
+          searchResultIds: "{searchResultIds}",
+          contacts: "{contacts}",
+          isJobChange: "{isJobChange}",
+          skipDeduplicationCheck: "{skipDeduplicationCheck}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "companies.research",
+      class: "mutation",
+      description: "Research (enrich) companies asynchronously by searchResultIds from a company search, or by direct company identifiers.",
+      parameters: {
+        type: "object",
+        properties: {
+          searchResultIds: { type: "array", items: { type: "string" } },
+          companies: { type: "array", items: { type: "object" } },
+          skipDeduplicationCheck: { type: "boolean" }
+        },
+        required: []
+      },
+      request: {
+        method: "POST",
+        path: "/companies/research",
+        body: {
+          searchResultIds: "{searchResultIds}",
+          companies: "{companies}",
+          skipDeduplicationCheck: "{skipDeduplicationCheck}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: false
+    },
+    {
+      name: "contacts.research.poll",
+      class: "read",
+      description: "Poll for the results of a previously submitted contact research (enrichment) request by request id.",
+      parameters: {
+        type: "object",
+        properties: { requestIds: { type: "array", items: { type: "string" } } },
+        required: ["requestIds"]
+      },
+      request: {
+        method: "GET",
+        path: "/contacts/research/poll",
+        query: { requestIds: "{requestIds}" }
+      }
+    }
+  ]
+});
+
+// src/connectors/adapters/theirstack.ts
+var theirstackConnector = declarativeRestConnector({
+  kind: "theirstack",
+  displayName: "TheirStack",
+  description: "Jobs and technographics data API. Search job postings and companies across 100+ countries, look up a company's tech stack, and detect buying intent.",
+  auth: {
+    kind: "api-key",
+    hint: "API key from app.theirstack.com/settings/api. Sent as the Authorization: Bearer header."
+  },
+  category: "sales-intelligence",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.theirstack.com",
+  credentialPlacement: { kind: "bearer" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/v0/billing/credit-balance" },
+  capabilities: [
+    {
+      name: "jobs.search",
+      class: "read",
+      description: "Search job postings with filters (title, country, technology, posting recency, company). Requires at least one filter such as posted_at_max_age_days. Costs 1 credit per job returned.",
+      parameters: {
+        type: "object",
+        properties: {
+          posted_at_max_age_days: { type: "integer" },
+          job_title_or: { type: "array", items: { type: "string" } },
+          job_country_code_or: { type: "array", items: { type: "string" } },
+          company_technology_slug_or: { type: "array", items: { type: "string" } },
+          company_name_or: { type: "array", items: { type: "string" } },
+          limit: { type: "integer" },
+          page: { type: "integer" }
+        },
+        required: ["posted_at_max_age_days", "limit", "page"]
+      },
+      request: {
+        method: "POST",
+        path: "/v1/jobs/search",
+        body: {
+          posted_at_max_age_days: "{posted_at_max_age_days}",
+          job_title_or: "{job_title_or}",
+          job_country_code_or: "{job_country_code_or}",
+          company_technology_slug_or: "{company_technology_slug_or}",
+          company_name_or: "{company_name_or}",
+          limit: "{limit}",
+          page: "{page}"
+        }
+      }
+    },
+    {
+      name: "companies.search",
+      class: "read",
+      description: "Search companies by country, technologies used, industry, funding, and nested job filters. Costs 3 credits per company returned.",
+      parameters: {
+        type: "object",
+        properties: {
+          company_country_code_or: { type: "array", items: { type: "string" } },
+          company_technology_slug_or: { type: "array", items: { type: "string" } },
+          industry_id_or: { type: "array", items: { type: "integer" } },
+          min_funding_usd: { type: "integer" },
+          max_funding_usd: { type: "integer" },
+          limit: { type: "integer" },
+          page: { type: "integer" }
+        },
+        required: ["limit", "page"]
+      },
+      request: {
+        method: "POST",
+        path: "/v1/companies/search",
+        body: {
+          company_country_code_or: "{company_country_code_or}",
+          company_technology_slug_or: "{company_technology_slug_or}",
+          industry_id_or: "{industry_id_or}",
+          min_funding_usd: "{min_funding_usd}",
+          max_funding_usd: "{max_funding_usd}",
+          limit: "{limit}",
+          page: "{page}"
+        }
+      }
+    },
+    {
+      name: "companies.technologies",
+      class: "read",
+      description: "Look up the technologies (tech stack) detected for a company identified by domain, name, or LinkedIn URL. Costs 3 credits per company lookup.",
+      parameters: {
+        type: "object",
+        properties: {
+          company_domain: { type: "string" },
+          company_name: { type: "string" },
+          company_linkedin_url: { type: "string" },
+          technology_slug_or: { type: "array", items: { type: "string" } }
+        },
+        required: ["company_domain"]
+      },
+      request: {
+        method: "POST",
+        path: "/v1/companies/technologies",
+        body: {
+          company_domain: "{company_domain}",
+          company_name: "{company_name}",
+          company_linkedin_url: "{company_linkedin_url}",
+          technology_slug_or: "{technology_slug_or}"
+        }
+      }
+    },
+    {
+      name: "companies.buying_intents",
+      class: "read",
+      description: "Retrieve buying-intent signals for a company identified by domain, name, or LinkedIn URL. Costs 3 credits per company lookup.",
+      parameters: {
+        type: "object",
+        properties: {
+          company_domain: { type: "string" },
+          company_name: { type: "string" },
+          company_linkedin_url: { type: "string" }
+        },
+        required: ["company_domain"]
+      },
+      request: {
+        method: "POST",
+        path: "/v1/companies/buying_intents",
+        body: {
+          company_domain: "{company_domain}",
+          company_name: "{company_name}",
+          company_linkedin_url: "{company_linkedin_url}"
+        }
+      }
+    }
+  ]
+});
+
+// src/connectors/adapters/usergems.ts
+var usergemsConnector = declarativeRestConnector({
+  kind: "usergems",
+  displayName: "UserGems",
+  description: "Job-change and relationship tracking ingestion API. Add or remove contacts and accounts on watchlists so UserGems surfaces job-change and buying signals for them.",
+  auth: {
+    kind: "api-key",
+    hint: "API key requested via support@usergems.com. Sent as the X-Api-Key header."
+  },
+  category: "sales-intelligence",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.usergems.com/v1",
+  credentialPlacement: { kind: "header", header: "X-Api-Key" },
+  defaultHeaders: { "content-type": "application/json" },
+  capabilities: [
+    {
+      name: "contacts.add",
+      class: "mutation",
+      description: "Add a contact to your UserGems tracking list so job changes and signals are monitored. Email is required; many profile and custom signal fields are optional.",
+      parameters: {
+        type: "object",
+        properties: {
+          email: { type: "string" },
+          firstName: { type: "string" },
+          lastName: { type: "string" },
+          fullName: { type: "string" },
+          company: { type: "string" },
+          relationshipType: { type: "string" },
+          linkedinUrl: { type: "string" },
+          signal: { type: "string" },
+          custom: { type: "object" }
+        },
+        required: ["email"]
+      },
+      request: {
+        method: "POST",
+        path: "/contact",
+        body: {
+          email: "{email}",
+          firstName: "{firstName}",
+          lastName: "{lastName}",
+          fullName: "{fullName}",
+          company: "{company}",
+          relationshipType: "{relationshipType}",
+          linkedinUrl: "{linkedinUrl}",
+          signal: "{signal}",
+          custom: "{custom}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "contacts.delete",
+      class: "mutation",
+      description: "Remove a contact from your UserGems tracking list by email.",
+      parameters: {
+        type: "object",
+        properties: {
+          email: { type: "string" },
+          relationshipType: { type: "string" },
+          signal: { type: "string" }
+        },
+        required: ["email"]
+      },
+      request: {
+        method: "DELETE",
+        path: "/contact",
+        body: {
+          email: "{email}",
+          relationshipType: "{relationshipType}",
+          signal: "{signal}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "accounts.add",
+      class: "mutation",
+      description: "Add an account (company) for which you want to receive new-prospect and signal reports. Name and domain are required.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          domain: { type: "string" },
+          reportName: { type: "string" },
+          signal: { type: "string" },
+          salesforceId: { type: "string" },
+          customId: { type: "string" },
+          custom: { type: "object" }
+        },
+        required: ["name", "domain"]
+      },
+      request: {
+        method: "POST",
+        path: "/account",
+        body: {
+          name: "{name}",
+          domain: "{domain}",
+          reportName: "{reportName}",
+          signal: "{signal}",
+          salesforceId: "{salesforceId}",
+          customId: "{customId}",
+          custom: "{custom}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "accounts.delete",
+      class: "mutation",
+      description: "Remove a previously added account by name and domain.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          domain: { type: "string" },
+          reportName: { type: "string" },
+          signal: { type: "string" },
+          salesforceId: { type: "string" },
+          customId: { type: "string" }
+        },
+        required: ["name", "domain"]
+      },
+      request: {
+        method: "DELETE",
+        path: "/account",
+        body: {
+          name: "{name}",
+          domain: "{domain}",
+          reportName: "{reportName}",
+          signal: "{signal}",
+          salesforceId: "{salesforceId}",
+          customId: "{customId}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
+// src/connectors/adapters/hightouch.ts
+var hightouchConnector = declarativeRestConnector({
+  kind: "hightouch",
+  displayName: "Hightouch",
+  description: "List and inspect Reverse ETL syncs, sources, destinations, and runs, and trigger sync runs.",
+  auth: {
+    kind: "api-key",
+    hint: "API key from Settings -> API keys (Add API key). Sent as the Authorization: Bearer header."
+  },
+  category: "database",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.hightouch.com/api/v1",
+  credentialPlacement: { kind: "bearer" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/syncs" },
+  capabilities: [
+    {
+      name: "syncs.list",
+      class: "read",
+      description: "List configured syncs in the workspace.",
+      parameters: {
+        type: "object",
+        properties: {
+          limit: { type: "integer" },
+          offset: { type: "integer" },
+          modelId: { type: "number" },
+          slug: { type: "string" },
+          orderBy: { type: "string" }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/syncs",
+        query: {
+          limit: "{limit}",
+          offset: "{offset}",
+          modelId: "{modelId}",
+          slug: "{slug}",
+          orderBy: "{orderBy}"
+        }
+      }
+    },
+    {
+      name: "syncs.get",
+      class: "read",
+      description: "Retrieve a single sync by its id.",
+      parameters: {
+        type: "object",
+        properties: { syncId: { type: "number" } },
+        required: ["syncId"]
+      },
+      request: { method: "GET", path: "/syncs/{syncId}" }
+    },
+    {
+      name: "syncs.list_runs",
+      class: "read",
+      description: "List the runs (execution history and status) for a sync.",
+      parameters: {
+        type: "object",
+        properties: {
+          syncId: { type: "number" },
+          limit: { type: "integer" },
+          offset: { type: "integer" },
+          runId: { type: "number" },
+          orderBy: { type: "string" }
+        },
+        required: ["syncId"]
+      },
+      request: {
+        method: "GET",
+        path: "/syncs/{syncId}/runs",
+        query: {
+          limit: "{limit}",
+          offset: "{offset}",
+          runId: "{runId}",
+          orderBy: "{orderBy}"
+        }
+      }
+    },
+    {
+      name: "sources.list",
+      class: "read",
+      description: "List configured data sources.",
+      parameters: {
+        type: "object",
+        properties: {
+          limit: { type: "integer" },
+          offset: { type: "integer" },
+          name: { type: "string" },
+          slug: { type: "string" }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/sources",
+        query: { limit: "{limit}", offset: "{offset}", name: "{name}", slug: "{slug}" }
+      }
+    },
+    {
+      name: "destinations.list",
+      class: "read",
+      description: "List configured destinations.",
+      parameters: {
+        type: "object",
+        properties: {
+          limit: { type: "integer" },
+          offset: { type: "integer" },
+          name: { type: "string" },
+          slug: { type: "string" }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/destinations",
+        query: { limit: "{limit}", offset: "{offset}", name: "{name}", slug: "{slug}" }
+      }
+    },
+    {
+      name: "syncs.trigger",
+      class: "mutation",
+      description: "Trigger a run of the given sync, optionally forcing a full resync.",
+      parameters: {
+        type: "object",
+        properties: {
+          syncId: { type: "string" },
+          fullResync: { type: "boolean" },
+          resetCDC: { type: "boolean" }
+        },
+        required: ["syncId"]
+      },
+      request: {
+        method: "POST",
+        path: "/syncs/{syncId}/trigger",
+        body: { fullResync: "{fullResync}", resetCDC: "{resetCDC}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
+// src/connectors/adapters/polytomic.ts
+var polytomicConnector = declarativeRestConnector({
+  kind: "polytomic",
+  displayName: "Polytomic",
+  description: "List and create ETL/reverse-ETL syncs, inspect sync status, and list available connection types.",
+  auth: {
+    kind: "api-key",
+    hint: "API key generated in the Polytomic Settings panel. Sent as the Authorization: Bearer header."
+  },
+  category: "database",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://app.polytomic.com/api",
+  credentialPlacement: { kind: "bearer" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/me" },
+  capabilities: [
+    {
+      name: "syncs.list",
+      class: "read",
+      description: "List configured syncs.",
+      parameters: {
+        type: "object",
+        properties: {
+          active: { type: "boolean" },
+          mode: { type: "string" },
+          target_connection_id: { type: "string" },
+          limit: { type: "integer" },
+          page_token: { type: "string" }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/syncs",
+        query: {
+          active: "{active}",
+          mode: "{mode}",
+          target_connection_id: "{target_connection_id}",
+          limit: "{limit}",
+          page_token: "{page_token}"
+        }
+      }
+    },
+    {
+      name: "syncs.status",
+      class: "read",
+      description: "Get the current status of a sync by its id.",
+      parameters: { type: "object", properties: { id: { type: "string" } }, required: ["id"] },
+      request: { method: "GET", path: "/syncs/{id}/status" }
+    },
+    {
+      name: "connection_types.list",
+      class: "read",
+      description: "List all connection types (source/destination connectors) supported by this deployment.",
+      parameters: { type: "object", properties: {}, required: [] },
+      request: { method: "GET", path: "/connection_types" }
+    },
+    {
+      name: "syncs.create",
+      class: "mutation",
+      description: "Create a new sync from one or more models to a destination.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          target: { type: "object" },
+          mode: { type: "string" },
+          fields: { type: "array", items: { type: "object" } },
+          schedule: { type: "object" }
+        },
+        required: ["name", "target", "mode", "fields"]
+      },
+      request: {
+        method: "POST",
+        path: "/syncs",
+        body: {
+          name: "{name}",
+          target: "{target}",
+          mode: "{mode}",
+          fields: "{fields}",
+          schedule: "{schedule}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
+// src/connectors/adapters/signwell.ts
+var signwellConnector = declarativeRestConnector({
+  kind: "signwell",
+  displayName: "SignWell",
+  description: "Create and send documents for electronic signature, and list or retrieve documents.",
+  auth: {
+    kind: "api-key",
+    hint: "API key from Settings -> API (Create API Key). Sent in the X-Api-Key header."
+  },
+  category: "other",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://www.signwell.com/api/v1",
+  credentialPlacement: { kind: "header", header: "X-Api-Key" },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/me" },
+  capabilities: [
+    {
+      name: "documents.list",
+      class: "read",
+      description: "List documents in the account.",
+      parameters: {
+        type: "object",
+        properties: { page: { type: "integer" }, limit: { type: "integer" } },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/documents",
+        query: { page: "{page}", limit: "{limit}" }
+      }
+    },
+    {
+      name: "documents.get",
+      class: "read",
+      description: "Retrieve a single document by its id.",
+      parameters: { type: "object", properties: { id: { type: "string" } }, required: ["id"] },
+      request: { method: "GET", path: "/documents/{id}" }
+    },
+    {
+      name: "account.get",
+      class: "read",
+      description: "Retrieve the account information associated with the API key.",
+      parameters: { type: "object", properties: {}, required: [] },
+      request: { method: "GET", path: "/me" }
+    },
+    {
+      name: "documents.create",
+      class: "mutation",
+      description: "Create and optionally send a new document for signing. Set draft to true to create without sending.",
+      parameters: {
+        type: "object",
+        properties: {
+          files: { type: "array", items: { type: "object" } },
+          recipients: { type: "array", items: { type: "object" } },
+          name: { type: "string" },
+          subject: { type: "string" },
+          message: { type: "string" },
+          draft: { type: "boolean" },
+          test_mode: { type: "boolean" },
+          embedded_signing: { type: "boolean" }
+        },
+        required: ["files", "recipients"]
+      },
+      request: {
+        method: "POST",
+        path: "/documents",
+        body: {
+          files: "{files}",
+          recipients: "{recipients}",
+          name: "{name}",
+          subject: "{subject}",
+          message: "{message}",
+          draft: "{draft}",
+          test_mode: "{test_mode}",
+          embedded_signing: "{embedded_signing}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
+// src/connectors/adapters/justcall.ts
+var justcallConnector = declarativeRestConnector({
+  kind: "justcall",
+  displayName: "JustCall",
+  description: "Cloud phone system and SMS platform. Place and list calls, manage contacts, and send SMS/MMS programmatically.",
+  auth: {
+    kind: "api-key",
+    hint: 'Get your API Key and API Secret from JustCall Settings -> Developers. Paste them joined by a colon as "api_key:api_secret"; sent as the Authorization header.'
+  },
+  category: "comms",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.justcall.io/v2.1",
+  credentialPlacement: { kind: "header", header: "Authorization" },
+  defaultHeaders: { "content-type": "application/json", accept: "application/json" },
+  test: { method: "GET", path: "/calls", query: { per_page: "1" } },
+  capabilities: [
+    {
+      name: "calls.list",
+      class: "read",
+      description: "List call records linked to the account, with optional filters for number, direction, type, and date range.",
+      parameters: {
+        type: "object",
+        properties: {
+          page: { type: "integer" },
+          per_page: { type: "integer" },
+          contact_number: { type: "string" },
+          from_datetime: { type: "string" },
+          to_datetime: { type: "string" },
+          call_direction: { type: "string" }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/calls",
+        query: {
+          page: "{page}",
+          per_page: "{per_page}",
+          contact_number: "{contact_number}",
+          from_datetime: "{from_datetime}",
+          to_datetime: "{to_datetime}",
+          call_direction: "{call_direction}"
+        }
+      }
+    },
+    {
+      name: "calls.get",
+      class: "read",
+      description: "Get a single Sales Dialer call by its unique call id.",
+      parameters: { type: "object", properties: { id: { type: "integer" } }, required: ["id"] },
+      request: { method: "GET", path: "/sales_dialer/calls/{id}" }
+    },
+    {
+      name: "contacts.list",
+      class: "read",
+      description: "List contacts in the account, optionally filtered by name or number.",
+      parameters: {
+        type: "object",
+        properties: {
+          page: { type: "integer" },
+          per_page: { type: "integer" },
+          contact_number: { type: "string" },
+          first_name: { type: "string" },
+          last_name: { type: "string" },
+          across_team: { type: "boolean" }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/contacts",
+        query: {
+          page: "{page}",
+          per_page: "{per_page}",
+          contact_number: "{contact_number}",
+          first_name: "{first_name}",
+          last_name: "{last_name}",
+          across_team: "{across_team}"
+        }
+      }
+    },
+    {
+      name: "contacts.create",
+      class: "mutation",
+      description: "Create a new contact in Sales Dialer.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          phone_number: { type: "string" },
+          email: { type: "string" }
+        },
+        required: ["name", "phone_number"]
+      },
+      request: {
+        method: "POST",
+        path: "/sales_dialer/contacts",
+        body: { name: "{name}", phone_number: "{phone_number}", email: "{email}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "sms.send",
+      class: "mutation",
+      description: "Send an SMS or MMS from a JustCall number to a contact number.",
+      parameters: {
+        type: "object",
+        properties: {
+          justcall_number: { type: "string" },
+          contact_number: { type: "string" },
+          body: { type: "string" },
+          media_url: { type: "string" }
+        },
+        required: ["justcall_number", "contact_number", "body"]
+      },
+      request: {
+        method: "POST",
+        path: "/texts/new",
+        body: {
+          justcall_number: "{justcall_number}",
+          contact_number: "{contact_number}",
+          body: "{body}",
+          media_url: "{media_url}"
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
+// src/connectors/adapters/nooks.ts
+var nooksConnector = declarativeRestConnector({
+  kind: "nooks",
+  displayName: "Nooks",
+  description: "AI sales engagement and dialer platform. Read call records, prospects, and accounts from the Nooks Sequencing API.",
+  auth: {
+    kind: "api-key",
+    hint: "Create a long-lived API key (nooks-api-...) in Nooks Developer Settings -> API Keys. Sent as the Authorization: Bearer header."
+  },
+  category: "comms",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://partner-api.nooks.in/v1",
+  credentialPlacement: { kind: "bearer" },
+  defaultHeaders: { "content-type": "application/json", accept: "application/json" },
+  test: { method: "GET", path: "/me" },
+  capabilities: [
+    {
+      name: "calls.list",
+      class: "read",
+      description: "List call records, with optional filters by prospect, account, or owner.",
+      parameters: {
+        type: "object",
+        properties: {
+          filter_prospect_id: { type: "string" },
+          filter_account_id: { type: "string" },
+          filter_owner_id: { type: "string" },
+          include: { type: "string" }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/calls",
+        query: {
+          "filter[prospect][id]": "{filter_prospect_id}",
+          "filter[account][id]": "{filter_account_id}",
+          "filter[owner][id]": "{filter_owner_id}",
+          include: "{include}"
+        }
+      }
+    },
+    {
+      name: "calls.get",
+      class: "read",
+      description: "Get a single call record by its id.",
+      parameters: {
+        type: "object",
+        properties: { id: { type: "string" }, include: { type: "string" } },
+        required: ["id"]
+      },
+      request: { method: "GET", path: "/calls/{id}", query: { include: "{include}" } }
+    },
+    {
+      name: "prospects.list",
+      class: "read",
+      description: "List prospects (contacts), with optional filters by name, email, or account.",
+      parameters: {
+        type: "object",
+        properties: {
+          filter_name: { type: "string" },
+          filter_primaryEmail: { type: "string" },
+          filter_account_id: { type: "string" },
+          include: { type: "string" }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/prospects",
+        query: {
+          "filter[name]": "{filter_name}",
+          "filter[primaryEmail]": "{filter_primaryEmail}",
+          "filter[account][id]": "{filter_account_id}",
+          include: "{include}"
+        }
+      }
+    },
+    {
+      name: "accounts.list",
+      class: "read",
+      description: "List accounts, with optional filters by name, domain, or CRM id.",
+      parameters: {
+        type: "object",
+        properties: {
+          filter_name: { type: "string" },
+          filter_domain: { type: "string" },
+          filter_crmId: { type: "string" }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/accounts",
+        query: {
+          "filter[name]": "{filter_name}",
+          "filter[domain]": "{filter_domain}",
+          "filter[crmId]": "{filter_crmId}"
+        }
+      }
+    },
+    {
+      name: "prospects.sync",
+      class: "mutation",
+      description: "Sync prospects from the connected CRM into Nooks.",
+      parameters: { type: "object", properties: {}, required: [] },
+      request: { method: "POST", path: "/integrations/prospects/sync", body: {} },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
+// src/connectors/adapters/modjo.ts
+var modjoConnector = declarativeRestConnector({
+  kind: "modjo",
+  displayName: "Modjo",
+  description: "Conversation intelligence platform. Export call records with transcripts and AI summaries, and list users and teams.",
+  auth: {
+    kind: "api-key",
+    hint: "Create an API key in Modjo (Administrator or Manager role required); copy it immediately as it is shown only once. Sent as the X-API-KEY header."
+  },
+  category: "doc",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.modjo.ai",
+  credentialPlacement: { kind: "header", header: "X-API-KEY" },
+  defaultHeaders: { "content-type": "application/json", accept: "application/json" },
+  test: { method: "GET", path: "/v1/users", query: { page: "1", perPage: "1" } },
+  capabilities: [
+    {
+      name: "calls.export",
+      class: "read",
+      description: "Retrieve a paginated list of calls with optional relations such as transcripts, AI summaries, and contacts.",
+      parameters: {
+        type: "object",
+        properties: {
+          page: { type: "integer" },
+          perPage: { type: "integer" },
+          transcript: { type: "boolean" },
+          aiSummary: { type: "boolean" },
+          contacts: { type: "boolean" }
+        },
+        required: ["page", "perPage"]
+      },
+      request: {
+        method: "POST",
+        path: "/v1/calls/exports",
+        body: {
+          pagination: { page: "{page}", perPage: "{perPage}" },
+          relations: {
+            transcript: "{transcript}",
+            aiSummary: "{aiSummary}",
+            contacts: "{contacts}"
+          }
+        }
+      }
+    },
+    {
+      name: "users.list",
+      class: "read",
+      description: "Retrieve a paginated list of users in the Modjo workspace.",
+      parameters: {
+        type: "object",
+        properties: { page: { type: "integer" }, perPage: { type: "integer" } },
+        required: ["page", "perPage"]
+      },
+      request: {
+        method: "GET",
+        path: "/v1/users",
+        query: { page: "{page}", perPage: "{perPage}" }
+      }
+    },
+    {
+      name: "teams.list",
+      class: "read",
+      description: "Retrieve a paginated list of teams in the Modjo workspace.",
+      parameters: {
+        type: "object",
+        properties: { page: { type: "integer" }, perPage: { type: "integer" } },
+        required: ["page", "perPage"]
+      },
+      request: {
+        method: "GET",
+        path: "/v1/teams",
+        query: { page: "{page}", perPage: "{perPage}" }
+      }
+    }
+  ]
+});
+
+// src/connectors/adapters/factors-ai.ts
+var factorsAiConnector = declarativeRestConnector({
+  kind: "factors-ai",
+  displayName: "Factors.ai",
+  description: "B2B account intelligence and ABM platform. Retrieve the engagement journey (activity timeline) for a target account by domain.",
+  auth: {
+    kind: "api-key",
+    hint: "Generate a private API token for the target project in Factors.ai. Sent as the Authorization: Bearer header."
+  },
+  category: "sales-intelligence",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.factors.ai/open/v1",
+  credentialPlacement: { kind: "bearer" },
+  defaultHeaders: { accept: "application/json" },
+  test: { method: "GET", path: "/account/factors.ai/journey" },
+  capabilities: [
+    {
+      name: "account.journey",
+      class: "read",
+      description: "Get the account journey (chronological engagement events) for a given account domain, optionally filtered by date range, event name, or user.",
+      parameters: {
+        type: "object",
+        properties: {
+          account_domain: { type: "string" },
+          from: { type: "string" },
+          to: { type: "string" },
+          event_name: { type: "string" },
+          user_name: { type: "string" }
+        },
+        required: ["account_domain"]
+      },
+      request: {
+        method: "GET",
+        path: "/account/{account_domain}/journey",
+        query: {
+          from: "{from}",
+          to: "{to}",
+          event_name: "{event_name}",
+          user_name: "{user_name}"
+        }
+      }
+    }
+  ]
+});
+
+// src/connectors/adapters/getresponse.ts
+var getresponseConnector = declarativeRestConnector({
+  kind: "getresponse",
+  displayName: "GetResponse",
+  description: "Email marketing platform for managing contacts, lists (campaigns), and sending newsletters.",
+  auth: {
+    kind: "api-key",
+    hint: "Generate an API key at app.getresponse.com/api. Sent as the X-Auth-Token header with the 'api-key ' prefix (X-Auth-Token: api-key <KEY>)."
+  },
+  category: "crm",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.getresponse.com/v3",
+  credentialPlacement: { kind: "header", header: "X-Auth-Token", prefix: "api-key " },
+  defaultHeaders: { "content-type": "application/json" },
+  test: { method: "GET", path: "/accounts" },
+  capabilities: [
+    {
+      name: "contacts.list",
+      class: "read",
+      description: "List or search contacts, optionally filtered by email or campaign (list).",
+      parameters: {
+        type: "object",
+        properties: {
+          email: { type: "string" },
+          campaignId: { type: "string" },
+          page: { type: "integer" },
+          perPage: { type: "integer" }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/contacts",
+        query: {
+          "query[email]": "{email}",
+          "query[campaignId]": "{campaignId}",
+          page: "{page}",
+          perPage: "{perPage}"
+        }
+      }
+    },
+    {
+      name: "campaigns.list",
+      class: "read",
+      description: "List campaigns (contact lists). The campaignId returned here is used when adding contacts or sending newsletters.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          page: { type: "integer" },
+          perPage: { type: "integer" }
+        },
+        required: []
+      },
+      request: {
+        method: "GET",
+        path: "/campaigns",
+        query: { "query[name]": "{name}", page: "{page}", perPage: "{perPage}" }
+      }
+    },
+    {
+      name: "contacts.create",
+      class: "mutation",
+      description: "Add (import) a contact to a campaign (list). Only email and campaign id are required.",
+      parameters: {
+        type: "object",
+        properties: {
+          email: { type: "string" },
+          campaign_id: { type: "string" },
+          name: { type: "string" },
+          dayOfCycle: { type: "integer" }
+        },
+        required: ["email", "campaign_id"]
+      },
+      request: {
+        method: "POST",
+        path: "/contacts",
+        body: {
+          email: "{email}",
+          name: "{name}",
+          dayOfCycle: "{dayOfCycle}",
+          campaign: { campaignId: "{campaign_id}" }
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "newsletters.create",
+      class: "mutation",
+      description: "Create and send a newsletter (broadcast email) to a campaign. Requires subject, fromFieldId, HTML content, and a target campaign.",
+      parameters: {
+        type: "object",
+        properties: {
+          subject: { type: "string" },
+          fromFieldId: { type: "string" },
+          html: { type: "string" },
+          campaign_id: { type: "string" },
+          name: { type: "string" }
+        },
+        required: ["subject", "fromFieldId", "html", "campaign_id"]
+      },
+      request: {
+        method: "POST",
+        path: "/newsletters",
+        body: {
+          name: "{name}",
+          subject: "{subject}",
+          fromField: { fromFieldId: "{fromFieldId}" },
+          content: { html: "{html}" },
+          campaign: { campaignId: "{campaign_id}" },
+          sendSettings: { selectedCampaigns: ["{campaign_id}"] }
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
+// src/connectors/adapters/outreach.ts
+var outreachConnector = declarativeRestConnector({
+  kind: "outreach",
+  displayName: "Outreach",
+  description: "Manage Outreach prospects, accounts, and opportunities, and enroll prospects into sequences, through the JSON:API v2 REST API.",
+  auth: {
+    kind: "oauth2",
+    authorizationUrl: "https://api.outreach.io/oauth/authorize",
+    tokenUrl: "https://api.outreach.io/oauth/token",
+    scopes: [
+      "prospects.read",
+      "prospects.write",
+      "accounts.read",
+      "accounts.write",
+      "opportunities.read",
+      "sequences.read",
+      "sequenceStates.read",
+      "sequenceStates.write",
+      "users.read"
+    ],
+    clientIdEnv: "OUTREACH_OAUTH_CLIENT_ID",
+    clientSecretEnv: "OUTREACH_OAUTH_CLIENT_SECRET"
+  },
+  category: "crm",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.outreach.io/api/v2",
+  // Outreach is JSON:API — both the request and response media type is
+  // application/vnd.api+json. The declarative runtime only forces a body
+  // content-type when one isn't already present, so pinning it here makes
+  // every write carry the JSON:API media type.
+  defaultHeaders: {
+    accept: "application/vnd.api+json",
+    "content-type": "application/vnd.api+json"
+  },
+  test: { method: "GET", path: "/users", query: { "page[size]": "1" } },
+  capabilities: [
+    {
+      name: "prospects.list",
+      class: "read",
+      description: "List or search prospects (contacts). Filter by email, paginate with pageSize/pageAfter, sort, and sideload related resources via include.",
+      parameters: {
+        type: "object",
+        properties: {
+          email: { type: "string", description: "Filter prospects by email address (filter[emails][email])." },
+          pageSize: { type: "number", description: "Results per page (default 50, max 1000)." },
+          pageAfter: { type: "string", description: "Cursor for the next page (cursor-based pagination)." },
+          sort: { type: "string", description: "Attribute to sort by; prefix with - for descending (e.g. -createdAt)." },
+          include: { type: "string", description: "Comma-separated related resources to sideload (e.g. account,owner)." }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/prospects",
+        query: {
+          "filter[emails][email]": "{email}",
+          "page[size]": "{pageSize}",
+          "page[after]": "{pageAfter}",
+          sort: "{sort}",
+          include: "{include}"
+        }
+      },
+      requiredScopes: ["prospects.read"]
+    },
+    {
+      name: "prospects.create",
+      class: "mutation",
+      description: 'Create a prospect. Pass JSON:API `attributes` (e.g. { firstName, lastName, emails: [{ email, emailType: "work" }], title }) and an optional `relationships` object (e.g. { account: { data: { type: "account", id: 123 } } }).',
+      parameters: {
+        type: "object",
+        properties: {
+          attributes: {
+            type: "object",
+            description: "JSON:API attributes for the prospect resource.",
+            additionalProperties: true
+          },
+          relationships: {
+            type: "object",
+            description: "Optional JSON:API relationships object linking the prospect to an account, owner, etc.",
+            additionalProperties: true
+          }
+        },
+        required: ["attributes"]
+      },
+      request: {
+        method: "POST",
+        path: "/prospects",
+        body: { data: { type: "prospect", attributes: "{attributes}", relationships: "{relationships}" } }
+      },
+      cas: "native-idempotency",
+      externalEffect: true,
+      requiredScopes: ["prospects.write"]
+    },
+    {
+      name: "prospects.update",
+      class: "mutation",
+      description: "Update a prospect by id. Pass the numeric id and a JSON:API `attributes` object; only provided fields change.",
+      parameters: {
+        type: "object",
+        properties: {
+          id: { type: "number", description: "Numeric prospect id." },
+          attributes: { type: "object", description: "JSON:API attributes to update.", additionalProperties: true },
+          relationships: { type: "object", description: "Optional JSON:API relationships to update.", additionalProperties: true }
+        },
+        required: ["id", "attributes"]
+      },
+      request: {
+        method: "PATCH",
+        path: "/prospects/{id}",
+        body: { data: { type: "prospect", id: "{id}", attributes: "{attributes}", relationships: "{relationships}" } }
+      },
+      cas: "native-idempotency",
+      externalEffect: true,
+      requiredScopes: ["prospects.write"]
+    },
+    {
+      name: "sequenceStates.create",
+      class: "mutation",
+      description: "Enroll a prospect into a sequence (start a sequence state). Provide the numeric prospectId and sequenceId.",
+      parameters: {
+        type: "object",
+        properties: {
+          prospectId: { type: "number", description: "Numeric prospect id to enroll." },
+          sequenceId: { type: "number", description: "Numeric sequence id to enroll the prospect into." }
+        },
+        required: ["prospectId", "sequenceId"]
+      },
+      request: {
+        method: "POST",
+        path: "/sequenceStates",
+        body: {
+          data: {
+            type: "sequenceState",
+            relationships: {
+              prospect: { data: { type: "prospect", id: "{prospectId}" } },
+              sequence: { data: { type: "sequence", id: "{sequenceId}" } }
+            }
+          }
+        }
+      },
+      cas: "native-idempotency",
+      externalEffect: true,
+      requiredScopes: ["sequenceStates.write"]
+    },
+    {
+      name: "opportunities.list",
+      class: "read",
+      description: "List opportunities, optionally filtered by account id; paginate and sideload via include.",
+      parameters: {
+        type: "object",
+        properties: {
+          accountId: { type: "number", description: "Filter opportunities by associated account id (filter[account][id])." },
+          pageSize: { type: "number", description: "Results per page." },
+          pageAfter: { type: "string", description: "Cursor for the next page." },
+          include: { type: "string", description: "Comma-separated related resources to sideload (e.g. account,prospects)." }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/opportunities",
+        query: {
+          "filter[account][id]": "{accountId}",
+          "page[size]": "{pageSize}",
+          "page[after]": "{pageAfter}",
+          include: "{include}"
+        }
+      },
+      requiredScopes: ["opportunities.read"]
+    },
+    {
+      name: "accounts.create",
+      class: "mutation",
+      description: "Create an account (company). Pass JSON:API `attributes` (name is required; domain and industry optional).",
+      parameters: {
+        type: "object",
+        properties: {
+          attributes: {
+            type: "object",
+            description: "JSON:API attributes for the account resource, e.g. { name, domain, industry }.",
+            additionalProperties: true
+          }
+        },
+        required: ["attributes"]
+      },
+      request: {
+        method: "POST",
+        path: "/accounts",
+        body: { data: { type: "account", attributes: "{attributes}" } }
+      },
+      cas: "native-idempotency",
+      externalEffect: true,
+      requiredScopes: ["accounts.write"]
+    }
+  ]
+});
+
+// src/connectors/adapters/salesloft.ts
+var salesloftConnector = declarativeRestConnector({
+  kind: "salesloft",
+  displayName: "Salesloft",
+  description: "Manage Salesloft people and accounts and enroll people into cadences through the REST API v2.",
+  auth: {
+    kind: "oauth2",
+    authorizationUrl: "https://accounts.salesloft.com/oauth/authorize",
+    tokenUrl: "https://accounts.salesloft.com/oauth/token",
+    scopes: [],
+    clientIdEnv: "SALESLOFT_OAUTH_CLIENT_ID",
+    clientSecretEnv: "SALESLOFT_OAUTH_CLIENT_SECRET"
+  },
+  category: "crm",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://api.salesloft.com/v2",
+  test: { method: "GET", path: "/me" },
+  capabilities: [
+    {
+      name: "me.get",
+      class: "read",
+      description: "Return the authenticated user and team \u2014 the cheapest grant-validity probe.",
+      parameters: { type: "object", properties: {} },
+      request: { method: "GET", path: "/me" }
+    },
+    {
+      name: "people.list",
+      class: "read",
+      description: "List people (contacts). Paginate with page/per_page.",
+      parameters: {
+        type: "object",
+        properties: {
+          page: { type: "number", description: "Page number (1-based)." },
+          per_page: { type: "number", description: "Records per page (max 100)." }
+        }
+      },
+      request: { method: "GET", path: "/people", query: { page: "{page}", per_page: "{per_page}" } }
+    },
+    {
+      name: "people.create",
+      class: "mutation",
+      description: "Create a person. Provide email_address, OR phone paired with last_name. first_name/last_name optional otherwise.",
+      parameters: {
+        type: "object",
+        properties: {
+          email_address: { type: "string", description: "Email address; required unless phone+last_name are provided." },
+          first_name: { type: "string", description: "Person's first name." },
+          last_name: { type: "string", description: "Person's last name; required when phone is provided instead of email_address." },
+          phone: { type: "string", description: "Phone number; required (with last_name) when email_address is absent." }
+        }
+      },
+      request: { method: "POST", path: "/people", body: "args" },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "accounts.create",
+      class: "mutation",
+      description: "Create an account (company). name is required; domain must be unique on the team.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Account/company name." },
+          domain: { type: "string", description: "Website domain; must be unique on the team." }
+        },
+        required: ["name"]
+      },
+      request: { method: "POST", path: "/accounts", body: "args" },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "cadences.list",
+      class: "read",
+      description: "List cadences. Paginate with page/per_page.",
+      parameters: {
+        type: "object",
+        properties: {
+          page: { type: "number", description: "Page number (1-based)." },
+          per_page: { type: "number", description: "Records per page (max 100)." }
+        }
+      },
+      request: { method: "GET", path: "/cadences", query: { page: "{page}", per_page: "{per_page}" } }
+    },
+    {
+      name: "cadence_memberships.create",
+      class: "mutation",
+      description: "Add a person to a cadence. Provide person_id and cadence_id; user_id defaults to the authenticated user.",
+      parameters: {
+        type: "object",
+        properties: {
+          person_id: { type: "number", description: "Id of the person to enroll (must be visible to the authenticated user)." },
+          cadence_id: { type: "number", description: "Id of the cadence to enroll the person into." },
+          user_id: { type: "number", description: "Owner of the membership; defaults to the authenticated user." }
+        },
+        required: ["person_id", "cadence_id"]
+      },
+      request: { method: "POST", path: "/cadence_memberships", body: "args" },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
+// src/connectors/adapters/gong.ts
+var gongConnector = declarativeRestConnector({
+  kind: "gong",
+  displayName: "Gong",
+  description: "Read Gong calls, transcripts, and users, ingest external calls, and assign prospects to Engage flows through the v2 API.",
+  auth: {
+    kind: "oauth2",
+    authorizationUrl: "https://app.gong.io/oauth2/authorize",
+    tokenUrl: "https://app.gong.io/oauth2/generate-customer-token",
+    scopes: [
+      "api:calls:read:basic",
+      "api:calls:read:extensive",
+      "api:calls:read:transcript",
+      "api:calls:create",
+      "api:users:read",
+      "api:flows:write"
+    ],
+    clientIdEnv: "GONG_OAUTH_CLIENT_ID",
+    clientSecretEnv: "GONG_OAUTH_CLIENT_SECRET"
+  },
+  category: "comms",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: { metadataKey: "apiBaseUrlForCustomer" },
+  test: { method: "GET", path: "/v2/users" },
+  capabilities: [
+    {
+      name: "calls.list",
+      class: "read",
+      description: "List calls in a time window. fromDateTime is required (ISO-8601); paginate with cursor.",
+      parameters: {
+        type: "object",
+        properties: {
+          fromDateTime: { type: "string", description: "ISO-8601 start datetime for calls to retrieve." },
+          toDateTime: { type: "string", description: "ISO-8601 end datetime for calls to retrieve." },
+          workspaceId: { type: "string", description: "Filter calls by a specific workspace id." },
+          cursor: { type: "string", description: "Pagination cursor from a previous response." }
+        },
+        required: ["fromDateTime"]
+      },
+      request: {
+        method: "GET",
+        path: "/v2/calls",
+        query: { fromDateTime: "{fromDateTime}", toDateTime: "{toDateTime}", workspaceId: "{workspaceId}", cursor: "{cursor}" }
+      },
+      requiredScopes: ["api:calls:read:basic"]
+    },
+    {
+      name: "calls.getTranscripts",
+      class: "read",
+      description: "Retrieve call transcripts. Pass a `filter` object (fromDateTime/toDateTime and/or callIds); paginate with cursor.",
+      parameters: {
+        type: "object",
+        properties: {
+          filter: {
+            type: "object",
+            description: 'Filter object, e.g. { fromDateTime, toDateTime, callIds: ["..."] }.',
+            additionalProperties: true
+          },
+          cursor: { type: "string", description: "Pagination cursor for the next page." }
+        },
+        required: ["filter"]
+      },
+      request: { method: "POST", path: "/v2/calls/transcript", body: { filter: "{filter}", cursor: "{cursor}" } },
+      requiredScopes: ["api:calls:read:transcript"]
+    },
+    {
+      name: "calls.getExtensive",
+      class: "read",
+      description: "Retrieve extensive call data. Pass a `filter` object and an optional `contentSelector` controlling which enrichment fields/context to include.",
+      parameters: {
+        type: "object",
+        properties: {
+          filter: {
+            type: "object",
+            description: "Filter object: fromDateTime, toDateTime, callIds, primaryUserIds, or workspaceId.",
+            additionalProperties: true
+          },
+          contentSelector: {
+            type: "object",
+            description: "Controls included enrichment data (exposedFields, context objects).",
+            additionalProperties: true
+          },
+          cursor: { type: "string", description: "Pagination cursor from a prior response." }
+        },
+        required: ["filter"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/calls/extensive",
+        body: { filter: "{filter}", contentSelector: "{contentSelector}", cursor: "{cursor}" }
+      },
+      requiredScopes: ["api:calls:read:extensive"]
+    },
+    {
+      name: "users.list",
+      class: "read",
+      description: "List Gong users (max 100 per page). Paginate with cursor.",
+      parameters: {
+        type: "object",
+        properties: {
+          cursor: { type: "string", description: "Pagination cursor; omit for the first page." },
+          includeAvatars: { type: "boolean", description: "Include avatar image URLs in the response (default false)." }
+        }
+      },
+      request: { method: "GET", path: "/v2/users", query: { cursor: "{cursor}", includeAvatars: "{includeAvatars}" } },
+      requiredScopes: ["api:users:read"]
+    },
+    {
+      name: "calls.create",
+      class: "mutation",
+      description: "Ingest an external call into Gong. Required: clientUniqueId, actualStart (ISO-8601), direction (Inbound/Outbound/Conference/Unknown), parties (array of participant objects).",
+      parameters: {
+        type: "object",
+        properties: {
+          clientUniqueId: { type: "string", description: "Unique identifier for the call in the source system." },
+          actualStart: { type: "string", description: "ISO-8601 datetime when the call started." },
+          direction: { type: "string", enum: ["Inbound", "Outbound", "Conference", "Unknown"], description: "Call direction." },
+          title: { type: "string", description: "Title or subject of the call." },
+          parties: {
+            type: "array",
+            description: "Participant objects with emailAddress, name, phoneNumber, speakerId.",
+            items: { type: "object", additionalProperties: true }
+          },
+          mediaChannels: { type: "object", description: "Media channel configuration.", additionalProperties: true },
+          workspaceId: { type: "string", description: "Workspace to associate the call with." }
+        },
+        required: ["clientUniqueId", "actualStart", "direction", "parties"]
+      },
+      request: { method: "POST", path: "/v2/calls", body: "args" },
+      cas: "native-idempotency",
+      externalEffect: true,
+      requiredScopes: ["api:calls:create"]
+    },
+    {
+      name: "flows.assignProspects",
+      class: "mutation",
+      description: "Assign prospects to a Gong Engage flow. Provide flowId and a prospects array (up to 100).",
+      parameters: {
+        type: "object",
+        properties: {
+          flowId: { type: "string", description: "Id of the Engage flow to assign prospects to." },
+          prospects: {
+            type: "array",
+            description: "Prospect objects (up to 100); each with crmProspectId and optional fields.",
+            items: { type: "object", additionalProperties: true }
+          },
+          actionSource: { type: "string", description: "Identifier of the integration making the assignment." }
+        },
+        required: ["flowId", "prospects"]
+      },
+      request: {
+        method: "POST",
+        path: "/v2/flows/prospects/assign",
+        body: { flowId: "{flowId}", prospects: "{prospects}", actionSource: "{actionSource}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: true,
+      requiredScopes: ["api:flows:write"]
+    }
+  ]
+});
+
+// src/connectors/adapters/ringcentral.ts
+var ringcentralConnector = declarativeRestConnector({
+  kind: "ringcentral",
+  displayName: "RingCentral",
+  description: "Read RingCentral extensions, call logs, and messages, send SMS, and create webhook subscriptions through the REST v1.0 API.",
+  auth: {
+    kind: "oauth2",
+    authorizationUrl: "https://platform.ringcentral.com/restapi/oauth/authorize",
+    tokenUrl: "https://platform.ringcentral.com/restapi/oauth/token",
+    scopes: ["ReadAccounts", "ReadCallLog", "ReadMessages", "SMS", "ReadContacts", "SubscriptionWebhook"],
+    clientIdEnv: "RINGCENTRAL_OAUTH_CLIENT_ID",
+    clientSecretEnv: "RINGCENTRAL_OAUTH_CLIENT_SECRET"
+  },
+  category: "comms",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://platform.ringcentral.com/restapi/v1.0",
+  test: { method: "GET", path: "/account/~/extension/~" },
+  capabilities: [
+    {
+      name: "extension.get",
+      class: "read",
+      description: "Get the authenticated user's extension record.",
+      parameters: { type: "object", properties: {} },
+      request: { method: "GET", path: "/account/~/extension/~" }
+    },
+    {
+      name: "extensions.list",
+      class: "read",
+      description: "List extensions on an account. Pass accountId or ~ for the authenticated account.",
+      parameters: {
+        type: "object",
+        properties: {
+          accountId: { type: "string", description: "Internal account id, or ~ for the authenticated account." },
+          page: { type: "number", description: "Page number for pagination." },
+          perPage: { type: "number", description: "Records per page." },
+          status: { type: "string", description: "Filter by extension status (e.g. Enabled, Disabled)." }
+        },
+        required: ["accountId"]
+      },
+      request: {
+        method: "GET",
+        path: "/account/{accountId}/extension",
+        query: { page: "{page}", perPage: "{perPage}", status: "{status}" }
+      }
+    },
+    {
+      name: "callLog.list",
+      class: "read",
+      description: "List the authenticated extension's call log. Use view=Detailed for full records.",
+      parameters: {
+        type: "object",
+        properties: {
+          dateFrom: { type: "string", description: "Start of range, ISO-8601 UTC." },
+          dateTo: { type: "string", description: "End of range, ISO-8601 UTC." },
+          view: { type: "string", description: "Set to 'Detailed' to fetch detailed call records." },
+          perPage: { type: "number", description: "Records per page." }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/account/~/extension/~/call-log",
+        query: { dateFrom: "{dateFrom}", dateTo: "{dateTo}", view: "{view}", perPage: "{perPage}" }
+      }
+    },
+    {
+      name: "messages.list",
+      class: "read",
+      description: "List the authenticated extension's message store (SMS, Fax, VoiceMail).",
+      parameters: {
+        type: "object",
+        properties: {
+          messageType: { type: "string", description: "Filter by message type: SMS, Fax, or VoiceMail." },
+          dateFrom: { type: "string", description: "Start of range, ISO-8601." },
+          dateTo: { type: "string", description: "End of range, ISO-8601." },
+          perPage: { type: "number", description: "Records per page (up to 1000)." },
+          readStatus: { type: "string", description: "Filter by read status: Read or Unread." }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/account/~/extension/~/message-store",
+        query: {
+          messageType: "{messageType}",
+          dateFrom: "{dateFrom}",
+          dateTo: "{dateTo}",
+          perPage: "{perPage}",
+          readStatus: "{readStatus}"
+        }
+      }
+    },
+    {
+      name: "sms.send",
+      class: "mutation",
+      description: "Send an SMS from the authenticated extension. from = { phoneNumber }, to = [{ phoneNumber }] (up to 10), text = body.",
+      parameters: {
+        type: "object",
+        properties: {
+          from: { type: "object", description: "Sender: { phoneNumber } \u2014 must be a number assigned to the user.", additionalProperties: true },
+          to: {
+            type: "array",
+            description: "Recipients: [{ phoneNumber }] \u2014 up to 10.",
+            items: { type: "object", additionalProperties: true }
+          },
+          text: { type: "string", description: "SMS message text." }
+        },
+        required: ["from", "to", "text"]
+      },
+      request: { method: "POST", path: "/account/~/extension/~/sms", body: { from: "{from}", to: "{to}", text: "{text}" } },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "subscriptions.create",
+      class: "mutation",
+      description: 'Create a webhook subscription. eventFilters = array of event URIs, deliveryMode = { transportType: "WebHook", address }.',
+      parameters: {
+        type: "object",
+        properties: {
+          eventFilters: {
+            type: "array",
+            description: "Event filter URI strings, e.g. /restapi/v1.0/account/~/extension/~/message-store.",
+            items: { type: "string" }
+          },
+          deliveryMode: {
+            type: "object",
+            description: 'Delivery config: { transportType: "WebHook", address }.',
+            additionalProperties: true
+          },
+          expiresIn: { type: "number", description: "Subscription lifetime in seconds." }
+        },
+        required: ["eventFilters", "deliveryMode"]
+      },
+      request: {
+        method: "POST",
+        path: "/subscription",
+        body: { eventFilters: "{eventFilters}", deliveryMode: "{deliveryMode}", expiresIn: "{expiresIn}" }
+      },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
+// src/connectors/adapters/dialpad.ts
+var dialpadConnector = declarativeRestConnector({
+  kind: "dialpad",
+  displayName: "Dialpad",
+  description: "Read Dialpad contacts, calls, and users, create contacts, and send SMS through the v2 API.",
+  auth: {
+    kind: "oauth2",
+    authorizationUrl: "https://dialpad.com/oauth2/authorize",
+    tokenUrl: "https://dialpad.com/oauth2/token",
+    scopes: ["calls:list", "offline_access"],
+    clientIdEnv: "DIALPAD_OAUTH_CLIENT_ID",
+    clientSecretEnv: "DIALPAD_OAUTH_CLIENT_SECRET"
+  },
+  category: "comms",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://dialpad.com/api/v2",
+  test: { method: "GET", path: "/users" },
+  capabilities: [
+    {
+      name: "contacts.list",
+      class: "read",
+      description: "List contacts. Set include_local + owner_id to include a user's local contacts; paginate with cursor.",
+      parameters: {
+        type: "object",
+        properties: {
+          cursor: { type: "string", description: "Pagination token from a previous response." },
+          include_local: { type: "boolean", description: "Include company local contacts (default false)." },
+          owner_id: { type: "string", description: "User id whose local contacts should be retrieved." }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/contacts",
+        query: { cursor: "{cursor}", include_local: "{include_local}", owner_id: "{owner_id}" }
+      }
+    },
+    {
+      name: "contacts.create",
+      class: "mutation",
+      description: "Create a contact. first_name and last_name are required. Omit owner_id for a shared company contact.",
+      parameters: {
+        type: "object",
+        properties: {
+          first_name: { type: "string", description: "Contact's first name." },
+          last_name: { type: "string", description: "Contact's last name." },
+          company_name: { type: "string", description: "Contact's company name." },
+          job_title: { type: "string", description: "Contact's job title." },
+          emails: { type: "array", description: "Email strings; primary first.", items: { type: "string" } },
+          phones: { type: "array", description: "E.164-formatted phone strings; primary first.", items: { type: "string" } },
+          owner_id: { type: "string", description: "User id to create a local contact for; omit for a shared company contact." }
+        },
+        required: ["first_name", "last_name"]
+      },
+      request: { method: "POST", path: "/contacts", body: "args" },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "calls.list",
+      class: "read",
+      description: "List calls. Filter by started_after/started_before (UTC ms) and target; paginate with cursor.",
+      parameters: {
+        type: "object",
+        properties: {
+          cursor: { type: "string", description: "Pagination token from a previous response." },
+          started_after: { type: "number", description: "UTC millisecond timestamp; calls started after this time." },
+          started_before: { type: "number", description: "UTC millisecond timestamp; calls started before this time." },
+          target_id: { type: "number", description: "Filter calls by target entity id." },
+          target_type: { type: "string", description: "Target type: callcenter, callrouter, channel, coaching, team, department, office, user, etc." },
+          include_anonymized: { type: "boolean", description: "Include anonymized call records (default false)." }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/call",
+        query: {
+          cursor: "{cursor}",
+          started_after: "{started_after}",
+          started_before: "{started_before}",
+          target_id: "{target_id}",
+          target_type: "{target_type}",
+          include_anonymized: "{include_anonymized}"
+        }
+      }
+    },
+    {
+      name: "calls.get",
+      class: "read",
+      description: "Get a single call by id.",
+      parameters: {
+        type: "object",
+        properties: { id: { type: "number", description: "The call's unique identifier (int64)." } },
+        required: ["id"]
+      },
+      request: { method: "GET", path: "/call/{id}" }
+    },
+    {
+      name: "sms.send",
+      class: "mutation",
+      description: "Send an SMS/MMS. to_numbers = up to 10 E.164 destinations, text = body. Provide one sender: user_id, from_number, or sender_group_id(+type).",
+      parameters: {
+        type: "object",
+        properties: {
+          to_numbers: { type: "array", description: "Up to 10 E.164-formatted destination numbers.", items: { type: "string" } },
+          text: { type: "string", description: "Message body text." },
+          user_id: { type: "number", description: "Sender's Dialpad user id." },
+          from_number: { type: "string", description: "Sender's phone number; overrides user_id/sender_group_id." },
+          sender_group_id: { type: "number", description: "Office, department, or call-center id to send from." },
+          sender_group_type: { type: "string", enum: ["callcenter", "department", "office"], description: "Sender group type." },
+          media: { type: "string", description: "Base64-encoded media attachment (max 500 KiB); triggers MMS." },
+          infer_country_code: { type: "boolean", description: "Relax strict E.164 requirement (default false)." }
+        },
+        required: ["to_numbers", "text"]
+      },
+      request: { method: "POST", path: "/sms", body: "args" },
+      cas: "native-idempotency",
+      externalEffect: true
+    },
+    {
+      name: "users.list",
+      class: "read",
+      description: "List users. Filter by email/name/state; paginate with cursor.",
+      parameters: {
+        type: "object",
+        properties: {
+          cursor: { type: "string", description: "Pagination token from a previous response." },
+          email: { type: "string", description: "Filter by user's email address." },
+          first_name: { type: "string", description: "Filter by first-name prefix." },
+          last_name: { type: "string", description: "Filter by last-name prefix." },
+          state: { type: "string", description: "Filter by state: active, all, cancelled, deleted, pending, suspended." },
+          company_admin: { type: "boolean", description: "Return only company admins (true) or non-admins (false)." }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/users",
+        query: {
+          cursor: "{cursor}",
+          email: "{email}",
+          first_name: "{first_name}",
+          last_name: "{last_name}",
+          state: "{state}",
+          company_admin: "{company_admin}"
+        }
+      }
+    }
+  ]
+});
+
+// src/connectors/adapters/demandbase.ts
+var demandbaseConnector = declarativeRestConnector({
+  kind: "demandbase",
+  displayName: "Demandbase",
+  description: "Manage Demandbase platform users (list, get, create) through the Admin API using client-credentials auth.",
+  auth: {
+    kind: "oauth2",
+    grantType: "client_credentials",
+    tokenUrl: "https://uapi.demandbase.com/auth/v1/token",
+    scopes: [],
+    clientIdEnv: "DEMANDBASE_OAUTH_CLIENT_ID",
+    clientSecretEnv: "DEMANDBASE_OAUTH_CLIENT_SECRET"
+  },
+  category: "sales-intelligence",
+  defaultConsistencyModel: "authoritative",
+  baseUrl: "https://uapi.demandbase.com",
+  test: { method: "GET", path: "/admin/v1/users", query: { limit: "1" } },
+  capabilities: [
+    {
+      name: "users.list",
+      class: "read",
+      description: "List platform users. Paginate with limit/offset; filter by status/role.",
+      parameters: {
+        type: "object",
+        properties: {
+          limit: { type: "number", description: "Max records to return (max 100)." },
+          offset: { type: "number", description: "Pagination offset." },
+          status: { type: "string", description: "Filter by user status." },
+          role: { type: "string", description: "Filter by user role." }
+        }
+      },
+      request: {
+        method: "GET",
+        path: "/admin/v1/users",
+        query: { limit: "{limit}", offset: "{offset}", status: "{status}", role: "{role}" }
+      }
+    },
+    {
+      name: "users.get",
+      class: "read",
+      description: "Get a single platform user by id.",
+      parameters: {
+        type: "object",
+        properties: { userId: { type: "string", description: "The user's unique identifier." } },
+        required: ["userId"]
+      },
+      request: { method: "GET", path: "/admin/v1/user/{userId}" }
+    },
+    {
+      name: "users.create",
+      class: "mutation",
+      description: "Create a platform user. email, first_name, last_name, and role are required.",
+      parameters: {
+        type: "object",
+        properties: {
+          email: { type: "string", description: "User email address." },
+          first_name: { type: "string", description: "User first name." },
+          last_name: { type: "string", description: "User last name." },
+          role: { type: "string", description: "User role within the platform." }
+        },
+        required: ["email", "first_name", "last_name", "role"]
+      },
+      request: { method: "POST", path: "/admin/v1/user", body: "args" },
+      cas: "native-idempotency",
+      externalEffect: true
+    }
+  ]
+});
+
 export {
   InMemoryOAuthFlowStore,
   startOAuthFlow,
@@ -120762,6 +125088,45 @@ export {
   n8nConnector,
   makeConnector,
   pipedreamConnector,
+  amplemarketConnector,
+  heyreachConnector,
+  lagrowthmachineConnector,
+  saleshandyConnector,
+  bettercontactConnector,
+  contactoutConnector,
+  findymailConnector,
+  snovIoConnector,
+  wizaConnector,
+  builtwithConnector,
+  commonRoomConnector,
+  leadfeederConnector,
+  serperConnector,
+  warmlyConnector,
+  autoboundConnector,
+  crustdataConnector,
+  fullenrichConnector,
+  leadmagicConnector,
+  brightdataConnector,
+  phantombusterConnector,
+  zenrowsConnector,
+  oceanIoConnector,
+  seamlessAiConnector,
+  theirstackConnector,
+  usergemsConnector,
+  hightouchConnector,
+  polytomicConnector,
+  signwellConnector,
+  justcallConnector,
+  nooksConnector,
+  modjoConnector,
+  factorsAiConnector,
+  getresponseConnector,
+  outreachConnector,
+  salesloftConnector,
+  gongConnector,
+  ringcentralConnector,
+  dialpadConnector,
+  demandbaseConnector,
   adapters_exports
 };
-//# sourceMappingURL=chunk-COKK7BOH.js.map
+//# sourceMappingURL=chunk-HRPCFEGL.js.map