@jskit-ai/connectors-catalog 0.1.1

package/src/client/google-maps-platform.js

@@ -0,0 +1,39 @@
+/** Compose an app-owned Google map after the application has loaded Google's SDK. */
+async function mountGoogleMap({ element, maps = globalThis.google?.maps, center, zoom = 12, mapId, markers = [], path = [], signal } = {}) {
+  const coordinate = point => {
+    if (!point || !Number.isFinite(point.lat) || Math.abs(point.lat) > 90 || !Number.isFinite(point.lng) || Math.abs(point.lng) > 180) throw new Error("Use finite lat/lng coordinates within Earth bounds.");
+    return { lat: point.lat, lng: point.lng };
+  };
+  if (!element?.replaceChildren || typeof maps?.importLibrary !== "function") throw new Error("Provide a map container and load the Google Maps JavaScript SDK first.");
+  if (!Number.isFinite(zoom) || zoom < 0 || zoom > 22) throw new Error("Use zoom between 0 and 22.");
+  if (!Array.isArray(markers) || markers.length > 100 || !Array.isArray(path) || path.length > 10000) throw new Error("Use at most 100 markers and 10000 route points.");
+  if (markers.length && (typeof mapId !== "string" || !mapId.trim())) throw new Error("Advanced markers require a Google JavaScript map ID.");
+  const position = coordinate(center);
+  const markerOptions = markers.map(marker => {
+    if (marker.title !== undefined && typeof marker.title !== "string") throw new Error("Marker titles must be text.");
+    return { position: coordinate(marker.position), title: marker.title || "" };
+  });
+  const route = path.map(coordinate);
+  signal?.throwIfAborted();
+  const library = await maps.importLibrary("maps");
+  const markerLibrary = markerOptions.length ? await maps.importLibrary("marker") : null;
+  signal?.throwIfAborted();
+  const map = new library.Map(element, { center: position, zoom, ...(mapId ? { mapId } : {}) });
+  const pins = []; let line; let disposed = false;
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    signal?.removeEventListener("abort", dispose);
+    for (const pin of pins) { maps.event.clearInstanceListeners(pin); pin.map = null; }
+    if (line) { maps.event.clearInstanceListeners(line); line.setMap(null); }
+    maps.event.clearInstanceListeners(map);
+    element.replaceChildren();
+  }
+  try {
+    for (const options of markerOptions) pins.push(new markerLibrary.AdvancedMarkerElement({ ...options, map }));
+    if (route.length) line = new library.Polyline({ map, path: route });
+    signal?.addEventListener("abort", dispose, { once: true });
+    return { map, dispose };
+  } catch (error) { dispose(); throw error; }
+}
+export { mountGoogleMap };

package/src/client/logo-dev.js

@@ -0,0 +1,36 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+
+const logoDevImageSchema = createSchema({
+  publishableKey: { type: "string", required: true, minLength: 4, maxLength: 512,
+    validator: (value) => /^pk_[A-Za-z0-9_-]+$/.test(value) || "Use a Logo.dev publishable key starting with pk_." },
+  domain: { type: "string", minLength: 3, maxLength: 253,
+    validator: (value) => /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z](?:[a-z0-9-]{0,61}[a-z0-9])?$/i.test(value) || "Enter an ASCII domain without a URL, port or path." },
+  ticker: { type: "string", minLength: 1, maxLength: 32,
+    validator: value => /^[a-z0-9][a-z0-9.-]*$/iu.test(value) || "Enter a stock ticker, optionally with its exchange suffix." },
+  email: { type: "string", minLength: 3, maxLength: 320,
+    validator: value => /^[^\s@]+@[^\s@]+$/u.test(value) || "Enter an email address for company-domain lookup." },
+  size: { type: "integer", min: 1, max: 800, defaultTo: 128 },
+  format: { type: "string", enum: ["png", "jpg", "webp", "svg"], defaultTo: "png" },
+  theme: { type: "string", enum: ["auto", "light", "dark"], defaultTo: "auto" },
+  greyscale: { type: "boolean", defaultTo: false },
+  retina: { type: "boolean", defaultTo: false },
+  fallback: { type: "string", enum: ["monogram", "404"], defaultTo: "monogram" }
+});
+
+function createLogoDevImageUrl(input) {
+  const { publishableKey, domain, ticker, email, ...parameters } = validateSchemaPayload({ schema: logoDevImageSchema, mode: "replace" }, input, { statusCode: 422 });
+  if ([domain, ticker, email].filter(value => value !== undefined).length !== 1) {
+    const error = new Error("Choose exactly one domain, stock ticker or email address.");
+    error.fieldErrors = { domain: "Choose exactly one lookup value." }; throw error;
+  }
+  // Resolve email locally: never transmit the address's local part to the CDN.
+  if (email !== undefined) return createLogoDevImageUrl({ publishableKey, domain: email.split("@")[1], ...parameters });
+  const identifier = ticker === undefined ? domain.toLowerCase() : `ticker/${ticker.toUpperCase()}`;
+  const url = new URL(`https://img.logo.dev/${identifier}`);
+  url.searchParams.set("token", publishableKey);
+  for (const [key, value] of Object.entries(parameters)) url.searchParams.set(key, String(value));
+  return url.href;
+}
+
+export { createLogoDevImageUrl, logoDevImageSchema };

package/src/server/ai.js

