@jskit-ai/connectors-catalog 0.1.1

package/src/server/jsonOperation.js

@@ -0,0 +1,34 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+
+// Providers with custom paths or bodies share input validation, while retaining
+// ownership of their request construction and response checks.
+function validatedOperation(fields, build, validateResult) {
+  const schema = createSchema(fields);
+  return {
+    scopes: [],
+    request(input) {
+      return build(validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 }));
+    },
+    validateResult
+  };
+}
+
+// Provider endpoints with either query parameters or a JSON request body.
+function jsonOperation(url, fields, validateResult, method = "GET") {
+  const schema = createSchema(fields);
+  return {
+    scopes: [],
+    request(input, settings = {}) {
+      const values = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+      const endpoint = typeof url === "function" ? url(settings) : url;
+      if (method === "POST") return { method, url: endpoint, body: values };
+      const destination = new URL(endpoint);
+      for (const [name, value] of Object.entries(values)) destination.searchParams.set(name, String(value));
+      return { method, url: destination.href };
+    },
+    validateResult
+  };
+}
+
+export { jsonOperation, validatedOperation };

package/src/server/klipy.js

@@ -0,0 +1,34 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { klipyDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const mediaFields = {
+  page: { type: "integer", min: 1, max: 100000, defaultTo: 1 },
+  per_page: { type: "integer", min: 1, max: 50, defaultTo: 24 },
+  customer_id: { type: "string", minLength: 1, maxLength: 256 },
+  locale: { type: "string", validator: (value) => /^[A-Za-z]{2}$/.test(value) || "Use a two-letter locale such as us." },
+  content_filter: { type: "string", enum: ["off", "low", "medium", "high"], defaultTo: "high" }
+};
+
+function mediaResult(response) {
+  if (response?.result === false) {
+    throw new ConnectorError("connector_provider_failed", "KLIPY rejected the operation.", { statusCode: 502 });
+  }
+  return response?.result === true && Array.isArray(response.data?.data);
+}
+
+const klipyProvider = Object.freeze({
+  ...klipyDefinition,
+  apiOrigins: ["https://api.klipy.com"],
+  apiKey: { pathPrefix: (key) => `/api/v1/${encodeURIComponent(key)}` },
+  checkOperation: "clips.trending",
+  operations: Object.fromEntries(["clips", "gifs", "stickers", "emojis"].flatMap((family) => [
+    [`${family}.trending`, jsonOperation(`https://api.klipy.com/${family}/trending`, mediaFields, mediaResult)],
+    [`${family}.search`, jsonOperation(`https://api.klipy.com/${family}/search`, {
+      ...mediaFields,
+      per_page: { type: "integer", min: 8, max: 50, defaultTo: 24 },
+      q: { type: "string", required: true, minLength: 1, maxLength: 500 }
+    }, mediaResult)]
+  ]))
+});
+export { klipyProvider };

package/src/server/lexware.js

@@ -0,0 +1,59 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { lexwareDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const id = { type: "string", required: true, validator: value => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(value) || "Use a Lexware resource UUID." };
+const text = { type: "string", minLength: 1, maxLength: 1000 };
+const date = { type: "string", required: true, validator: value => /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/u.test(value) && Number.isFinite(Date.parse(value)) && new Date(`${value.slice(0, 10)}T00:00:00Z`).toISOString().startsWith(value.slice(0, 10)) || "Use an ISO timestamp with timezone." };
+const paging = { page: { type: "integer", min: 0, max: 100000, defaultTo: 0 }, size: { type: "integer", min: 1, max: 250, defaultTo: 25 } };
+const pageResult = result => Array.isArray(result?.content) && typeof result.first === "boolean" && typeof result.last === "boolean" &&
+  ["totalPages", "totalElements", "numberOfElements", "number"].every(field => Number.isInteger(result[field]) && result[field] >= 0) && Number.isInteger(result.size) && result.size > 0;
+const resourceResult = result => typeof result?.id === "string";
+function operation(fields, build, validateResult = resourceResult) {
+  const schema = createSchema(fields);
+  return { scopes: [], request(input) { return build(validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 })); }, validateResult };
+}
+const line = createSchema({
+  name: { ...text, required: true }, description: { ...text, maxLength: 5000 },
+  quantity: { type: "number", required: true, min: 0.000001, max: 1000000 },
+  unitName: { ...text, required: true, maxLength: 100 },
+  netAmount: { type: "number", required: true, min: 0, max: 1000000000 },
+  taxRatePercentage: { type: "number", required: true, min: 0, max: 100 }
+});
+const lexwareProvider = Object.freeze({
+  ...lexwareDefinition,
+  apiOrigins: ["https://api.lexware.io"],
+  apiKey: { headers: key => ({ Authorization: `Bearer ${key}` }) },
+  checkOperation: "contacts.list",
+  operations: {
+    "contacts.list": jsonOperation("https://api.lexware.io/v1/contacts", {
+      ...paging, customer: { type: "boolean" }, vendor: { type: "boolean" }
+    }, pageResult),
+    ...Object.fromEntries(["contacts", "articles", "invoices", "vouchers"].map(resource => [
+      `${resource}.get`, operation({ id }, ({ id }) => ({ method: "GET", url: `https://api.lexware.io/v1/${resource}/${id}` }))
+    ])),
+    "articles.list": jsonOperation("https://api.lexware.io/v1/articles", {
+      ...paging, articleNumber: text, gtin: text, type: { type: "string", enum: ["PRODUCT", "SERVICE"] }
+    }, pageResult),
+    "vouchers.list": jsonOperation("https://api.lexware.io/v1/voucherlist", {
+      ...paging,
+      voucherType: { type: "string", required: true, enum: ["any", "invoice", "salesinvoice", "salescreditnote", "purchaseinvoice", "purchasecreditnote"] },
+      voucherStatus: { type: "string", required: true, enum: ["any", "draft", "open", "overdue", "paid", "paidoff", "voided", "transferred", "sepadebit", "unchecked"] },
+      contactId: { ...id, required: false }, archived: { type: "boolean" }
+    }, pageResult),
+    "invoices.createDraft": operation({
+      contactId: id, voucherDate: date, shippingDate: date,
+      shippingType: { type: "string", required: true, enum: ["service", "delivery"] },
+      lineItems: { type: "array", required: true, validator: value => value.length > 0 && value.length <= 100 || "Use 1–100 invoice lines.",
+        items: { type: "object", schema: line } },
+      title: text, introduction: { ...text, maxLength: 5000 }, remark: { ...text, maxLength: 5000 }
+    }, ({ contactId, voucherDate, shippingDate, shippingType, lineItems, ...other }) => ({
+      method: "POST", url: "https://api.lexware.io/v1/invoices?finalize=false",
+      body: { ...other, voucherDate, address: { contactId },
+        lineItems: lineItems.map(({ netAmount, taxRatePercentage, ...item }) => ({ ...item, type: "custom", unitPrice: { currency: "EUR", netAmount, taxRatePercentage } })),
+        totalPrice: { currency: "EUR" }, taxConditions: { taxType: "net" }, shippingConditions: { shippingDate, shippingType } }
+    }))
+  }
+});
+export { lexwareProvider };

