@jskit-ai/connectors-catalog 0.1.1

package/src/server/calendly.js

@@ -0,0 +1,77 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { calendlyDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const id = { type: "string", required: true, minLength: 1, maxLength: 100, pattern: "^[A-Za-z0-9_-]+$" };
+const text = { type: "string", minLength: 1, maxLength: 1000 };
+const email = { ...text, maxLength: 320, pattern: "^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$" };
+const date = { ...text, validator: value => /^\d{4}-\d{2}-\d{2}T.*Z$/.test(value) && Number.isFinite(Date.parse(value)) || "Use a UTC ISO timestamp ending in Z." };
+const page = { count: { type: "integer", min: 1, max: 100, defaultTo: 20 }, page_token: { type: "string", maxLength: 4096 } };
+const status = { type: "string", enum: ["active", "canceled"] };
+const record = result => typeof result?.resource?.uri === "string";
+const collection = result => Array.isArray(result?.collection) && Number.isInteger(result?.pagination?.count);
+function uri(kind) { return { type: "string", maxLength: 2048, pattern: `^https://api\\.calendly\\.com/${kind}/[A-Za-z0-9_-]+$` }; }
+function operation(method, endpoint, fields, scope, validateResult, prepare = value => value) {
+  const schema = createSchema(fields);
+  return { scopes: [scope], request(input) {
+    const { uuid, invitee_uuid, ...values } = prepare(validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 }));
+    const url = new URL(`https://api.calendly.com/${endpoint.replace("{uuid}", uuid || "").replace("{invitee_uuid}", invitee_uuid || "")}`);
+    if (method === "GET") { for (const [key, value] of Object.entries(values)) url.searchParams.set(key, String(value)); return { method, url: url.href }; }
+    return { method, url: url.href, ...(method === "POST" ? { body: values } : {}) };
+  }, validateResult };
+}
+const calendlyProvider = Object.freeze({
+  ...calendlyDefinition, apiOrigins: ["https://api.calendly.com"],
+  apiKey: { headers: (key) => ({ Authorization: `Bearer ${key}` }) },
+  oauth: {
+    issuer: "https://auth.calendly.com",
+    authorization_endpoint: "https://auth.calendly.com/oauth/authorize",
+    token_endpoint: "https://auth.calendly.com/oauth/token"
+  },
+  checkOperation: "profile.read",
+  operations: {
+    "eventTypes.get": operation("GET", "event_types/{uuid}", { uuid: id }, "event_types:read", record),
+    "availability.list": operation("GET", "event_type_available_times", { event_type: { ...uri("event_types"), required: true },
+      start_time: { ...date, required: true }, end_time: { ...date, required: true }
+    }, "availability:read", result => Array.isArray(result?.collection), value => {
+      const span = Date.parse(value.end_time) - Date.parse(value.start_time);
+      if (span <= 0 || span > 31 * 86400000) throw new ConnectorError("connector_input_invalid", "Choose a positive range of at most 31 days.", { statusCode: 422 }); return value;
+    }),
+    "events.list": operation("GET", "scheduled_events", { user: uri("users"), organization: uri("organizations"), group: uri("groups"),
+      invitee_email: email, status, ...page, sort: { type: "string", enum: ["start_time:asc", "start_time:desc"] }, min_start_time: date, max_start_time: date
+    }, "scheduled_events:read", collection, value => {
+      if (!(value.user || value.organization || value.group)) throw new ConnectorError("connector_input_invalid", "Choose the user, organization or group whose events to read.", { statusCode: 422 }); return value;
+    }),
+    "events.get": operation("GET", "scheduled_events/{uuid}", { uuid: id }, "scheduled_events:read", record),
+    "events.cancel": operation("POST", "scheduled_events/{uuid}/cancellation", { uuid: id, reason: { ...text, maxLength: 10000 } },
+      "scheduled_events:write", result => typeof result?.resource?.canceled_by === "string" && typeof result.resource.created_at === "string"),
+    "invitees.list": operation("GET", "scheduled_events/{uuid}/invitees", { uuid: id, ...page, status, email,
+      sort: { type: "string", enum: ["created_at:asc", "created_at:desc"] } }, "scheduled_events:read", collection),
+    "invitees.get": operation("GET", "scheduled_events/{uuid}/invitees/{invitee_uuid}", { uuid: id, invitee_uuid: id }, "scheduled_events:read", record),
+    "invitees.create": operation("POST", "invitees", { event_type: { ...uri("event_types"), required: true }, start_time: { ...date, required: true },
+      invitee: { type: "object", required: true, schema: createSchema({ email: { ...email, required: true }, name: text,
+        timezone: { ...text, required: true, validator: value => { try { new Intl.DateTimeFormat("en", { timeZone: value }); return true; } catch { return "Choose an IANA timezone."; } } } }) },
+      questions_and_answers: { type: "array", items: { type: "object", schema: createSchema({ question: { ...text, required: true }, answer: { ...text, required: true }, position: { type: "integer", required: true, min: 0 } }) },
+        validator: value => value.length <= 100 || "Use at most 100 answers." },
+      event_guests: { type: "array", items: email, validator: value => value.length <= 10 || "Use at most 10 guests." }
+    }, "scheduled_events:write", record),
+    "schedulingLinks.create": operation("POST", "scheduling_links", { owner: { ...uri("event_types"), required: true },
+      owner_type: { type: "string", enum: ["EventType"], defaultTo: "EventType" }, max_event_count: { type: "integer", enum: [1], defaultTo: 1 }
+    }, "scheduling_links:write", result => typeof result?.resource?.booking_url === "string" && typeof result.resource.owner === "string"),
+    "noShows.create": operation("POST", "invitee_no_shows", { invitee: { type: "string", required: true,
+      pattern: "^https://api\\.calendly\\.com/scheduled_events/[A-Za-z0-9_-]+/invitees/[A-Za-z0-9_-]+$" } }, "scheduled_events:write", record),
+    "noShows.get": operation("GET", "invitee_no_shows/{uuid}", { uuid: id }, "scheduled_events:read", record),
+    "noShows.delete": operation("DELETE", "invitee_no_shows/{uuid}", { uuid: id }, "scheduled_events:write", result => result === null),
+    "profile.read": { ...jsonOperation("https://api.calendly.com/users/me", {},
+      (result) => typeof result?.resource?.uri === "string" && typeof result.resource.name === "string"), scopes: ["users:read"] },
+    "eventTypes.list": { ...jsonOperation("https://api.calendly.com/event_types", {
+      user: { type: "string", required: true, minLength: 1, maxLength: 2048 },
+      count: { type: "integer", min: 1, max: 100, defaultTo: 20 },
+      page_token: { type: "string", maxLength: 4096 },
+      active: { type: "boolean" }
+    }, (result) => Array.isArray(result?.collection) && Number.isInteger(result.pagination?.count)), scopes: ["event_types:read"] }
+  }
+});
+export { calendlyProvider };