@@ -0,0 +1,46 @@
+import { ConnectorError, createEnvironmentReferenceResolver } from "@jskit-ai/connectors-core/server";
+import { validateIntegrationConfiguration } from "@jskit-ai/connectors-core/shared/configuration";
+import { aiCatalogue, aiDefinition, getAiModel } from "../shared/ai.js";
+
+// A server-only credential boundary. The consuming application's SDK owns all
+// inference, transport, streaming, tool execution and error/fallback policy.
+function createAiConnectionResolver({ configuration, authorize, resolveReference = createEnvironmentReferenceResolver() }) {
+  if (typeof authorize !== "function") throw new TypeError("AI connections require application authorization.");
+  const config = validateIntegrationConfiguration(configuration, { providers: [aiDefinition], allowUnknownProviders: true });
+
+  async function resolve({ context, integrationId }) {
+    const integration = Object.hasOwn(config.integrations, integrationId) ? config.integrations[integrationId] : null;
+    if (integration?.provider !== "ai") throw new ConnectorError("connector_not_found", "This AI connection is not configured.", { statusCode: 404 });
+    const owner = await authorize(context, { integrationId, operation: "ai.resolve", accountMode: integration.accountMode });
+    if (!owner?.applicationId || !owner?.subjectId) {
+      throw new ConnectorError("connector_access_denied", "Access to this AI connection was denied.", { statusCode: 403 });
+    }
+    const model = getAiModel(integration.settings.model);
+    const provider = aiCatalogue.providers.find((item) => item.id === model.providerId);
+    let apiKey;
+    if (integration.authentication.method === "none") {
+      // OpenCode Zen's published no-account protocol uses this fixed marker.
+      // It is not a user's secret and requires no OpenCode process or account.
+      apiKey = "public";
+    } else {
+      if (integration.accountMode === "per-user" && integration.authentication.secretRef.startsWith("env:")) {
+        throw new ConnectorError("connector_binding_invalid", "Individual AI accounts require a user-owned reference, not a shared environment variable.", { statusCode: 422 });
+      }
+      try {
+        apiKey = await resolveReference(integration.authentication.secretRef, { ...owner }, {
+          integrationId, accountMode: integration.accountMode, providerId: provider.id
+        });
+        if (typeof apiKey !== "string" || !apiKey.trim() || /[\r\n\0]/u.test(apiKey) || apiKey.length > 16384) throw new Error();
+      } catch {
+        throw new ConnectorError("connector_binding_missing", "The authorized AI account's API key is unavailable.", { statusCode: 422 });
+      }
+    }
+    // Never expose this result through a browser API or include it in logs.
+    // Missing baseURL means use the named provider SDK's own default endpoint.
+    return Object.freeze({ providerId: provider.id, model: model.id, sdkPackage: model.sdkPackage,
+      ...(provider.baseURL ? { baseURL: provider.baseURL } : {}), apiKey, access: model.access });
+  }
+  return Object.freeze({ resolve });
+}
+
+export { createAiConnectionResolver };

package/src/server/airtable.js

@@ -0,0 +1,67 @@
+import { createSchema } from "json-rest-schema";
+import { airtableDefinition } from "../shared/tokens.js";
+import { jsonOperation, validatedOperation } from "./jsonOperation.js";
+
+const identifier = { type: "string", required: true, minLength: 1, maxLength: 200,
+  pattern: "^[A-Za-z0-9_-]+$" };
+const table = { type: "string", required: true, minLength: 1, maxLength: 1000,
+  validator: value => ![".", ".."].includes(value) || "Use a table ID or name." };
+const name = { type: "string", required: true, minLength: 1, maxLength: 1000 };
+const description = { type: "string", maxLength: 20000 };
+const fields = { type: "object", required: true, additionalProperties: true,
+  validator: value => (Object.keys(value).length > 0 && Object.keys(value).every(key => key.length > 0 && key.length <= 1000)) || "Provide named fields to change." };
+const fieldSchema = createSchema({ name, type: { ...name, maxLength: 100 },
+  description, options: { type: "object", additionalProperties: true } });
+const tableFields = { type: "array", required: true,
+  validator: value => (value.length > 0 && value.length <= 500 && new Set(value.map(field => field.name.toLowerCase())).size === value.length) || "Provide 1–500 fields with unique names.",
+  items: { type: "object", schema: fieldSchema } };
+const tableSchema = createSchema({ name, description, fields: tableFields });
+const basePath = baseId => `https://api.airtable.com/v0/meta/bases/${encodeURIComponent(baseId)}/tables`;
+const recordPath = (baseId, tableId) => `https://api.airtable.com/v0/${encodeURIComponent(baseId)}/${encodeURIComponent(tableId)}`;
+const recordResult = result => typeof result?.id === "string" && !!result.fields && typeof result.fields === "object";
+const tableResult = result => typeof result?.id === "string" && typeof result.name === "string";
+
+const airtableProvider = Object.freeze({
+  ...airtableDefinition, apiOrigins: ["https://api.airtable.com"],
+  apiKey: { headers: (key) => ({ Authorization: `Bearer ${key}` }) },
+  checkOperation: "bases.list",
+  operations: {
+    "bases.create": validatedOperation({ name, workspaceId: identifier,
+      tables: { type: "array", required: true,
+        validator: value => value.length > 0 || "Provide at least one table.",
+        items: { type: "object", schema: tableSchema } }
+    }, body => ({ method: "POST", url: "https://api.airtable.com/v0/meta/bases", body }),
+      result => typeof result?.id === "string" && Array.isArray(result.tables)),
+    "tables.list": validatedOperation({ baseId: identifier }, ({ baseId }) => ({ method: "GET", url: basePath(baseId) }),
+      result => Array.isArray(result?.tables)),
+    "tables.create": validatedOperation({ baseId: identifier, name, description,
+      fields: tableFields
+    }, ({ baseId, ...body }) => ({ method: "POST", url: basePath(baseId), body }), tableResult),
+    "tables.update": validatedOperation({ baseId: identifier, tableId: table, name, description },
+      ({ baseId, tableId, ...body }) => ({ method: "PATCH", url: `${basePath(baseId)}/${encodeURIComponent(tableId)}`, body }), tableResult),
+    "fields.create": validatedOperation({ baseId: identifier, tableId: identifier,
+      field: { type: "object", required: true, schema: fieldSchema } },
+      ({ baseId, tableId, field }) => ({ method: "POST", url: `${basePath(baseId)}/${tableId}/fields`, body: field }), tableResult),
+    "fields.update": validatedOperation({ baseId: identifier, tableId: identifier, fieldId: identifier, name, description,
+      options: { type: "object", additionalProperties: true } },
+      ({ baseId, tableId, fieldId, ...body }) => ({ method: "PATCH", url: `${basePath(baseId)}/${tableId}/fields/${fieldId}`, body }), tableResult),
+    "records.list": validatedOperation({ baseId: identifier, tableId: table,
+      pageSize: { type: "integer", min: 1, max: 100, defaultTo: 100 },
+      offset: { type: "string", minLength: 1, maxLength: 4096 },
+      view: { type: "string", minLength: 1, maxLength: 1000 },
+      filterByFormula: { type: "string", minLength: 1, maxLength: 10000 }
+    }, ({ baseId, tableId, ...body }) => ({ method: "POST", url: `${recordPath(baseId, tableId)}/listRecords`, body }),
+      result => Array.isArray(result?.records) && (result.offset === undefined || typeof result.offset === "string")),
+    "records.create": validatedOperation({ baseId: identifier, tableId: table, fields },
+      ({ baseId, tableId, fields }) => ({ method: "POST", url: recordPath(baseId, tableId), body: { fields, typecast: false } }), recordResult),
+    "records.update": validatedOperation({ baseId: identifier, tableId: table, recordId: identifier, fields },
+      ({ baseId, tableId, recordId, fields }) => ({ method: "PATCH", url: `${recordPath(baseId, tableId)}/${recordId}`, body: { fields, typecast: false } }), recordResult),
+    "records.delete": validatedOperation({ baseId: identifier, tableId: table, recordId: identifier },
+      ({ baseId, tableId, recordId }) => ({ method: "DELETE", url: `${recordPath(baseId, tableId)}/${recordId}` }),
+      result => typeof result?.id === "string" && result.deleted === true),
+    "bases.list": jsonOperation("https://api.airtable.com/v0/meta/bases", {
+      offset: { type: "string", minLength: 1, maxLength: 4096 }
+    }, (result) => Array.isArray(result?.bases) && (result.offset === undefined || typeof result.offset === "string"))
+  }
+});
+export { airtableProvider };