package/src/server/lightspeed.js

@@ -0,0 +1,82 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { lightspeedDefinition } from "../shared/lightspeed.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const apiOrigin = (settings) => `https://${settings.domainPrefix}.retail.lightspeed.app`;
+const versionNumber = (value) => Number.isSafeInteger(value) && value >= 0;
+const identifier = (value) => typeof value === "string" && /^[a-zA-Z0-9_-]{1,128}$/u.test(value);
+
+function collection(resource) {
+  const operation = jsonOperation((settings) => `${apiOrigin(settings)}/api/2026-07/${resource}`, {
+    after: { type: "integer", min: 0, max: Number.MAX_SAFE_INTEGER },
+    before: { type: "integer", min: 0, max: Number.MAX_SAFE_INTEGER },
+    page_size: { type: "integer", min: 1, max: 100, defaultTo: 20 },
+    ...(resource === "sales" ? {} : { deleted: { type: "boolean", defaultTo: false } })
+  }, (result) => {
+    if (!Array.isArray(result?.data) || !result.data.every((row) => identifier(row?.id) && versionNumber(row.version))) return false;
+    // The customer reference includes a response without the optional envelope version.
+    if (resource === "customers" && result.version === undefined) return true;
+    const { min, max } = result.version || {};
+    return result.data.length === 0 ? min === null && max === null :
+      versionNumber(min) && versionNumber(max) && min <= max && result.data.every((row) => row.version >= min && row.version <= max);
+  });
+  return {
+    ...operation, scopes: [`${resource}:read`],
+    request(input, settings) {
+      const request = operation.request(input, settings);
+      const query = new URL(request.url).searchParams;
+      if (query.has("after") && query.has("before") && Number(query.get("after")) >= Number(query.get("before"))) {
+        throw new ConnectorError("connector_input_invalid", "The lower version must be below the upper version.", { statusCode: 422 });
+      }
+      return request;
+    }
+  };
+}
+
+const inventoryRead = jsonOperation(settings => `${apiOrigin(settings)}/api/2026-07/inventory`, {
+  after: { type: "integer", min: 0, max: Number.MAX_SAFE_INTEGER },
+  before: { type: "integer", min: 0, max: Number.MAX_SAFE_INTEGER },
+  size: { type: "integer", min: 1, max: 1000, defaultTo: 100 },
+  include_deleted: { type: "boolean", defaultTo: false },
+  sort_direction: { type: "string", enum: ["asc", "desc"], defaultTo: "asc" },
+  product_id: { type: "string", validator: value => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(value) || "Use a product UUID." },
+  variants: { type: "boolean", defaultTo: false }
+}, result => Array.isArray(result) && result.every(row => row && typeof row === "object" && !Array.isArray(row) && versionNumber(row.version)), "POST");
+
+const lightspeedProvider = Object.freeze({
+  ...lightspeedDefinition,
+  oauth: (settings) => ({ issuer: "https://secure.retail.lightspeed.app", authorization_endpoint: "https://secure.retail.lightspeed.app/connect",
+    token_endpoint: `${apiOrigin(settings)}/api/1.0/token` }),
+  apiOrigins: (settings) => [apiOrigin(settings)], checkOperation: "products.list",
+  async normalizeTokenResponse(response, { settings }) {
+    if (response.ok) {
+      let value;
+      try { value = await response.clone().json(); } catch { /* reported below */ }
+      if (value?.domain_prefix !== settings.domainPrefix || typeof value.refresh_token !== "string" || !value.refresh_token.trim() ||
+        !Number.isSafeInteger(value.expires_in) || value.expires_in <= 0 ||
+        typeof value.scope !== "string" || !/^[^\s]+(?: [^\s]+)*$/u.test(value.scope)) {
+        throw new ConnectorError("connector_response_invalid", "Lightspeed returned an invalid token grant or a different store.", { statusCode: 502 });
+      }
+    }
+    return response;
+  },
+  operations: { "products.list": collection("products"), "customers.list": collection("customers"), "outlets.list": collection("outlets"), "sales.list": collection("sales"),
+    "inventory.list": { ...inventoryRead, scopes: ["inventory:read"], request(input, settings) {
+      const request = inventoryRead.request(input, settings);
+      const { after, before, variants, product_id } = request.body;
+      if (after !== undefined && before !== undefined && after >= before || variants && !product_id)
+        throw new ConnectorError("connector_input_invalid", "Use ordered inventory version bounds and a product ID when requesting variants.", { statusCode: 422 });
+      return request;
+    } }
+  },
+  async exchange(address, options, { request }) {
+    const result = await request(address, options);
+    const inventory = new URL(address).pathname.endsWith("/inventory");
+    const limit = inventory ? options.body.size : Number(new URL(address).searchParams.get("page_size"));
+    if ((inventory ? result?.length : result?.data?.length) > limit) {
+      throw new ConnectorError("connector_response_invalid", "Lightspeed returned more records than requested.", { statusCode: 502 });
+    }
+    return result;
+  }
+});
+export { lightspeedProvider };

