@jskit-ai/connectors-catalog 0.1.1

package/src/server/ashby.js

@@ -0,0 +1,61 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { ashbyDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const text = { type: "string", minLength: 1, maxLength: 256 };
+const uuid = { type: "string", required: true,
+  pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$" };
+const page = { limit: { type: "integer", min: 1, max: 100, defaultTo: 25 },
+  cursor: { type: "string", minLength: 1, maxLength: 8192 }, syncToken: { type: "string", minLength: 1, maxLength: 8192 } };
+const candidate = { name: text, email: { ...text, pattern: "^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$" }, phoneNumber: text };
+function response(check) {
+  return result => {
+    if (result?.success === false) throw new ConnectorError("connector_provider_failed", "Ashby could not complete the operation.", { statusCode: 502 });
+    return result?.success === true && check(result);
+  };
+}
+const record = response(result => typeof result.results?.id === "string");
+const paged = response(result => Array.isArray(result.results) && typeof result.moreDataAvailable === "boolean" &&
+  (!result.moreDataAvailable || typeof result.nextCursor === "string" && result.nextCursor.length > 0) &&
+  (result.syncToken === undefined || typeof result.syncToken === "string" && result.syncToken.length > 0));
+const call = (endpoint, fields, validate = record) => jsonOperation(`https://api.ashbyhq.com/${endpoint}`, fields, validate, "POST");
+
+const candidateUpdate = call("candidate.update", { candidateId: uuid, ...candidate,
+  sendNotifications: { type: "boolean", defaultTo: false } });
+const ashbyProvider = Object.freeze({
+  ...ashbyDefinition,
+  apiOrigins: ["https://api.ashbyhq.com"],
+  apiKey: { headers: (key) => {
+    if (/[:\s\p{Cc}]/u.test(key)) throw new ConnectorError("connector_binding_missing", "Use the Ashby API key without spaces, control characters or colons.");
+    return { Authorization: `Basic ${Buffer.from(`${key}:`).toString("base64")}`, Accept: "application/json; version=1" };
+  } },
+  checkOperation: "jobs.list",
+  operations: {
+    "jobs.list": call("job.list", page, paged),
+    "jobs.get": call("job.info", { id: uuid }),
+    "candidates.list": call("candidate.list", page, paged),
+    "candidates.get": call("candidate.info", { id: uuid }),
+    "candidates.create": call("candidate.create", { ...candidate, name: { ...text, required: true } }),
+    "candidates.update": { ...candidateUpdate, request(input) {
+      const request = candidateUpdate.request(input);
+      if (!["name", "email", "phoneNumber"].some(key => Object.hasOwn(request.body, key))) {
+        throw new ConnectorError("connector_input_invalid", "Supply at least one candidate profile change.", { statusCode: 422 });
+      }
+      return request;
+    } },
+    "applications.list": call("application.list", { ...page, jobId: { ...uuid, required: false },
+      status: { type: "string", enum: ["Hired", "Archived", "Active", "Lead"] }
+    }, paged),
+    "applications.get": call("application.info", { applicationId: uuid }),
+    "applications.create": call("application.create", { candidateId: uuid, jobId: uuid,
+      interviewPlanId: { ...uuid, required: false }, interviewStageId: { ...uuid, required: false }
+    }),
+    "applications.changeStage": call("application.changeStage", { applicationId: uuid, interviewStageId: uuid,
+      archiveReasonId: { ...uuid, required: false }
+    }),
+    "interviewPlans.list": call("interviewPlan.list", { ...page, includeArchived: { type: "boolean", defaultTo: false } }, paged),
+    "archiveReasons.list": call("archiveReason.list", { includeArchived: { type: "boolean", defaultTo: false } }, response(result => Array.isArray(result.results))),
+    "interviewStages.list": call("interviewStage.list", { interviewPlanId: uuid }, response(result => Array.isArray(result.results)))
+  }
+});
+export { ashbyProvider };

package/src/server/atlassian.js

@@ -0,0 +1,32 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { atlassianDefinition } from "../shared/atlassian.js";
+import { mcpOperations, exchangeMcp } from "./mcpTransport.js";
+import { mcpRegistrationFields, registerMcpClient } from "./mcpRegistration.js";
+
+const resource = "https://mcp.atlassian.com/v2/mcp";
+const oauth = Object.freeze({
+  issuer: "https://auth.atlassian.com/VCeDsk8ZHncYF1g234fKtc4lNipbBhu3",
+  authorization_endpoint: "https://auth.atlassian.com/authorize",
+  token_endpoint: "https://auth.atlassian.com/oauth/token",
+  registration_endpoint: atlassianDefinition.setup.clientRegistrationEndpoint,
+  response_types_supported: ["code"]
+});
+const atlassianProvider = Object.freeze({
+  ...atlassianDefinition, oauth, oauthResource: resource,
+  apiOrigins: ["https://mcp.atlassian.com"], checkOperation: "tools.list", exchange: exchangeMcp,
+  operations: mcpOperations(() => `${resource}?tools=all`)
+});
+const registrationSchema = createSchema({
+  ...mcpRegistrationFields,
+  scopes: { type: "array", required: true, minLength: 1,
+    items: { type: "string", enum: atlassianDefinition.scopes.map((scope) => scope.value) },
+    validator: (scopes) => scopes.length > 0 && new Set(scopes).size === scopes.length || "Select at least one permission and include each once." }
+});
+
+async function registerAtlassianClient(input, options) {
+  const values = validateSchemaPayload({ schema: registrationSchema, mode: "replace" }, input, { statusCode: 422 });
+  return registerMcpClient("Atlassian", oauth, values, options);
+}
+
+export { atlassianProvider, registerAtlassianClient };

package/src/server/attention.js

@@ -0,0 +1,93 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { attentionDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const text = { type: "string", minLength: 1, maxLength: 2000 };
+const id = { type: "string", minLength: 1, maxLength: 100, pattern: "^[A-Za-z0-9_-]+$" };
+const requiredId = { ...id, required: true };
+const ids = { type: "array", items: id, validator: value => value.length <= 100 || "Use at most 100 IDs." };
+const bool = { type: "boolean" };
+const page = { page: { type: "integer", min: 1, defaultTo: 1 }, size: { type: "integer", min: 1, max: 200, defaultTo: 50 } };
+const dateTime = { ...text, validator: value => /^\d{4}-\d{2}-\d{2}T/.test(value) && Number.isFinite(Date.parse(value)) || "Use an ISO timestamp." };
+const list = result => Array.isArray(result?.data);
+const record = result => result?.data !== null && typeof result?.data === "object" && !Array.isArray(result.data) && typeof (result.data.uuid ?? result.data.id) === "string";
+const conversation = result => result?.type === "conversations" && typeof result.id === "string" && result.attributes !== null && typeof result.attributes === "object" && !Array.isArray(result.attributes);
+function operation(method, endpoint, fields, validateResult, prepare = value => value) {
+  const schema = createSchema(fields);
+  return { scopes: [], request(input) {
+    const values = prepare(validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 }));
+    const { id: resource, ...body } = values;
+    const url = new URL(`https://api.attention.tech/v2/${endpoint.replace("{id}", resource || "")}`);
+    if (method === "GET") { for (const [key, value] of Object.entries(body)) url.searchParams.set(key, String(value)); return { method, url: url.href }; }
+    if (method === "DELETE") return { method, url: url.href };
+    if (!Object.keys(body).length) throw new ConnectorError("connector_input_invalid", "Supply at least one change.", { statusCode: 422 });
+    return { method, url: url.href, body };
+  }, validateResult };
+}
+const team = { type: "object", schema: createSchema({ uuid: requiredId, primary: bool }) };
+const attentionProvider = Object.freeze({
+  ...attentionDefinition,
+  apiOrigins: ["https://api.attention.tech"],
+  apiKey: { headers: (key) => ({ Authorization: `Bearer ${key}` }) },
+  checkOperation: "conversations.list",
+  operations: {
+    "conversations.get": operation("GET", "conversations/{id}", { id: requiredId, by: { type: "string", enum: ["id", "external_id"] },
+      detailedTranscript: { ...bool, defaultTo: true }, "filter[include_internal_participants]": bool,
+      "filter[include_zoom_metadata]": bool, "filter[include_import_metadata]": bool }, conversation),
+    "conversations.update": operation("PUT", "conversations/{id}", { id: requiredId, title: text, labels: { type: "object", additionalProperties: true } }, conversation),
+    "conversations.archive": operation("DELETE", "conversations/{id}", { id: requiredId }, conversation),
+    "conversations.import": operation("POST", "conversations/import", {
+      mediaURL: { ...text, required: true, validator: value => { try { const url = new URL(value); return url.protocol === "https:" && !url.username && !url.password || "Use an HTTPS media URL without embedded credentials."; } catch { return "Use an HTTPS media URL."; } } },
+      userID: requiredId, applicationName: text, applicationExternalID: id, conversationTitle: text,
+      conversationStartedAt: dateTime, opportunityID: id, skipScorecardCalculation: bool,
+      skipCRMFieldsCalculation: bool, skipOpportunitiesExport: bool
+    }, result => typeof result?.uuid === "string"),
+    "snippets.create": operation("POST", "snippets", { user_uuid: requiredId, conversation_id: requiredId,
+      internal: { ...bool, required: true }, notify_views: { ...bool, required: true }, title: text, notes: { type: "string", maxLength: 20000 },
+      video: { type: "object", required: true, schema: createSchema({ start_time: { type: "number", required: true, min: 0 }, end_time: { type: "number", required: true, min: 0 } }),
+        validator: value => value.end_time > value.start_time || "End time must follow start time." }
+    }, result => typeof result?.id === "string" && typeof result.url === "string"),
+    "analysis.ask": operation("POST", "ask_attention/v2", { conversations_ids: { ...ids, required: true },
+      deal_id: { type: "string", required: true, maxLength: 100 }, prompt: { ...text, required: true, maxLength: 20000 }
+    }, result => Array.isArray(result) && result.every(item => typeof item?.output === "string" && typeof item.error === "string" && typeof item.conversation_id === "string")),
+    "scorecards.list": operation("GET", "scorecards", page, list),
+    "scorecards.get": operation("GET", "scorecards/{id}", { id: requiredId }, record),
+    "scorecardItems.list": operation("GET", "scorecards/{id}/items", { id: requiredId, ...page }, list),
+    "scorecards.summary": operation("POST", "scorecards/summary", { fromDateTime: { ...dateTime, required: true }, toDateTime: { ...dateTime, required: true },
+      scorecardUUID: requiredId, scorecardsItemsUUIDs: { ...ids, required: true }, teamUUIDs: { ...ids, required: true }, userUUIDs: { ...ids, required: true }
+    }, list, value => { if (Date.parse(value.fromDateTime) >= Date.parse(value.toDateTime)) throw new ConnectorError("connector_input_invalid", "End time must follow start time.", { statusCode: 422 }); return value; }),
+    "scorecardResults.create": operation("POST", "createScorecardResult", { scorecard_uuid: requiredId, conversation_uuid: requiredId,
+      summary: { ...text, required: true, maxLength: 20000 }, items: { type: "array", required: true,
+        items: { type: "object", schema: createSchema({ scorecard_item_uuid: requiredId, numeric_result: { type: "integer" }, description: { ...text, required: true } }) },
+        validator: value => value.length > 0 && value.length <= 100 || "Supply 1–100 scoring items." }
+    }, result => result?.success === true),
+    "users.list": operation("GET", "organizations/users", { teamUUID: id }, list),
+    "roles.list": operation("GET", "organizations/roles", {}, list),
+    "users.create": operation("POST", "organizations/users", { email: { ...text, required: true, pattern: "^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$" },
+      first_name: { ...text, required: true }, last_name: { ...text, required: true }, roleUUID: requiredId,
+      seat_type: { type: "string", required: true, enum: ["listener", "recording"] },
+      teams: { type: "array", required: true, items: team, validator: value => value.length > 0 && value.length <= 100 || "Supply 1–100 teams." }
+    }, record),
+    "users.update": operation("PATCH", "organizations/users/{id}", { id: requiredId, firstName: text, lastName: text,
+      roleUUID: id, seat_type: { type: "string", enum: ["listener", "recording"] }, teamUUIDsToRemove: ids,
+      teamsToAdd: { type: "array", items: team, validator: value => value.length <= 100 || "Use at most 100 teams." }
+    }, record),
+    "users.delete": operation("DELETE", "organizations/users/{id}", { id: requiredId }, result => result === null || result !== null && typeof result === "object" && !Array.isArray(result) && Object.keys(result).length === 0),
+    "teams.list": operation("GET", "organizations/teams", {}, list),
+    "teams.create": operation("POST", "organizations/teams", { name: { ...text, required: true }, parentTeamUUID: id }, record),
+    "teams.update": operation("PATCH", "organizations/teams/{id}", { id: requiredId, name: text, parentTeamUUID: id }, record),
+    "conversations.list": jsonOperation("https://api.attention.tech/v2/conversations/list", {
+      page: { type: "integer", min: 1, max: 100000, defaultTo: 1 },
+      size: { type: "integer", min: 1, max: 50, defaultTo: 20 },
+      "filter[title]": { type: "string", minLength: 1, maxLength: 500 },
+      "filter[hide_internal]": { type: "boolean" },
+      detailedTranscript: { type: "boolean", defaultTo: false }
+    }, (result) => Array.isArray(result?.data) && (result.meta === undefined ||
+      result.meta !== null && typeof result.meta === "object" && !Array.isArray(result.meta) &&
+      ["totalRecords", "pageCount", "pageNumber", "pageSize"].every((field) => result.meta[field] === undefined ||
+        Number.isInteger(result.meta[field]) && result.meta[field] >= 0)))
+  }
+});
+export { attentionProvider };

package/src/server/aws-athena.js

@@ -0,0 +1,82 @@
+import { AthenaClient, GetWorkGroupCommand, StartQueryExecutionCommand, GetQueryExecutionCommand, GetQueryResultsCommand, StopQueryExecutionCommand, ListDataCatalogsCommand, ListDatabasesCommand, ListTableMetadataCommand } from "@aws-sdk/client-athena";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { awsAthenaDefinition } from "../shared/aws.js";
+import { awsOrigin, awsOperation, awsExchange } from "./awsTransport.js";
+
+const queryId = { type: "string", required: true, minLength: 1, maxLength: 128, pattern: "^\\S+$" };
+const validQuery = (r) => typeof r?.QueryExecution?.QueryExecutionId === "string" && typeof r.QueryExecution.WorkGroup === "string" &&
+  ["QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED"].includes(r.QueryExecution.Status?.State);
+const metadataPage = {
+  maxResults: { type: "integer", min: 1, max: 50, defaultTo: 50 },
+  nextToken: { type: "string", noTrim: true, minLength: 1, maxLength: 1024 }
+};
+const catalog = { type: "string", required: true, noTrim: true, minLength: 1, maxLength: 256 };
+const metadataInput = (v, s) => ({ input: { WorkGroup: s.workgroup, MaxResults: v.maxResults,
+  ...(v.nextToken ? { NextToken: v.nextToken } : {}),
+  ...(v.catalog ? { CatalogName: v.catalog } : {}),
+  ...(v.database ? { DatabaseName: v.database } : {}) } });
+const validCursor = (r) => r.NextToken === undefined || typeof r.NextToken === "string" && r.NextToken.length > 0 && r.NextToken.length <= 1024;
+const validColumns = (columns) => columns === undefined || Array.isArray(columns) && columns.every((c) => typeof c?.Name === "string" && typeof c.Type === "string");
+const queryInput = (v) => ({ input: { QueryExecutionId: v.queryId } });
+const awsAthenaProvider = Object.freeze({
+  ...awsAthenaDefinition,
+  apiOrigins: (settings) => [awsOrigin("athena", settings)], apiKey: { headers: () => ({}) }, checkOperation: "workgroup.get",
+  exchange: awsExchange("athena", AthenaClient, async (client, body, { settings, signal }) => {
+    const send = (command) => client.send(command, { abortSignal: signal });
+    if (body.command === "GetWorkGroup") {
+      const result = await send(new GetWorkGroupCommand(body.input));
+      if (result.WorkGroup?.Name !== settings.workgroup) throw new ConnectorError("connector_response_invalid", "Athena returned a different workgroup.", { statusCode: 502 });
+      return result;
+    }
+    if (body.command === "ListDataCatalogs") return send(new ListDataCatalogsCommand(body.input));
+    if (body.command === "ListDatabases") return send(new ListDatabasesCommand(body.input));
+    if (body.command === "ListTableMetadata") return send(new ListTableMetadataCommand(body.input));
+    if (body.command === "StartQueryExecution") return send(new StartQueryExecutionCommand(body.input));
+    const query = await send(new GetQueryExecutionCommand({ QueryExecutionId: body.input.QueryExecutionId }));
+    if (!validQuery(query) || query.QueryExecution.QueryExecutionId !== body.input.QueryExecutionId) {
+      throw new ConnectorError("connector_response_invalid", "Athena returned an unexpected query.", { statusCode: 502 });
+    }
+    if (query.QueryExecution.WorkGroup !== settings.workgroup) {
+      throw new ConnectorError("connector_access_denied", "This query belongs to a different workgroup.", { statusCode: 403 });
+    }
+    if (body.command === "GetQueryExecution") return query;
+    if (body.command === "GetQueryResults") return send(new GetQueryResultsCommand(body.input));
+    return send(new StopQueryExecutionCommand(body.input));
+  }),
+  operations: {
+    "catalogs.list": awsOperation("athena", "ListDataCatalogs", {
+      ...metadataPage, maxResults: { ...metadataPage.maxResults, min: 2 }
+    }, metadataInput, (r) => Array.isArray(r?.DataCatalogsSummary) && r.DataCatalogsSummary.length <= 50 &&
+      r.DataCatalogsSummary.every((c) => typeof c?.CatalogName === "string" && typeof c.Type === "string") && validCursor(r)),
+    "databases.list": awsOperation("athena", "ListDatabases", { ...metadataPage, catalog }, metadataInput,
+      (r) => Array.isArray(r?.DatabaseList) && r.DatabaseList.length <= 50 &&
+        r.DatabaseList.every((d) => typeof d?.Name === "string") && validCursor(r)),
+    "tables.list": awsOperation("athena", "ListTableMetadata", { ...metadataPage, catalog,
+      database: { type: "string", required: true, noTrim: true, minLength: 1, maxLength: 128 }
+    }, metadataInput, (r) => Array.isArray(r?.TableMetadataList) && r.TableMetadataList.length <= 50 &&
+      r.TableMetadataList.every((t) => typeof t?.Name === "string" && validColumns(t.Columns) && validColumns(t.PartitionKeys)) && validCursor(r)),
+    "workgroup.get": awsOperation("athena", "GetWorkGroup", {}, (_, s) => ({ input: { WorkGroup: s.workgroup } }),
+      (r) => typeof r?.WorkGroup?.Name === "string" && ["ENABLED", "DISABLED"].includes(r.WorkGroup.State)),
+    "query.start": awsOperation("athena", "StartQueryExecution", {
+      sql: { type: "string", required: true, noTrim: true, minLength: 1, maxLength: 262144,
+        validator: (value) => (value.trim().length > 0 && Buffer.byteLength(value, "utf8") <= 262144) || "Enter SQL of at most 262144 UTF-8 bytes." },
+      clientRequestToken: { type: "string", required: true, noTrim: true, minLength: 32, maxLength: 128 },
+      database: { type: "string", minLength: 1, maxLength: 255 }, catalog: { type: "string", minLength: 1, maxLength: 256 }
+    }, (v, s) => ({ input: { QueryString: v.sql, ClientRequestToken: v.clientRequestToken, WorkGroup: s.workgroup,
+      ...(v.database || v.catalog ? { QueryExecutionContext: { ...(v.database ? { Database: v.database } : {}), ...(v.catalog ? { Catalog: v.catalog } : {}) } } : {}),
+      ...(s.resultLocation ? { ResultConfiguration: { OutputLocation: s.resultLocation } } : {}) } }),
+    (r) => typeof r?.QueryExecutionId === "string" && /^\S{1,128}$/u.test(r.QueryExecutionId)),
+    "query.status": awsOperation("athena", "GetQueryExecution", { queryId }, queryInput, validQuery),
+    "query.results": awsOperation("athena", "GetQueryResults", { queryId,
+      maxResults: { type: "integer", min: 1, max: 1000, defaultTo: 100 }, nextToken: { type: "string", noTrim: true, minLength: 1, maxLength: 1024 }
+    }, (v) => ({ input: { QueryExecutionId: v.queryId, MaxResults: v.maxResults, QueryResultType: "DATA_ROWS", ...(v.nextToken ? { NextToken: v.nextToken } : {}) } }),
+    (r) => Array.isArray(r?.ResultSet?.ResultSetMetadata?.ColumnInfo) &&
+      r.ResultSet.ResultSetMetadata.ColumnInfo.every((c) => typeof c.Name === "string" && typeof c.Type === "string") &&
+      Array.isArray(r.ResultSet.Rows) && r.ResultSet.Rows.length <= 1000 &&
+      r.ResultSet.Rows.every((row) => Array.isArray(row.Data) && row.Data.every((cell) => cell && (cell.VarCharValue === undefined || typeof cell.VarCharValue === "string"))) &&
+      (r.NextToken === undefined || typeof r.NextToken === "string" && r.NextToken.length > 0)),
+    "query.cancel": awsOperation("athena", "StopQueryExecution", { queryId }, queryInput, (r) => r && Object.keys(r).length === 0)
+  }
+});
+
+export { awsAthenaProvider };

package/src/server/aws-s3.js

@@ -0,0 +1,49 @@
+import { S3Client, ListObjectsV2Command, GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { awsS3Definition } from "../shared/aws.js";
+import { awsOrigin, awsOperation, awsExchange } from "./awsTransport.js";
+
+const key = { type: "string", required: true, noTrim: true, minLength: 1, maxLength: 1024,
+  validator: (value) => (Buffer.byteLength(value, "utf8") <= 1024 && !value.split("/").some((part) => part === "." || part === "..")) || "Use an object key of at most 1024 UTF-8 bytes, without standalone . or .. path segments." };
+const expires = { type: "integer", min: 1, max: 900, defaultTo: 300 };
+const validUrl = (result) => typeof result?.url === "string" && Number.isInteger(result.expiresInSeconds) && ["GET", "PUT"].includes(result.method);
+const awsS3Provider = Object.freeze({
+  ...awsS3Definition,
+  apiOrigins: (settings) => [awsOrigin("s3", settings)],
+  apiKey: { headers: () => ({}) },
+  checkOperation: "objects.list",
+  exchange: awsExchange("s3", S3Client, async (client, body, { settings, signal }) => {
+    if (body.command === "ListObjectsV2") {
+      const result = await client.send(new ListObjectsV2Command(body.input), { abortSignal: signal });
+      if (result.Name !== settings.bucket || (result.Contents?.length || 0) > body.input.MaxKeys) {
+        throw new ConnectorError("connector_response_invalid", "S3 returned an unexpected bucket or page size.", { statusCode: 502 });
+      }
+      return result;
+    }
+    const upload = body.command === "PutObject";
+    const command = upload ? new PutObjectCommand(body.input) : new GetObjectCommand(body.input);
+    const url = await getSignedUrl(client, command, { expiresIn: body.expiresInSeconds });
+    return { url, method: upload ? "PUT" : "GET", expiresInSeconds: body.expiresInSeconds };
+  }),
+  operations: {
+    "objects.list": awsOperation("s3", "ListObjectsV2", {
+      maxKeys: { type: "integer", min: 1, max: 1000, defaultTo: 100 },
+      prefix: { type: "string", noTrim: true, maxLength: 1024 },
+      delimiter: { type: "string", enum: ["/"] },
+      continuationToken: { type: "string", noTrim: true, minLength: 1, maxLength: 8192 }
+    }, (v, s) => ({ input: { Bucket: s.bucket, MaxKeys: v.maxKeys, EncodingType: "url",
+      ...(v.prefix === undefined ? {} : { Prefix: v.prefix }), ...(v.delimiter ? { Delimiter: v.delimiter } : {}),
+      ...(v.continuationToken ? { ContinuationToken: v.continuationToken } : {}) } }),
+    (r) => typeof r?.Name === "string" && typeof r.IsTruncated === "boolean" && Number.isInteger(r.KeyCount) && r.KeyCount >= 0 &&
+      (!r.IsTruncated || typeof r.NextContinuationToken === "string" && r.NextContinuationToken.length > 0) &&
+      (r.Contents === undefined || Array.isArray(r.Contents) && r.Contents.every((o) => typeof o.Key === "string" && Number.isInteger(o.Size) && o.Size >= 0)) &&
+      (r.CommonPrefixes === undefined || Array.isArray(r.CommonPrefixes) && r.CommonPrefixes.every((p) => typeof p.Prefix === "string")), ["read"]),
+    "objects.downloadUrl": awsOperation("s3", "GetObject", { key, expiresInSeconds: expires },
+      (v, s) => ({ input: { Bucket: s.bucket, Key: v.key }, expiresInSeconds: v.expiresInSeconds }), validUrl, ["read"]),
+    "objects.uploadUrl": awsOperation("s3", "PutObject", { key, expiresInSeconds: expires },
+      (v, s) => ({ input: { Bucket: s.bucket, Key: v.key }, expiresInSeconds: v.expiresInSeconds }), validUrl, ["write"])
+  }
+});
+
+export { awsS3Provider };

package/src/server/awsTransport.js

@@ -0,0 +1,75 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { FetchHttpHandler } from "@smithy/fetch-http-handler";
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+
+const awsOrigin = (service, settings) => `https://${service}.${settings.region}.amazonaws.com`;
+
+function awsOperation(service, command, fields, makeInput, validateResult, scopes = []) {
+  const schema = createSchema(fields);
+  return {
+    scopes,
+    request(input, settings) {
+      const values = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+      return { method: "POST", url: awsOrigin(service, settings), body: { command, ...makeInput(values, settings) } };
+    },
+    validateResult
+  };
+}
+
+function awsExchange(service, Client, execute) {
+  return async (endpoint, options, { settings, apiKey, resolveReference, fetchImpl }) => {
+    let credentials;
+    try {
+      const accessKeyId = await resolveReference(settings.accessKeyIdRef);
+      const sessionToken = settings.sessionTokenRef ? await resolveReference(settings.sessionTokenRef) : undefined;
+      if (typeof accessKeyId !== "string" || !/^[A-Z0-9]{16,128}$/u.test(accessKeyId) || !apiKey ||
+        (settings.sessionTokenRef && (typeof sessionToken !== "string" || !sessionToken || /\s/u.test(sessionToken))) ||
+        (accessKeyId.startsWith("ASIA") && !sessionToken)) throw new Error("Invalid credentials");
+      credentials = { accessKeyId, secretAccessKey: apiKey, ...(sessionToken ? { sessionToken } : {}) };
+    } catch {
+      throw new ConnectorError("connector_binding_missing", "Provide the AWS access key ID, secret access key and any required session token bindings.");
+    }
+    const origin = awsOrigin(service, settings);
+    if (new URL(endpoint).origin !== origin) throw new ConnectorError("connector_destination_invalid", "The AWS region does not match the operation destination.");
+    const client = new Client({ region: settings.region, endpoint: origin, credentials, maxAttempts: 1,
+      ...(service === "s3" ? { forcePathStyle: true, followRegionRedirects: false, requestChecksumCalculation: "WHEN_REQUIRED" } : {}),
+      requestHandler: new FetchHttpHandler({
+        requestInit: () => ({ credentials: "omit", redirect: "error" }),
+        customFetch: async (request) => {
+          if (new URL(request.url).origin !== origin) throw new ConnectorError("connector_destination_invalid", "The AWS SDK selected an unexpected destination.");
+          options.signal.throwIfAborted();
+          return fetchImpl(request.url, { method: request.method, headers: request.headers,
+            ...(request.body ? { body: await request.text() } : {}), signal: options.signal, credentials: "omit", redirect: "error" });
+        }
+      })
+    });
+    try {
+      options.signal.throwIfAborted();
+      const result = await execute(client, options.body, { settings, signal: options.signal });
+      options.signal.throwIfAborted();
+      const { $metadata, ...data } = result;
+      return data;
+    } catch (error) {
+      options.signal.throwIfAborted();
+      if (error instanceof ConnectorError || ["AbortError", "TimeoutError"].includes(error.name)) throw error;
+      const status = error.$metadata?.httpStatusCode;
+      if (["ExpiredToken", "ExpiredTokenException", "InvalidAccessKeyId", "InvalidClientTokenId", "UnrecognizedClientException", "InvalidToken", "SignatureDoesNotMatch"].includes(error.name) || status === 401) {
+        throw new ConnectorError("connector_reconnect_required", "Renew the AWS credential bindings and connect again.", { statusCode: 401 });
+      }
+      if (["TooManyRequestsException", "ThrottlingException", "SlowDown", "RequestLimitExceeded", "ActiveStatementsExceededException", "ActiveSessionsExceededException", "ActiveWaitingRequestsExceededException"].includes(error.name) || status === 429) {
+        throw new ConnectorError("connector_rate_limited", "The AWS request limit was reached.", { statusCode: 429 });
+      }
+      if (status === 403) throw new ConnectorError("connector_permission_denied", "AWS denied this operation. Check IAM, resource and database permissions.", { statusCode: 403 });
+      if (status === 404 || error.name === "ResourceNotFoundException") throw new ConnectorError("connector_not_found", "The AWS resource was not found.", { statusCode: 404 });
+      if (status === 301 || status === 307 || ["AuthorizationHeaderMalformed", "PermanentRedirect", "InvalidRequestException", "ValidationException"].includes(error.name)) {
+        throw new ConnectorError("connector_configuration_invalid", "Check the AWS region, resource and operation settings.", { statusCode: 422 });
+      }
+      throw new ConnectorError("connector_provider_failed", "The AWS request failed or returned an unreadable response.", { statusCode: 502 });
+    } finally {
+      client.destroy();
+    }
+  };
+}
+
+export { awsOrigin, awsOperation, awsExchange };

package/src/server/bigquery.js

@@ -0,0 +1,97 @@
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { jsonOperation } from "./jsonOperation.js";
+import { bigqueryDefinition } from "../shared/google.js";
+import { googleRead, googleProvider, pageToken } from "./google.js";
+const origin = "https://bigquery.googleapis.com";
+const queryScopes = ["https://www.googleapis.com/auth/bigquery", "https://www.googleapis.com/auth/cloud-platform"];
+const resultFields = {
+  maxResults: { type: "integer", min: 1, max: 1000, defaultTo: 100 },
+  timeoutMs: { type: "integer", min: 0, max: 10000, defaultTo: 1000 },
+  location: { type: "string", minLength: 1, maxLength: 100, pattern: "^[a-zA-Z0-9-]+$" }
+};
+const resultsSchema = createSchema({ ...resultFields,
+  jobId: { type: "string", required: true, minLength: 1, maxLength: 1024, pattern: "^[a-zA-Z0-9_-]+$" }, pageToken: { ...pageToken, noTrim: true }
+});
+const validQueryResult = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value) && !value.error &&
+  typeof value.jobComplete === "boolean" && (value.rows === undefined || Array.isArray(value.rows) && value.rows.every((row) =>
+    Array.isArray(row?.f) && row.f.every((cell) => cell && typeof cell === "object" && !Array.isArray(cell) && Object.hasOwn(cell, "v")))) &&
+  (value.schema === undefined || Array.isArray(value.schema?.fields)) &&
+  (value.pageToken === undefined || typeof value.pageToken === "string") &&
+  (value.totalRows === undefined || (typeof value.totalRows === "string" && /^\d+$/.test(value.totalRows))) &&
+  (value.jobComplete || (typeof value.jobReference?.jobId === "string" && value.jobReference.jobId.length > 0)));
+const submitQuery = jsonOperation((settings) => `${origin}/bigquery/v2/projects/${encodeURIComponent(settings.projectId)}/queries`, {
+  ...resultFields,
+  query: { type: "string", required: true, noTrim: true, minLength: 1, maxLength: 1000000, validator: (value) => value.trim().length > 0 || "Enter SQL." },
+  parameters: { type: "array", validator: (values) => (values.length <= 100 && new Set(values.map((value) => value.name)).size === values.length) || "Use at most 100 uniquely named parameters.",
+    items: { type: "object", schema: createSchema({
+      name: { type: "string", required: true, minLength: 1, maxLength: 128, pattern: "^[a-zA-Z_][a-zA-Z0-9_]*$" },
+      type: { type: "string", required: true, enum: ["STRING", "INT64", "FLOAT64", "NUMERIC", "BIGNUMERIC", "BOOL", "DATE", "DATETIME", "TIME", "TIMESTAMP", "BYTES"] },
+      value: { type: "string", required: true, noTrim: true, maxLength: 1000000 }
+    }) }
+  },
+  maximumBytesBilled: { type: "string", minLength: 1, maxLength: 19, pattern: "^[0-9]+$" },
+  requestId: { type: "string", minLength: 1, maxLength: 36, pattern: "^[a-zA-Z0-9_-]+$" }
+}, validQueryResult, "POST");
+const metadataScopes = [...queryScopes, "https://www.googleapis.com/auth/bigquery.readonly", "https://www.googleapis.com/auth/cloud-platform.read-only"];
+const resourceId = { type: "string", required: true, noTrim: true, minLength: 1, maxLength: 1024,
+  // eslint-disable-next-line no-control-regex -- Reject literal control characters in provider input.
+  validator: (value) => (!/[\/\\\u0000-\u001f]/u.test(value) && value !== "." && value !== "..") || "Enter a resource ID, not a path." };
+const metadataPage = { maxResults: resultFields.maxResults, pageToken: { ...pageToken, noTrim: true } };
+const jobFields = { jobId: resultsSchema.getFieldDefinitions().jobId, location: resultFields.location };
+const validJob = (job) => Boolean(typeof job?.jobReference?.jobId === "string" && job.jobReference.jobId.length > 0 && typeof job.jobReference.projectId === "string" &&
+  ["PENDING", "RUNNING", "DONE"].includes(job.status?.state));
+const validPage = (result, field, reference) => Boolean(result && typeof result === "object" && !Array.isArray(result) && !result.error &&
+  (result[field] === undefined || Array.isArray(result[field]) && result[field].every((item) => typeof item?.[reference]?.projectId === "string")) &&
+  (result.nextPageToken === undefined || typeof result.nextPageToken === "string"));
+
+function projectOperation(fields, destination, validateResult, scopes = metadataScopes, method = "GET") {
+  const schema = createSchema(fields);
+  return { scopes, validateResult,
+    request(input, settings) {
+      const values = validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 });
+      const { path, query = {} } = destination(values);
+      const url = new URL(`${origin}/bigquery/v2/projects/${encodeURIComponent(settings.projectId)}${path}`);
+      for (const [name, value] of Object.entries(query)) if (value !== undefined) url.searchParams.set(name, String(value));
+      return { method, url: url.href };
+    }
+  };
+}
+const bigqueryProvider = googleProvider(bigqueryDefinition, origin, "projects.list", {
+  "datasets.list": projectOperation(metadataPage, (query) => ({ path: "/datasets", query }),
+    (result) => validPage(result, "datasets", "datasetReference")),
+  "tables.list": projectOperation({ datasetId: resourceId, ...metadataPage }, ({ datasetId, ...query }) => ({ path: `/datasets/${encodeURIComponent(datasetId)}/tables`, query }),
+    (result) => validPage(result, "tables", "tableReference")),
+  "tables.get": projectOperation({ datasetId: resourceId, tableId: resourceId }, ({ datasetId, tableId }) => ({ path: `/datasets/${encodeURIComponent(datasetId)}/tables/${encodeURIComponent(tableId)}` }),
+    (result) => Boolean(result?.tableReference?.tableId && result.tableReference.datasetId && typeof result.tableReference.projectId === "string" &&
+      (result.schema === undefined || Array.isArray(result.schema.fields)))),
+  "jobs.get": projectOperation(jobFields, ({ jobId, ...query }) => ({ path: `/jobs/${encodeURIComponent(jobId)}`, query }), validJob),
+  "jobs.cancel": projectOperation(jobFields, ({ jobId, ...query }) => ({ path: `/jobs/${encodeURIComponent(jobId)}/cancel`, query }),
+    (result) => validJob(result?.job), queryScopes, "POST"),
+  "jobs.query": { ...submitQuery, scopes: queryScopes,
+    request(input, settings) {
+      const request = submitQuery.request(input, settings);
+      const { parameters, ...body } = request.body;
+      return { ...request, body: { ...body, useLegacySql: false,
+        ...(parameters?.length ? { parameterMode: "NAMED", queryParameters: parameters.map(({ name, type, value }) => ({
+          name, parameterType: { type }, parameterValue: { value }
+        })) } : {})
+      } };
+    }
+  },
+  "jobs.getQueryResults": { scopes: queryScopes, validateResult: validQueryResult,
+    request(input, settings) {
+      const { jobId, ...query } = validateSchemaPayload({ schema: resultsSchema, mode: "replace" }, input, { statusCode: 422 });
+      const url = new URL(`${origin}/bigquery/v2/projects/${encodeURIComponent(settings.projectId)}/queries/${encodeURIComponent(jobId)}`);
+      for (const [key, value] of Object.entries(query)) if (value !== undefined) url.searchParams.set(key, String(value));
+      return { method: "GET", url: url.href };
+    }
+  },
+  "projects.list": googleRead(["bigquery.readonly", "bigquery", "cloud-platform.read-only", "cloud-platform"], {
+    maxResults: { type: "integer", min: 1, max: 50, defaultTo: 50 }, pageToken
+  }, (query) => ({ url: `${origin}/bigquery/v2/projects`, query }),
+  (result) => Boolean(result && typeof result === "object" && !Array.isArray(result) && !result.error
+    && Number.isInteger(result.totalItems) && result.totalItems >= 0
+    && (Array.isArray(result.projects) || (result.totalItems === 0 && result.projects === undefined))))
+});
+export { bigqueryProvider };

