@jskit-ai/connectors-catalog 0.1.1

package/src/server/google-sheets.js

@@ -0,0 +1,60 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { googleSheetsDefinition } from "../shared/google.js";
+import { googleRead, googleProvider, googleFileVerification, documentId } from "./google.js";
+const origin = "https://sheets.googleapis.com";
+const scopes = ["spreadsheets.readonly", "spreadsheets", "drive.readonly", "drive.file", "drive"];
+const writable = ["spreadsheets", "drive.file", "drive"].map(scope => `https://www.googleapis.com/auth/${scope}`);
+const range = { type: "string", required: true, minLength: 1, maxLength: 2048 };
+const inputOption = { type: "string", enum: ["RAW", "USER_ENTERED"], default: "RAW" };
+const values = { type: "array", required: true };
+const validSheet = value => typeof value?.spreadsheetId === "string" && typeof value.properties?.title === "string";
+const sheetUrl = id => `${origin}/v4/spreadsheets/${encodeURIComponent(id)}`;
+const get = googleRead(scopes, { spreadsheetId: documentId }, ({ spreadsheetId }) => ({ url: sheetUrl(spreadsheetId), query: { includeGridData: false } }), validSheet);
+function write(fields, destination, validateResult) {
+  const schema = createSchema(fields);
+  return { scopes: writable, validateResult, request(input) {
+    return destination(validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 }));
+  } };
+}
+function checkValues(rows) {
+  if (!rows.length || rows.length > 10000 || rows.some(row => !Array.isArray(row) || row.some(cell => cell !== null && typeof cell !== "string" && typeof cell !== "boolean" && !(typeof cell === "number" && Number.isFinite(cell)))) || rows.reduce((count, row) => count + row.length, 0) > 10000 || Buffer.byteLength(JSON.stringify(rows)) > 1048576) {
+    throw Object.assign(new Error("Supply a matrix of at most 10,000 cells and 1 MiB, containing strings, finite numbers, booleans or null."), { statusCode: 422 });
+  }
+  return rows;
+}
+const validUpdate = value => typeof value?.spreadsheetId === "string" && typeof value.updatedRange === "string";
+const base = googleProvider(googleSheetsDefinition, origin, "connection.verify", {
+  "connection.verify": googleFileVerification(get, "spreadsheetId"),
+  "spreadsheets.get": get,
+  "spreadsheets.create": write({ title: { type: "string", required: true, minLength: 1, maxLength: 1024 } }, ({ title }) => ({ method: "POST", url: `${origin}/v4/spreadsheets`, body: { properties: { title } } }), validSheet),
+  "values.get": googleRead(scopes, {
+    spreadsheetId: documentId, range,
+    valueRenderOption: { type: "string", enum: ["FORMATTED_VALUE", "UNFORMATTED_VALUE", "FORMULA"] },
+    dateTimeRenderOption: { type: "string", enum: ["SERIAL_NUMBER", "FORMATTED_STRING"] }
+  }, ({ spreadsheetId, range, ...query }) => ({ url: `${sheetUrl(spreadsheetId)}/values/${encodeURIComponent(range)}`, query }), value => typeof value?.range === "string" && (value.values === undefined || Array.isArray(value.values))),
+  "values.update": write({ spreadsheetId: documentId, range, values, valueInputOption: inputOption }, ({ spreadsheetId, range, values, valueInputOption = "RAW" }) => ({
+    method: "PUT", url: `${sheetUrl(spreadsheetId)}/values/${encodeURIComponent(range)}?valueInputOption=${valueInputOption}`,
+    body: { range, majorDimension: "ROWS", values: checkValues(values) }
+  }), validUpdate),
+  "values.append": write({ spreadsheetId: documentId, range, values, valueInputOption: inputOption, insertDataOption: { type: "string", enum: ["INSERT_ROWS", "OVERWRITE"], default: "INSERT_ROWS" } }, ({ spreadsheetId, range, values, valueInputOption = "RAW", insertDataOption = "INSERT_ROWS" }) => ({
+    method: "POST", url: `${sheetUrl(spreadsheetId)}/values/${encodeURIComponent(range)}:append?valueInputOption=${valueInputOption}&insertDataOption=${insertDataOption}`,
+    body: { range, majorDimension: "ROWS", values: checkValues(values) }
+  }), value => typeof value?.spreadsheetId === "string" && validUpdate(value.updates)),
+  "values.clear": write({ spreadsheetId: documentId, range }, ({ spreadsheetId, range }) => ({ method: "POST", url: `${sheetUrl(spreadsheetId)}/values/${encodeURIComponent(range)}:clear`, body: {} }), value => typeof value?.spreadsheetId === "string" && typeof value.clearedRange === "string"),
+  "values.batchUpdate": write({ spreadsheetId: documentId, data: { type: "array", required: true }, valueInputOption: inputOption }, ({ spreadsheetId, data, valueInputOption = "RAW" }) => {
+    const schema = createSchema({ range, values });
+    if (!data.length || data.length > 100 || Buffer.byteLength(JSON.stringify(data)) > 1048576) throw Object.assign(new Error("Supply 1–100 ranges within 1 MiB."), { statusCode: 422 });
+    const ranges = data.map(value => {
+      const parsed = validateSchemaPayload({ schema, mode: "replace" }, value, { statusCode: 422 });
+      return { ...parsed, majorDimension: "ROWS", values: checkValues(parsed.values) };
+    });
+    return { method: "POST", url: `${sheetUrl(spreadsheetId)}/values:batchUpdate`, body: { data: ranges, valueInputOption } };
+  }, value => typeof value?.spreadsheetId === "string" && Array.isArray(value.responses)),
+  "spreadsheets.batchUpdate": write({ spreadsheetId: documentId, requests: { type: "array", required: true } }, ({ spreadsheetId, requests }) => {
+    if (!requests.length || requests.length > 100 || Buffer.byteLength(JSON.stringify(requests)) > 1048576 || requests.some(request => !request || typeof request !== "object" || Array.isArray(request) || Object.keys(request).length !== 1 || !/^[a-zA-Z][a-zA-Z0-9]+$/.test(Object.keys(request)[0]) || !Object.values(request)[0] || typeof Object.values(request)[0] !== "object" || Array.isArray(Object.values(request)[0]))) throw Object.assign(new Error("Supply 1–100 native Sheets request objects, one operation per object, within 1 MiB."), { statusCode: 422 });
+    return { method: "POST", url: `${sheetUrl(spreadsheetId)}:batchUpdate`, body: { requests } };
+  }, value => typeof value?.spreadsheetId === "string" && (value.replies === undefined || Array.isArray(value.replies)))
+});
+const googleSheetsProvider = Object.freeze({ ...base, apiOrigins: [origin, "https://www.googleapis.com"] });
+export { googleSheetsProvider };