package/src/server/linear.js

@@ -0,0 +1,52 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { mcpOperations, exchangeMcp } from "./mcpTransport.js";
+import { linearDefinition } from "../shared/tokens.js";
+import { graphqlOperation } from "./graphqlOperation.js";
+
+function queryOperation(query, fields, validateData) {
+  return { ...graphqlOperation("https://api.linear.app/graphql", query, fields, validateData), scopes: ["read"] };
+}
+
+const linearProvider = Object.freeze({
+  ...linearDefinition, apiOrigins: ["https://api.linear.app", "https://mcp.linear.app"],
+  oauth: {
+    issuer: "https://linear.app",
+    authorization_endpoint: "https://linear.app/oauth/authorize",
+    token_endpoint: "https://api.linear.app/oauth/token"
+  },
+  scopeSeparator: ",",
+  authorizationParameters: { actor: "user", prompt: "consent" },
+  async normalizeTokenResponse(response) {
+    if (!response.ok) return response;
+    let value;
+    try { value = await response.clone().json(); } catch {
+      throw new ConnectorError("connector_response_invalid", "Linear returned an invalid token response.", { statusCode: 502 });
+    }
+    // Linear accepts commas at authorization but returns space-separated grants.
+    const scopes = typeof value?.scope === "string" ? value.scope.split(" ").filter(Boolean) : value?.scope;
+    if (!Array.isArray(scopes) || !scopes.every(scope => typeof scope === "string" && /^[^\s,]+$/u.test(scope))) {
+      throw new ConnectorError("connector_response_invalid", "Linear returned an invalid permission grant.", { statusCode: 502 });
+    }
+    return Response.json({ ...value, scope: scopes.join(",") }, { status: response.status });
+  },
+  apiKey: { headers: (key) => ({ Authorization: key }) },
+  checkOperation: "profile.read",
+  exchange(address, options, context) {
+    if (address === "https://mcp.linear.app/mcp") {
+      const headers = context.apiKey === undefined ? options.headers : { ...options.headers, Authorization: `Bearer ${context.apiKey}` };
+      return exchangeMcp(address, { ...options, headers }, context);
+    }
+    return context.request(address, options);
+  },
+  operations: {
+    ...Object.fromEntries(Object.entries(mcpOperations(() => "https://mcp.linear.app/mcp")).map(([name, operation]) =>
+      [name, { ...operation, scopes: ["read"] }])),
+    "profile.read": queryOperation("query ConnectorViewer { viewer { id name email } }", {},
+      (data) => typeof data?.viewer?.id === "string" && typeof data.viewer.name === "string"),
+    "issues.list": queryOperation("query ConnectorIssues($first: Int!, $after: String) { issues(first: $first, after: $after) { nodes { id identifier title } pageInfo { hasNextPage endCursor } } }", {
+      first: { type: "integer", min: 1, max: 100, defaultTo: 50 },
+      after: { type: "string", maxLength: 4096 }
+    }, (data) => Array.isArray(data?.issues?.nodes) && typeof data.issues.pageInfo?.hasNextPage === "boolean")
+  }
+});
+export { linearProvider };