package/src/server/algolia.js

@@ -0,0 +1,63 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { algoliaDefinition } from "../shared/algolia.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const origin = ({ applicationId }) => `https://${applicationId.toLowerCase()}.algolia.net`;
+const searchSchema = createSchema({
+  indexName: { type: "string", required: true, minLength: 1, maxLength: 255,
+    validator: (value) => ![".", ".."].includes(value) || "Enter an index name." },
+  query: { type: "string", defaultTo: "", maxLength: 512,
+    validator: (value) => Buffer.byteLength(value, "utf8") <= 512 || "Use a query of at most 512 UTF-8 bytes." },
+  page: { type: "integer", min: 0, max: 2147483647, defaultTo: 0 },
+  hitsPerPage: { type: "integer", min: 1, max: 1000, defaultTo: 20 }
+});
+const indexField = { type: "string", required: true, minLength: 1, maxLength: 255,
+  validator: value => ![".", ".."].includes(value) || "Enter an index name." };
+const objectField = { type: "string", required: true, minLength: 1, maxLength: 512,
+  validator: value => ![".", ".."].includes(value) || "Enter a record ID." };
+const writeSchema = createSchema({ indexName: indexField, objectID: objectField,
+  attributes: { type: "object", required: true, additionalProperties: true,
+    validator: value => (Object.keys(value).length > 0 && !Object.hasOwn(value, "objectID")) || "Provide attributes without objectID; use the separate record ID." } });
+const deleteSchema = createSchema({ indexName: indexField, objectID: objectField });
+const taskSchema = createSchema({ indexName: indexField,
+  taskID: { type: "integer", required: true, min: 0, max: Number.MAX_SAFE_INTEGER } });
+const taskResult = result => Number.isSafeInteger(result?.taskID) && result.taskID >= 0;
+function writeOperation(method, suffix = "") {
+  return { scopes: [], request(input, settings) {
+    const { indexName, objectID, attributes } = validateSchemaPayload({ schema: writeSchema, mode: "replace" }, input, { statusCode: 422 });
+    return { method, url: `${origin(settings)}/1/indexes/${encodeURIComponent(indexName)}/${encodeURIComponent(objectID)}${suffix}`,
+      body: attributes };
+  }, validateResult: result => taskResult(result) && typeof result.objectID === "string" };
+}
+const algoliaProvider = Object.freeze({
+  ...algoliaDefinition,
+  apiOrigins: (settings) => [origin(settings)],
+  apiKey: { headers: (key, settings) => ({ "X-Algolia-Application-Id": settings.applicationId, "X-Algolia-API-Key": key }) },
+  checkOperation: "indices.list",
+  operations: {
+    "records.replace": writeOperation("PUT"),
+    "records.update": writeOperation("POST", "/partial?createIfNotExists=false"),
+    "records.delete": { scopes: [], request(input, settings) {
+      const { indexName, objectID } = validateSchemaPayload({ schema: deleteSchema, mode: "replace" }, input, { statusCode: 422 });
+      return { method: "DELETE", url: `${origin(settings)}/1/indexes/${encodeURIComponent(indexName)}/${encodeURIComponent(objectID)}` };
+    }, validateResult: taskResult },
+    "tasks.get": { scopes: [], request(input, settings) {
+      const { indexName, taskID } = validateSchemaPayload({ schema: taskSchema, mode: "replace" }, input, { statusCode: 422 });
+      return { method: "GET", url: `${origin(settings)}/1/indexes/${encodeURIComponent(indexName)}/task/${taskID}` };
+    }, validateResult: result => ["published", "notPublished"].includes(result?.status) },
+    "indices.list": jsonOperation((settings) => `${origin(settings)}/1/indexes`, {
+      page: { type: "integer", min: 0, max: 2147483647, defaultTo: 0 },
+      hitsPerPage: { type: "integer", min: 1, max: 1000, defaultTo: 100 }
+    }, (result) => Array.isArray(result?.items) && (result.nbPages === undefined || Number.isInteger(result.nbPages) && result.nbPages >= 0)),
+    "index.search": {
+      scopes: [],
+      request(input, settings) {
+        const { indexName, ...body } = validateSchemaPayload({ schema: searchSchema, mode: "replace" }, input, { statusCode: 422 });
+        return { method: "POST", url: `${origin(settings)}/1/indexes/${encodeURIComponent(indexName)}/query`, body };
+      },
+      validateResult: (result) => Array.isArray(result?.hits) && ["nbHits", "nbPages", "page", "hitsPerPage"].every((key) => Number.isInteger(result[key]) && result[key] >= 0)
+    }
+  }
+});
+export { algoliaProvider };