package/src/server/google-slides.js

@@ -0,0 +1,36 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { googleSlidesDefinition } from "../shared/google.js";
+import { googleRead, googleProvider, googleFileVerification, documentId } from "./google.js";
+const origin = "https://slides.googleapis.com";
+const readScopes = ["presentations.readonly", "presentations", "drive.readonly", "drive.file", "drive"];
+const writable = ["presentations", "drive.file", "drive"].map(scope => `https://www.googleapis.com/auth/${scope}`);
+const validPresentation = value => typeof value?.presentationId === "string" && typeof value.title === "string";
+const get = googleRead(readScopes, { presentationId: documentId }, ({ presentationId }) => ({
+  url: `${origin}/v1/presentations/${encodeURIComponent(presentationId)}`
+}), validPresentation);
+const pageId = { ...documentId, validator: value => /^[a-zA-Z0-9_][a-zA-Z0-9_:-]*$/.test(value) || "Enter a slide object ID, not its URL." };
+const create = createSchema({ title: { type: "string", required: true, minLength: 1, maxLength: 1024 } });
+const batch = createSchema({ presentationId: documentId, requests: { type: "array", required: true }, requiredRevisionId: { type: "string", minLength: 1, maxLength: 1024 } });
+const base = googleProvider(googleSlidesDefinition, origin, "connection.verify", {
+  "connection.verify": googleFileVerification(get, "presentationId"),
+  "presentations.get": get,
+  "presentations.create": { scopes: writable, validateResult: validPresentation, request(input) {
+    return { method: "POST", url: `${origin}/v1/presentations`, body: validateSchemaPayload({ schema: create, mode: "replace" }, input, { statusCode: 422 }) };
+  } },
+  "presentations.batchUpdate": { scopes: writable,
+    validateResult: value => typeof value?.presentationId === "string" && (value.replies === undefined || Array.isArray(value.replies)),
+    request(input) {
+      const { presentationId, requests, requiredRevisionId } = validateSchemaPayload({ schema: batch, mode: "replace" }, input, { statusCode: 422 });
+      if (!requests.length || requests.length > 100 || Buffer.byteLength(JSON.stringify(requests)) > 1048576 || requests.some(request => !request || typeof request !== "object" || Array.isArray(request) || Object.keys(request).length !== 1 || !/^[a-zA-Z][a-zA-Z0-9]+$/.test(Object.keys(request)[0]) || !Object.values(request)[0] || typeof Object.values(request)[0] !== "object" || Array.isArray(Object.values(request)[0]))) throw Object.assign(new Error("Supply 1–100 native Slides request objects, one operation per object, within 1 MiB."), { statusCode: 422 });
+      return { method: "POST", url: `${origin}/v1/presentations/${encodeURIComponent(presentationId)}:batchUpdate`, body: { requests, ...(requiredRevisionId ? { writeControl: { requiredRevisionId } } : {}) } };
+    }
+  },
+  "pages.get": googleRead(readScopes, { presentationId: documentId, pageObjectId: pageId }, ({ presentationId, pageObjectId }) => ({ url: `${origin}/v1/presentations/${encodeURIComponent(presentationId)}/pages/${encodeURIComponent(pageObjectId)}` }), value => typeof value?.objectId === "string"),
+  "pages.getThumbnail": googleRead(readScopes, { presentationId: documentId, pageObjectId: pageId, size: { type: "string", enum: ["SMALL", "MEDIUM", "LARGE"] } }, ({ presentationId, pageObjectId, size }) => ({ url: `${origin}/v1/presentations/${encodeURIComponent(presentationId)}/pages/${encodeURIComponent(pageObjectId)}/thumbnail`, query: { "thumbnailProperties.mimeType": "PNG", "thumbnailProperties.thumbnailSize": size } }), value => {
+    if (typeof value?.contentUrl !== "string" || !Number.isFinite(value.width) || !Number.isFinite(value.height) || value.width <= 0 || value.height <= 0) return false;
+    try { const url = new URL(value.contentUrl); return url.protocol === "https:" && !url.username && !url.password; } catch { return false; }
+  })
+});
+const googleSlidesProvider = Object.freeze({ ...base, apiOrigins: [origin, "https://www.googleapis.com"] });
+export { googleSlidesProvider };