package/src/server/linkedin.js

@@ -0,0 +1,74 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { linkedinDefinition } from "../shared/linkedin.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+async function normalizeTokenResponse(response, { grantType }) {
+  let value;
+  try { value = await response.clone().json(); } catch {
+    if (!response.ok) return response;
+    throw new ConnectorError("connector_response_invalid", "LinkedIn returned an invalid token response.", { statusCode: 502 });
+  }
+  if (!response.ok) {
+    if (grantType === "refresh_token" && response.status === 400 && value?.error === "invalid_request") {
+      throw new ConnectorError("connector_reconnect_required", "Connect this LinkedIn account again.", { statusCode: 401 });
+    }
+    return response;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value) ||
+    !Number.isSafeInteger(value.expires_in) || value.expires_in <= 0 ||
+    (value.scope !== undefined && (typeof value.scope !== "string" || !/^[^\s]+(?: [^\s]+)*$/u.test(value.scope)))) {
+    throw new ConnectorError("connector_response_invalid", "LinkedIn returned an invalid permission grant.", { statusCode: 502 });
+  }
+  if (value.scope !== undefined && !["openid", "profile"].every((scope) => value.scope.split(" ").includes(scope))) {
+    throw new ConnectorError("connector_reconnect_required", "Connect LinkedIn with OpenID and profile permissions.", { statusCode: 401 });
+  }
+  // LinkedIn documents bearer responses without token_type. Identity tokens are
+  // unused: this adapter reads userinfo with the access token, never logs users in.
+  delete value.id_token;
+  return Response.json({ ...value, token_type: value.token_type === undefined ? "Bearer" : value.token_type }, { status: response.status });
+}
+
+const publish = jsonOperation("https://api.linkedin.com/v2/ugcPosts", {
+  text: { type: "string", required: true, minLength: 1, maxLength: 3000,
+    validator: value => value.trim().length > 0 || "Enter the post text." },
+  visibility: { type: "string", required: true, enum: ["PUBLIC", "CONNECTIONS"] }
+}, value => /^urn:li:(?:share|ugcPost):[0-9]+$/u.test(value?.id), "POST");
+
+const linkedinProvider = Object.freeze({
+  ...linkedinDefinition,
+  oauth: {
+    issuer: "https://www.linkedin.com",
+    authorization_endpoint: "https://www.linkedin.com/oauth/v2/authorization",
+    token_endpoint: "https://www.linkedin.com/oauth/v2/accessToken"
+  },
+  normalizeTokenResponse,
+  apiOrigins: ["https://api.linkedin.com"], checkOperation: "profile.read",
+  async exchange(address, options, { request, fetchImpl }) {
+    if (address !== "https://api.linkedin.com/v2/ugcPosts") return request(address, options);
+    const member = await request("https://api.linkedin.com/v2/userinfo", { ...options, method: "GET", body: undefined });
+    if (typeof member?.sub !== "string" || !/^[a-zA-Z0-9_-]{1,1024}$/u.test(member.sub))
+      throw new ConnectorError("connector_response_invalid", "LinkedIn returned an invalid member identity.", { statusCode: 502 });
+    const response = await fetchImpl(address, { ...options, credentials: "omit", redirect: "error",
+      headers: { ...options.headers, "Content-Type": "application/json", "X-Restli-Protocol-Version": "2.0.0" },
+      body: JSON.stringify({ author: `urn:li:person:${member.sub}`, lifecycleState: "PUBLISHED",
+        specificContent: { "com.linkedin.ugc.ShareContent": { shareCommentary: { text: options.body.text }, shareMediaCategory: "NONE" } },
+        visibility: { "com.linkedin.ugc.MemberNetworkVisibility": options.body.visibility } }) });
+    await response.body?.cancel();
+    if (!response.ok) throw Object.assign(new Error("LinkedIn publishing failed."), { status: response.status });
+    if (response.status !== 201) throw new ConnectorError("connector_response_invalid", "LinkedIn did not confirm post creation.", { statusCode: 502 });
+    return { id: response.headers.get("x-restli-id") };
+  },
+  operations: {
+    "posts.create": { ...publish, scopes: ["w_member_social"] },
+    "profile.read": {
+      ...jsonOperation("https://api.linkedin.com/v2/userinfo", {}, (value) =>
+        typeof value?.sub === "string" && value.sub.length > 0 && value.sub.length <= 1024 &&
+        ["name", "given_name", "family_name", "picture", "locale", "email"].every((field) =>
+          value[field] === undefined || typeof value[field] === "string") &&
+        (value.email_verified === undefined || typeof value.email_verified === "boolean")),
+      scopes: ["profile"]
+    }
+  }
+});
+
+export { linkedinProvider };

