@jskit-ai/connectors-catalog 0.1.1

package/src/server/notion.js

@@ -0,0 +1,76 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { mcpOperations, exchangeMcp } from "./mcpTransport.js";
+import { mcpRegistrationFields, registerMcpClient } from "./mcpRegistration.js";
+import { notionDefinition } from "../shared/tokens.js";
+import { jsonOperation, validatedOperation } from "./jsonOperation.js";
+
+const identifier = { type: "string", required: true, pattern: "^(?:[a-fA-F0-9]{32}|[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12})$" };
+const document = { type: "object", additionalProperties: true,
+  validator: value => Buffer.byteLength(JSON.stringify(value)) <= 65536 || "Keep each document below 64 KiB." };
+const pagination = { page_size: { type: "integer", min: 1, max: 100, defaultTo: 100 },
+  start_cursor: { type: "string", minLength: 1, maxLength: 4096 } };
+const listResult = result => result?.object === "list" && Array.isArray(result.results) && typeof result.has_more === "boolean";
+const objectResult = object => result => result?.object === object && typeof result.id === "string" && result.id.length > 0;
+const children = { type: "array", required: true, minLength: 1, maxLength: 100,
+  items: { ...document, required: true }, validator: value => value.length >= 1 && value.length <= 100 && Buffer.byteLength(JSON.stringify(value)) <= 262144 || "Keep blocks below 256 KiB." };
+// Notion owns its property/block grammar. Bound documents without inventing a second content schema.
+function readObject(collection, object) {
+  return validatedOperation({ id: identifier }, ({ id }) => ({ method: "GET", url: `https://api.notion.com/v1/${collection}/${id}` }), objectResult(object));
+}
+
+const mcpMetadata = Object.freeze({ issuer: "https://mcp.notion.com",
+  authorization_endpoint: "https://mcp.notion.com/authorize", token_endpoint: "https://mcp.notion.com/token",
+  registration_endpoint: "https://mcp.notion.com/register" });
+const mcpRuntime = Object.freeze({ oauth: mcpMetadata, oauthPkce: true,
+  oauthBasicEncoding: undefined, tokenRequestEncoding: undefined, authorizationParameters: {}, oauthHeaders: undefined,
+  apiOrigins: ["https://mcp.notion.com"], checkOperation: "tools.list", exchange: exchangeMcp,
+  operations: mcpOperations(() => "https://mcp.notion.com/mcp") });
+const notionProvider = Object.freeze({
+  ...notionDefinition,
+  runtimeForSettings: (settings) => settings.connectionType === "mcp" ? mcpRuntime : {},
+  oauth: {
+    issuer: "https://api.notion.com",
+    authorization_endpoint: "https://api.notion.com/v1/oauth/authorize",
+    token_endpoint: "https://api.notion.com/v1/oauth/token"
+  },
+  oauthPkce: false,
+  oauthBasicEncoding: "raw",
+  tokenRequestEncoding: "json",
+  authorizationParameters: { owner: "user" },
+  oauthHeaders: () => ({ "Notion-Version": "2026-03-11" }),
+  apiOrigins: ["https://api.notion.com"],
+  apiKey: { headers: (key) => ({ Authorization: `Bearer ${key}`, "Notion-Version": "2026-03-11" }) },
+  checkOperation: "content.search",
+  operations: {
+    "pages.get": readObject("pages", "page"),
+    "databases.get": readObject("databases", "database"),
+    "dataSources.get": readObject("data_sources", "data_source"),
+    "blocks.list": validatedOperation({ id: identifier, ...pagination }, ({ id, ...query }) => ({ method: "GET",
+      url: `https://api.notion.com/v1/blocks/${id}/children?${new URLSearchParams(query)}` }), listResult),
+    "dataSources.query": validatedOperation({ id: identifier, ...pagination, filter: document,
+      sorts: { type: "array", validator: value => value.length <= 20 || "Use at most 20 sorts.", items: document } }, ({ id, ...body }) => ({ method: "POST",
+      url: `https://api.notion.com/v1/data_sources/${id}/query`, body }), listResult),
+    "pages.create": validatedOperation({ parentId: identifier, parentType: { type: "string", required: true, enum: ["page_id", "data_source_id"] },
+      properties: { ...document, required: true }, children: { ...children, required: false } },
+      ({ parentId, parentType, ...body }) => ({ method: "POST", url: "https://api.notion.com/v1/pages",
+        body: { parent: { type: parentType, [parentType]: parentId }, ...body } }), objectResult("page")),
+    "pages.update": validatedOperation({ id: identifier, properties: { ...document, required: true } },
+      ({ id, ...body }) => ({ method: "PATCH", url: `https://api.notion.com/v1/pages/${id}`, body }), objectResult("page")),
+    "blocks.append": validatedOperation({ id: identifier, children }, ({ id, ...body }) => ({ method: "PATCH",
+      url: `https://api.notion.com/v1/blocks/${id}/children`, body }), listResult),
+    "content.search": jsonOperation("https://api.notion.com/v1/search", {
+      query: { type: "string", maxLength: 4096 },
+      page_size: { type: "integer", min: 1, max: 100, defaultTo: 100 },
+      start_cursor: { type: "string", minLength: 1, maxLength: 4096 }
+    }, (result) => result?.object === "list" && Array.isArray(result.results) && typeof result.has_more === "boolean", "POST"),
+    "identity.read": jsonOperation("https://api.notion.com/v1/users/me", {},
+      (result) => result?.object === "user" && typeof result.id === "string" && ["bot", "person"].includes(result.type))
+  }
+});
+const registrationSchema = createSchema(mcpRegistrationFields);
+async function registerNotionMcpClient(input, options) {
+  const values = validateSchemaPayload({ schema: registrationSchema, mode: "replace" }, input, { statusCode: 422 });
+  return registerMcpClient("Notion MCP", mcpMetadata, { ...values, scopes: ["default"] }, options);
+}
+export { notionProvider, registerNotionMcpClient };