package/src/server/google.js

@@ -0,0 +1,61 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+
+const oauth = Object.freeze({
+  issuer: "https://accounts.google.com",
+  authorization_endpoint: "https://accounts.google.com/o/oauth2/v2/auth",
+  token_endpoint: "https://oauth2.googleapis.com/token"
+});
+const googleScope = (name) => name.startsWith("https:") ? name : `https://www.googleapis.com/auth/${name}`;
+const documentId = { type: "string", required: true, minLength: 1, maxLength: 1024, validator: (value) => /^[a-zA-Z0-9_-]+$/u.test(value) || "Enter the document ID from its URL." };
+const pageToken = { type: "string", minLength: 1, maxLength: 4096 };
+
+function googleOperation(scopes, fields, request, validateResult) {
+  const schema = createSchema(fields);
+  return {
+    scopes: scopes.map(scope => `https://www.googleapis.com/auth/${scope}`),
+    validateResult,
+    request(input) {
+      return request(validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 }));
+    }
+  };
+}
+
+function googleRead(scopes, fields, destination, validateResult) {
+  const schema = createSchema(fields);
+  return {
+    scopes: scopes.map(googleScope), validateResult,
+    request(input) {
+      const params = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+      const { url: address, query = {} } = destination(params);
+      const url = new URL(address);
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined) {
+          for (const item of Array.isArray(value) ? value : [value]) url.searchParams.append(key, String(item));
+        }
+      }
+      return { method: "GET", url: url.href };
+    }
+  };
+}
+
+function googleProvider(definition, origin, checkOperation, operations) {
+  return Object.freeze({
+    ...definition, oauth, apiOrigins: [origin],
+    authorizationParameters: { access_type: "offline", prompt: "consent" },
+    checkOperation, operations
+  });
+}
+function googleFileVerification(get, field) {
+  const schema = createSchema({ [field]: { ...documentId, required: false } });
+  return {
+    scopes: get.scopes,
+    request(input = {}) {
+      const params = validateSchemaPayload({ schema, mode: "replace" }, { ...input, ...(input[field] === "" ? { [field]: undefined } : {}) }, { statusCode: 422 });
+      if (params[field]) return get.request(params);
+      return { method: "GET", url: "https://www.googleapis.com/drive/v3/files?pageSize=1&fields=files(id)&q=trashed%3Dfalse" };
+    },
+    validateResult: value => get.validateResult(value) || Array.isArray(value?.files)
+  };
+}
+export { googleOperation, googleRead, googleProvider, googleFileVerification, documentId, pageToken };

package/src/server/granola.js