package/src/server/mailgun.js

@@ -0,0 +1,76 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { mailgunDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const origins = { us: "https://api.mailgun.net", eu: "https://api.eu.mailgun.net" };
+const domainField = { type: "string", required: true, minLength: 3, maxLength: 253,
+  pattern: "^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)+$" };
+const domainSchema = createSchema({ domain: domainField });
+const sendSchema = createSchema({
+  domain: domainField,
+  from: { type: "string", required: true, minLength: 3, maxLength: 320, pattern: "^[^\\r\\n]+$" },
+  to: { type: "array", required: true,
+    validator: value => (value.length > 0 && value.length <= 1000) || "Provide 1–1000 recipients.",
+    items: { type: "string", minLength: 3, 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 },
+  html: { type: "string", noTrim: true, minLength: 1, maxLength: 1000000 }
+});
+const logsSchema = createSchema({
+  domain: domainField,
+  duration: { type: "string", defaultTo: "1d", pattern: "^[1-9][0-9]*[dh]$", maxLength: 12 },
+  limit: { type: "integer", min: 1, max: 100, defaultTo: 50 },
+  token: { type: "string", minLength: 1, maxLength: 8192 },
+  end: { type: "string", minLength: 1, maxLength: 100 }
+});
+const validDomain = result => typeof result?.domain?.name === "string" &&
+  Array.isArray(result.sending_dns_records) && Array.isArray(result.receiving_dns_records);
+
+// Domain access and sending remain separate authorized application operations.
+function domainOperation(method, suffix = "") {
+  return { scopes: [], request(input, settings) {
+    const { domain } = validateSchemaPayload({ schema: domainSchema, mode: "replace" }, input, { statusCode: 422 });
+    return { method, url: `${origins[settings.region]}/v4/domains/${encodeURIComponent(domain)}${suffix}` };
+  }, validateResult: validDomain };
+}
+
+const mailgunProvider = Object.freeze({
+  ...mailgunDefinition, apiOrigins: Object.values(origins),
+  apiKey: { headers: (key) => ({ Authorization: `Basic ${Buffer.from(`api:${key}`).toString("base64")}` }) },
+  checkOperation: "domains.list",
+  operations: {
+    "messages.send": { scopes: [], request(input, settings) {
+      const { domain, to, ...fields } = validateSchemaPayload({ schema: sendSchema, mode: "replace" }, input, { statusCode: 422 });
+      const body = new FormData();
+      for (const [name, value] of Object.entries(fields)) body.append(name, value);
+      for (const recipient of to) body.append("to", recipient);
+      return { method: "POST", url: `${origins[settings.region]}/v3/${encodeURIComponent(domain)}/messages`, body };
+    }, validateResult: result => typeof result?.id === "string" && result.id.length > 0 && typeof result.message === "string" },
+    "domains.get": domainOperation("GET"),
+    "domains.verify": domainOperation("PUT", "/verify"),
+    "domains.create": { scopes: [], request(input, settings) {
+      const { domain } = validateSchemaPayload({ schema: domainSchema, mode: "replace" }, input, { statusCode: 422 });
+      const body = new FormData();
+      body.append("name", domain);
+      return { method: "POST", url: `${origins[settings.region]}/v4/domains`, body };
+    }, validateResult: validDomain },
+    "logs.list": { scopes: [], request(input, settings) {
+      const { domain, limit, token, ...range } = validateSchemaPayload({ schema: logsSchema, mode: "replace" }, input, { statusCode: 422 });
+      return { method: "POST", url: `${origins[settings.region]}/v1/analytics/logs`, body: {
+        ...range, include_subaccounts: false,
+        filter: { AND: [{ attribute: "domain", comparator: "=", values: [{ label: domain, value: domain }] }] },
+        pagination: { limit, sort: "timestamp:asc", ...(token ? { token } : {}) }
+      } };
+    }, validateResult: result => Array.isArray(result?.items) && !!result.pagination && typeof result.pagination === "object" },
+    "domains.list": jsonOperation((settings) => `${origins[settings.region]}/v4/domains`, {
+      limit: { type: "integer", min: 1, max: 1000, defaultTo: 100 },
+      skip: { type: "integer", min: 0, max: 2147483647, defaultTo: 0 },
+      state: { type: "string", enum: ["active", "unverified", "disabled"] },
+      sort: { type: "string", enum: ["name", "name:asc", "name:desc"] },
+      search: { type: "string", maxLength: 253 },
+      include_subaccounts: { type: "boolean", defaultTo: false }
+    }, (result) => Array.isArray(result?.items) && Number.isInteger(result.total_count) && result.total_count >= 0)
+  }
+});
+export { mailgunProvider };

package/src/server/mapbox.js

@@ -0,0 +1,46 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { mapboxDefinition } from "../shared/mapbox.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const directionsSchema = createSchema({
+  profile: { type: "string", enum: ["driving", "driving-traffic", "walking", "cycling"], defaultTo: "driving" },
+  coordinates: { type: "array", required: true, validator: points => points.length >= 2 && points.length <= 25 || "Use 2–25 waypoints.",
+    items: { type: "object", schema: createSchema({ longitude: { type: "number", required: true, min: -180, max: 180 }, latitude: { type: "number", required: true, min: -90, max: 90 } }) } },
+  steps: { type: "boolean", defaultTo: false }
+});
+const geocodingResult = (result) => result?.type === "FeatureCollection" && Array.isArray(result.features) && typeof result.attribution === "string";
+const mapboxProvider = Object.freeze({
+  ...mapboxDefinition,
+  apiOrigins: ["https://api.mapbox.com"],
+  apiKey: { queryParameter: "access_token" },
+  checkOperation: "token.read",
+  operations: {
+    "directions.get": { scopes: [], request(input) {
+      const { profile, coordinates, steps } = validateSchemaPayload({ schema: directionsSchema, mode: "replace" }, input, { statusCode: 422 });
+      const points = coordinates.map(point => `${point.longitude},${point.latitude}`).join(";");
+      return { method: "GET", url: `https://api.mapbox.com/directions/v5/mapbox/${profile}/${points}?geometries=geojson&overview=full&steps=${steps}` };
+    }, validateResult: result => ["NoRoute", "NoSegment"].includes(result?.code) || result?.code === "Ok" && Array.isArray(result.routes) && result.routes.every(route =>
+      Number.isFinite(route.distance) && route.distance >= 0 && Number.isFinite(route.duration) && route.duration >= 0 && route.geometry?.type === "LineString" && Array.isArray(route.geometry.coordinates)) },
+    "token.read": jsonOperation("https://api.mapbox.com/tokens/v2", {}, (result) => {
+      if (["TokenMalformed", "TokenInvalid", "TokenExpired", "TokenRevoked"].includes(result?.code)) {
+        throw new ConnectorError("connector_reconnect_required", "Configure a valid Mapbox token and connect again.", { statusCode: 401 });
+      }
+      return result?.code === "TokenValid" && ["pk", "sk", "tk"].includes(result.token?.usage) && typeof result.token.user === "string";
+    }),
+    "geocoding.forward": jsonOperation("https://api.mapbox.com/search/geocode/v6/forward", {
+      q: { type: "string", required: true, minLength: 1, maxLength: 256,
+        validator: (value) => !value.includes(";") && (value.match(/[\p{L}\p{N}]+/gu) || []).length <= 20 || "Use at most 20 words or numbers and no semicolons." },
+      limit: { type: "integer", min: 1, max: 10, defaultTo: 5 },
+      autocomplete: { type: "boolean", defaultTo: false },
+      permanent: { type: "boolean", defaultTo: false }
+    }, geocodingResult),
+    "geocoding.reverse": jsonOperation("https://api.mapbox.com/search/geocode/v6/reverse", {
+      longitude: { type: "number", required: true, min: -180, max: 180 },
+      latitude: { type: "number", required: true, min: -90, max: 90 },
+      permanent: { type: "boolean", defaultTo: false }
+    }, geocodingResult)
+  }
+});
+export { mapboxProvider };