package/src/server/oura.js

@@ -0,0 +1,48 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { ouraDefinition } from "../shared/oura.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const date = {
+  type: "string",
+  validator: (value) => (/^\d{4}-\d{2}-\d{2}$/u.test(value) &&
+    Number.isFinite(Date.parse(value)) && new Date(value).toISOString().slice(0, 10) === value) || "Enter a valid date as YYYY-MM-DD."
+};
+const datetime = { type: "string", validator: value =>
+  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/.test(value) && Number.isFinite(Date.parse(value)) && date.validator(value.slice(0, 10)) === true || "Enter an ISO timestamp with timezone." };
+function collection(endpoint, scope = "daily", timed = false) {
+  const start = timed ? "start_datetime" : "start_date", end = timed ? "end_datetime" : "end_date";
+  const operation = jsonOperation(`https://api.ouraring.com/v2/usercollection/${endpoint}`, {
+    [start]: timed ? datetime : date, [end]: timed ? datetime : date,
+    next_token: { type: "string", minLength: 1, maxLength: 4096 }
+  }, result => Array.isArray(result?.data) && (result.next_token == null || typeof result.next_token === "string"));
+  return { ...operation, scopes: [scope], request(input, settings) {
+    const request = operation.request(input, settings);
+    const query = new URL(request.url).searchParams;
+    if (query.has(start) && query.has(end) && Date.parse(query.get(start)) > Date.parse(query.get(end)))
+      throw new ConnectorError("connector_input_invalid", "Start must be before or equal to end.", { statusCode: 422 });
+    return request;
+  } };
+}
+const ouraProvider = Object.freeze({
+  ...ouraDefinition,
+  oauth: {
+    issuer: "https://cloud.ouraring.com",
+    authorization_endpoint: "https://cloud.ouraring.com/oauth/authorize",
+    token_endpoint: "https://api.ouraring.com/oauth/token"
+  },
+  scopesInAuthorizationResponse: true,
+  apiOrigins: ["https://api.ouraring.com"], checkOperation: "dailySleep.list",
+  operations: {
+    "dailySleep.list": collection("daily_sleep"),
+    "sleep.list": collection("sleep"),
+    "dailyReadiness.list": collection("daily_readiness"),
+    "dailyActivity.list": collection("daily_activity"),
+    "heartRate.list": collection("heartrate", "heartrate", true),
+    "personalInfo.read": {
+      ...jsonOperation("https://api.ouraring.com/v2/usercollection/personal_info", {},
+        (result) => typeof result?.id === "string" && result.id.length > 0),
+      scopes: ["personal", "email"]
+    }
+  }
+});
+export { ouraProvider };

package/src/server/paddle.js