@@ -0,0 +1,115 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { granolaDefinition } from "../shared/granola.js";
+import { jsonOperation } from "./jsonOperation.js";
+import { mcpOperations, exchangeMcp } from "./mcpTransport.js";
+import { mcpRegistrationFields, registerMcpClient } from "./mcpRegistration.js";
+
+const apiOrigin = "https://public-api.granola.ai";
+const noteId = (value) => typeof value === "string" && /^not_[A-Za-z0-9]{14}$/u.test(value);
+const folderId = (value) => typeof value === "string" && /^fol_[A-Za-z0-9]{14}$/u.test(value);
+const cursorValid = (value) => typeof value === "string" && value.length > 0 && value.length <= 8192 && !/[\s\p{Cc}]/u.test(value);
+const cursor = { type: "string", noTrim: true, validator: (value) => cursorValid(value) || "Use the cursor returned by the previous page." };
+const date = { type: "string", noTrim: true, validator: (value) => {
+  const match = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z)?$/u.test(value);
+  return match && Number.isFinite(Date.parse(value)) && new Date(value).toISOString().startsWith(value.slice(0, 10)) || "Use a valid YYYY-MM-DD date or UTC timestamp.";
+} };
+const noteSummary = (value) => noteId(value?.id) && value.object === "note" && (value.title === null || typeof value.title === "string") &&
+  typeof value.owner?.email === "string" && typeof value.created_at === "string" && typeof value.updated_at === "string";
+const transcriptItem = (value) => typeof value?.text === "string" && typeof value.speaker?.source === "string" &&
+  typeof value.start_time === "string" && typeof value.end_time === "string";
+const validFolder = (value) => folderId(value?.id) && value.object === "folder" && typeof value.name === "string" &&
+  (value.parent_folder_id === null || folderId(value.parent_folder_id));
+const validPage = (value, field, itemValid) => typeof value?.hasMore === "boolean" &&
+  (value.cursor === null || cursorValid(value.cursor)) && (!value.hasMore || cursorValid(value.cursor)) &&
+  Array.isArray(value[field]) && value[field].every(itemValid);
+
+function noteRead(suffix, fields, validateResult) {
+  const schema = createSchema({ note_id: { type: "string", required: true, validator: (value) => noteId(value) || "Use the not_ ID returned by notes.list." }, ...fields });
+  return {
+    scopes: [], validateResult,
+    request(input) {
+      const { note_id, ...values } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+      const url = new URL(`${apiOrigin}/v1/notes/${note_id}${suffix}`);
+      for (const [name, value] of Object.entries(values)) url.searchParams.set(name, String(value));
+      return { method: "GET", url: url.href };
+    }
+  };
+}
+
+const granolaApiProvider = Object.freeze({
+  ...granolaDefinition, apiOrigins: [apiOrigin], checkOperation: "notes.list",
+  apiKey: { headers: (key) => {
+    if (!key.startsWith("grn_") || key.length <= 4 || /[\s\p{Cc}]/u.test(key)) {
+      throw new ConnectorError("connector_binding_missing", "Use the Granola grn_ API key without whitespace or control characters.");
+    }
+    return { Authorization: `Bearer ${key}` };
+  } },
+  operations: {
+    "notes.list": jsonOperation(`${apiOrigin}/v1/notes`, {
+      created_before: date, created_after: date, updated_after: date,
+      folder_id: { type: "string", validator: (value) => folderId(value) || "Use a fol_ ID returned by folders.list." },
+      cursor, page_size: { type: "integer", min: 1, max: 30, defaultTo: 10 }
+    }, (value) => validPage(value, "notes", noteSummary)),
+    "folders.list": jsonOperation(`${apiOrigin}/v1/folders`, {
+      cursor, page_size: { type: "integer", min: 1, max: 30, defaultTo: 10 }
+    }, (value) => validPage(value, "folders", validFolder)),
+    "notes.get": noteRead("", { include: { type: "string", enum: ["transcript"] } }, (value) => noteSummary(value) &&
+      typeof value.summary_text === "string" && (value.summary_markdown === null || typeof value.summary_markdown === "string") &&
+      (value.private_notes_text === null || typeof value.private_notes_text === "string") &&
+      (value.private_notes_markdown === null || typeof value.private_notes_markdown === "string") &&
+      (value.transcript === null || Array.isArray(value.transcript) && value.transcript.every(transcriptItem))),
+    "transcripts.list": noteRead("/transcript", {
+      cursor, page_size: { type: "integer", min: 1, max: 100, defaultTo: 50 }
+    }, (value) => validPage(value, "transcript", transcriptItem))
+  },
+  async exchange(address, options, { fetchImpl }) {
+    const response = await fetchImpl(address, { ...options, credentials: "omit" });
+    if (response.status === 404) throw new ConnectorError("connector_resource_not_found", "The Granola note is unavailable, inaccessible or still being processed.", { statusCode: 404 });
+    if (response.status === 413) throw new ConnectorError("connector_response_too_large", "Read the transcript in pages with transcripts.list.", { statusCode: 413 });
+    if (!response.ok) throw Object.assign(new Error("Granola request failed."), { status: response.status });
+    let value;
+    try { value = await response.json(); } catch { /* checked below */ }
+    if (response.status !== 200 || !value || typeof value !== "object" || value.error) {
+      throw new ConnectorError("connector_response_invalid", "Granola returned an unexpected response.", { statusCode: 502 });
+    }
+    const url = new URL(address);
+    const list = url.pathname === "/v1/notes" ? "notes" : url.pathname === "/v1/folders" ? "folders" : url.pathname.endsWith("/transcript") ? "transcript" : null;
+    if (list ? value[list]?.length > Number(url.searchParams.get("page_size")) : value.id !== url.pathname.split("/").at(-1)) {
+      throw new ConnectorError("connector_response_invalid", "Granola returned data that does not match this request.", { statusCode: 502 });
+    }
+    return value;
+  }
+});
+
+const mcpResource = "https://mcp.granola.ai/mcp";
+const oauth = Object.freeze({
+  issuer: "https://mcp-auth.granola.ai",
+  authorization_endpoint: "https://mcp-auth.granola.ai/oauth2/authorize",
+  token_endpoint: "https://mcp-auth.granola.ai/oauth2/token",
+  registration_endpoint: "https://mcp-auth.granola.ai/oauth2/register",
+  response_types_supported: ["code"], code_challenge_methods_supported: ["S256"]
+});
+const granolaProvider = Object.freeze({
+  ...granolaApiProvider, oauth, oauthResource: mcpResource,
+  apiOrigins: [apiOrigin, "https://mcp.granola.ai"],
+  checkOperation: (method) => method === "oauth2" ? "tools.list" : "notes.list",
+  operations: {
+    ...Object.fromEntries(Object.entries(granolaApiProvider.operations).map(([name, operation]) =>
+      [name, { ...operation, authenticationMethods: ["api-key"] }])),
+    ...Object.fromEntries(Object.entries(mcpOperations(() => mcpResource)).map(([name, operation]) =>
+      [name, { ...operation, authenticationMethods: ["oauth2"], scopes: ["openid"] }]))
+  },
+  exchange(address, options, context) {
+    return address === mcpResource ? exchangeMcp(address, options, context) : granolaApiProvider.exchange(address, options, context);
+  }
+});
+const registrationSchema = createSchema(mcpRegistrationFields);
+
+async function registerGranolaClient(input, options) {
+  const values = validateSchemaPayload({ schema: registrationSchema, mode: "replace" }, input, { statusCode: 422 });
+  return registerMcpClient("Granola", oauth, { ...values, scopes: granolaDefinition.scopes.map((scope) => scope.value) }, options);
+}
+
+export { granolaProvider, registerGranolaClient };

package/src/server/graphqlOperation.js