package/src/server/mcpRegistration.js

@@ -0,0 +1,41 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { registerClient } from "@modelcontextprotocol/sdk/client/auth.js";
+
+const mcpRegistrationFields = {
+  clientName: { type: "string", required: true, minLength: 1, maxLength: 200 },
+  callbackUrl: { type: "string", required: true, validator(value) {
+    try {
+      const url = new URL(value);
+      return (url.protocol === "https:" || url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname)) &&
+        !url.username && !url.password && !url.search && !url.hash || "Use an HTTPS callback or local loopback URL, without credentials, query or fragment.";
+    } catch { return "Enter the callback URL served by the assistant host."; }
+  } }
+};
+
+// Provider wrappers validate input; the trusted setup caller owns authorization and secret storage.
+async function registerMcpClient(providerName, metadata, { clientName, callbackUrl, scopes }, { fetchImpl = globalThis.fetch, signal } = {}) {
+  const redirectUri = new URL(callbackUrl).href;
+  const requestSignal = AbortSignal.any([...(signal ? [signal] : []), AbortSignal.timeout(15000)]);
+  try {
+    requestSignal.throwIfAborted();
+    const client = await registerClient(metadata.issuer, {
+      metadata,
+      clientMetadata: { client_name: clientName, redirect_uris: [redirectUri], token_endpoint_auth_method: "client_secret_post",
+        grant_types: ["authorization_code", "refresh_token"], response_types: ["code"], scope: scopes.join(" ") },
+      fetchFn: async (address, init) => {
+        if (String(address) !== metadata.registration_endpoint) throw new Error("Unexpected registration destination.");
+        return fetchImpl(address, { ...init, credentials: "omit", redirect: "error", signal: requestSignal });
+      }
+    });
+    if (typeof client.client_id !== "string" || !client.client_id.trim() || typeof client.client_secret !== "string" || !client.client_secret.trim() ||
+      client.token_endpoint_auth_method !== "client_secret_post" || client.redirect_uris?.length !== 1 || client.redirect_uris[0] !== redirectUri ||
+      /[\p{Cc}]/u.test(client.client_id + client.client_secret)) throw new Error("Invalid client registration.");
+    return { clientId: client.client_id, clientSecret: client.client_secret,
+      ...(client.client_secret_expires_at === undefined ? {} : { clientSecretExpiresAt: client.client_secret_expires_at }) };
+  } catch {
+    if (requestSignal.aborted) throw new ConnectorError("connector_registration_interrupted", "Registration was interrupted. Check the provider before creating another client.");
+    throw new ConnectorError("connector_registration_failed", `${providerName} client registration failed. Check the provider before creating another client.`, { statusCode: 502 });
+  }
+}
+
+export { mcpRegistrationFields, registerMcpClient };