package/src/server/amazon-redshift.js

@@ -0,0 +1,96 @@
+import { RedshiftDataClient, ListDatabasesCommand, ListSchemasCommand, ListTablesCommand, DescribeTableCommand, ExecuteStatementCommand, DescribeStatementCommand, GetStatementResultCommand, CancelStatementCommand } from "@aws-sdk/client-redshift-data";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { createSchema } from "json-rest-schema";
+import { amazonRedshiftDefinition } from "../shared/amazon-redshift.js";
+import { awsOrigin, awsOperation, awsExchange } from "./awsTransport.js";
+
+const statementPattern = "^[a-z0-9]{8}(-[a-z0-9]{4}){3}-[a-z0-9]{12}(:[0-9]{1,2})?$";
+const statementId = { type: "string", required: true, pattern: statementPattern };
+const text = { type: "string", noTrim: true, minLength: 1, maxLength: 1024 };
+const nextToken = { ...text, maxLength: 8192 };
+const maxResults = { type: "integer", min: 1, max: 1000, defaultTo: 100 };
+const hasCursor = (r) => r?.NextToken === undefined || typeof r.NextToken === "string";
+const validId = (r) => typeof r?.Id === "string" && new RegExp(statementPattern, "u").test(r.Id);
+const validStatement = (r) => validId(r) && typeof r.Database === "string" &&
+  ["SUBMITTED", "PICKED", "STARTED", "FINISHED", "ABORTED", "FAILED"].includes(r.Status);
+const validColumns = (columns) => Array.isArray(columns) && columns.every((c) => c && typeof c.name === "string" && typeof c.typeName === "string");
+const target = (s) => ({ Database: s.database, ...(s.deploymentType === "provisioned"
+  ? { ClusterIdentifier: s.clusterIdentifier, ...(s.databaseUser ? { DbUser: s.databaseUser } : {}) }
+  : { WorkgroupName: s.workgroup }) });
+const pageInput = (v) => ({ ...(v.nextToken ? { NextToken: v.nextToken } : {}), MaxResults: v.maxResults });
+
+function assertTarget(result, settings) {
+  const matches = result.Database === settings.database && (settings.deploymentType === "provisioned"
+    ? result.ClusterIdentifier === settings.clusterIdentifier && !result.WorkgroupName && (!settings.databaseUser || result.DbUser === settings.databaseUser)
+    : result.WorkgroupName === settings.workgroup && !result.ClusterIdentifier);
+  if (!matches) throw new ConnectorError("connector_access_denied", "This statement belongs to a different Redshift target.", { statusCode: 403 });
+}
+
+function validCell(cell) {
+  if (!cell || Object.keys(cell).length !== 1) return false;
+  const [key, value] = Object.entries(cell)[0];
+  if (key === "isNull") return value === true;
+  if (key === "booleanValue") return typeof value === "boolean";
+  if (key === "longValue") return Number.isSafeInteger(value);
+  if (key === "doubleValue") return typeof value === "number" && Number.isFinite(value);
+  if (key === "stringValue") return typeof value === "string";
+  return key === "blobValue" && value instanceof Uint8Array;
+}
+
+const amazonRedshiftProvider = Object.freeze({
+  ...amazonRedshiftDefinition,
+  apiOrigins: (settings) => [awsOrigin("redshift-data", settings)], apiKey: { headers: () => ({}) }, checkOperation: "tables.list",
+  exchange: awsExchange("redshift-data", RedshiftDataClient, async (client, body, { settings, signal }) => {
+    const send = (command) => client.send(command, { abortSignal: signal });
+    if (body.command === "ListDatabases") return send(new ListDatabasesCommand(body.input));
+    if (body.command === "ListSchemas") return send(new ListSchemasCommand(body.input));
+    if (body.command === "ListTables") return send(new ListTablesCommand(body.input));
+    if (body.command === "DescribeTable") return send(new DescribeTableCommand(body.input));
+    if (body.command === "ExecuteStatement") {
+      const result = await send(new ExecuteStatementCommand(body.input));
+      if (!validId(result)) throw new ConnectorError("connector_response_invalid", "Redshift did not return a statement identifier.", { statusCode: 502 });
+      assertTarget(result, settings);
+      return result;
+    }
+    const statement = await send(new DescribeStatementCommand({ Id: body.input.Id }));
+    if (!validStatement(statement) || statement.Id !== body.input.Id) throw new ConnectorError("connector_response_invalid", "Redshift returned an unexpected statement.", { statusCode: 502 });
+    assertTarget(statement, settings);
+    if (body.command === "DescribeStatement") return statement;
+    if (body.command === "CancelStatement") return send(new CancelStatementCommand(body.input));
+    if (statement.Status !== "FINISHED" || !statement.HasResultSet) throw new ConnectorError("connector_result_unavailable", "This statement has no finished result set.", { statusCode: 409 });
+    return send(new GetStatementResultCommand(body.input));
+  }),
+  operations: {
+    "databases.list": awsOperation("redshift-data", "ListDatabases", { maxResults, nextToken },
+      (v, s) => ({ input: { ...target(s), ...pageInput(v) } }),
+      (r) => Array.isArray(r?.Databases) && r.Databases.length <= 1000 && r.Databases.every((name) => typeof name === "string") && hasCursor(r)),
+    "schemas.list": awsOperation("redshift-data", "ListSchemas", { maxResults, nextToken, schemaPattern: text },
+      (v, s) => ({ input: { ...target(s), ...pageInput(v), ...(v.schemaPattern ? { SchemaPattern: v.schemaPattern } : {}) } }),
+      (r) => Array.isArray(r?.Schemas) && r.Schemas.length <= 1000 && r.Schemas.every((name) => typeof name === "string") && hasCursor(r)),
+    "tables.list": awsOperation("redshift-data", "ListTables", { maxResults, nextToken, schemaPattern: text, tablePattern: text },
+      (v, s) => ({ input: { ...target(s), ...pageInput(v), ...(v.schemaPattern ? { SchemaPattern: v.schemaPattern } : {}), ...(v.tablePattern ? { TablePattern: v.tablePattern } : {}) } }),
+      (r) => Array.isArray(r?.Tables) && r.Tables.length <= 1000 && r.Tables.every((t) => typeof t?.name === "string" && typeof t.schema === "string" && typeof t.type === "string") && hasCursor(r)),
+    "table.describe": awsOperation("redshift-data", "DescribeTable", { table: { ...text, required: true }, schema: text, maxResults, nextToken },
+      (v, s) => ({ input: { ...target(s), ...pageInput(v), Table: v.table, ...(v.schema ? { Schema: v.schema } : {}) } }),
+      (r) => validColumns(r?.ColumnList) && r.ColumnList.length <= 1000 && typeof r.TableName === "string" && hasCursor(r)),
+    "query.start": awsOperation("redshift-data", "ExecuteStatement", {
+      sql: { type: "string", required: true, noTrim: true, minLength: 1, maxLength: 200000,
+        validator: (v) => (v.trim().length > 0 && Buffer.byteLength(v, "utf8") <= 200000) || "Enter SQL of at most 200000 UTF-8 bytes." },
+      clientToken: { ...text, required: true, maxLength: 64 },
+      parameters: { type: "array", validator: (v) => (v.length >= 1 && v.length <= 100) || "Supply between 1 and 100 SQL parameters, or omit parameters.", items: { type: "object", schema: createSchema({
+        name: { type: "string", required: true, pattern: "^[a-zA-Z0-9_]+$" }, value: { ...text, required: true, maxLength: 65536 }
+      }) } }
+    }, (v, s) => {
+      if (v.parameters && new Set(v.parameters.map((p) => p.name)).size !== v.parameters.length) throw new ConnectorError("connector_input_invalid", "Use each SQL parameter name only once.", { statusCode: 422 });
+      return { input: { ...target(s), Sql: v.sql, ClientToken: v.clientToken, ResultFormat: "JSON", ...(v.parameters ? { Parameters: v.parameters } : {}) } };
+    }, validId),
+    "query.status": awsOperation("redshift-data", "DescribeStatement", { statementId }, (v) => ({ input: { Id: v.statementId } }), validStatement),
+    "query.results": awsOperation("redshift-data", "GetStatementResult", { statementId, nextToken },
+      (v) => ({ input: { Id: v.statementId, ...(v.nextToken ? { NextToken: v.nextToken } : {}) } }),
+      (r) => validColumns(r?.ColumnMetadata) && Array.isArray(r.Records) && r.Records.every((row) => Array.isArray(row) && row.length === r.ColumnMetadata.length && row.every(validCell)) &&
+        (r.TotalNumRows === undefined || Number.isSafeInteger(r.TotalNumRows) && r.TotalNumRows >= 0) && hasCursor(r)),
+    "query.cancel": awsOperation("redshift-data", "CancelStatement", { statementId }, (v) => ({ input: { Id: v.statementId } }), (r) => typeof r?.Status === "boolean")
+  }
+});
+
+export { amazonRedshiftProvider };