package/src/server/canva.js

@@ -0,0 +1,13 @@
+import { canvaDefinition } from "../shared/canva.js";
+import { mcpOperations, exchangeMcp } from "./mcpTransport.js";
+
+const canvaProvider = Object.freeze({
+  ...canvaDefinition,
+  oauth: { issuer: "https://mcp.canva.com", authorization_endpoint: "https://mcp.canva.com/authorize",
+    token_endpoint: "https://mcp.canva.com/token", response_types_supported: ["code"] },
+  oauthResource: "https://mcp.canva.com", apiOrigins: ["https://mcp.canva.com"],
+  requestTimeoutMs: 60_000, checkOperation: "tools.list", exchange: exchangeMcp,
+  operations: mcpOperations(() => "https://mcp.canva.com/mcp")
+});
+
+export { canvaProvider };

package/src/server/chargebee.js

@@ -0,0 +1,88 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { chargebeeDefinition } from "../shared/chargebee.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const origin = ({ siteName }) => `https://${siteName.toLowerCase()}.chargebee.com`;
+const text = { type: "string", minLength: 1, maxLength: 250 };
+const resource = { ...text, required: true, maxLength: 100, pattern: "^[A-Za-z0-9_-]+$" };
+const pagination = { limit: { type: "integer", min: 1, max: 100, defaultTo: 20 }, offset: { ...text, maxLength: 1000 } };
+const itemList = { type: "array", required: true, items: { type: "object", schema: createSchema({
+  item_price_id: { ...resource }, quantity: { type: "integer", min: 1, required: true }
+}) }, validator: values => values.length > 0 && values.length <= 100 || "Choose between 1 and 100 item prices." };
+const customerFields = { email: { ...text, pattern: "^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$" }, first_name: text, last_name: text, company: text };
+const returnUrl = { ...text, required: true, validator: value => {
+  try { const u = new URL(value); return !u.username && !u.password && (u.protocol === "https:" || u.protocol === "http:" && ["localhost", "127.0.0.1"].includes(u.hostname)) || "Use an HTTPS or localhost return URL."; }
+  catch { return "Use an absolute return URL."; }
+} };
+const record = key => result => typeof result?.[key]?.id === "string" && result[key].id.length > 0;
+const collection = key => result => Array.isArray(result?.list) && result.list.every(entry => record(key)(entry)) &&
+  (result.next_offset === undefined || typeof result.next_offset === "string");
+function operation(method, endpoint, fields, validateResult, defaults = {}) {
+  const schema = createSchema({ ...fields, ...(method === "POST" ? { idempotencyKey: { ...resource } } : {}) });
+  return { scopes: [], request(input, settings) {
+    const { resource: id, idempotencyKey, ...values } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+    const body = new URLSearchParams();
+    for (const [key, value] of Object.entries({ ...values, ...defaults })) {
+      if (Array.isArray(value)) value.forEach((entry, index) => { for (const [field, child] of Object.entries(entry)) body.set(`${key}[${field}][${index}]`, String(child)); });
+      else if (value && typeof value === "object") { for (const [field, child] of Object.entries(value)) body.set(`${key}[${field}]`, String(child)); }
+      else body.set(key, String(value));
+    }
+    const url = new URL(`${origin(settings)}/api/v2/${endpoint.replace("{resource}", id || "")}`);
+    if (method === "GET") { url.search = body.toString(); return { method, url: url.href }; }
+    return { method, url: url.href, body: body.toString(), headers: { "Content-Type": "application/x-www-form-urlencoded", "chargebee-idempotency-key": idempotencyKey } };
+  }, validateResult };
+}
+const chargebeeProvider = Object.freeze({
+  ...chargebeeDefinition,
+  apiOrigins: (settings) => [origin(settings)],
+  apiKey: { headers: (key) => {
+    if (/[:\s\p{Cc}]/u.test(key)) {
+      throw new ConnectorError("connector_binding_missing", "Use the Chargebee API key without spaces, control characters or colons.");
+    }
+    return { Authorization: `Basic ${Buffer.from(`${key}:`).toString("base64")}` };
+  } },
+  checkOperation: "customers.list",
+  operations: {
+    "customers.get": operation("GET", "customers/{resource}", { resource }, record("customer")),
+    "customers.create": operation("POST", "customers", { ...customerFields, email: { ...customerFields.email, required: true }, id: { ...resource, required: false } }, record("customer")),
+    "customers.update": operation("POST", "customers/{resource}", { resource, ...customerFields }, record("customer")),
+    "itemFamilies.list": operation("GET", "item_families", pagination, collection("item_family")),
+    "items.list": operation("GET", "items", pagination, collection("item")),
+    "items.get": operation("GET", "items/{resource}", { resource }, record("item")),
+    "itemPrices.list": operation("GET", "item_prices", pagination, collection("item_price")),
+    "itemPrices.get": operation("GET", "item_prices/{resource}", { resource }, record("item_price")),
+    "subscriptions.list": operation("GET", "subscriptions", { ...pagination, "customer_id[is]": text }, collection("subscription")),
+    "subscriptions.get": operation("GET", "subscriptions/{resource}", { resource }, record("subscription")),
+    "subscriptions.create": operation("POST", "customers/{resource}/subscription_for_items", { resource, subscription_items: itemList,
+      auto_collection: { type: "string", required: true, enum: ["on", "off"] }, invoice_immediately: { type: "boolean", required: true },
+      id: { ...resource, required: false }, trial_end: { type: "integer", min: 0 }
+    }, record("subscription")),
+    "subscriptions.updateAtTermEnd": operation("POST", "subscriptions/{resource}/update_for_items", { resource, subscription_items: itemList,
+      replace_items_list: { type: "boolean", required: true }
+    }, record("subscription"), { end_of_term: true }),
+    "subscriptions.cancelAtTermEnd": operation("POST", "subscriptions/{resource}/cancel_for_items", { resource, cancel_reason_code: text }, record("subscription"), { cancel_option: "end_of_term" }),
+    "invoices.list": operation("GET", "invoices", { ...pagination, "customer_id[is]": text, "subscription_id[is]": text }, collection("invoice")),
+    "invoices.get": operation("GET", "invoices/{resource}", { resource, line_items_limit: { type: "integer", min: 1, max: 300 }, line_items_offset: { ...text, maxLength: 1000 } }, record("invoice")),
+    "invoices.pdf": operation("POST", "invoices/{resource}/pdf", { resource, disposition_type: { type: "string", enum: ["inline", "attachment"], defaultTo: "attachment" } }, result => typeof result?.download?.download_url === "string"),
+    "hostedPages.checkoutNew": operation("POST", "hosted_pages/checkout_new_for_items", { subscription_items: itemList,
+      customer: { type: "object", required: true, schema: createSchema({ id: { ...resource } }) }, redirect_url: returnUrl, cancel_url: returnUrl
+    }, record("hosted_page")),
+    "hostedPages.checkoutExisting": operation("POST", "hosted_pages/checkout_existing_for_items", { subscription_items: itemList,
+      subscription: { type: "object", required: true, schema: createSchema({ id: { ...resource } }) }, redirect_url: returnUrl, cancel_url: returnUrl
+    }, record("hosted_page")),
+    "hostedPages.get": operation("GET", "hosted_pages/{resource}", { resource }, record("hosted_page")),
+    "portalSessions.create": operation("POST", "portal_sessions", { customer: { type: "object", required: true, schema: createSchema({ id: { ...resource } }) }, redirect_url: returnUrl }, record("portal_session")),
+    "events.list": operation("GET", "events", pagination, collection("event")),
+    "events.get": operation("GET", "events/{resource}", { resource }, record("event")),
+    "customers.list": jsonOperation((settings) => `${origin(settings)}/api/v2/customers`, {
+      limit: { type: "integer", min: 1, max: 100, defaultTo: 10 },
+      offset: { type: "string", minLength: 1, maxLength: 1000 },
+      include_deleted: { type: "boolean", defaultTo: false }
+    }, (result) => Array.isArray(result?.list) && result.list.every((entry) =>
+      entry?.customer && typeof entry.customer.id === "string" && entry.customer.id.length > 0) &&
+      (result.next_offset === undefined || typeof result.next_offset === "string" && result.next_offset.length > 0 && result.next_offset.length <= 1000))
+  }
+});
+export { chargebeeProvider };

