@jskit-ai/connectors-catalog 0.1.1

package/src/server/elevenlabs.js

@@ -0,0 +1,81 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { elevenlabsDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const voiceId = { type: "string", required: true, minLength: 1, maxLength: 128, pattern: "^[A-Za-z0-9_-]+$" };
+const speechSchema = createSchema({
+  voiceId, text: { type: "string", required: true, minLength: 1, maxLength: 5000 },
+  model_id: { type: "string", required: true, minLength: 1, maxLength: 128, pattern: "^[A-Za-z0-9_-]+$" },
+  output_format: { type: "string", enum: ["mp3_44100_128", "mp3_22050_32", "pcm_16000", "ulaw_8000"], defaultTo: "mp3_44100_128" },
+  language_code: { type: "string", pattern: "^[a-z]{2}$" },
+  voice_settings: { type: "object", schema: createSchema({
+    stability: { type: "number", min: 0, max: 1 }, similarity_boost: { type: "number", min: 0, max: 1 },
+    style: { type: "number", min: 0, max: 1 }, use_speaker_boost: { type: "boolean" }, speed: { type: "number", min: 0.7, max: 1.2 }
+  }) }
+});
+const cloneSchema = createSchema({
+  name: { type: "string", required: true, minLength: 1, maxLength: 100 },
+  description: { type: "string", maxLength: 1000 },
+  consentConfirmed: { type: "boolean", required: true, validator: value => value === true || "Confirm permission to clone this voice." },
+  remove_background_noise: { type: "boolean", defaultTo: false },
+  files: { type: "array", required: true, validator: value => (value.length >= 1 && value.length <= 5) || "Supply one to five audio samples.",
+    items: { type: "object", schema: createSchema({
+      name: { type: "string", required: true, minLength: 1, maxLength: 100, pattern: "^[A-Za-z0-9_.-]+$" },
+      contentType: { type: "string", required: true, enum: ["audio/mpeg", "audio/wav", "audio/x-wav", "audio/mp4", "audio/flac", "audio/ogg"] },
+      base64: { type: "string", required: true, minLength: 4, maxLength: 12 * 1024 * 1024,
+        validator: value => (/^[A-Za-z0-9+/]*={0,2}$/u.test(value) && Buffer.from(value, "base64").toString("base64") === value) || "Supply canonical base64 audio." }
+    }) } }
+});
+const elevenlabsProvider = Object.freeze({
+  ...elevenlabsDefinition, apiOrigins: ["https://api.elevenlabs.io"],
+  apiKey: { headers: (key) => ({ "xi-api-key": key }) },
+  checkOperation: "account.read",
+  async exchange(url, options, { request, fetchImpl }) {
+    if (!new URL(url).pathname.startsWith("/v1/text-to-speech/")) return request(url, options);
+    const response = await fetchImpl(url, { ...options, body: JSON.stringify(options.body),
+      headers: { ...options.headers, "Content-Type": "application/json", Accept: "audio/*" }, credentials: "omit", redirect: "error" });
+    if (!response.ok) { await response.body?.cancel(); throw Object.assign(new Error("ElevenLabs speech request failed."), { status: response.status }); }
+    const contentType = response.headers.get("content-type")?.split(";")[0] || "application/octet-stream";
+    if (!contentType.startsWith("audio/") && contentType !== "application/octet-stream") {
+      await response.body?.cancel(); throw new ConnectorError("connector_response_invalid", "ElevenLabs did not return audio.", { statusCode: 502 });
+    }
+    const reader = response.body?.getReader(); const chunks = []; let size = 0;
+    if (reader) try {
+      while (true) {
+        const { done, value } = await reader.read(); if (done) break;
+        size += value.byteLength;
+        if (size > 16 * 1024 * 1024) { await reader.cancel(); throw new ConnectorError("connector_response_too_large", "Use native streaming for audio above 16 MiB.", { statusCode: 413 }); }
+        chunks.push(value);
+      }
+    } finally { reader.releaseLock(); }
+    if (!size) throw new ConnectorError("connector_response_invalid", "ElevenLabs returned empty audio.", { statusCode: 502 });
+    return { bodyBase64: Buffer.concat(chunks).toString("base64"), contentType, size };
+  },
+  operations: {
+    "speech.create": { scopes: [], request(input) {
+      const { voiceId, output_format, ...body } = validateSchemaPayload({ schema: speechSchema, mode: "replace" }, input, { statusCode: 422 });
+      return { method: "POST", url: `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}?output_format=${output_format}`, body };
+    }, validateResult: result => typeof result?.bodyBase64 === "string" && result.size > 0 },
+    "voices.clone": { scopes: [], request(input) {
+      const { files, consentConfirmed, ...values } = validateSchemaPayload({ schema: cloneSchema, mode: "replace" }, input, { statusCode: 422 });
+      const body = new FormData(); let total = 0;
+      for (const file of files) {
+        const bytes = Buffer.from(file.base64, "base64"); total += bytes.byteLength;
+        if (total > 16 * 1024 * 1024) throw new ConnectorError("connector_input_invalid", "Audio samples must total at most 16 MiB.", { statusCode: 422 });
+        body.append("files", new Blob([bytes], { type: file.contentType }), file.name);
+      }
+      for (const [key, value] of Object.entries(values)) body.append(key, String(value));
+      return { method: "POST", url: "https://api.elevenlabs.io/v1/voices/add", body };
+    }, validateResult: result => typeof result?.voice_id === "string" && typeof result.requires_verification === "boolean" },
+    "models.list": jsonOperation("https://api.elevenlabs.io/v1/models", {}, Array.isArray),
+    "account.read": jsonOperation("https://api.elevenlabs.io/v1/user", {}, (result) => typeof result?.user_id === "string"),
+    "voices.list": jsonOperation("https://api.elevenlabs.io/v2/voices", {
+      search: { type: "string", maxLength: 4096 },
+      page_size: { type: "integer", min: 1, max: 100, defaultTo: 10 },
+      next_page_token: { type: "string", minLength: 1, maxLength: 4096 }
+    }, (result) => Array.isArray(result?.voices) && typeof result.has_more === "boolean")
+  }
+});
+export { elevenlabsProvider };

package/src/server/figma.js

@@ -0,0 +1,24 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { figmaDefinition } from "../shared/figma.js";
+import { mcpOperations, exchangeMcp } from "./mcpTransport.js";
+import { mcpRegistrationFields, registerMcpClient } from "./mcpRegistration.js";
+
+const resource = "https://mcp.figma.com/mcp";
+const oauth = Object.freeze({
+  issuer: "https://api.figma.com", authorization_endpoint: "https://www.figma.com/oauth/mcp",
+  token_endpoint: "https://api.figma.com/v1/oauth/token", registration_endpoint: "https://api.figma.com/v1/oauth/mcp/register",
+  response_types_supported: ["code"], authorization_response_iss_parameter_supported: true
+});
+const figmaProvider = Object.freeze({
+  ...figmaDefinition, oauth, oauthResource: resource, apiOrigins: ["https://mcp.figma.com"],
+  checkOperation: "tools.list", exchange: exchangeMcp, operations: mcpOperations(() => resource)
+});
+const registrationSchema = createSchema(mcpRegistrationFields);
+
+async function registerFigmaClient(input, options) {
+  const values = validateSchemaPayload({ schema: registrationSchema, mode: "replace" }, input, { statusCode: 422 });
+  return registerMcpClient("Figma", oauth, { ...values, scopes: ["mcp:connect"] }, options);
+}
+
+export { figmaProvider, registerFigmaClient };

package/src/server/firebase-cloud-messaging.js

@@ -0,0 +1,111 @@
+import { importPKCS8, SignJWT } from "jose";
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { firebaseCloudMessagingDefinition, firebaseMessagingScope, firebaseProjectId } from "../shared/firebase-cloud-messaging.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const tokenUrl = "https://oauth2.googleapis.com/token";
+const endpoint = ({ projectId }) => `https://fcm.googleapis.com/v1/projects/${projectId}/messages:send`;
+const credentialSchema = createSchema({ project_id: firebaseProjectId });
+const invalidCredential = () => new ConnectorError("connector_binding_missing", "Use a valid Firebase service-account JSON credential for the default Google API domain.");
+
+async function serviceAccountGrant({ credential, scopes, fetchImpl, signal, now }) {
+  let account, key;
+  try {
+    account = JSON.parse(credential);
+    if (account?.type !== "service_account" || account.token_uri !== tokenUrl ||
+      (account.universe_domain !== undefined && account.universe_domain !== "googleapis.com") ||
+      typeof account.client_email !== "string" || !/^[a-z0-9][a-z0-9._-]*@(?:[a-z0-9-]+\.iam|developer)\.gserviceaccount\.com$/u.test(account.client_email) ||
+      typeof account.private_key_id !== "string" || !/^[a-f0-9]{1,128}$/u.test(account.private_key_id) ||
+      typeof account.private_key !== "string") throw invalidCredential();
+    validateSchemaPayload({ schema: credentialSchema, mode: "replace" }, { project_id: account.project_id });
+    key = await importPKCS8(account.private_key, "RS256");
+  } catch { throw invalidCredential(); }
+  const seconds = Math.floor(now / 1000);
+  const assertion = await new SignJWT({ scope: scopes.join(" ") })
+    .setProtectedHeader({ alg: "RS256", typ: "JWT", kid: account.private_key_id })
+    .setIssuer(account.client_email).setAudience(tokenUrl).setIssuedAt(seconds).setExpirationTime(seconds + 3600).sign(key);
+  signal.throwIfAborted();
+  const response = await fetchImpl(tokenUrl, {
+    method: "POST", redirect: "error", credentials: "omit", signal,
+    headers: { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" },
+    body: new URLSearchParams({ grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer", assertion }).toString()
+  });
+  if (response.redirected || (response.status >= 300 && response.status < 400)) {
+    throw new ConnectorError("connector_response_invalid", "Google returned an unexpected token redirect.", { statusCode: 502 });
+  }
+  let value;
+  try { value = await response.json(); } catch {
+    throw new ConnectorError("connector_response_invalid", "Google returned an invalid token response.", { statusCode: 502 });
+  }
+  if (!response.ok) {
+    const denied = response.status === 401 || ["invalid_grant", "invalid_client"].includes(value?.error);
+    throw new ConnectorError(denied ? "connector_reconnect_required" : response.status === 403 ? "connector_permission_denied" : response.status === 429 ? "connector_rate_limited" : "connector_provider_failed",
+      "Google could not authorize the service account. Check the credential and project permissions.", { statusCode: denied ? 401 : [403, 429].includes(response.status) ? response.status : 502 });
+  }
+  return value;
+}
+
+const target = { type: "string", noTrim: true, minLength: 1, maxLength: 4096, pattern: "^[^\\s]+$" };
+const notification = createSchema({
+  title: { type: "string", noTrim: true, maxLength: 1024 }, body: { type: "string", noTrim: true, maxLength: 4096 },
+  image: { type: "string", maxLength: 2048, validator: (value) => {
+    try { const url = new URL(value); return (url.protocol === "https:" && !url.username && !url.password) || "Use an HTTPS image URL."; } catch { return "Use an HTTPS image URL."; }
+  } }
+});
+const messageSchema = createSchema({
+  fid: { ...target, maxLength: 128 }, token: target,
+  topic: { ...target, maxLength: 900, pattern: "^[A-Za-z0-9_.~%\\-]+$" },
+  condition: { type: "string", noTrim: true, minLength: 1, maxLength: 2048 },
+  notification: { type: "object", schema: notification },
+  data: { type: "object", additionalProperties: true, validator: (value) => Object.entries(value).every(([key, item]) =>
+    key.length > 0 && !["from", "message_type"].includes(key) && !key.startsWith("google.") && !key.startsWith("gcm.notification.") && typeof item === "string") || "Use string values and non-reserved Firebase data keys." }
+});
+const messageFields = { message: { type: "object", required: true, schema: messageSchema,
+  validator: (value) => (["fid", "token", "topic", "condition"].filter((key) => Object.hasOwn(value, key)).length === 1 &&
+    ((value.notification && Object.values(value.notification).some(Boolean)) || Object.keys(value.data || {}).length > 0) &&
+    new TextEncoder().encode(JSON.stringify(value)).length <= (value.topic || value.condition ? 2048 : 4096)) || "Supply one target and a notification or data payload within the message size limit." } };
+const receipt = (value) => typeof value?.name === "string" && /^projects\/[^/\s]+\/messages\/[^/\s]+$/u.test(value.name);
+function messageOperation(validateOnly) {
+  const operation = jsonOperation(endpoint, messageFields, receipt, "POST");
+  return { ...operation, scopes: [firebaseMessagingScope], request(input, settings) {
+    const request = operation.request(input, settings);
+    return { ...request, body: { ...request.body, validate_only: validateOnly } };
+  } };
+}
+const check = jsonOperation(endpoint, {}, receipt, "POST");
+const firebaseCloudMessagingProvider = Object.freeze({
+  ...firebaseCloudMessagingDefinition, apiOrigins: ["https://fcm.googleapis.com"], serviceAccountGrant,
+  checkOperation: "connection.check",
+  operations: {
+    "connection.check": { ...check, scopes: [firebaseMessagingScope], request(input, settings) {
+      return { ...check.request(input, settings), body: { validate_only: true, message: { topic: "jskit-connection-check", data: { connectionCheck: "true" } } } };
+    } },
+    "messages.validate": messageOperation(true), "messages.send": messageOperation(false)
+  },
+  async exchange(address, options, { fetchImpl, settings }) {
+    const response = await fetchImpl(address, { ...options, body: JSON.stringify(options.body), credentials: "omit", redirect: "error",
+      headers: { ...options.headers, "Content-Type": "application/json" } });
+    let result;
+    try { result = await response.json(); }
+    catch { throw new ConnectorError("connector_response_invalid", "Firebase returned invalid message JSON.", { statusCode: 502 }); }
+    if (!response.ok) {
+      const details = result?.error?.details;
+      const fcmError = Array.isArray(details) ? details.find(detail => detail?.["@type"] === "type.googleapis.com/google.firebase.fcm.v1.FcmError")?.errorCode : undefined;
+      if (response.status === 404 && fcmError === "UNREGISTERED" && (options.body.message.token || options.body.message.fid)) {
+        throw new ConnectorError("connector_recipient_unregistered", "This Firebase recipient is no longer registered. Remove its association and wait for client registration again.", { statusCode: 410 });
+      }
+      if (response.status === 400) {
+        throw new ConnectorError("connector_message_invalid", "Firebase rejected the message or target. Do not delete a registration unless the payload is known to be valid.", { statusCode: 422 });
+      }
+      throw Object.assign(new Error("Firebase message request failed."), { status: response.status });
+    }
+    if (!receipt(result) || !result.name.startsWith(`projects/${settings.projectId}/messages/`)) {
+      throw new ConnectorError("connector_response_invalid", "Firebase returned an unexpected message receipt.", { statusCode: 502 });
+    }
+    return result;
+  }
+});
+
+export { firebaseCloudMessagingProvider };

package/src/server/firecrawl.js

@@ -0,0 +1,70 @@
+import { validatedOperation } from "./jsonOperation.js";
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { firecrawlDefinition } from "../shared/definitions.js";
+
+const empty = createSchema({});
+const pageUrl = {
+    type: "string", required: true, minLength: 1, maxLength: 8192,
+    validator(value) {
+      try {
+        const url = new URL(value);
+        return (["https:", "http:"].includes(url.protocol) && !url.username && !url.password) || "Use an HTTP or HTTPS page URL without credentials.";
+      } catch { return "Use an HTTP or HTTPS page URL without credentials."; }
+    }
+};
+const scrape = createSchema({ url: pageUrl,
+  onlyMainContent: { type: "boolean", defaultTo: true }
+});
+
+const jobId = { type: "string", required: true, pattern: "^[A-Za-z0-9-]{1,128}$" };
+const firecrawlProvider = Object.freeze({
+  ...firecrawlDefinition,
+  apiOrigins: ["https://api.firecrawl.dev"],
+  apiKey: { headers: (key) => ({ Authorization: `Bearer ${key}` }) },
+  checkOperation: "credits.read",
+  operations: {
+    "pages.search": validatedOperation({ query: { type: "string", required: true, minLength: 1, maxLength: 4096 },
+      limit: { type: "integer", min: 1, max: 100, defaultTo: 5 }, includeContent: { type: "boolean", defaultTo: false }
+    }, ({ includeContent, ...body }) => ({ method: "POST", url: "https://api.firecrawl.dev/v2/search", body: {
+      ...body, sources: ["web"], ...(includeContent ? { scrapeOptions: { formats: ["markdown"] } } : {})
+    } }), result => result?.success === true && Array.isArray(result.data?.web)),
+    "sites.map": validatedOperation({ url: pageUrl, limit: { type: "integer", required: true, min: 1, max: 1000 }, search: { type: "string", minLength: 1, maxLength: 1000 } },
+      body => ({ method: "POST", url: "https://api.firecrawl.dev/v2/map", body }), result => result?.success === true && Array.isArray(result.links)),
+    "pages.extract": validatedOperation({ url: pageUrl, schema: { type: "object", required: true, additionalProperties: true,
+      validator: value => JSON.stringify(value).length <= 32000 || "Use a schema below 32,000 characters." }, prompt: { type: "string", maxLength: 4000 }
+    }, ({ url, schema, prompt }) => ({ method: "POST", url: "https://api.firecrawl.dev/v2/scrape", body: { url, formats: [{ type: "json", schema, ...(prompt ? { prompt } : {}) }] } }),
+      result => result?.success === true && result.data != null && Object.hasOwn(result.data, "json")),
+    "crawls.start": validatedOperation({ url: pageUrl, limit: { type: "integer", required: true, min: 1, max: 1000 },
+      maxDiscoveryDepth: { type: "integer", min: 0, max: 10, defaultTo: 2 }
+    }, body => ({ method: "POST", url: "https://api.firecrawl.dev/v2/crawl", body: { ...body,
+      allowExternalLinks: false, allowSubdomains: false, scrapeOptions: { formats: ["markdown"], onlyMainContent: true }
+    } }), result => result?.success === true && typeof result.id === "string"),
+    "crawls.get": validatedOperation({ id: jobId, next: { type: "string", maxLength: 8192 } }, ({ id, next }) => {
+      const expected = `https://api.firecrawl.dev/v2/crawl/${id}`;
+      let url; try { url = new URL(next || expected); } catch { throw new ConnectorError("connector_input_invalid", "Use the returned next-page URL for this crawl."); }
+      if (url.origin + url.pathname !== expected || url.username || url.password || url.hash) throw new ConnectorError("connector_input_invalid", "Use the returned next-page URL for this crawl.");
+      return { method: "GET", url: url.href };
+    }, result => typeof result?.status === "string" && Array.isArray(result.data) && Number.isInteger(result.total) && result.total >= 0 && Number.isInteger(result.completed) && result.completed >= 0),
+    "crawls.errors": validatedOperation({ id: jobId }, ({ id }) => ({ method: "GET", url: `https://api.firecrawl.dev/v2/crawl/${id}/errors` }), result => Array.isArray(result?.errors)),
+    "crawls.cancel": validatedOperation({ id: jobId }, ({ id }) => ({ method: "DELETE", url: `https://api.firecrawl.dev/v2/crawl/${id}` }), result => result?.status === "cancelled" || result?.success === true),
+    "credits.read": {
+      scopes: [],
+      request(input) {
+        validateSchemaPayload({ schema: empty, mode: "replace" }, input, { statusCode: 422 });
+        return { method: "GET", url: "https://api.firecrawl.dev/v2/team/credit-usage" };
+      },
+      validateResult: (result) => result?.success === true && Number.isFinite(result.data?.remainingCredits)
+    },
+    "pages.scrape": {
+      scopes: [],
+      request(input) {
+        const body = validateSchemaPayload({ schema: scrape, mode: "replace" }, input, { statusCode: 422 });
+        return { method: "POST", url: "https://api.firecrawl.dev/v2/scrape", body: { ...body, formats: ["markdown"] } };
+      },
+      validateResult: (result) => result?.success === true && typeof result.data?.markdown === "string"
+    }
+  }
+});
+export { firecrawlProvider };

package/src/server/fireflies.js

@@ -0,0 +1,31 @@
+import { firefliesDefinition } from "../shared/tokens.js";
+import { graphqlOperation } from "./graphqlOperation.js";
+
+const firefliesProvider = Object.freeze({
+  ...firefliesDefinition, apiOrigins: ["https://api.fireflies.ai"],
+  apiKey: { headers: (key) => ({ Authorization: `Bearer ${key}` }) },
+  checkOperation: "profile.read",
+  operations: {
+    "profile.read": graphqlOperation("https://api.fireflies.ai/graphql", "query ConnectorUser { user { user_id name email } }", {},
+      (data) => typeof data?.user?.user_id === "string"),
+    "transcripts.get": graphqlOperation("https://api.fireflies.ai/graphql",
+      "query ConnectorTranscript($id: String!) { transcript(id: $id) { id title date duration participants calendar_type meeting_link transcript_url speakers { id name } sentences { index speaker_name speaker_id text start_time end_time } summary { keywords action_items outline overview } } }", {
+        id: { type: "string", required: true, minLength: 1, maxLength: 256 }
+      }, data => typeof data?.transcript?.id === "string" && (data.transcript.sentences === null || Array.isArray(data.transcript.sentences))),
+    "transcripts.search": graphqlOperation("https://api.fireflies.ai/graphql",
+      "query ConnectorSearch($keyword: String!, $scope: TranscriptsQueryScope!, $limit: Int!, $skip: Int!, $mine: Boolean!) { transcripts(keyword: $keyword, scope: $scope, limit: $limit, skip: $skip, mine: $mine) { id title date duration participants } }", {
+        keyword: { type: "string", required: true, minLength: 1, maxLength: 255 },
+        scope: { type: "string", enum: ["title", "sentences", "all"], defaultTo: "all" },
+        limit: { type: "integer", min: 1, max: 50, defaultTo: 25 },
+        skip: { type: "integer", min: 0, max: 2147483647, defaultTo: 0 },
+        mine: { type: "boolean", defaultTo: true }
+      }, data => Array.isArray(data?.transcripts)),
+    "transcripts.list": graphqlOperation("https://api.fireflies.ai/graphql",
+      "query ConnectorTranscripts($limit: Int!, $skip: Int!, $mine: Boolean!) { transcripts(limit: $limit, skip: $skip, mine: $mine) { id title } }", {
+        limit: { type: "integer", min: 1, max: 50, defaultTo: 25 },
+        skip: { type: "integer", min: 0, max: 2147483647, defaultTo: 0 },
+        mine: { type: "boolean", defaultTo: true }
+      }, (data) => Array.isArray(data?.transcripts))
+  }
+});
+export { firefliesProvider };

package/src/server/fireworks-ai.js

@@ -0,0 +1,16 @@
+import { fireworksAiDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const fireworksAiProvider = Object.freeze({
+  ...fireworksAiDefinition, apiOrigins: ["https://api.fireworks.ai"],
+  apiKey: { headers: (key) => ({ Authorization: `Bearer ${key}`, "Content-Type": "application/json" }) },
+  checkOperation: "accounts.list",
+  operations: {
+    "accounts.list": jsonOperation("https://api.fireworks.ai/v1/accounts", {
+      pageSize: { type: "integer", min: 1, max: 200, defaultTo: 50 },
+      pageToken: { type: "string", maxLength: 4096 },
+      filter: { type: "string", maxLength: 2048 }
+    }, (result) => Array.isArray(result?.accounts))
+  }
+});
+export { fireworksAiProvider };

package/src/server/gatewayapi.js

@@ -0,0 +1,48 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { createSchema } from "json-rest-schema";
+import { gatewayApiDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const origins = { global: "https://gatewayapi.com", eu: "https://gatewayapi.eu" };
+const messagingOrigins = { global: "https://messaging.gatewayapi.com", eu: "https://messaging.gatewayapi.eu" };
+const messageFields = {
+  sender: { type: "string", required: true, minLength: 3, maxLength: 15,
+    validator: value => (/^[0-9]{3,15}$/.test(value) || /^[A-Za-z0-9]{3,11}$/.test(value)) || "Use 3–11 alphanumeric or 3–15 numeric sender characters." },
+  recipient: { type: "integer", required: true, min: 1001, max: 999999999999999 },
+  message: { type: "string", required: true, minLength: 1, maxLength: 39015 },
+  reference: { type: "string", required: true, minLength: 1, maxLength: 256 },
+  label: { type: "string", maxLength: 128 },
+  priority: { type: "string", enum: ["normal", "urgent"], defaultTo: "normal" }
+};
+const messageSchema = createSchema(messageFields);
+const validReceipt = result => typeof result?.msg_id === "string" && Number.isSafeInteger(result.recipient) && (typeof result.reference === "string" || result.reference === null);
+const gatewayApiProvider = Object.freeze({
+  ...gatewayApiDefinition, apiOrigins: [...Object.values(origins), ...Object.values(messagingOrigins)],
+  apiKey: { headers: (key) => ({ Authorization: `Token ${key}` }) },
+  checkOperation: "balance.read",
+  operations: {
+    "messages.send": jsonOperation(settings => `${messagingOrigins[settings.region]}/mobile/single`, messageFields, validReceipt, "POST"),
+    "messages.sendBatch": jsonOperation(settings => `${messagingOrigins[settings.region]}/mobile/multi`, {
+      messages: { type: "array", required: true, items: { type: "object", schema: messageSchema },
+        validator: value => value.length >= 1 && value.length <= 1000 || "Send 1–1000 messages per batch." }
+    }, result => Array.isArray(result?.responses) && result.responses.every(validReceipt), "POST"),
+    "balance.read": jsonOperation((settings) => `${origins[settings.region]}/rest/me`, {},
+      (result) => Number.isInteger(result?.id) && typeof result.credit === "string" && typeof result.currency === "string")
+  }
+});
+// Call at the application's webhook route before trusting or persisting its body.
+function verifyGatewayApiEvent({ rawBody, signature, secret }) {
+  if (!(rawBody instanceof Uint8Array) || rawBody.byteLength > 1048576 || typeof secret !== "string" || secret.length < 1 || typeof signature !== "string" || !/^v1=[a-fA-F0-9]{64}$/.test(signature)) {
+    throw new ConnectorError("connector_webhook_invalid", "Invalid GatewayAPI webhook signature.");
+  }
+  const expected = createHmac("sha256", secret).update(rawBody).digest();
+  if (!timingSafeEqual(expected, Buffer.from(signature.slice(3), "hex"))) throw new ConnectorError("connector_webhook_invalid", "Invalid GatewayAPI webhook signature.");
+  let event;
+  try { event = JSON.parse(Buffer.from(rawBody).toString("utf8")); } catch { throw new ConnectorError("connector_webhook_invalid", "Invalid GatewayAPI webhook event."); }
+  if (typeof event?.event_id !== "string" || !event.event_id || typeof event.event_type !== "string" || !Number.isFinite(Date.parse(event.timestamp)) || !event.event || typeof event.event !== "object" || Array.isArray(event.event)) {
+    throw new ConnectorError("connector_webhook_invalid", "Invalid GatewayAPI webhook event.");
+  }
+  return event;
+}
+export { gatewayApiProvider, verifyGatewayApiEvent };

package/src/server/gemini-enterprise.js

@@ -0,0 +1,47 @@
+import { createSchema } from "json-rest-schema";
+import { geminiEnterpriseDefinition, geminiEnterpriseScope } from "../shared/gemini-enterprise.js";
+import { googleProvider } from "./google.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+function apiOrigin({ location = "global" } = {}) {
+  return `https://${location === "global" ? "" : `${location}-`}discoveryengine.googleapis.com`;
+}
+function engineUrl(settings) {
+  return `${apiOrigin(settings)}/v1/projects/${settings.projectId}/locations/${settings.location || "global"}/collections/default_collection/engines/${settings.engineId}`;
+}
+const object = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const text = (value) => typeof value === "string" && value.length > 0;
+const geminiEnterpriseProvider = Object.freeze({
+  ...googleProvider(geminiEnterpriseDefinition, apiOrigin(), "engine.get", {
+    "engine.get": {
+      ...jsonOperation(engineUrl, {}, (result) => object(result) && !result.error && text(result.displayName)
+        && typeof result.name === "string" && /^projects\/[a-z0-9-]+\/locations\/(global|us|eu)\/collections\/default_collection\/engines\/[a-z0-9][a-z0-9_-]{0,62}$/u.test(result.name)),
+      scopes: [geminiEnterpriseScope]
+    },
+    search: {
+      ...jsonOperation((settings) => `${engineUrl(settings)}/servingConfigs/default_serving_config:search`, {
+        query: { type: "string", required: true, minLength: 1, maxLength: 4096, noTrim: true },
+        pageSize: { type: "integer", min: 1, max: 25, defaultTo: 10 },
+        contentSearchSpec: { type: "object", schema: createSchema({
+          snippetSpec: { type: "object", schema: createSchema({ returnSnippet: { type: "boolean", required: true } }) },
+          summarySpec: { type: "object", schema: createSchema({
+            summaryResultCount: { type: "integer", required: true, min: 1, max: 10 },
+            includeCitations: { type: "boolean", defaultTo: true },
+            ignoreAdversarialQuery: { type: "boolean", defaultTo: true },
+            ignoreNonSummarySeekingQuery: { type: "boolean", defaultTo: true },
+            ignoreLowRelevantContent: { type: "boolean", defaultTo: true }
+          }) }
+        }) },
+        pageToken: { type: "string", minLength: 1, maxLength: 16000, noTrim: true }
+      }, (result) => object(result) && !result.error && text(result.attributionToken)
+        && (result.totalSize === undefined || Number.isInteger(result.totalSize) && result.totalSize >= 0)
+        && (result.nextPageToken === undefined || typeof result.nextPageToken === "string")
+        && (result.redirectUri === undefined || typeof result.redirectUri === "string")
+        && (result.results === undefined || Array.isArray(result.results) && result.results.length <= 25
+          && result.results.every((item) => object(item) && text(item.id) && object(item.document))), "POST"),
+      scopes: [geminiEnterpriseScope]
+    }
+  }),
+  apiOrigins: (settings) => [apiOrigin(settings)]
+});
+export { geminiEnterpriseProvider };

package/src/server/github-api.js

@@ -0,0 +1,90 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { githubApiDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+async function normalizeTokenResponse(response) {
+  if (!response.ok) return response;
+  let value;
+  try { value = await response.clone().json(); } catch {
+    throw new ConnectorError("connector_response_invalid", "GitHub returned an invalid token response.", { statusCode: 502 });
+  }
+  if (value.error || value.scope === undefined) return response;
+  if (typeof value.scope !== "string" || !/^[a-zA-Z0-9_:.-]*(?:,[a-zA-Z0-9_:.-]+)*$/u.test(value.scope)) {
+    throw new ConnectorError("connector_response_invalid", "GitHub returned an invalid permission grant.", { statusCode: 502 });
+  }
+  return Response.json({ ...value, scope: value.scope.replaceAll(",", " ") }, { status: response.status });
+}
+
+const repositoryFields = {
+  owner: { type: "string", required: true, minLength: 1, maxLength: 100, pattern: "^[A-Za-z0-9][A-Za-z0-9-]*$" },
+  repo: { type: "string", required: true, minLength: 1, maxLength: 100, pattern: "^[A-Za-z0-9_][A-Za-z0-9_.-]*$" }
+};
+const pageFields = { per_page: { type: "integer", min: 1, max: 100, defaultTo: 30 }, page: { type: "integer", min: 1, max: 1000000, defaultTo: 1 } };
+const numberField = { type: "integer", required: true, min: 1, max: Number.MAX_SAFE_INTEGER };
+const issueResult = value => Number.isSafeInteger(value?.number) && typeof value.title === "string";
+function repositoryOperation(suffix, fields, validateResult, method = "GET") {
+  const schema = createSchema({ ...repositoryFields, ...fields });
+  return { scopes: [], request(input) {
+    const { owner, repo, number, path, ...values } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+    const tail = typeof suffix === "function" ? suffix({ number, path }) : suffix;
+    const url = new URL(`https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}${tail}`);
+    if (method === "GET") {
+      for (const [key, value] of Object.entries(values)) url.searchParams.set(key, String(value));
+      return { method, url: url.href };
+    }
+    if (!Object.keys(values).length) throw new ConnectorError("connector_input_invalid", "Supply at least one change.");
+    return { method, url: url.href, body: values };
+  }, validateResult };
+}
+const issueChanges = { title: { type: "string", minLength: 1, maxLength: 256 }, body: { type: "string", maxLength: 65536 }, state: { type: "string", enum: ["open", "closed"] } };
+
+const githubApiProvider = Object.freeze({
+  ...githubApiDefinition, apiOrigins: ["https://api.github.com"],
+  apiKey: { headers: (key) => ({
+    Authorization: `Bearer ${key}`, Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2026-03-10", "User-Agent": "jskit-connectors"
+  }) },
+  oauth: {
+    issuer: "https://github.com",
+    authorization_endpoint: "https://github.com/login/oauth/authorize",
+    token_endpoint: "https://github.com/login/oauth/access_token"
+  },
+  normalizeTokenResponse,
+  oauthHeaders: () => ({ Accept: "application/vnd.github+json", "X-GitHub-Api-Version": "2026-03-10", "User-Agent": "jskit-connectors" }),
+  checkOperation: "account.read",
+  operations: {
+    "repositories.get": repositoryOperation("", {}, value => Number.isSafeInteger(value?.id) && typeof value.full_name === "string"),
+    "branches.list": repositoryOperation("/branches", pageFields, Array.isArray),
+    "commits.list": repositoryOperation("/commits", pageFields, Array.isArray),
+    "releases.list": repositoryOperation("/releases", pageFields, Array.isArray),
+    "workflows.runs": repositoryOperation("/actions/runs", pageFields, value => Array.isArray(value?.workflow_runs)),
+    "contents.get": repositoryOperation(({ path }) => `/contents/${path.split("/").map(encodeURIComponent).join("/")}`, {
+      path: { type: "string", required: true, minLength: 1, maxLength: 4096,
+        validator: value => !value.includes("\\") && value.split("/").every(segment => segment && segment !== "." && segment !== "..") || "Use a repository-relative file path." },
+      ref: { type: "string", minLength: 1, maxLength: 256 }
+    }, value => Array.isArray(value) || typeof value?.type === "string" && typeof value.path === "string"),
+    "issues.list": repositoryOperation("/issues", { ...pageFields, state: { type: "string", enum: ["open", "closed", "all"], defaultTo: "open" } }, Array.isArray),
+    "issues.get": repositoryOperation(({ number }) => `/issues/${number}`, { number: numberField }, issueResult),
+    "issues.create": repositoryOperation("/issues", { title: { ...issueChanges.title, required: true }, body: issueChanges.body }, issueResult, "POST"),
+    "issues.update": repositoryOperation(({ number }) => `/issues/${number}`, { number: numberField, ...issueChanges }, issueResult, "PATCH"),
+    "pulls.list": repositoryOperation("/pulls", { ...pageFields, state: { type: "string", enum: ["open", "closed", "all"], defaultTo: "open" } }, Array.isArray),
+    "pulls.reviews": repositoryOperation(({ number }) => `/pulls/${number}/reviews`, { number: numberField, ...pageFields }, Array.isArray),
+    "issues.comments": repositoryOperation(({ number }) => `/issues/${number}/comments`, { number: numberField, ...pageFields }, Array.isArray),
+    "pulls.get": repositoryOperation(({ number }) => `/pulls/${number}`, { number: numberField }, issueResult),
+    "pulls.create": repositoryOperation("/pulls", {
+      title: { ...issueChanges.title, required: true }, body: issueChanges.body,
+      head: { type: "string", required: true, minLength: 1, maxLength: 256 }, base: { type: "string", required: true, minLength: 1, maxLength: 256 }, draft: { type: "boolean", defaultTo: false }
+    }, issueResult, "POST"),
+    "pulls.update": repositoryOperation(({ number }) => `/pulls/${number}`, { number: numberField, ...issueChanges }, issueResult, "PATCH"),
+    "account.read": jsonOperation("https://api.github.com/user", {}, (result) => Number.isInteger(result?.id) && typeof result.login === "string"),
+    "repositories.list": jsonOperation("https://api.github.com/user/repos", {
+      per_page: { type: "integer", min: 1, max: 100, defaultTo: 30 },
+      page: { type: "integer", min: 1, defaultTo: 1 },
+      sort: { type: "string", enum: ["created", "updated", "pushed", "full_name"], defaultTo: "full_name" },
+      direction: { type: "string", enum: ["asc", "desc"], defaultTo: "asc" }
+    }, (result) => Array.isArray(result))
+  }
+});
+export { githubApiProvider };

package/src/server/gitlab-api.js

@@ -0,0 +1,67 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { gitlabApiDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const origin = (settings = {}) => new URL(settings.instanceUrl || "https://gitlab.com").origin;
+
+const pageFields = { per_page: { type: "integer", min: 1, max: 100, defaultTo: 20 }, page: { type: "integer", min: 1, max: 1000000, defaultTo: 1 } };
+const iidField = { type: "integer", required: true, min: 1, max: Number.MAX_SAFE_INTEGER };
+const changes = { title: { type: "string", minLength: 1, maxLength: 255 }, description: { type: "string", maxLength: 65536 }, state_event: { type: "string", enum: ["close", "reopen"] } };
+const itemResult = value => Number.isSafeInteger(value?.iid) && typeof value.title === "string";
+function projectOperation(suffix, fields, validateResult, method = "GET") {
+  const schema = createSchema({ project: { type: "string", required: true, minLength: 1, maxLength: 512,
+    validator: value => value.split("/").every(part => /^[A-Za-z0-9_][A-Za-z0-9_.-]*$/.test(part)) || "Use a numeric project ID or full namespace/project path." }, ...fields });
+  return { scopes: [], request(input, settings) {
+    const { project, iid, filePath, ...values } = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+    const tail = typeof suffix === "function" ? suffix({ iid, filePath }) : suffix;
+    const url = new URL(`${origin(settings)}/api/v4/projects/${encodeURIComponent(project)}${tail}`);
+    if (method === "GET") {
+      for (const [key, value] of Object.entries(values)) url.searchParams.set(key, String(value));
+      return { method, url: url.href };
+    }
+    if (!Object.keys(values).length) throw new ConnectorError("connector_input_invalid", "Supply at least one change.");
+    return { method, url: url.href, body: values };
+  }, validateResult };
+}
+
+const gitlabApiProvider = Object.freeze({
+  ...gitlabApiDefinition, apiOrigins: (settings) => [origin(settings)],
+  oauth: (settings) => ({ issuer: origin(settings), authorization_endpoint: `${origin(settings)}/oauth/authorize`, token_endpoint: `${origin(settings)}/oauth/token` }),
+  refreshRequiresRedirectUri: true,
+  apiKey: { headers: (key) => ({ "PRIVATE-TOKEN": key }) },
+  checkOperation: "profile.read",
+  operations: {
+    "projects.get": projectOperation("", {}, value => Number.isSafeInteger(value?.id) && typeof value.path_with_namespace === "string"),
+    "branches.list": projectOperation("/repository/branches", pageFields, Array.isArray),
+    "commits.list": projectOperation("/repository/commits", pageFields, Array.isArray),
+    "pipelines.list": projectOperation("/pipelines", pageFields, Array.isArray),
+    "files.get": projectOperation(({ filePath }) => `/repository/files/${encodeURIComponent(filePath)}`, {
+      filePath: { type: "string", required: true, minLength: 1, maxLength: 4096,
+        validator: value => !value.includes("\\") && value.split("/").every(part => part && part !== "." && part !== "..") || "Use a repository-relative file path." },
+      ref: { type: "string", required: true, minLength: 1, maxLength: 256 }
+    }, value => typeof value?.file_path === "string" && typeof value.content === "string"),
+    "issues.list": projectOperation("/issues", { ...pageFields, state: { type: "string", enum: ["opened", "closed", "all"], defaultTo: "opened" }, search: { type: "string", maxLength: 256 } }, Array.isArray),
+    "issues.get": projectOperation(({ iid }) => `/issues/${iid}`, { iid: iidField }, itemResult),
+    "issues.notes": projectOperation(({ iid }) => `/issues/${iid}/notes`, { iid: iidField, ...pageFields }, Array.isArray),
+    "issues.create": projectOperation("/issues", { title: { ...changes.title, required: true }, description: changes.description }, itemResult, "POST"),
+    "issues.update": projectOperation(({ iid }) => `/issues/${iid}`, { iid: iidField, ...changes }, itemResult, "PUT"),
+    "mergeRequests.list": projectOperation("/merge_requests", { ...pageFields, state: { type: "string", enum: ["opened", "closed", "merged", "all"], defaultTo: "opened" } }, Array.isArray),
+    "mergeRequests.get": projectOperation(({ iid }) => `/merge_requests/${iid}`, { iid: iidField }, itemResult),
+    "mergeRequests.notes": projectOperation(({ iid }) => `/merge_requests/${iid}/notes`, { iid: iidField, ...pageFields }, Array.isArray),
+    "mergeRequests.create": projectOperation("/merge_requests", { title: { ...changes.title, required: true }, description: changes.description,
+      source_branch: { type: "string", required: true, minLength: 1, maxLength: 256 }, target_branch: { type: "string", required: true, minLength: 1, maxLength: 256 }
+    }, itemResult, "POST"),
+    "mergeRequests.update": projectOperation(({ iid }) => `/merge_requests/${iid}`, { iid: iidField, ...changes }, itemResult, "PUT"),
+    "profile.read": jsonOperation((settings) => `${origin(settings)}/api/v4/user`, {},
+      (result) => Number.isInteger(result?.id) && typeof result.username === "string"),
+    "projects.list": jsonOperation((settings) => `${origin(settings)}/api/v4/projects`, {
+      per_page: { type: "integer", min: 1, max: 100, defaultTo: 20 },
+      page: { type: "integer", min: 1, defaultTo: 1 },
+      membership: { type: "boolean", enum: [true], defaultTo: true },
+      simple: { type: "boolean", enum: [true], defaultTo: true }
+    }, Array.isArray)
+  }
+});
+export { gitlabApiProvider };