package/src/server/amplitude.js

@@ -0,0 +1,31 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { mcpRegistrationFields, registerMcpClient } from "./mcpRegistration.js";
+import { amplitudeDefinition } from "../shared/amplitude.js";
+import { mcpOperations, exchangeMcp } from "./mcpTransport.js";
+
+const origin = (settings) => settings.region === "eu" ? "https://mcp.eu.amplitude.com" : "https://mcp.amplitude.com";
+const oauth = (settings) => ({ issuer: origin(settings), authorization_endpoint: `${origin(settings)}/authorize`,
+  token_endpoint: `${origin(settings)}/token`, registration_endpoint: amplitudeDefinition.setup.clientRegistrationEndpoint(settings), response_types_supported: ["code"] });
+const operations = mcpOperations((settings) => `${origin(settings)}/mcp`);
+const amplitudeProvider = Object.freeze({
+  ...amplitudeDefinition, oauth, oauthResource: origin,
+  apiOrigins: (settings) => [origin(settings)], checkOperation: "tools.list", exchange: exchangeMcp,
+  operations: Object.fromEntries(Object.entries(operations).map(([name, operation]) => [name, { ...operation, scopes: ["mcp:read"] }]))
+});
+
+const registrationSchema = createSchema({
+  region: { type: "string", enum: ["us", "eu"], defaultTo: "us" },
+  ...mcpRegistrationFields,
+  scopes: { type: "array", required: true, minLength: 1,
+    items: { type: "string", enum: amplitudeDefinition.scopes.map((scope) => scope.value) },
+    validator: (scopes) => scopes.includes("mcp:read") && new Set(scopes).size === scopes.length || "Select read access and include each permission once." }
+});
+
+// Explicit setup operation. Callers own authorization and secure storage of its returned secret.
+async function registerAmplitudeClient(input, options) {
+  const values = validateSchemaPayload({ schema: registrationSchema, mode: "replace" }, input, { statusCode: 422 });
+  return registerMcpClient("Amplitude", oauth(values), values, options);
+}
+
+export { amplitudeProvider, registerAmplitudeClient };