package/src/server/mcpTransport.js

@@ -0,0 +1,60 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { jsonOperation } from "./jsonOperation.js";
+
+function mcpOperations(endpoint) {
+  const operation = (method, fields) => {
+    const definition = jsonOperation(endpoint, fields, undefined, "POST");
+    return { ...definition, request(input, settings) {
+      const request = definition.request(input, settings);
+      return { ...request, body: { method, params: request.body } };
+    } };
+  };
+  return {
+    "tools.list": operation("tools/list", { cursor: { type: "string", minLength: 1, maxLength: 4096 } }),
+    "tools.call": operation("tools/call", {
+      name: { type: "string", required: true, minLength: 1, maxLength: 128,
+        validator: (value) => /^[a-z0-9_.-]+$/iu.test(value) || "Enter an MCP tool name using letters, digits, underscores, dots or hyphens." },
+      arguments: { type: "object", required: true }
+    })
+  };
+}
+
+async function exchangeMcp(endpoint, { headers, signal, body }, { fetchImpl }) {
+  const client = new Client({ name: "jskit-connectors", version: "0.1.0" }, { capabilities: {} });
+  let cleanup = false;
+  const transport = new StreamableHTTPClientTransport(new URL(endpoint), {
+    reconnectionOptions: { initialReconnectionDelay: 1000, maxReconnectionDelay: 1000, reconnectionDelayGrowFactor: 1, maxRetries: 0 },
+    fetch: async (address, init = {}) => {
+      if (new URL(String(address)).href !== endpoint) {
+        throw new ConnectorError("connector_destination_invalid", "The MCP transport requested an unexpected destination.");
+      }
+      const requestHeaders = new Headers(init.headers);
+      // Keep MCP's Accept/protocol/session headers, and bind credentials to this endpoint only.
+      requestHeaders.set("Authorization", headers.Authorization);
+      const requestSignal = cleanup ? AbortSignal.timeout(2000) : AbortSignal.any([...(init.signal ? [init.signal] : []), signal]);
+      const response = await fetchImpl(address, { ...init, headers: requestHeaders, credentials: "omit", redirect: "error", signal: requestSignal });
+      if (!response.ok && !(response.status === 405 && ["GET", "DELETE"].includes(init.method))) {
+        await response.body?.cancel();
+        const error = new Error("MCP request failed.");
+        error.statusCode = response.status;
+        throw error;
+      }
+      return response;
+    }
+  });
+  try {
+    signal.throwIfAborted();
+    await client.connect(transport, { signal });
+    if (body.method === "tools/list") return await client.listTools(body.params, { signal });
+    return await client.callTool(body.params, undefined, { signal });
+  } finally {
+    cleanup = true;
+    // Closing a local client alone does not delete a server-side MCP session.
+    try { await transport.terminateSession(); } catch { /* Cleanup failure must not replace the operation's result. */ }
+    await client.close();
+  }
+}
+
+export { mcpOperations, exchangeMcp };