@@ -0,0 +1,15 @@
+import { jsonOperation } from "./jsonOperation.js";
+
+function graphqlOperation(url, query, fields, validateData) {
+  const operation = jsonOperation(url, fields,
+    (result) => (result?.errors === undefined || (Array.isArray(result.errors) && result.errors.length === 0)) && validateData(result?.data), "POST");
+  return {
+    ...operation,
+    request(input, settings) {
+      const request = operation.request(input, settings);
+      return { ...request, body: { query, variables: request.body } };
+    }
+  };
+}
+
+export { graphqlOperation };

package/src/server/hex.js

@@ -0,0 +1,29 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { hexDefinition, hexHosts, hexEndpointField } from "../shared/hex.js";
+import { mcpOperations, exchangeMcp } from "./mcpTransport.js";
+import { mcpRegistrationFields, registerMcpClient } from "./mcpRegistration.js";
+
+const origin = (settings) => `https://${hexHosts[settings.endpoint]}`;
+const resource = (settings) => `${origin(settings)}/mcp`;
+const oauth = (settings) => {
+  const issuer = `https://auth.${hexHosts[settings.endpoint]}`;
+  return { issuer, authorization_endpoint: `${issuer}/oauth2/authorize`, token_endpoint: `${issuer}/oauth2/token`,
+    registration_endpoint: `${issuer}/oauth2/register`, response_types_supported: ["code"], code_challenge_methods_supported: ["S256"] };
+};
+const hexProvider = Object.freeze({
+  ...hexDefinition, oauth, oauthResource: resource, apiOrigins: (settings) => [origin(settings)],
+  checkOperation: "tools.list", exchange: exchangeMcp,
+  operations: Object.fromEntries(Object.entries(mcpOperations(resource)).map(([name, operation]) => [name, { ...operation, scopes: ["openid"] }]))
+});
+const registrationSchema = createSchema({ endpoint: hexEndpointField, ...mcpRegistrationFields,
+  scopes: { type: "array", required: true, minLength: 1, items: { type: "string", enum: hexDefinition.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 registerHexClient(input, options) {
+  const values = validateSchemaPayload({ schema: registrationSchema, mode: "replace" }, input, { statusCode: 422 });
+  return registerMcpClient("Hex", oauth(values), values, options);
+}
+
+export { hexProvider, registerHexClient };

package/src/server/heygen.js

@@ -0,0 +1,54 @@
+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 { heygenDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const heygenApiProvider = Object.freeze({
+  ...heygenDefinition, apiOrigins: ["https://api.heygen.com"],
+  apiKey: { headers: (key) => ({ "x-api-key": key }) },
+  checkOperation: "profile.read",
+  operations: {
+    "profile.read": jsonOperation("https://api.heygen.com/v3/users/me", {},
+      (result) => typeof result?.data?.username === "string"),
+    "voices.list": jsonOperation("https://api.heygen.com/v3/voices", {
+      limit: { type: "integer", min: 1, max: 100, defaultTo: 20 },
+      token: { type: "string", maxLength: 4096 },
+      type: { type: "string", enum: ["public", "private"], defaultTo: "public" },
+      engine: { type: "string", maxLength: 100 },
+      language: { type: "string", maxLength: 100 },
+      gender: { type: "string", enum: ["male", "female"] }
+    }, (result) => Array.isArray(result?.data) && typeof result.has_more === "boolean")
+  }
+});
+const mcpEndpoint = "https://mcp.heygen.com/mcp/v1/";
+const oauth = Object.freeze({
+  issuer: "https://api2.heygen.com",
+  authorization_endpoint: "https://api2.heygen.com/v1/oauth/authorize",
+  token_endpoint: "https://api2.heygen.com/v1/oauth/token",
+  registration_endpoint: "https://api2.heygen.com/v1/oauth/register",
+  response_types_supported: ["code"], code_challenge_methods_supported: ["S256"]
+});
+const heygenProvider = Object.freeze({
+  ...heygenApiProvider, oauth, oauthResource: "https://mcp.heygen.com",
+  apiOrigins: ["https://api.heygen.com", "https://mcp.heygen.com"],
+  checkOperation: (method) => method === "oauth2" ? "tools.list" : "profile.read",
+  operations: {
+    ...Object.fromEntries(Object.entries(heygenApiProvider.operations).map(([name, operation]) =>
+      [name, { ...operation, authenticationMethods: ["api-key"] }])),
+    ...Object.fromEntries(Object.entries(mcpOperations(() => mcpEndpoint)).map(([name, operation]) =>
+      [name, { ...operation, authenticationMethods: ["oauth2"], scopes: ["openid"] }]))
+  },
+  exchange(address, options, context) {
+    return address === mcpEndpoint ? exchangeMcp(address, options, context) : context.request(address, options);
+  }
+});
+const registrationSchema = createSchema(mcpRegistrationFields);
+
+async function registerHeyGenClient(input, options) {
+  const values = validateSchemaPayload({ schema: registrationSchema, mode: "replace" }, input, { statusCode: 422 });
+  return registerMcpClient("HeyGen", oauth, { ...values, scopes: heygenDefinition.scopes.map((scope) => scope.value) }, options);
+}
+
+export { heygenProvider, registerHeyGenClient };

package/src/server/hubspot.js

@@ -0,0 +1,85 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { hubspotDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const base = "https://api.hubapi.com/crm/objects/2026-09";
+const recordId = { type: "string", required: true, minLength: 1, maxLength: 100,
+  validator: value => /^[0-9]+$/u.test(value) || "Use the HubSpot numeric record ID." };
+const properties = { type: "object", required: true, validator: value => {
+  const entries = Object.entries(value);
+  return entries.length > 0 && entries.length <= 100 && entries.every(([key, item]) =>
+    /^[a-zA-Z_][a-zA-Z0-9_]*$/u.test(key) && typeof item === "string") &&
+    Buffer.byteLength(JSON.stringify(value)) <= 100000 || "Provide 1–100 named string properties, within 100KB.";
+} };
+const readFields = {
+  properties: { type: "string", maxLength: 4096, validator: value => /^[a-zA-Z0-9_,]+$/u.test(value) || "Use comma-separated property names." },
+  associations: { type: "string", enum: ["contacts", "deals", "contacts,deals"] },
+  archived: { type: "boolean", defaultTo: false }
+};
+const validRecord = value => typeof value?.id === "string" && value.properties && typeof value.properties === "object" && !Array.isArray(value.properties);
+function objectOperations(object) {
+  const readScope = `crm.objects.${object}.read`, writeScope = `crm.objects.${object}.write`;
+  const read = createSchema({ id: recordId, ...readFields });
+  const write = createSchema({ id: recordId, properties });
+  const create = createSchema({ properties });
+  return {
+    [`${object}.list`]: { ...jsonOperation(`${base}/${object}`, {
+      limit: { type: "integer", min: 1, max: 100, defaultTo: 20 },
+      after: { type: "string", maxLength: 4096 }, ...readFields
+    }, value => Array.isArray(value?.results)), scopes: [readScope] },
+    [`${object}.get`]: { scopes: [readScope], request(input) {
+      const { id, ...query } = validateSchemaPayload({ schema: read, mode: "replace" }, input, { statusCode: 422 });
+      const url = new URL(`${base}/${object}/${encodeURIComponent(id)}`);
+      for (const [key, value] of Object.entries(query)) url.searchParams.set(key, String(value));
+      return { method: "GET", url: url.href };
+    }, validateResult: validRecord },
+    [`${object}.create`]: { scopes: [writeScope], request(input) {
+      const body = validateSchemaPayload({ schema: create, mode: "replace" }, input, { statusCode: 422 });
+      if (object === "contacts" ? !["email", "firstname", "lastname"].some(key => body.properties[key]?.trim()) :
+        !body.properties.dealname?.trim() || !body.properties.dealstage?.trim()) {
+        throw new ConnectorError("connector_input_invalid", object === "contacts" ? "Supply email, firstname or lastname." : "Supply dealname and the internal dealstage ID.", { statusCode: 422 });
+      }
+      return { method: "POST", url: `${base}/${object}`, body };
+    }, validateResult: validRecord },
+    [`${object}.update`]: { scopes: [writeScope], request(input) {
+      const { id, ...body } = validateSchemaPayload({ schema: write, mode: "replace" }, input, { statusCode: 422 });
+      return { method: "PATCH", url: `${base}/${object}/${encodeURIComponent(id)}`, body };
+    }, validateResult: validRecord }
+  };
+}
+const associationSchema = createSchema({ contactId: recordId, dealId: recordId });
+
+const hubspotProvider = Object.freeze({
+  ...hubspotDefinition, apiOrigins: ["https://api.hubapi.com"],
+  apiKey: { headers: (key) => ({ Authorization: `Bearer ${key}` }) },
+  oauth: {
+    issuer: "https://api.hubspot.com",
+    authorization_endpoint: "https://app.hubspot.com/oauth/authorize",
+    token_endpoint: "https://api.hubspot.com/oauth/2026-09/token"
+  },
+  // HubSpot documents confidential-client code grants without PKCE.
+  oauthPkce: false,
+  async normalizeTokenResponse(response) {
+    if (!response.ok) return response;
+    let value;
+    try { value = await response.clone().json(); } catch {
+      throw new ConnectorError("connector_response_invalid", "HubSpot returned an invalid token response.", { statusCode: 502 });
+    }
+    if (!Array.isArray(value?.scopes) || !value.scopes.every((scope) => typeof scope === "string" && /^[^\s]+$/u.test(scope))) {
+      throw new ConnectorError("connector_response_invalid", "HubSpot returned an invalid permission grant.", { statusCode: 502 });
+    }
+    return Response.json({ ...value, scope: value.scopes.join(" ") }, { status: response.status });
+  },
+  checkOperation: "contacts.list",
+  operations: {
+    ...objectOperations("contacts"), ...objectOperations("deals"),
+    "deals.associateContact": { scopes: ["crm.objects.contacts.write", "crm.objects.deals.write"], request(input) {
+      const { contactId, dealId } = validateSchemaPayload({ schema: associationSchema, mode: "replace" }, input, { statusCode: 422 });
+      return { method: "PUT", url: `${base}/deals/${dealId}/associations/default/contacts/${contactId}` };
+    }, validateResult: value => Array.isArray(value?.results) },
+    "pipelines.list": { ...jsonOperation("https://api.hubapi.com/crm/pipelines/2026-09/deals", {}, value => Array.isArray(value?.results)), scopes: ["crm.objects.deals.read"] }
+  }
+});
+export { hubspotProvider };

package/src/server/incident-io.js

@@ -0,0 +1,68 @@
+import { createSchema } from "json-rest-schema";
+import { incidentIoDefinition } from "../shared/tokens.js";
+import { jsonOperation, validatedOperation } from "./jsonOperation.js";
+
+const id = { type: "string", required: true, minLength: 1, maxLength: 200,
+  validator: value => /^[a-zA-Z0-9_-]+$/u.test(value) || "Use the incident.io resource ID, not a URL." };
+const text = { type: "string", minLength: 1, maxLength: 20000 };
+const optionalId = { ...id, required: false };
+const after = { type: "string", minLength: 1, maxLength: 4096 };
+const page = max => ({ type: "integer", min: 1, max, defaultTo: 25 });
+const result = key => value => typeof value?.[key]?.id === "string";
+const address = path => `https://api.incident.io${path}`;
+const incidentFields = { name: text, summary: text, severity_id: optionalId, incident_status_id: optionalId };
+const followUpFields = { title: { ...text, required: true, maxLength: 1000 }, description: text,
+  assignee_id: optionalId, assignee_team_id: optionalId, follow_up_category_id: optionalId, follow_up_priority_option_id: optionalId };
+const literal = value => value && typeof value === "object" && !Array.isArray(value) &&
+  Object.keys(value).length === 1 && typeof value.literal === "string" && value.literal.length <= 20000;
+const attributes = { type: "object", required: true, additionalProperties: true,
+  validator: value => Object.keys(value).length <= 250 && Buffer.byteLength(JSON.stringify(value)) <= 100000 &&
+    Object.entries(value).every(([key, binding]) => /^[a-zA-Z0-9_-]+$/u.test(key) && binding && typeof binding === "object" && !Array.isArray(binding) &&
+      Object.keys(binding).every(field => ["value", "array_value"].includes(field)) &&
+      (binding.value === undefined || literal(binding.value)) &&
+      (binding.array_value === undefined || Array.isArray(binding.array_value) && binding.array_value.length <= 100 && binding.array_value.every(literal))) ||
+    "Use at most 250 attributes with literal string value/array_value bindings, within 100KB." };
+
+const incidentIoProvider = Object.freeze({
+  ...incidentIoDefinition, apiOrigins: ["https://api.incident.io"],
+  apiKey: { headers: (key) => ({ Authorization: `Bearer ${key}` }) },
+  checkOperation: "incidents.list",
+  operations: {
+    ...Object.fromEntries([
+      ["incidents.get", "/v2/incidents", "incident"], ["followUps.get", "/v2/follow_ups", "follow_up"],
+      ["alerts.get", "/v2/alerts", "alert"], ["schedules.get", "/v2/schedules", "schedule"],
+      ["catalog.get", "/v3/catalog_entries", "catalog_entry"]
+    ].map(([name, path, key]) => [name, validatedOperation({ id }, ({ id }) => ({ method: "GET", url: address(`${path}/${id}`) }), result(key))])),
+    "incidents.create": validatedOperation({ ...incidentFields, idempotency_key: { ...text, required: true, maxLength: 200 },
+      visibility: { type: "string", required: true, enum: ["public", "private"] },
+      mode: { type: "string", enum: ["standard", "retrospective", "test", "tutorial"], defaultTo: "standard" }, incident_type_id: optionalId
+    }, body => ({ method: "POST", url: address("/v2/incidents"), body }), result("incident")),
+    "incidents.update": validatedOperation({ id, incident: { type: "object", required: true, schema: createSchema(incidentFields),
+      validator: value => Object.keys(value).length > 0 || "Provide at least one incident field." },
+      notify_incident_channel: { type: "boolean", required: true }
+    }, ({ id, ...body }) => ({ method: "POST", url: address(`/v2/incidents/${id}/actions/edit`), body }), result("incident")),
+    "followUps.list": jsonOperation(address("/v2/follow_ups"), { incident_id: optionalId, assignee_team_id: optionalId,
+      incident_mode: { type: "string", enum: ["standard", "retrospective", "test", "tutorial", "stream"] }
+    }, value => Array.isArray(value?.follow_ups)),
+    "followUps.create": validatedOperation({ ...followUpFields, incident_id: id }, body => ({ method: "POST", url: address("/v2/follow_ups"), body }), result("follow_up")),
+    "followUps.update": validatedOperation({ id, ...followUpFields, status: { type: "string", required: true, enum: ["outstanding", "completed", "deleted", "not_doing"] }
+    }, ({ id, ...body }) => ({ method: "PUT", url: address(`/v2/follow_ups/${id}`), body }), result("follow_up")),
+    "alerts.list": jsonOperation(address("/v2/alerts"), { page_size: page(50), after }, value => Array.isArray(value?.alerts)),
+    "alerts.resolve": validatedOperation({ id }, ({ id }) => ({ method: "POST", url: address(`/v2/alerts/${id}/actions/resolve`), body: {} }), result("alert")),
+    "schedules.list": jsonOperation(address("/v2/schedules"), { page_size: page(25), after }, value => Array.isArray(value?.schedules)),
+    "catalog.types": jsonOperation(address("/v3/catalog_types"), {}, value => Array.isArray(value?.catalog_types)),
+    "catalog.list": jsonOperation(address("/v3/catalog_entries"), { catalog_type_id: id, page_size: page(250), after, identifier: text }, value => Array.isArray(value?.catalog_entries)),
+    "catalog.create": validatedOperation({ catalog_type_id: id, name: { ...text, required: true, maxLength: 1000 }, external_id: text,
+      attribute_values: attributes
+    }, body => ({ method: "POST", url: address("/v3/catalog_entries"), body }), result("catalog_entry")),
+    "catalog.update": validatedOperation({ id, name: { ...text, required: true, maxLength: 1000 }, external_id: text,
+      attribute_values: attributes
+    }, ({ id, ...body }) => ({ method: "PUT", url: address(`/v3/catalog_entries/${id}`), body }), result("catalog_entry")),
+    "incidents.list": jsonOperation("https://api.incident.io/v2/incidents", {
+      page_size: { type: "integer", min: 1, max: 500, defaultTo: 25 },
+      after: { type: "string", maxLength: 4096 },
+      sort_by: { type: "string", enum: ["created_at_newest_first", "created_at_oldest_first"], defaultTo: "created_at_newest_first" }
+    }, (result) => Array.isArray(result?.incidents) && (result.pagination_meta === undefined || Number.isInteger(result.pagination_meta?.page_size)))
+  }
+});
+export { incidentIoProvider };

package/src/server/inngest.js

@@ -0,0 +1,86 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { inngestDefinition } from "../shared/inngest.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const api = "https://api.inngest.com/v2";
+const eventEndpoint = "https://inn.gs/e/";
+const pageFields = {
+  limit: { type: "integer", min: 1, max: 100, defaultTo: 20 },
+  cursor: { type: "string", minLength: 1, maxLength: 4096 }
+};
+const functionsSchema = createSchema({
+  appId: { type: "string", required: true, minLength: 1, maxLength: 255,
+    validator: (value) => ![".", ".."].includes(value) && !/[\p{Cc}]/u.test(value) || "Enter a valid Inngest app ID." },
+  ...pageFields
+});
+const eventSchema = createSchema({
+  name: { type: "string", required: true, minLength: 1, maxLength: 255,
+    validator: (value) => Boolean(value.trim()) && !/[\p{Cc}]/u.test(value) || "Enter an event name without control characters." },
+  data: { type: "object", required: true },
+  id: { type: "string", minLength: 1, maxLength: 512 },
+  ts: { type: "integer", min: 315532800000, max: Number.MAX_SAFE_INTEGER },
+  v: { type: "string", minLength: 1, maxLength: 255 },
+  user: { type: "object" }
+});
+
+function validPage(result) {
+  return Array.isArray(result?.data) && result.data.every((item) => typeof item?.id === "string" && item.id.length > 0) &&
+    typeof result.page?.hasMore === "boolean" && Number.isInteger(result.page.limit) && result.page.limit >= 1 &&
+    (result.page.cursor == null || typeof result.page.cursor === "string");
+}
+
+const inngestProvider = Object.freeze({
+  ...inngestDefinition,
+  apiOrigins: ["https://api.inngest.com", "https://inn.gs"],
+  apiKey: { headers: (key) => ({ Authorization: `Bearer ${key}` }) },
+  checkOperation: "apps.list",
+  async exchange(url, options, { request, resolveReference }) {
+    if (url !== eventEndpoint) return request(url, options);
+    const { eventKeyRef, branchEnvironment, event } = options.body;
+    let key;
+    try {
+      key = await resolveReference(eventKeyRef);
+      if (typeof key !== "string" || !key.trim() || /[\p{Cc}]/u.test(key)) throw new Error("Invalid Event Key.");
+    } catch {
+      throw new ConnectorError("connector_binding_missing", "The Inngest Event Key binding is missing or invalid.");
+    }
+    options.signal.throwIfAborted();
+    // The Event API uses only the Event Key in its path. Never forward the Signing Key.
+    return request(`${eventEndpoint}${encodeURIComponent(key)}`, {
+      ...options, body: event,
+      headers: { Accept: "application/json", ...(branchEnvironment ? { "x-inngest-env": branchEnvironment } : {}) }
+    });
+  },
+  operations: {
+    "apps.list": jsonOperation(`${api}/apps`, { ...pageFields, archived: { type: "boolean", defaultTo: false } }, validPage),
+    "functions.list": {
+      scopes: [],
+      request(input) {
+        const { appId, ...query } = validateSchemaPayload({ schema: functionsSchema, mode: "replace" }, input, { statusCode: 422 });
+        const url = new URL(`${api}/apps/${encodeURIComponent(appId)}/functions`);
+        for (const [name, value] of Object.entries(query)) url.searchParams.set(name, value);
+        return { method: "GET", url: url.href };
+      },
+      validateResult: validPage
+    },
+    "events.send": {
+      scopes: [],
+      request(input, settings) {
+        const event = validateSchemaPayload({ schema: eventSchema, mode: "replace" }, input, { statusCode: 422 });
+        return { method: "POST", url: eventEndpoint,
+          body: { event, eventKeyRef: settings.eventKeyRef, branchEnvironment: settings.branchEnvironment } };
+      },
+      validateResult(result) {
+        if (result?.status === 401) throw new ConnectorError("connector_reconnect_required", "Configure a valid Inngest Event Key and reconnect.", { statusCode: 401 });
+        if (result?.status === 403) throw new ConnectorError("connector_permission_denied", "Inngest denied this event.", { statusCode: 403 });
+        if (result?.status === 429) throw new ConnectorError("connector_rate_limited", "Inngest's event limit was reached.", { statusCode: 429 });
+        return result?.status === 200 && !result.error && Array.isArray(result.ids) && result.ids.length === 1 &&
+          result.ids.every((id) => typeof id === "string" && id.length > 0);
+      }
+    }
+  }
+});
+
+export { inngestProvider };