package/src/server/apify.js

@@ -0,0 +1,68 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { apifyDefinition } from "../shared/tokens.js";
+import { jsonOperation, validatedOperation } from "./jsonOperation.js";
+
+const id = { type: "string", required: true, minLength: 1, maxLength: 250, pattern: "^[A-Za-z0-9_~-]+$" };
+const runResult = value => typeof value?.data?.id === "string" && typeof value.data.status === "string";
+const apifyProvider = Object.freeze({
+  ...apifyDefinition, apiOrigins: ["https://api.apify.com"],
+  apiKey: { headers: (key) => ({ Authorization: `Bearer ${key}` }) },
+  checkOperation: "actors.list",
+  async exchange(url, options, { request, fetchImpl }) {
+    if (!new URL(url).pathname.startsWith("/v2/key-value-stores/")) return request(url, options);
+    const response = await fetchImpl(url, { ...options, credentials: "omit", redirect: "error" });
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw Object.assign(new Error("Apify storage request failed."), { status: response.status });
+    }
+    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 > 8 * 1024 * 1024) {
+          await reader.cancel();
+          throw new ConnectorError("connector_response_too_large", "Use the framework's native Apify client to stream records larger than 8 MiB.", { statusCode: 413 });
+        }
+        chunks.push(value);
+      }
+    } finally { reader.releaseLock(); }
+    return { contentType: response.headers.get("content-type") || "application/octet-stream",
+      bodyBase64: Buffer.concat(chunks).toString("base64"), size };
+  },
+  operations: {
+    "actors.get": validatedOperation({ actorId: id }, ({ actorId }) => ({ method: "GET", url: `https://api.apify.com/v2/actors/${actorId}` }),
+      result => typeof result?.data?.id === "string"),
+    "runs.start": validatedOperation({ actorId: id,
+      input: { type: "object", required: true, additionalProperties: true },
+      timeout: { type: "integer", required: true, min: 1, max: 86400 },
+      maxTotalChargeUsd: { type: "number", required: true, min: 0.01, max: 100000 },
+      build: { type: "string", minLength: 1, maxLength: 100, pattern: "^[A-Za-z0-9_.-]+$" }
+    }, ({ actorId, input, ...options }) => {
+      const url = new URL(`https://api.apify.com/v2/actors/${actorId}/runs`);
+      for (const [name, value] of Object.entries(options)) url.searchParams.set(name, String(value));
+      url.searchParams.set("restartOnError", "false");
+      url.searchParams.set("waitForFinish", "0");
+      return { method: "POST", url: url.href, body: input };
+    }, runResult),
+    "runs.get": validatedOperation({ runId: id }, ({ runId }) => ({ method: "GET", url: `https://api.apify.com/v2/actor-runs/${runId}` }), runResult),
+    "runs.abort": validatedOperation({ runId: id }, ({ runId }) => ({ method: "POST", url: `https://api.apify.com/v2/actor-runs/${runId}/abort?gracefully=true` }), runResult),
+    "datasets.items": validatedOperation({ datasetId: id,
+      offset: { type: "integer", min: 0, defaultTo: 0 }, limit: { type: "integer", min: 1, max: 1000, defaultTo: 100 }
+    }, ({ datasetId, offset, limit }) => ({ method: "GET",
+      url: `https://api.apify.com/v2/datasets/${datasetId}/items?format=json&offset=${offset}&limit=${limit}` }), Array.isArray),
+    "stores.record": validatedOperation({ storeId: id, key: { type: "string", required: true, minLength: 1, maxLength: 250,
+      validator: value => ![".", ".."].includes(value) || "Enter a storage key." }
+    }, ({ storeId, key }) => ({ method: "GET", url: `https://api.apify.com/v2/key-value-stores/${storeId}/records/${encodeURIComponent(key)}` }),
+      result => typeof result?.bodyBase64 === "string" && typeof result.contentType === "string"),
+    "actors.list": jsonOperation("https://api.apify.com/v2/actors", {
+      limit: { type: "integer", min: 1, max: 1000, defaultTo: 100 },
+      offset: { type: "integer", min: 0, defaultTo: 0 },
+      desc: { type: "boolean", defaultTo: false }
+    }, (result) => Array.isArray(result?.data?.items) && Number.isInteger(result.data.total) && Number.isInteger(result.data.offset))
+  }
+});
+export { apifyProvider };