package/src/server/brevo.js

@@ -0,0 +1,97 @@
+import { ConnectorError } from "@jskit-ai/connectors-core/server";
+import { createSchema } from "json-rest-schema";
+import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { brevoDefinition } from "../shared/tokens.js";
+import { jsonOperation } from "./jsonOperation.js";
+
+const text = { type: "string", minLength: 1, maxLength: 1000 };
+const email = { ...text, maxLength: 320, pattern: "^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$" };
+const id = { type: "integer", min: 1, required: true };
+const bag = { type: "object", additionalProperties: true };
+const bool = { type: "boolean" };
+const page = { limit: { type: "integer", min: 1, max: 50, defaultTo: 50 }, offset: { type: "integer", min: 0, defaultTo: 0 } };
+const mailbox = { type: "object", schema: createSchema({ email: { ...email, required: true }, name: text }) };
+const ids = { type: "array", items: { type: "integer", min: 1 }, validator: value => value.length <= 100 || "Use at most 100 list IDs." };
+const emails = { type: "array", items: email, validator: value => value.length > 0 && value.length <= 150 || "Supply 1–150 email addresses." };
+const domain = { type: "string", minLength: 3, maxLength: 253, pattern: "^(?:[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?\\.)+[A-Za-z]{2,}$", required: true };
+const empty = result => result === null || result !== null && typeof result === "object" && !Array.isArray(result) && Object.keys(result).length === 0;
+const record = result => Number.isInteger(result?.id);
+function operation(method, endpoint, fields, validateResult, prepare = value => value) {
+  const schema = createSchema(fields);
+  return { scopes: [], request(input) {
+    const values = prepare(validateSchemaPayload({ schema, mode: "replace" }, input, { statusCode: 422 }));
+    const { resource, ...body } = values;
+    const url = new URL(`https://api.brevo.com/v3/${endpoint.replace("{resource}", encodeURIComponent(resource ?? ""))}`);
+    if (method === "GET") { for (const [key, value] of Object.entries(body)) url.searchParams.set(key, String(value)); return { method, url: url.href }; }
+    return { method, url: url.href, ...(Object.keys(body).length ? { body } : {}) };
+  }, validateResult };
+}
+function changed(value) {
+  if (Object.keys(value).every(key => key === "resource")) throw new ConnectorError("connector_input_invalid", "Supply at least one change.", { statusCode: 422 });
+  return value;
+}
+const content = value => {
+  if (value.templateId === undefined && !(value.subject && (value.htmlContent || value.textContent))) {
+    throw new ConnectorError("connector_input_invalid", "Choose a template or provide a subject and email content.", { statusCode: 422 });
+  }
+  return value;
+};
+const contact = { attributes: bag, emailBlacklisted: bool, smsBlacklisted: bool, listIds: ids };
+const brevoProvider = Object.freeze({
+  ...brevoDefinition, apiOrigins: ["https://api.brevo.com"],
+  apiKey: { headers: (key) => ({ "api-key": key }) },
+  checkOperation: "contacts.list",
+  operations: {
+    "email.send": operation("POST", "smtp/email", { sender: { ...mailbox, required: true },
+      to: { type: "array", required: true, items: mailbox, validator: value => value.length > 0 && value.length <= 50 || "Supply 1–50 recipients." },
+      subject: text, htmlContent: { ...text, maxLength: 1000000 }, textContent: { ...text, maxLength: 1000000 },
+      templateId: { ...id, required: false }, params: bag, replyTo: mailbox
+    }, result => typeof result?.messageId === "string", content),
+    "sms.send": operation("POST", "transactionalSMS/sms", { sender: { ...text, required: true, maxLength: 15,
+      validator: value => /^[A-Za-z0-9]{1,11}$/.test(value) || /^[0-9]{12,15}$/.test(value) || "Use 1–11 letters/digits or 12–15 digits for the SMS sender." },
+      recipient: { type: "string", required: true, pattern: "^\\+?[0-9]{6,15}$" }, type: { type: "string", required: true, enum: ["transactional", "marketing"] },
+      content: { ...text, maxLength: 10000 }, templateId: { ...id, required: false }, params: bag, unicodeEnabled: bool, organisationPrefix: text, tag: text
+    }, result => Number.isInteger(result?.messageId) && typeof result.reference === "string", value => {
+      if ((value.content === undefined) === (value.templateId === undefined)) throw new ConnectorError("connector_input_invalid", "Choose SMS content or a template, not both.", { statusCode: 422 }); return value;
+    }),
+    "contacts.get": operation("GET", "contacts/{resource}", { resource: { ...email, required: true } }, record),
+    "contacts.create": operation("POST", "contacts", { email: { ...email, required: true }, ...contact,
+      updateEnabled: { ...bool, defaultTo: false } }, result => empty(result) || record(result)),
+    "contacts.update": operation("PUT", "contacts/{resource}", { resource: { ...email, required: true }, ...contact, unlinkListIds: ids }, empty, changed),
+    "folders.list": operation("GET", "contacts/folders", page, result => Array.isArray(result?.folders)),
+    "lists.list": operation("GET", "contacts/lists", page, result => Array.isArray(result?.lists)),
+    "lists.create": operation("POST", "contacts/lists", { name: { ...text, required: true }, folderId: id }, record),
+    "lists.addContacts": operation("POST", "contacts/lists/{resource}/contacts/add", { resource: id, emails: { ...emails, required: true } }, result => result?.contacts !== null && typeof result?.contacts === "object"),
+    "lists.removeContacts": operation("POST", "contacts/lists/{resource}/contacts/remove", { resource: id, emails: { ...emails, required: true } }, result => result?.contacts !== null && typeof result?.contacts === "object"),
+    "senders.list": operation("GET", "senders", {}, result => Array.isArray(result?.senders)),
+    "senders.create": operation("POST", "senders", { email: { ...email, required: true }, name: { ...text, required: true } }, record),
+    "domains.create": operation("POST", "senders/domains", { name: domain }, result => typeof result?.domain_name === "string" && typeof result.message === "string"),
+    "domains.get": operation("GET", "senders/domains/{resource}", { resource: domain }, result => typeof result?.domain === "string" && typeof result.verified === "boolean" && typeof result.authenticated === "boolean" && result.dns_records !== null && typeof result.dns_records === "object"),
+    "domains.authenticate": operation("PUT", "senders/domains/{resource}/authenticate", { resource: domain }, result => typeof result?.domain_name === "string" && typeof result.message === "string"),
+    "campaigns.list": operation("GET", "emailCampaigns", page, result => Array.isArray(result?.campaigns)),
+    "campaigns.get": operation("GET", "emailCampaigns/{resource}", { resource: id }, record),
+    "campaigns.create": operation("POST", "emailCampaigns", { name: { ...text, required: true }, sender: { ...mailbox, required: true },
+      subject: text, htmlContent: { ...text, maxLength: 1000000 }, templateId: { ...id, required: false }, params: bag,
+      recipients: { type: "object", required: true, schema: createSchema({ listIds: { ...ids, required: true,
+        validator: value => value.length > 0 && value.length <= 100 || "Choose 1–100 recipient lists." }, exclusionListIds: ids }) },
+      replyTo: email, previewText: text, tag: text
+    }, record, content),
+    "campaigns.sendTest": operation("POST", "emailCampaigns/{resource}/sendTest", { resource: id, emailTo: { ...emails, required: true } }, empty),
+    "campaigns.sendNow": operation("POST", "emailCampaigns/{resource}/sendNow", { resource: id }, empty),
+    "email.events": operation("GET", "smtp/statistics/events", { ...page, messageId: text, email, days: { type: "integer", min: 1, max: 90 },
+      event: { type: "string", enum: ["blocked", "bounces", "deferred", "delivered", "hardBounces", "invalid", "opened", "requests", "softBounces", "spam", "unsubscribed", "clicks", "error", "loadedByProxy"] }
+    }, result => Array.isArray(result?.events)),
+    "sms.events": operation("GET", "transactionalSMS/statistics/events", { ...page, phoneNumber: text, days: { type: "integer", min: 1, max: 90 } }, result => Array.isArray(result?.events)),
+    "events.create": operation("POST", "events", { event_name: { type: "string", required: true, maxLength: 255, pattern: "^[A-Za-z0-9_-]+$" },
+      identifiers: { type: "object", required: true, schema: createSchema({ email_id: { ...email, required: true } }) },
+      event_properties: { ...bag, validator: value => Buffer.byteLength(JSON.stringify(value)) <= 50000 || "Event properties exceed 50KB." }, contact_properties: bag,
+      event_date: { ...text, validator: value => Number.isFinite(Date.parse(value)) && /^\d{4}-\d{2}-\d{2}T/.test(value) || "Use an ISO timestamp." }
+    }, empty),
+    "contacts.list": jsonOperation("https://api.brevo.com/v3/contacts", {
+      limit: { type: "integer", min: 1, max: 1000, defaultTo: 50 },
+      offset: { type: "integer", min: 0, defaultTo: 0 },
+      sort: { type: "string", enum: ["asc", "desc"], defaultTo: "desc" }
+    }, (result) => Array.isArray(result?.contacts) && Number.isInteger(result.count))
+  }
+});
+export { brevoProvider };