@@ -0,0 +1,83 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { paddleDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const origins = { sandbox: "https://sandbox-api.paddle.com", live: "https://api.paddle.com" };
+const webhookUpdateSchema = createSchema({
+  notification_setting_id: { type: "string", required: true,
+    validator: (value) => /^ntfset_[a-z0-9]{26}$/.test(value) || "Enter a Paddle notification setting ID." },
+  description: { type: "string", minLength: 1, maxLength: 500 },
+  destination: { type: "string", minLength: 1, maxLength: 2048 },
+  active: { type: "boolean" },
+  api_version: { type: "integer", min: 1 },
+  include_sensitive_fields: { type: "boolean" },
+  subscribed_events: { type: "array", items: { type: "string", minLength: 3, maxLength: 100,
+    validator: (value) => /^[a-z_]+\.[a-z_]+$/.test(value) || "Use a Paddle event type name." } },
+  traffic_source: { type: "string", enum: ["platform", "simulation", "all"] }
+});
+const paddleProvider = Object.freeze({
+  ...paddleDefinition, apiOrigins: Object.values(origins),
+  apiKey: { headers: (key) => ({ Authorization: `Bearer ${key}`, "Paddle-Version": "1" }) },
+  checkOperation: "products.list",
+  async exchange(address, options, { request }) {
+    const result = await request(address, options);
+    if (new URL(address).pathname.startsWith("/notification-settings/") && result?.data) {
+      // Editing a destination must not expose its signing secret to assistant tools.
+      const { endpoint_secret_key, ...data } = result.data;
+      return { ...result, data };
+    }
+    return result;
+  },
+  operations: {
+    "checkoutDomains.get": {
+      scopes: [], assistantAction: "goLive.check",
+      request(input, settings) {
+        const { domain_id } = validateSchemaPayload({ schema: createSchema({
+          domain_id: { type: "string", required: true,
+            validator: (value) => /^chedom_[a-z0-9]{26}$/.test(value) || "Enter a Paddle checkout domain ID." }
+        }), mode: "replace" }, input, { statusCode: 422 });
+        return { method: "GET", url: `${origins[settings.environment]}/checkout-domains/${domain_id}` };
+      },
+      validateResult: (result) => /^chedom_[a-z0-9]{26}$/.test(result?.data?.id || "") &&
+        typeof result.data.domain === "string" && result.data.domain.length > 0 &&
+        ["pending_review", "approved", "rejected", "in_review", "action_required"].includes(result.data.status)
+    },
+    "webhooks.update": {
+      scopes: [],
+      request(input, settings) {
+        const { notification_setting_id, ...body } = validateSchemaPayload(
+          { schema: webhookUpdateSchema, mode: "replace" }, input, { statusCode: 422 });
+        if (!Object.keys(body).length) throw new ConnectorError("connector_input_invalid", "Choose at least one notification setting to change.", { statusCode: 422 });
+        return { method: "PATCH", url: `${origins[settings.environment]}/notification-settings/${notification_setting_id}`, body };
+      },
+      validateResult: (result) => /^ntfset_[a-z0-9]{26}$/.test(result?.data?.id || "") && typeof result.data.active === "boolean"
+    },
+    "products.create": jsonOperation((settings) => `${origins[settings.environment]}/products`, {
+      name: { type: "string", required: true, minLength: 1, maxLength: 200 },
+      description: { type: "string", maxLength: 2048 },
+      tax_category: { type: "string", required: true, enum: ["digital-goods", "ebooks", "implementation-services", "professional-services", "saas", "software-programming-services", "standard", "training-services", "website-hosting"] }
+    }, (result) => /^pro_[a-z0-9]{26}$/.test(result?.data?.id || ""), "POST"),
+    "prices.create": jsonOperation((settings) => `${origins[settings.environment]}/prices`, {
+      product_id: { type: "string", required: true, validator: (value) => /^pro_[a-z0-9]{26}$/.test(value) || "Enter a Paddle product ID." },
+      description: { type: "string", required: true, minLength: 2, maxLength: 500 },
+      unit_price: { type: "object", required: true, schema: createSchema({
+        amount: { type: "string", required: true, validator: (value) => /^\d+$/.test(value) || "Enter an integer amount in the currency's smallest unit." },
+        currency_code: { type: "string", required: true, validator: (value) => /^[A-Z]{3}$/.test(value) || "Enter a three-letter currency code supported by Paddle." }
+      }) },
+      billing_cycle: { type: "object", schema: createSchema({
+        interval: { type: "string", required: true, enum: ["day", "week", "month", "year"] },
+        frequency: { type: "integer", required: true, min: 1 }
+      }) }
+    }, (result) => /^pri_[a-z0-9]{26}$/.test(result?.data?.id || ""), "POST"),
+
+    "products.list": { assistantAction: "api.read", ...jsonOperation((settings) => `${origins[settings.environment]}/products`, {
+      per_page: { type: "integer", min: 1, max: 200, defaultTo: 50 },
+      after: { type: "string", maxLength: 200 },
+      status: { type: "string", enum: ["active", "archived"], defaultTo: "active" }
+    }, (result) => Array.isArray(result?.data) && Boolean(result.meta?.pagination)
+      && typeof result.meta.pagination.has_more === "boolean") }
+  }
+});
+export { paddleProvider };

package/src/server/perplexity.js

@@ -0,0 +1,15 @@
+import { perplexityDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const perplexityProvider = Object.freeze({
+  ...perplexityDefinition, apiOrigins: ["https://api.perplexity.ai"],
+  apiKey: { headers: (key) => ({ Authorization: `Bearer ${key}` }) },
+  checkOperation: "requests.list",
+  operations: {
+    "requests.list": jsonOperation("https://api.perplexity.ai/v1/async/sonar", {},
+      (result) => Array.isArray(result?.requests) && (result.next_token === undefined || result.next_token === null || typeof result.next_token === "string")),
+    "models.list": jsonOperation("https://api.perplexity.ai/v1/models", {},
+      (result) => result?.object === "list" && Array.isArray(result.data))
+  }
+});
+export { perplexityProvider };

package/src/server/pipedrive.js

@@ -0,0 +1,95 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { pipedriveDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+
+function companyApiDomain(value) {
+  if (typeof value !== "string" || !/^https:\/\/[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.pipedrive\.com$/.test(value)) {
+    throw new ConnectorError("connector_response_invalid", "Pipedrive returned an invalid company API address.", { statusCode: 502 });
+  }
+  return value;
+}
+
+const numberId = { type: "integer", min: 1 };
+const text = { type: "string", minLength: 1, maxLength: 1000 };
+const contactValues = { type: "array", validator: values => values.length <= 20 || "Use at most 20 contact values.",
+  items: { type: "object", schema: createSchema({ value: { ...text, required: true }, primary: { type: "boolean" }, label: text }) } };
+const recordFields = {
+  deals: { title: text, person_id: numberId, org_id: numberId, owner_id: numberId, stage_id: numberId,
+    value: { type: "number", min: 0 }, currency: { type: "string", pattern: "^[A-Z]{3}$" }, status: { type: "string", enum: ["open", "won", "lost"] } },
+  persons: { name: text, org_id: numberId, owner_id: numberId, emails: contactValues, phones: contactValues },
+  organizations: { name: text, owner_id: numberId },
+  activities: { subject: text, type: text, person_id: numberId, org_id: numberId, deal_id: numberId,
+    done: { type: "boolean" }, due_date: { type: "string", pattern: "^\\d{4}-\\d{2}-\\d{2}$" }, due_time: { type: "string", pattern: "^\\d{2}:\\d{2}$" } },
+  leads: { title: text, person_id: numberId, organization_id: numberId, owner_id: numberId }
+};
+function crmOperation(collection, action) {
+  const lead = collection === "leads", write = ["create", "update"].includes(action);
+  const id = lead ? { type: "string", pattern: "^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$" } : numberId;
+  const primary = ["deals", "leads"].includes(collection) ? "title" : collection === "activities" ? "subject" : "name";
+  const fields = write ? { ...recordFields[collection], ...(action === "create" ? { [primary]: { ...text, required: true } } : {}) } : action === "list"
+    ? { limit: { type: "integer", min: 1, max: 500, defaultTo: 100 }, ...(lead ? { start: { type: "integer", min: 0 } } : { cursor: { type: "string", minLength: 1, maxLength: 4096 } }) } : {};
+  const schema = createSchema({ ...fields, ...(["get", "update"].includes(action) ? { id: { ...id, required: true } } : {}) });
+  return { scopes: [], request(input, settings = {}, data) {
+    const { id, ...values } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+    if (action === "update" && !Object.keys(values).length || lead && action === "create" && !values.person_id && !values.organization_id)
+      throw new ConnectorError("connector_input_invalid", "Supply changed fields; a new lead also needs a person or organization.", { statusCode: 422 });
+    if (!data && !settings.companyDomain) throw new ConnectorError("connector_binding_missing", "Set the Pipedrive Company domain for API-token CRM operations.", { statusCode: 422 });
+    const origin = data ? companyApiDomain(data.apiDomain) : companyApiDomain(`https://${settings.companyDomain}.pipedrive.com`);
+    const url = new URL(`${origin}/api/${lead ? "v1" : "v2"}/${collection}${id === undefined ? "" : `/${id}`}`);
+    if (!write) for (const [name, value] of Object.entries(values)) url.searchParams.set(name, String(value));
+    return { method: action === "create" ? "POST" : action === "update" ? "PATCH" : "GET", url: url.href, ...(write ? { body: values } : {}) };
+  }, validateResult: result => result?.success === true && (action === "list" ? Array.isArray(result.data)
+    : lead ? typeof result.data?.id === "string" : Number.isInteger(result.data?.id)) };
+}
+
+const profile = jsonOperation("https://api.pipedrive.com/v1/users/me", {},
+  (result) => result?.success === true && Number.isInteger(result.data?.id));
+
+const pipedriveProvider = Object.freeze({
+  ...pipedriveDefinition,
+  oauth: { issuer: "https://oauth.pipedrive.com", authorization_endpoint: "https://oauth.pipedrive.com/oauth/authorize",
+    token_endpoint: "https://oauth.pipedrive.com/oauth/token" },
+  oauthPkce: false,
+  oauthBasicEncoding: "raw",
+  dataFromTokenResponse(response, previous) {
+    const apiDomain = companyApiDomain(response.api_domain);
+    if (previous && apiDomain !== previous.apiDomain) {
+      throw new ConnectorError("connector_reconnect_required", "The Pipedrive company address changed. Connect this account again.", { statusCode: 401 });
+    }
+    return { apiDomain };
+  },
+  apiOrigins: (settings, data) => data ? [companyApiDomain(data.apiDomain)] : ["https://api.pipedrive.com", ...(settings.companyDomain ? [companyApiDomain(`https://${settings.companyDomain}.pipedrive.com`)] : [])],
+  apiKey: { headers: (key) => ({ "x-api-token": key }) },
+  checkOperation: "profile.read",
+  operations: {
+    "deals.list": crmOperation("deals", "list"),
+    "deals.get": crmOperation("deals", "get"),
+    "deals.create": crmOperation("deals", "create"),
+    "deals.update": crmOperation("deals", "update"),
+    "persons.list": crmOperation("persons", "list"),
+    "persons.get": crmOperation("persons", "get"),
+    "persons.create": crmOperation("persons", "create"),
+    "persons.update": crmOperation("persons", "update"),
+    "organizations.list": crmOperation("organizations", "list"),
+    "organizations.get": crmOperation("organizations", "get"),
+    "organizations.create": crmOperation("organizations", "create"),
+    "organizations.update": crmOperation("organizations", "update"),
+    "activities.list": crmOperation("activities", "list"),
+    "activities.get": crmOperation("activities", "get"),
+    "activities.create": crmOperation("activities", "create"),
+    "activities.update": crmOperation("activities", "update"),
+    "leads.list": crmOperation("leads", "list"),
+    "leads.get": crmOperation("leads", "get"),
+    "leads.create": crmOperation("leads", "create"),
+    "leads.update": crmOperation("leads", "update"),
+    "pipelines.list": crmOperation("pipelines", "list"),
+    "pipelines.get": crmOperation("pipelines", "get"),
+    "profile.read": { ...profile, request(input, settings, data) {
+      const request = profile.request(input, settings);
+      return { ...request, url: data ? `${companyApiDomain(data.apiDomain)}/api/v1/users/me` : request.url };
+    } }
+  }
+});
+export { pipedriveProvider };

package/src/server/polar.js

@@ -0,0 +1,20 @@
+import { polarDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const origins = { sandbox: "https://sandbox-api.polar.sh", production: "https://api.polar.sh" };
+const polarProvider = Object.freeze({
+  ...polarDefinition, apiOrigins: Object.values(origins),
+  apiKey: { headers: (key) => ({ Authorization: `Bearer ${key}` }) },
+  checkOperation: "products.list",
+  operations: {
+    "products.list": jsonOperation((settings) => `${origins[settings.environment]}/v1/products/`, {
+      page: { type: "integer", min: 1, max: 2147483647, defaultTo: 1 },
+      limit: { type: "integer", min: 1, max: 100, defaultTo: 10 },
+      query: { type: "string", maxLength: 1024 },
+      is_archived: { type: "boolean" },
+      is_recurring: { type: "boolean" }
+    }, (result) => Array.isArray(result?.items) && Number.isInteger(result.pagination?.total_count) &&
+      result.pagination.total_count >= 0 && Number.isInteger(result.pagination.max_page) && result.pagination.max_page >= 0)
+  }
+});
+export { polarProvider };

package/src/server/posthog.js

@@ -0,0 +1,44 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { posthogDefinition } from "../shared/posthog.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const origin = (settings) => `https://${settings.region}.i.posthog.com`;
+const distinctId = { type: "string", required: true, minLength: 1, maxLength: 200 };
+const posthogProvider = Object.freeze({
+  ...posthogDefinition,
+  apiOrigins: (settings) => [origin(settings)],
+  apiKey: { bodyParameter: "api_key", headers: (token) => {
+    if (!/^phc_[a-zA-Z0-9_-]+$/u.test(token)) {
+      throw new ConnectorError("connector_binding_missing", "Use the public PostHog project token starting with phc_.");
+    }
+    return { "User-Agent": "jskit-connectors/0.1.0 (posthog-node/compatible)" };
+  } },
+  checkOperation: "flags.evaluate",
+  operations: {
+    "flags.evaluate": jsonOperation((settings) => `${origin(settings)}/flags?v=2`, {
+      distinct_id: distinctId,
+      groups: { type: "object", additionalProperties: true },
+      person_properties: { type: "object", additionalProperties: true }
+    }, (result) => {
+      if (!result?.flags || typeof result.flags !== "object" || Array.isArray(result.flags) ||
+        typeof result.errorsWhileComputingFlags !== "boolean" ||
+        (result.quotaLimited !== undefined && (!Array.isArray(result.quotaLimited) || !result.quotaLimited.every((item) => typeof item === "string")))) return false;
+      if (result.quotaLimited?.includes("feature_flags")) {
+        throw new ConnectorError("connector_quota_limited", "PostHog's feature flag quota has been reached.", { statusCode: 429 });
+      }
+      if (result.errorsWhileComputingFlags) {
+        throw new ConnectorError("connector_provider_failed", "PostHog could not evaluate all requested flags.", { statusCode: 502 });
+      }
+      return Object.values(result.flags).every((flag) => flag && typeof flag.enabled === "boolean" &&
+        (flag.variant === undefined || typeof flag.variant === "string"));
+    }, "POST"),
+    "events.capture": jsonOperation((settings) => `${origin(settings)}/i/v0/e/`, {
+      event: { type: "string", required: true, minLength: 1, maxLength: 200 },
+      distinct_id: distinctId,
+      properties: { type: "object", additionalProperties: true, defaultTo: {},
+        validator: (value) => !Object.hasOwn(value, "token") && !Object.hasOwn(value, "distinct_id") || "Set the event identity through distinct_id; properties cannot override its token or identity." }
+    }, (result) => result?.status === "Ok" &&
+      (result.quota_limited === undefined || Array.isArray(result.quota_limited) && result.quota_limited.every((item) => typeof item === "string")), "POST")
+  }
+});
+export { posthogProvider };

package/src/server/prestashop.js

@@ -0,0 +1,42 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { prestashopDefinition } from "../shared/prestashop.js";
+
+const pageSchema = createSchema({
+  offset: { type: "integer", min: 0, max: 1000000, defaultTo: 0 },
+  limit: { type: "integer", min: 1, max: 100, defaultTo: 20 },
+  language: { type: "integer", min: 1, max: 2147483647 }
+});
+
+function listOperation(resource) {
+  return {
+    scopes: [],
+    request(input, settings) {
+      const values = validateSchemaPayload({ schema: pageSchema, mode: "replace" }, input, { statusCode: 422 });
+      const url = new URL(`${settings.siteUrl.replace(/\/+$/u, "")}/api/${resource}`);
+      url.searchParams.set("output_format", "JSON");
+      url.searchParams.set("display", "full");
+      url.searchParams.set("sort", "[id_ASC]");
+      url.searchParams.set("limit", `${values.offset},${values.limit}`);
+      if (values.language !== undefined) url.searchParams.set("language", String(values.language));
+      return { method: "GET", url: url.href };
+    },
+    validateResult(result) {
+      // PrestaShop's JSON writer emits [] when no resource nodes were rendered.
+      if (Array.isArray(result)) return result.length === 0;
+      return Boolean(result && !result.errors && Array.isArray(result[resource]) && result[resource].every((record) =>
+        (typeof record?.id === "string" && /^[1-9]\d*$/u.test(record.id)) ||
+        (Number.isSafeInteger(record?.id) && record.id > 0)));
+    }
+  };
+}
+
+const prestashopProvider = Object.freeze({
+  ...prestashopDefinition,
+  apiOrigins: (settings) => [new URL(settings.siteUrl).origin],
+  apiKey: { headers: (key) => ({ Authorization: `Basic ${Buffer.from(`${key}:`).toString("base64")}` }) },
+  checkOperation: "products.list",
+  operations: { "products.list": listOperation("products"), "orders.list": listOperation("orders") }
+});
+
+export { prestashopProvider };

package/src/server/replicate.js

@@ -0,0 +1,42 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { replicateDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const identifier = { type: "string", required: true, minLength: 1, maxLength: 200, pattern: "^[A-Za-z0-9_-]+$" };
+const modelFields = { owner: identifier, name: identifier };
+const modelInput = { type: "object", required: true, additionalProperties: true,
+  validator: (value) => Buffer.byteLength(JSON.stringify(value)) <= 262144 || "Model input must fit within 256 KiB; use file URLs for larger inputs." };
+const predictionResult = (result) => typeof result?.id === "string" &&
+  ["starting", "processing", "succeeded", "failed", "canceled"].includes(result.status);
+function predictionOperation(fields, method, destination, validateResult = predictionResult) {
+  const schema = createSchema(fields);
+  return { scopes: [], request(input) {
+    const values = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+    const { owner, name, id, ...body } = values;
+    return { method, url: `https://api.replicate.com/v1/${destination(values)}`,
+      ...(method === "POST" ? { body } : {}) };
+  }, validateResult };
+}
+
+const replicateProvider = Object.freeze({
+  ...replicateDefinition, apiOrigins: ["https://api.replicate.com"],
+  apiKey: { headers: (key) => ({ Authorization: `Bearer ${key}` }) },
+  checkOperation: "account.read",
+  operations: {
+    "account.read": jsonOperation("https://api.replicate.com/v1/account", {},
+      (result) => ["user", "organization"].includes(result?.type) && typeof result.username === "string"),
+    "models.get": predictionOperation(modelFields, "GET", ({ owner, name }) => `models/${owner}/${name}`,
+      (result) => typeof result?.name === "string" && typeof result.owner === "string"),
+    "predictions.create": predictionOperation({ version: { type: "string", required: true,
+      pattern: "^(?:[A-Za-z0-9_-]+/[A-Za-z0-9_-]+:)?[a-f0-9]{64}$" }, input: modelInput },
+      "POST", () => "predictions"),
+    "models.predict": predictionOperation({ ...modelFields, input: modelInput }, "POST",
+      ({ owner, name }) => `models/${owner}/${name}/predictions`),
+    "predictions.get": predictionOperation({ id: identifier }, "GET", ({ id }) => `predictions/${id}`),
+    "predictions.cancel": predictionOperation({ id: identifier }, "POST", ({ id }) => `predictions/${id}/cancel`),
+    "hardware.list": jsonOperation("https://api.replicate.com/v1/hardware", {},
+      (result) => Array.isArray(result) && result.every((item) => typeof item?.name === "string" && typeof item.sku === "string"))
+  }
+});
+export { replicateProvider };

package/src/server/resend.js

@@ -0,0 +1,93 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { resendDefinition } from "../shared/definitions.js";
+
+const pagination = createSchema({
+  limit: { type: "integer", min: 1, max: 100, defaultTo: 20 },
+  after: { type: "string", minLength: 1, maxLength: 200 }
+});
+
+const email = createSchema({
+  from: { type: "string", required: true, minLength: 1, maxLength: 320, pattern: "^[^\\r\\n]+$" },
+  to: { type: "array", required: true,
+    validator: (value) => (value.length >= 1 && value.length <= 50) || "Provide between 1 and 50 recipients.",
+    items: { type: "string", minLength: 1, maxLength: 320, pattern: "^[^\\s@]+@[^\\s@]+$" } },
+  subject: { type: "string", required: true, minLength: 1, maxLength: 998, pattern: "^[^\\r\\n]+$" },
+  text: { type: "string", required: true, noTrim: true, minLength: 1, maxLength: 1000000 },
+  idempotencyKey: { type: "string", required: true, minLength: 1, maxLength: 256, pattern: "^[A-Za-z0-9_./:-]+$" }
+});
+
+const resourceId = { type: "string", required: true, minLength: 1, maxLength: 200, pattern: "^[A-Za-z0-9_-]+$" };
+const shortText = { type: "string", minLength: 1, maxLength: 1000, pattern: "^[^\\r\\n]+$" };
+const emailAddress = { type: "string", required: true, maxLength: 320, pattern: "^[^\\s@]+@[^\\s@]+$" };
+const listFields = { limit: { type: "integer", min: 1, max: 100, defaultTo: 20 },
+  after: { type: "string", minLength: 1, maxLength: 200 } };
+const broadcastFields = { segment_id: resourceId, from: { ...shortText, required: true, maxLength: 320 },
+  subject: { ...shortText, required: true, maxLength: 998 }, name: shortText,
+  html: { type: "string", required: true, noTrim: true, minLength: 1, maxLength: 1000000,
+    validator: (value) => value.includes("{{{RESEND_UNSUBSCRIBE_URL}}}") || "Include {{{RESEND_UNSUBSCRIBE_URL}}} in the broadcast HTML." },
+  text: { type: "string", noTrim: true, maxLength: 1000000 }, preview_text: shortText };
+const hasId = (result) => typeof result?.id === "string" && result.id.length > 0;
+const membershipResult = (result) => result?.object === "contact_segment" && typeof result.contact_id === "string" && typeof result.segment_id === "string";
+const listResult = (result) => result?.object === "list" && Array.isArray(result.data);
+// Fixed provider routes; the application authorizes each named operation before HTTP.
+function marketingOperation(fields, method, destination, validateResult = hasId, draft = false) {
+  const schema = createSchema(fields);
+  return { scopes: [], request(input) {
+    const values = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+    const { id, segmentId, ...body } = values;
+    const url = new URL(`https://api.resend.com/${destination(values)}`);
+    if (method === "GET") {
+      for (const [key, value] of Object.entries(body)) url.searchParams.set(key, String(value));
+      return { method, url: url.href };
+    }
+    return { method, url: url.href, ...(method === "DELETE" ? {} : { body: draft ? { ...body, send: false } : body }) };
+  }, validateResult };
+}
+
+const resendProvider = Object.freeze({
+  ...resendDefinition,
+  apiOrigins: ["https://api.resend.com"],
+  apiKey: { headers: (key) => ({ Authorization: `Bearer ${key}` }) },
+  checkOperation: "domains.list",
+  operations: {
+    "segments.list": marketingOperation(listFields, "GET", () => "segments", listResult),
+    "segments.create": marketingOperation({ name: { ...shortText, required: true } }, "POST", () => "segments"),
+    "contacts.list": marketingOperation({ ...listFields, segment_id: { ...resourceId, required: false } }, "GET", () => "contacts", listResult),
+    "contacts.get": marketingOperation({ id: resourceId }, "GET", ({ id }) => `contacts/${id}`),
+    "contacts.create": marketingOperation({ email: emailAddress, first_name: shortText, last_name: shortText,
+      unsubscribed: { type: "boolean", required: true },
+      segments: { type: "array", validator: (value) => value.length <= 100 || "Provide at most 100 segments.",
+        items: { type: "object", properties: { id: resourceId } } } }, "POST", () => "contacts"),
+    "contacts.update": marketingOperation({ id: resourceId, unsubscribed: { type: "boolean", required: true }, first_name: shortText, last_name: shortText },
+      "PATCH", ({ id }) => `contacts/${id}`),
+    "contacts.addSegment": marketingOperation({ id: resourceId, segmentId: resourceId }, "POST", ({ id, segmentId }) => `contacts/${id}/segments/${segmentId}`, membershipResult),
+    "contacts.removeSegment": marketingOperation({ id: resourceId, segmentId: resourceId }, "DELETE", ({ id, segmentId }) => `contacts/${id}/segments/${segmentId}`, (result) => membershipResult(result) && result.deleted === true),
+    "broadcasts.create": marketingOperation(broadcastFields, "POST", () => "broadcasts", hasId, true),
+    "broadcasts.get": marketingOperation({ id: resourceId }, "GET", ({ id }) => `broadcasts/${id}`),
+    "broadcasts.list": marketingOperation(listFields, "GET", () => "broadcasts", listResult),
+    "broadcasts.update": marketingOperation({ id: resourceId, ...broadcastFields }, "PATCH", ({ id }) => `broadcasts/${id}`),
+    "broadcasts.send": marketingOperation({ id: resourceId }, "POST", ({ id }) => `broadcasts/${id}/send`),
+    "domains.get": marketingOperation({ id: resourceId }, "GET", ({ id }) => `domains/${id}`),
+    "emails.send": {
+      scopes: [],
+      request(input) {
+        const { idempotencyKey, ...body } = validateSchemaPayload({ schema: email, mode: "replace" }, input, { statusCode: 422 });
+        return { method: "POST", url: "https://api.resend.com/emails",
+          headers: { "Idempotency-Key": idempotencyKey }, body };
+      },
+      validateResult: (result) => typeof result?.id === "string" && result.id.length > 0
+    },
+    "domains.list": {
+      scopes: [],
+      request(input) {
+        const query = validateSchemaPayload({ schema: pagination, mode: "replace" }, input, { statusCode: 422 });
+        const url = new URL("https://api.resend.com/domains");
+        for (const [name, value] of Object.entries(query)) url.searchParams.set(name, String(value));
+        return { method: "GET", url: url.href };
+      },
+      validateResult: (result) => result?.object === "list" && Array.isArray(result.data) && typeof result.has_more === "boolean"
+    }
+  }
+});
+export { resendProvider };