package/src/server/apollo-io.js

@@ -0,0 +1,85 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { apolloIoDefinition } from "../shared/tokens.js";
+import { jsonOperation, validatedOperation } from "./jsonOperation.js";
+
+const text = { type: "string", minLength: 1, maxLength: 256 };
+const id = { ...text, pattern: "^[A-Za-z0-9_-]+$" };
+const page = { page: { type: "integer", min: 1, max: 500, defaultTo: 1 },
+  per_page: { type: "integer", min: 1, max: 100, defaultTo: 25 } };
+const strings = { type: "array", items: text, validator: value => value.length <= 100 || "Use at most 100 filter values." };
+const domain = { ...text, pattern: "^(?!www\\.)(?:[A-Za-z0-9-]+\\.)+[A-Za-z]{2,}$" };
+const charge = { type: "boolean", required: true, validator: value => value === true || "Explicitly authorize provider credit consumption." };
+const record = key => result => typeof result?.[key]?.id === "string";
+const collection = key => result => Array.isArray(result?.[key]);
+const accountFields = { name: text, domain, owner_id: id, account_stage_id: id, phone: text, raw_address: text };
+const contactFields = { first_name: text, last_name: text, organization_name: text, title: text,
+  account_id: id, email: { ...text, pattern: "^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$" },
+  label_names: strings, contact_stage_id: id, present_raw_address: text, direct_phone: text,
+  corporate_phone: text, mobile_phone: text };
+const dealFields = { name: text, owner_id: id,
+  amount: { ...text, pattern: "^[0-9]+(?:\\.[0-9]+)?$" }, opportunity_stage_id: id,
+  closed_date: { ...text, pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+    validator: value => { const date = new Date(value); return !Number.isNaN(date.valueOf()) && date.toISOString().slice(0, 10) === value || "Enter a real YYYY-MM-DD date."; } } };
+
+function query(method, endpoint, input) {
+  const url = new URL(`https://api.apollo.io/api/v1/${endpoint}`);
+  for (const [key, value] of Object.entries(input)) {
+    if (key === "allowCreditConsumption") continue;
+    if (Array.isArray(value)) for (const entry of value) url.searchParams.append(`${key}[]`, entry);
+    else url.searchParams.set(key, String(value));
+  }
+  return { method, url: url.href };
+}
+function write(method, endpoint, fields, key, requiredNames = []) {
+  return validatedOperation({ ...(method === "PATCH" ? { id: { ...id, required: true } } : {}), ...fields },
+    ({ id: recordId, ...body }) => {
+      if (!Object.keys(body).length || (requiredNames.length && !requiredNames.some(name => body[name]))) {
+        throw new ConnectorError("connector_input_invalid", "Enter the record's required identifying fields or changes.", { statusCode: 422 });
+      }
+      return { method, url: `https://api.apollo.io/api/v1/${endpoint}${recordId ? `/${recordId}` : ""}`, body };
+    }, record(key));
+}
+const apolloIoProvider = Object.freeze({
+  ...apolloIoDefinition,
+  apiOrigins: ["https://api.apollo.io"],
+  apiKey: { headers: (key) => ({ "X-Api-Key": key }) },
+  checkOperation: "accounts.search",
+  operations: {
+    "accounts.search": jsonOperation("https://api.apollo.io/api/v1/accounts/search", {
+      ...page, q_organization_name: text
+    }, collection("accounts"), "POST"),
+    "people.search": validatedOperation({ ...page, q_person_name: text, q_keywords: text,
+      person_titles: strings, person_locations: strings, organization_ids: strings,
+      q_organization_domains_list: { ...strings, items: domain },
+      include_similar_titles: { type: "boolean" }
+    }, input => query("POST", "mixed_people/api_search", input), collection("people")),
+    "organizations.search": validatedOperation({ ...page, q_organization_name: text,
+      q_organization_domains_list: { ...strings, items: domain }, organization_locations: strings,
+      allowCreditConsumption: charge
+    }, input => query("POST", "mixed_companies/search", input), collection("organizations")),
+    "people.enrich": validatedOperation({ id: { ...id, required: true }, allowCreditConsumption: charge,
+      reveal_personal_emails: { type: "boolean", defaultTo: false }
+    }, input => query("POST", "people/match", { ...input, reveal_phone_number: false,
+      run_waterfall_email: false, run_waterfall_phone: false }),
+      result => result?.person === null || record("person")(result)),
+    "organizations.enrich": validatedOperation({ domain: { ...domain, required: true }, allowCreditConsumption: charge },
+      input => query("GET", "organizations/enrich", input),
+      result => result?.organization === null || record("organization")(result)),
+    "contacts.search": jsonOperation("https://api.apollo.io/api/v1/contacts/search", {
+      ...page, q_keywords: text, contact_stage_ids: strings, contact_label_ids: strings
+    }, collection("contacts"), "POST"),
+    "contacts.create": write("POST", "contacts", { ...contactFields,
+      run_dedupe: { type: "boolean", required: true }
+    }, "contact", ["first_name", "last_name", "email"]),
+    "contacts.update": write("PATCH", "contacts", contactFields, "contact"),
+    "accounts.create": write("POST", "accounts", accountFields, "account", ["name", "domain"]),
+    "accounts.update": write("PATCH", "accounts", accountFields, "account"),
+    "deals.list": validatedOperation({ ...page, sort_by_field: { ...text, enum: ["amount", "is_closed", "is_won"] } },
+      input => query("GET", "opportunities/search", input), collection("opportunities")),
+    "deals.create": write("POST", "opportunities", { ...dealFields, name: { ...text, required: true }, account_id: id }, "opportunity"),
+    "deals.update": write("PATCH", "opportunities", dealFields, "opportunity"),
+    "dealStages.list": jsonOperation("https://api.apollo.io/api/v1/opportunity_stages", {}, collection("opportunity_stages")),
+    "users.list": validatedOperation(page, input => query("GET", "users/search", input), collection("users"))
+  }
+});
+export { apolloIoProvider };