package/src/server/clay.js

@@ -0,0 +1,78 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { clayDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const endpoint = "https://api.clay.com/public/v0";
+const pageSchema = createSchema({
+  searchId: { type: "string", required: true, minLength: 1, maxLength: 1024,
+    validator: (value) => /^[a-zA-Z0-9_-]+$/u.test(value) || "Use the search ID returned by Clay." },
+  limit: { type: "integer", min: 1, max: 500, defaultTo: 20 }
+});
+
+const routineId = { type: "string", required: true, minLength: 1, maxLength: 64,
+  validator: value => /^[a-zA-Z0-9_:-]+$/u.test(value) || "Use the routine ID from Clay, including function: for custom functions." };
+const object = { type: "object", additionalProperties: true };
+const array = (items, maximum, minimum = 0) => ({ type: "array", items,
+  validator: value => value.length >= minimum && value.length <= maximum || `Use ${minimum}–${maximum} entries.` });
+const text = { type: "string", minLength: 1 };
+
+function routineOperation(method, suffix, fields, validateResult) {
+  const schema = createSchema({ routineId, ...fields });
+  return { scopes: [], request(input) {
+    const { routineId: id, ...values } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+    const url = new URL(`${endpoint}/routines/${suffix.replace("{id}", encodeURIComponent(id))}`);
+    if (method === "POST") return { method, url: url.href, body: values };
+    for (const [key, value] of Object.entries(values)) url.searchParams.set(key, String(value));
+    return { method, url: url.href };
+  }, validateResult };
+}
+
+const clayProvider = Object.freeze({
+  ...clayDefinition,
+  apiOrigins: ["https://api.clay.com"],
+  apiKey: { headers: (key) => ({ "clay-api-key": key }) },
+  checkOperation: "identity.read",
+  operations: {
+    "identity.read": jsonOperation(`${endpoint}/me`, {}, (result) =>
+      typeof result?.user?.id === "string" && result.user.id.length > 0 &&
+      typeof result?.workspace?.id === "string" && result.workspace.id.length > 0),
+    "credits.balance": jsonOperation(`${endpoint}/credits/balance`, {}, result => typeof result?.balance === "number"),
+    "searches.reference": jsonOperation(`${endpoint}/search/query-mode/reference`, {}, result => typeof result?.reference === "string"),
+    "routines.run": routineOperation("POST", "{id}/run", {
+      items: { ...array({ type: "object", schema: createSchema({
+        id: { ...text, required: true, maxLength: 64 }, inputs: { ...object, required: true }
+      }) }, 100, 1), required: true },
+      webhook_id: { ...text, maxLength: 64 }
+    }, result => typeof result?.routine_run_id === "string" && result.routine_run_id.length > 0 && result.status === "in_progress"),
+    "routines.results": routineOperation("GET", "run/{id}/results", {
+      cursor: text, limit: { type: "integer", min: 1, max: 100, defaultTo: 20 }
+    }, result => typeof result?.routine_run_id === "string" && typeof result.total === "number" && typeof result.finished === "number" &&
+      (result.status === "in_progress" || result.status === "complete" && Array.isArray(result.data))),
+    "tables.query": jsonOperation(`${endpoint}/tables/query`, {
+      query: { type: "object", required: true, schema: createSchema({
+        tables: { ...array({ type: "object", schema: createSchema({ id: { ...text, required: true }, alias: { type: "string" } }) }, 5, 1), required: true },
+        field_mode: { type: "string", enum: ["names", "ids"] },
+        filter: object, select: array(object, 20), join: array(object, 4),
+        group_by: array(text, 5), order_by: array(object, 3)
+      }) },
+      cursor: text, limit: { type: "integer", min: 1, max: 100, defaultTo: 50 }
+    }, result => Array.isArray(result?.data), "POST"),
+    "searches.create": jsonOperation(`${endpoint}/search/query-mode`, {
+      query: { type: "string", required: true, minLength: 1, maxLength: 16000,
+        validator: (value) => value.trim().length > 0 || "Enter a Clay search query." }
+    }, (result) => typeof result?.search_id === "string" && result.search_id.length > 0 &&
+      ["people", "companies"].includes(result.source_type), "POST"),
+    "searches.next": {
+      scopes: [],
+      request(input) {
+        const { searchId, limit } = validateSchemaPayload({ schema: pageSchema, mode: "replace" }, input, { statusCode: 422 });
+        return { method: "POST", url: `${endpoint}/search/query-mode/${encodeURIComponent(searchId)}/run`, body: { limit } };
+      },
+      validateResult: (result) => Array.isArray(result?.data) && typeof result.has_more === "boolean" &&
+        ["people", "companies"].includes(result.source_type)
+    }
+  }
+});
+
+export { clayProvider };

package/src/server/clickhouse.js

@@ -0,0 +1,66 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { clickhouseDefinition } from "../shared/clickhouse.js";
+
+const name = { type: "string", required: true, minLength: 1, maxLength: 256,
+  validator: (value) => !/[\p{Cc}]/u.test(value) || "Use a name without control characters." };
+const pagination = {
+  limit: { type: "integer", min: 1, max: 100, defaultTo: 20 },
+  offset: { type: "integer", min: 0, max: 1000000, defaultTo: 0 }
+};
+
+function queryOperation(query, fields, validateData, parameters = values => values) {
+  const schema = createSchema(fields);
+  return {
+    scopes: [],
+    request(input, settings) {
+      const values = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+      const url = new URL(settings.httpUrl);
+      const sql = typeof query === "function" ? query(values) : query;
+      url.searchParams.set("query", `${sql} FORMAT JSON`);
+      url.searchParams.set("readonly", "1");
+      url.searchParams.set("wait_end_of_query", "1");
+      url.searchParams.set("max_execution_time", "10");
+      url.searchParams.set("max_result_rows", "100");
+      url.searchParams.set("max_result_bytes", "5242880");
+      url.searchParams.set("result_overflow_mode", "throw");
+      for (const [key, value] of Object.entries(parameters(values))) url.searchParams.set(`param_${key}`, String(value).replaceAll("\\", "\\\\"));
+      return { method: "GET", url: url.href };
+    },
+    validateResult(result) {
+      return Boolean(result && !result.exception && !result.error && Array.isArray(result.meta) &&
+        result.meta.every((column) => typeof column?.name === "string" && typeof column.type === "string") &&
+        Array.isArray(result.data) && result.data.length <= 100 && Number.isInteger(result.rows) && result.rows === result.data.length &&
+        result.data.every((row) => row && typeof row === "object" && !Array.isArray(row)) && (!validateData || validateData(result.data)));
+    }
+  };
+}
+
+const clickhouseProvider = Object.freeze({
+  ...clickhouseDefinition,
+  apiOrigins: (settings) => [new URL(settings.httpUrl).origin],
+  apiKey: { headers: (password, settings) => ({ Authorization: `Basic ${Buffer.from(`${settings.username || "default"}:${password}`).toString("base64")}` }) },
+  checkOperation: "connection.check",
+  operations: {
+    "connection.check": queryOperation("SELECT 1 AS ok, currentUser() AS user", {},
+      (rows) => rows.length === 1 && rows[0].ok === 1 && typeof rows[0].user === "string" && rows[0].user.length > 0),
+    "queries.read": queryOperation(values => values.sql, {
+      sql: { type: "string", required: true, minLength: 1, maxLength: 16000,
+        // eslint-disable-next-line no-control-regex -- Reject literal control characters in provider input.
+        validator: value => /^\s*(SELECT|WITH)\b/iu.test(value) && !/[;\u0000]/u.test(value) || "Use one SELECT/WITH query without a terminating semicolon; pass values as typed parameters." },
+      parameters: { type: "object", additionalProperties: true,
+        validator: value => Object.keys(value).length <= 100 && Object.entries(value).every(([key, item]) =>
+          /^[a-zA-Z_][a-zA-Z0-9_]*$/u.test(key) && typeof item === "string" && item.length <= 16000 && !/[\p{Cc}]/u.test(item)) || "Use up to 100 named string parameters without control characters." }
+    }, undefined, values => values.parameters || {}),
+    "tables.list": queryOperation((values) => `SELECT database, name, engine FROM system.tables${values.database === undefined ? "" : " WHERE database = {database:String}"} ORDER BY database, name LIMIT {limit:UInt32} OFFSET {offset:UInt64}`,
+      { ...pagination, database: { ...name, required: false } },
+      (rows) => rows.every((row) => typeof row.database === "string" && typeof row.name === "string" && typeof row.engine === "string")),
+    "columns.list": queryOperation("SELECT name, type, position, default_kind, default_expression FROM system.columns WHERE database = {database:String} AND table = {table:String} ORDER BY position LIMIT {limit:UInt32} OFFSET {offset:UInt64}",
+      { database: name, table: name, ...pagination },
+      (rows) => rows.every((row) => typeof row.name === "string" && typeof row.type === "string")),
+    "rows.list": queryOperation((values) => `SELECT * FROM {database:Identifier}.{table:Identifier}${values.orderBy === undefined ? "" : " ORDER BY {orderBy:Identifier}"} LIMIT {limit:UInt32} OFFSET {offset:UInt64}`,
+      { database: name, table: name, orderBy: { ...name, required: false }, ...pagination })
+  }
+});
+
+export { clickhouseProvider };

package/src/server/confidence.js

@@ -0,0 +1,29 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { confidenceFlagsDefinition, confidenceExpDefinition } from "../shared/confidence.js";
+import { mcpOperations, exchangeMcp } from "./mcpTransport.js";
+import { mcpRegistrationFields, registerMcpClient } from "./mcpRegistration.js";
+
+const origin = "https://mcp.confidence.dev";
+const oauth = Object.freeze({ issuer: origin, authorization_endpoint: `${origin}/authorize`, token_endpoint: `${origin}/token`,
+  registration_endpoint: `${origin}/register`, response_types_supported: ["code"], code_challenge_methods_supported: ["S256"] });
+
+function provider(definition, path) {
+  return Object.freeze({
+    ...definition, oauth, oauthResource: `${origin}/mcp`, apiOrigins: [origin], checkOperation: "tools.list", exchange: exchangeMcp,
+    operations: Object.fromEntries(Object.entries(mcpOperations(() => `${origin}/mcp/${path}`)).map(([name, operation]) => [name, { ...operation, scopes: ["openid"] }]))
+  });
+}
+const confidenceFlagsProvider = provider(confidenceFlagsDefinition, "flags");
+const confidenceExpProvider = provider(confidenceExpDefinition, "experiments");
+const registrationSchema = createSchema({ ...mcpRegistrationFields,
+  scopes: { type: "array", required: true, minLength: 1, items: { type: "string", enum: confidenceFlagsDefinition.scopes.map((scope) => scope.value) },
+    validator: (scopes) => scopes.includes("openid") && new Set(scopes).size === scopes.length || "Select account identity and include each permission once." }
+});
+
+async function registerConfidenceClient(input, options) {
+  const values = validateSchemaPayload({ schema: registrationSchema, mode: "replace" }, input, { statusCode: 422 });
+  return registerMcpClient("Confidence", oauth, values, options);
+}
+
+export { confidenceFlagsProvider, confidenceExpProvider, registerConfidenceClient };

package/src/server/contentful.js

@@ -0,0 +1,40 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { contentfulDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const text = { type: "string", minLength: 1, maxLength: 256 };
+const page = { limit: { type: "integer", min: 1, max: 1000, defaultTo: 1 }, skip: { type: "integer", min: 0, defaultTo: 0 } };
+const localized = { locale: text };
+const resource = type => result => result?.sys?.type === type && typeof result.sys.id === "string" && result.sys.id.length > 0;
+const collection = type => result => result?.sys?.type === "Array" && Array.isArray(result.items) && result.items.every(resource(type)) &&
+  Number.isInteger(result.total) && result.total >= 0 && Number.isInteger(result.skip) && result.skip >= 0 && Number.isInteger(result.limit) && result.limit >= 0;
+const endpoint = (settings, path) => `https://${settings.region === "eu" ? "cdn.eu.contentful.com" : "cdn.contentful.com"}/spaces/${encodeURIComponent(settings.spaceId)}/environments/${encodeURIComponent(settings.environmentId || "master")}/${path}`;
+function getOperation(path, type, fields = {}) {
+  const schema = createSchema({ id: { type: "string", required: true, minLength: 1, maxLength: 64,
+    validator: value => /^[a-zA-Z0-9_-]+$/u.test(value) || "Use the Contentful resource ID." }, ...fields });
+  return { scopes: [], request(input, settings) {
+    const { id, ...values } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+    const url = new URL(endpoint(settings, `${path}/${encodeURIComponent(id)}`));
+    for (const [name, value] of Object.entries(values)) url.searchParams.set(name, String(value));
+    return { method: "GET", url: url.href };
+  }, validateResult: resource(type) };
+}
+const contentfulProvider = Object.freeze({
+  ...contentfulDefinition, apiOrigins: ["https://cdn.contentful.com", "https://cdn.eu.contentful.com"],
+  apiKey: { headers: key => ({ Authorization: `Bearer ${key}` }) }, checkOperation: "entries.list",
+  operations: {
+    "entries.list": jsonOperation(settings => endpoint(settings, "entries"), {
+      ...page, ...localized, content_type: { ...text, maxLength: 64 },
+      include: { type: "integer", min: 0, max: 10 }, order: text, query: { ...text, maxLength: 1000 },
+      "sys.id": { ...text, maxLength: 64 }
+    }, collection("Entry")),
+    "entries.get": getOperation("entries", "Entry", localized),
+    "assets.list": jsonOperation(settings => endpoint(settings, "assets"), { ...page, ...localized, order: text, query: { ...text, maxLength: 1000 } }, collection("Asset")),
+    "assets.get": getOperation("assets", "Asset", localized),
+    "contentTypes.list": jsonOperation(settings => endpoint(settings, "content_types"), page, collection("ContentType")),
+    "contentTypes.get": getOperation("content_types", "ContentType"),
+    "locales.list": jsonOperation(settings => endpoint(settings, "locales"), page, collection("Locale"))
+  }
+});
+export { contentfulProvider };

package/src/server/databricks.js

@@ -0,0 +1,55 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { databricksDefinition } from "../shared/databricks.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const origin = (settings) => new URL(settings.workspaceUrl).origin;
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const identifier = (value) => Number.isSafeInteger(value) && value > 0;
+const pageToken = { type: "string", minLength: 1, maxLength: 8192 };
+const pagination = (value) => ["next_page_token", "prev_page_token"].every((key) => value[key] === undefined ||
+  typeof value[key] === "string" && value[key].length > 0 && value[key].length <= 8192);
+const job = (value) => object(value) && identifier(value.job_id) &&
+  (value.settings === undefined || object(value.settings)) && (value.has_more === undefined || typeof value.has_more === "boolean");
+const jobsList = jsonOperation((settings) => `${origin(settings)}/api/2.2/jobs/list`, {
+  limit: { type: "integer", min: 1, max: 100, defaultTo: 20 },
+  expand_tasks: { type: "boolean", defaultTo: false }, name: { type: "string", minLength: 1, maxLength: 4096 }, page_token: pageToken
+}, (value) => object(value) && pagination(value) && (value.jobs === undefined || Array.isArray(value.jobs) && value.jobs.every(job)));
+const jobsGet = jsonOperation((settings) => `${origin(settings)}/api/2.2/jobs/get`, {
+  job_id: { type: "integer", required: true, min: 1, max: Number.MAX_SAFE_INTEGER },
+  include_trigger_state: { type: "boolean", defaultTo: false }, page_token: pageToken
+}, (value) => job(value) && pagination(value));
+
+const databricksProvider = Object.freeze({
+  ...databricksDefinition,
+  oauth: (settings) => ({ issuer: `${origin(settings)}/oidc`, authorization_endpoint: `${origin(settings)}/oidc/v1/authorize`,
+    token_endpoint: `${origin(settings)}/oidc/v1/token` }),
+  apiOrigins: (settings) => [origin(settings)], checkOperation: "jobs.list", tokenRefreshLeewayMs: 40_000,
+  async normalizeTokenResponse(response) {
+    if (response.ok) {
+      let value;
+      try { value = await response.clone().json(); } catch { /* reported below */ }
+      if (!Number.isSafeInteger(value?.expires_in) || value.expires_in <= 40 ||
+        (value.scope !== undefined && (typeof value.scope !== "string" || !/^[^\s]+(?: [^\s]+)*$/u.test(value.scope))) ||
+        (value.refresh_token !== undefined && (typeof value.refresh_token !== "string" || !value.refresh_token.trim()))) {
+        throw new ConnectorError("connector_response_invalid", "Databricks returned an invalid token grant.", { statusCode: 502 });
+      }
+    }
+    return response;
+  },
+  operations: { "jobs.list": { ...jobsList, scopes: ["all-apis", "jobs"] }, "jobs.get": { ...jobsGet, scopes: ["all-apis", "jobs"] } },
+  async exchange(address, options, { fetchImpl }) {
+    const url = new URL(address);
+    // An empty jobs list is {}, but JSON null or an unparseable body is not a verified list.
+    const response = await fetchImpl(address, { ...options, credentials: "omit" });
+    if (!response.ok) throw Object.assign(new Error("Databricks request failed."), { status: response.status });
+    let result;
+    try { result = await response.json(); } catch { /* checked below */ }
+    if (response.status !== 200 || !object(result) || result.error_code || result.error ||
+      (url.pathname.endsWith("/list") && result?.jobs?.length > Number(url.searchParams.get("limit"))) ||
+      (url.pathname.endsWith("/get") && result?.job_id !== Number(url.searchParams.get("job_id")))) {
+      throw new ConnectorError("connector_response_invalid", "Databricks returned an unexpected job response.", { statusCode: 502 });
+    }
+    return result;
+  }
+});
+export { databricksProvider };

package/src/server/dbt-semantic-layer.js

@@ -0,0 +1,95 @@
+import { createSchema } from "json-rest-schema";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { dbtSemanticLayerDefinition } from "../shared/dbt-semantic-layer.js";
+import { graphqlOperation } from "./graphqlOperation.js";
+
+const origin = (settings) => `https://${settings.host}`;
+const endpoint = (settings) => `${origin(settings)}/api/graphql`;
+const text = (value) => typeof value === "string" && value.length > 0;
+const description = (value) => value === null || typeof value === "string";
+const paging = {
+  pageNum: { type: "integer", min: 1, max: 2_147_483_647, defaultTo: 1 },
+  pageSize: { type: "integer", min: 1, max: 100, defaultTo: 20 },
+  search: { type: "string", maxLength: 512 }
+};
+const pageFields = "pageNum pageSize totalItems totalPages items { name description type }";
+const validPage = (page, typed = true) => Array.isArray(page?.items) && page.items.length <= 100 &&
+  page.items.every((item) => text(item?.name) && description(item.description) && (!typed || text(item.type))) &&
+  Number.isSafeInteger(page.pageNum) && page.pageNum >= 1 && Number.isSafeInteger(page.pageSize) && page.pageSize >= 1 && page.pageSize <= 100 &&
+  Number.isSafeInteger(page.totalItems) && page.totalItems >= page.items.length && Number.isSafeInteger(page.totalPages) && page.totalPages >= 0;
+
+function environmentOperation(query, fields, validateData) {
+  const operation = graphqlOperation(endpoint, query, fields, validateData);
+  return { ...operation, request(input, settings) {
+    const request = operation.request(input, settings);
+    request.body.variables.environmentId = settings.environmentId;
+    return request;
+  } };
+}
+const dbtSemanticLayerProvider = Object.freeze({
+  ...dbtSemanticLayerDefinition,
+  apiOrigins: (settings) => [origin(settings)],
+  apiKey: { headers: (key) => {
+    if (/[\s\p{Cc}]/u.test(key)) throw new ConnectorError("connector_binding_missing", "Use a dbt service token without spaces or control characters.");
+    return { Authorization: `Bearer ${key}` };
+  } },
+  checkOperation: "environment.read",
+  operations: {
+    "queries.create": environmentOperation("mutation ConnectorDbtQuery($environmentId: BigInt!, $metrics: [MetricInput!]!, $groupBy: [GroupByInput!], $where: [WhereInput!], $limit: Int!) { createQuery(environmentId: $environmentId, metrics: $metrics, groupBy: $groupBy, where: $where, limit: $limit) { queryId } }", {
+      metrics: { type: "array", required: true, validator: (value) => (value.length >= 1 && value.length <= 100) || "Choose between 1 and 100 metrics.",
+        items: { type: "object", schema: createSchema({ name: { type: "string", required: true, minLength: 1, maxLength: 512 }, alias: { type: "string", minLength: 1, maxLength: 512 } }) } },
+      groupBy: { type: "array", validator: (value) => value.length <= 100 || "Choose at most 100 dimensions.",
+        items: { type: "object", schema: createSchema({ name: { type: "string", required: true, minLength: 1, maxLength: 512 }, grain: { type: "string", enum: ["DAY", "WEEK", "MONTH", "QUARTER", "YEAR"] } }) } },
+      where: { type: "array", validator: (value) => value.length <= 20 || "Use at most 20 filters.",
+        items: { type: "object", schema: createSchema({ sql: { type: "string", required: true, minLength: 1, maxLength: 4000 } }) } },
+      limit: { type: "integer", min: 1, max: 10000, defaultTo: 100 }
+    }, (data) => text(data?.createQuery?.queryId)),
+    "queries.get": environmentOperation("query ConnectorDbtQueryResult($environmentId: BigInt!, $queryId: String!, $pageNum: Int!) { query(environmentId: $environmentId, queryId: $queryId, pageNum: $pageNum) { status error totalPages jsonResult(orient: TABLE, encoded: false) } }", {
+      queryId: { type: "string", required: true, minLength: 1, maxLength: 512 },
+      pageNum: { type: "integer", min: 1, max: 2_147_483_647, defaultTo: 1 }
+    }, (data) => text(data?.query?.status) && description(data.query.error) &&
+      (data.query.totalPages === null || (Number.isSafeInteger(data.query.totalPages) && data.query.totalPages >= 0)) &&
+      (data.query.jsonResult === null || (typeof data.query.jsonResult === "object" && Array.isArray(data.query.jsonResult?.data) && Array.isArray(data.query.jsonResult?.schema?.fields)))),
+    "environment.read": environmentOperation("query ConnectorDbtEnvironment($environmentId: BigInt!) { environmentInfo(environmentId: $environmentId) { dialect } }", {},
+      (data) => text(data?.environmentInfo?.dialect)),
+    "metrics.list": environmentOperation(`query ConnectorDbtMetrics($environmentId: BigInt!, $pageNum: Int!, $pageSize: Int!, $search: String) { metricsPaginated(environmentId: $environmentId, pageNum: $pageNum, pageSize: $pageSize, search: $search) { ${pageFields} } }`, paging,
+      (data) => validPage(data?.metricsPaginated)),
+    "dimensions.list": environmentOperation(`query ConnectorDbtDimensions($environmentId: BigInt!, $metrics: [MetricInput!]!, $pageNum: Int!, $pageSize: Int!, $search: String) { dimensionsPaginated(environmentId: $environmentId, metrics: $metrics, pageNum: $pageNum, pageSize: $pageSize, search: $search) { ${pageFields} } }`, {
+      ...paging, metrics: { type: "array", required: true, validator: (value) => (value.length >= 1 && value.length <= 100) || "Choose between 1 and 100 metrics.",
+        items: { type: "object", schema: createSchema({ name: { type: "string", required: true, minLength: 1, maxLength: 512 } }) } }
+    }, (data) => validPage(data?.dimensionsPaginated)),
+    "savedQueries.list": environmentOperation(`query ConnectorDbtSavedQueries($environmentId: BigInt!, $pageNum: Int!, $pageSize: Int!, $search: String) { savedQueriesPaginated(environmentId: $environmentId, pageNum: $pageNum, pageSize: $pageSize, search: $search) { pageNum pageSize totalItems totalPages items { name description } } }`, paging,
+      (data) => validPage(data?.savedQueriesPaginated, false))
+  },
+  async exchange(address, options, { request }) {
+    const result = await request(address, options);
+    if (Array.isArray(result?.errors) && result.errors.length > 0) {
+      throw new ConnectorError("connector_provider_failed", "dbt could not complete the requested operation. Check the environment and service token permissions.", { statusCode: 502 });
+    }
+    const queryResult = result?.data?.query;
+    if (queryResult) {
+      if (queryResult.status === "FAILED") {
+        throw new ConnectorError("connector_provider_failed", "dbt query failed. Inspect its status in dbt; do not automatically submit it again.", { statusCode: 502 });
+      }
+      if (queryResult.jsonResult !== null && queryResult.jsonResult !== undefined) {
+        if (typeof queryResult.jsonResult !== "string" || Buffer.byteLength(queryResult.jsonResult) > 5 * 1024 * 1024) {
+          throw new ConnectorError("connector_response_invalid", "dbt returned an invalid or oversized JSON result page.", { statusCode: 502 });
+        }
+        try { queryResult.jsonResult = JSON.parse(queryResult.jsonResult); }
+        catch { throw new ConnectorError("connector_response_invalid", "dbt returned an invalid JSON result page.", { statusCode: 502 }); }
+        if (!Array.isArray(queryResult.jsonResult?.data) || queryResult.jsonResult.data.length > 1024 || !Array.isArray(queryResult.jsonResult?.schema?.fields)) {
+          throw new ConnectorError("connector_response_invalid", "dbt returned an invalid JSON table.", { statusCode: 502 });
+        }
+      } else if (queryResult.status === "SUCCESSFUL") {
+        throw new ConnectorError("connector_response_invalid", "dbt completed without a JSON result table.", { statusCode: 502 });
+      }
+    }
+    const page = result?.data?.metricsPaginated || result?.data?.dimensionsPaginated || result?.data?.savedQueriesPaginated;
+    if (page && (page.pageNum !== options.body.variables.pageNum || page.pageSize !== options.body.variables.pageSize || page.items?.length > options.body.variables.pageSize)) {
+      throw new ConnectorError("connector_response_invalid", "dbt returned an unexpected metadata page.", { statusCode: 502 });
+    }
+    return result;
+  }
+});
+
+export { dbtSemanticLayerProvider };