package/src/server/asana.js

@@ -0,0 +1,64 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { asanaDefinition } from "../shared/tokens.js";
+import { jsonOperation, validatedOperation } from "./jsonOperation.js";
+
+const gid = { type: "string", minLength: 1, maxLength: 100, pattern: "^[0-9]+$" };
+const requiredGid = { ...gid, required: true };
+const page = { limit: { type: "integer", min: 1, max: 100, defaultTo: 50 }, offset: { type: "string", maxLength: 4096 } };
+const date = { type: "string", nullable: true, pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+  validator: value => { if (value === null) return true; const parsed = new Date(value);
+    return !Number.isNaN(parsed.valueOf()) && parsed.toISOString().slice(0, 10) === value || "Enter a real YYYY-MM-DD date."; } };
+const common = { name: { type: "string", minLength: 1, maxLength: 1000 },
+  notes: { type: "string", maxLength: 50000 }, due_on: date, start_on: date };
+const task = { ...common, completed: { type: "boolean" }, assignee: { ...gid, nullable: true },
+  parent: { ...gid, nullable: true } };
+const project = { ...common, archived: { type: "boolean" }, owner: { ...gid, nullable: true },
+  privacy_setting: { type: "string", enum: ["private", "public_to_workspace"] } };
+const taskFields = "gid,name,notes,completed,assignee.gid,assignee.name,due_on,start_on,projects.gid,parent.gid";
+const projectFields = "gid,name,notes,archived,owner.gid,privacy_setting,due_on,start_on,workspace.gid";
+const record = result => typeof result?.data?.gid === "string";
+const list = result => Array.isArray(result?.data);
+function read(endpoint, input = {}, fields) {
+  const url = new URL(`https://app.asana.com/api/1.0/${endpoint}`);
+  for (const [key, value] of Object.entries(input)) url.searchParams.set(key, String(value));
+  if (fields) url.searchParams.set("opt_fields", fields);
+  return { method: "GET", url: url.href };
+}
+function write(method, endpoint, fields, resultFields) {
+  return validatedOperation({ ...(method === "PUT" ? { gid: requiredGid } : {}), ...fields }, ({ gid: resource, ...data }) => {
+    if (!Object.keys(data).length) throw new ConnectorError("connector_input_invalid", "Supply at least one change.", { statusCode: 422 });
+    if (Object.hasOwn(data, "start_on") && !Object.hasOwn(data, "due_on")) throw new ConnectorError("connector_input_invalid", "Include due_on when setting or clearing start_on.", { statusCode: 422 });
+    if (data.start_on && data.due_on && (data.start_on > data.due_on || endpoint === "projects" && data.start_on === data.due_on)) {
+      throw new ConnectorError("connector_input_invalid", "The start date must precede the project due date, or be no later than the task due date.", { statusCode: 422 });
+    }
+    const request = read(`${endpoint}${resource ? `/${resource}` : ""}`, {}, resultFields);
+    return { ...request, method, body: { data } };
+  }, record);
+}
+const asanaProvider = Object.freeze({
+  ...asanaDefinition, apiOrigins: ["https://app.asana.com"],
+  apiKey: { headers: (key) => ({ Authorization: `Bearer ${key}` }) },
+  checkOperation: "workspaces.list",
+  operations: {
+    "workspaces.list": jsonOperation("https://app.asana.com/api/1.0/workspaces", page, list),
+    "projects.list": validatedOperation({ workspace: requiredGid, ...page, archived: { type: "boolean" } },
+      input => read("projects", input, projectFields), list),
+    "projects.get": validatedOperation({ gid: requiredGid }, ({ gid }) => read(`projects/${gid}`, {}, projectFields), record),
+    "projects.create": write("POST", "projects", { ...project, name: { ...common.name, required: true },
+      workspace: requiredGid, privacy_setting: { ...project.privacy_setting, required: true } }, projectFields),
+    "projects.update": write("PUT", "projects", project, projectFields),
+    "tasks.list": validatedOperation({ project: requiredGid, ...page, completed_since: { type: "string", maxLength: 100 } },
+      ({ project, ...input }) => read(`projects/${project}/tasks`, input, taskFields), list),
+    "tasks.get": validatedOperation({ gid: requiredGid }, ({ gid }) => read(`tasks/${gid}`, {}, taskFields), record),
+    "tasks.create": write("POST", "tasks", { ...task, name: { ...common.name, required: true }, workspace: requiredGid,
+      projects: { type: "array", items: gid, validator: values => values.length <= 100 || "Choose at most 100 projects." } }, taskFields),
+    "tasks.update": write("PUT", "tasks", task, taskFields),
+    "users.list": validatedOperation({ workspace: requiredGid, ...page }, ({ workspace, ...input }) => read(`workspaces/${workspace}/users`, input), list),
+    "teams.list": validatedOperation({ workspace: requiredGid, ...page }, ({ workspace, ...input }) => read(`workspaces/${workspace}/teams`, input), list),
+    "projectMembers.add": validatedOperation({ project: requiredGid, member: requiredGid,
+      access_level: { type: "string", required: true, enum: ["admin", "editor", "commenter"] } },
+      ({ project, member, access_level }) => ({ method: "POST", url: "https://app.asana.com/api/1.0/memberships",
+        body: { data: { parent: project, member, access_level } } }), record)
+  }
+});
+export { asanaProvider };