@jskit-ai/connectors-catalog 0.1.67 → 0.2.0

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@jskit-ai/connectors-catalog",
-  "version": "0.1.67",
+  "version": "0.2.0",
   "description": "Provider definitions and focused API operations for JSKIT connectors.",
   "type": "module",
   "exports": {
-    "./shared/ai": "./src/shared/ai.js",
+    "./shared/ai": "./src/shared/english-ai.js",
     "./server/ai": "./src/server/ai.js",
-    "./shared": "./src/shared/definitions.js",
+    "./shared": "./src/shared/english-definitions.js",
     "./server/resend": "./src/server/resend.js",
     "./server/firecrawl": "./src/server/firecrawl.js",
     "./server/gmail": "./src/server/gmail.js",
@@ -116,21 +116,22 @@
     "./server/gemini-enterprise": "./src/server/gemini-enterprise.js",
     "./server/workday": "./src/server/workday.js",
     "./server/shopify": "./src/server/shopify.js",
-    "./server/wiz": "./src/server/wiz.js"
+    "./server/wiz": "./src/server/wiz.js",
+    "./locales/en.json": "./locales/en.json"
   },
   "dependencies": {
     "@aws-sdk/client-athena": "3.1128.0",
     "@aws-sdk/client-redshift-data": "3.1128.0",
     "@aws-sdk/client-s3": "3.1128.0",
     "@aws-sdk/s3-request-presigner": "3.1128.0",
-    "@jskit-ai/connectors-core": "0.1.65",
+    "@jskit-ai/connectors-core": "0.2.0",
     "@modelcontextprotocol/sdk": "1.32.1",
     "@smithy/fetch-http-handler": "5.8.0",
     "jose": "^6.1.3",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {
-    "@jskit-ai/kernel": "0.1.248"
+    "@jskit-ai/kernel": "0.2.0"
   },
   "jskit": {
     "kind": "runtime",

package/src/server/ai.js

@@ -10,10 +10,10 @@ function createAiConnectionResolver({ configuration, authorize, resolveReference
 
   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 });
+    if (integration?.provider !== "ai") throw new ConnectorError("connector_not_found", "This AI connection is not configured.", { statusCode: 404, messageCode: "connectors.ai.connectionNotConfigured" });
     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 });
+      throw new ConnectorError("connector_access_denied", "Access to this AI connection was denied.", { statusCode: 403, messageCode: "connectors.ai.accessConnectionDenied" });
     }
     const model = getAiModel(integration.settings.model);
     const provider = aiCatalogue.providers.find((item) => item.id === model.providerId);
@@ -24,7 +24,7 @@ function createAiConnectionResolver({ configuration, authorize, resolveReference
       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 });
+        throw new ConnectorError("connector_binding_invalid", "Individual AI accounts require a user-owned reference, not a shared environment variable.", { statusCode: 422, messageCode: "connectors.ai.individualAccountsRequireUserOwned" });
       }
       try {
         apiKey = await resolveReference(integration.authentication.secretRef, { ...owner }, {
@@ -32,7 +32,7 @@ function createAiConnectionResolver({ configuration, authorize, resolveReference
         });
         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 });
+        throw new ConnectorError("connector_binding_missing", "The authorized AI account's API key is unavailable.", { statusCode: 422, messageCode: "connectors.ai.authorizedAccountApiKeyUnavailable" });
       }
     }
     // Never expose this result through a browser API or include it in logs.

package/src/server/amazon-redshift.js

@@ -23,7 +23,7 @@ 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 });
+  if (!matches) throw new ConnectorError("connector_access_denied", "This statement belongs to a different Redshift target.", { statusCode: 403, messageCode: "connectors.amazonRedshift.statementBelongsDifferentTarget" });
 }
 
 function validCell(cell) {
@@ -48,16 +48,16 @@ const amazonRedshiftProvider = Object.freeze({
     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 });
+      if (!validId(result)) throw new ConnectorError("connector_response_invalid", "Redshift did not return a statement identifier.", { statusCode: 502, messageCode: "connectors.amazonRedshift.didNotReturnStatementIdentifier" });
       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 });
+    if (!validStatement(statement) || statement.Id !== body.input.Id) throw new ConnectorError("connector_response_invalid", "Redshift returned an unexpected statement.", { statusCode: 502, messageCode: "connectors.amazonRedshift.returnedUnexpectedStatement" });
     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 });
+    if (statement.Status !== "FINISHED" || !statement.HasResultSet) throw new ConnectorError("connector_result_unavailable", "This statement has no finished result set.", { statusCode: 409, messageCode: "connectors.amazonRedshift.statementNoFinishedResultSet" });
     return send(new GetStatementResultCommand(body.input));
   }),
   operations: {
@@ -81,7 +81,7 @@ const amazonRedshiftProvider = Object.freeze({
         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 });
+      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, messageCode: "connectors.amazonRedshift.useSqlParameterNameOnce" });
       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),

package/src/server/apify.js

@@ -25,7 +25,7 @@ const apifyProvider = Object.freeze({
         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 });
+          throw new ConnectorError("connector_response_too_large", "Use the framework's native Apify client to stream records larger than 8 MiB.", { statusCode: 413, messageCode: "connectors.apify.useFrameworkNativeClientStream" });
         }
         chunks.push(value);
       }

package/src/server/apollo-io.js

@@ -34,7 +34,7 @@ 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 });
+        throw new ConnectorError("connector_input_invalid", "Enter the record's required identifying fields or changes.", { statusCode: 422, messageCode: "connectors.apolloIo.enterRecordRequiredIdentifyingFields" });
       }
       return { method, url: `https://api.apollo.io/api/v1/${endpoint}${recordId ? `/${recordId}` : ""}`, body };
     }, record(key));

package/src/server/asana.js

@@ -26,10 +26,10 @@ function read(endpoint, input = {}, fields) {
 }
 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 (!Object.keys(data).length) throw new ConnectorError("connector_input_invalid", "Supply at least one change.", { statusCode: 422, messageCode: "connectors.shared.supplyLeastChange" });
+    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, messageCode: "connectors.asana.includeDueSettingClearingStart" });
     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 });
+      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, messageCode: "connectors.asana.startDateMustPrecedeProject" });
     }
     const request = read(`${endpoint}${resource ? `/${resource}` : ""}`, {}, resultFields);
     return { ...request, method, body: { data } };

package/src/server/ashby.js

@@ -10,7 +10,7 @@ const page = { limit: { type: "integer", min: 1, max: 100, defaultTo: 25 },
 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 });
+    if (result?.success === false) throw new ConnectorError("connector_provider_failed", "Ashby could not complete the operation.", { statusCode: 502, messageCode: "connectors.ashby.couldNotCompleteOperation" });
     return result?.success === true && check(result);
   };
 }
@@ -26,7 +26,7 @@ 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.");
+    if (/[:\s\p{Cc}]/u.test(key)) throw new ConnectorError("connector_binding_missing", "Use the Ashby API key without spaces, control characters or colons.", { messageCode: "connectors.shared.apiKeyFormat", messageParams: { provider: "Ashby" } });
     return { Authorization: `Basic ${Buffer.from(`${key}:`).toString("base64")}`, Accept: "application/json; version=1" };
   } },
   checkOperation: "jobs.list",
@@ -39,7 +39,7 @@ const ashbyProvider = Object.freeze({
     "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 });
+        throw new ConnectorError("connector_input_invalid", "Supply at least one candidate profile change.", { statusCode: 422, messageCode: "connectors.ashby.supplyLeastCandidateProfileChange" });
       }
       return request;
     } },

package/src/server/attention.js

@@ -19,7 +19,7 @@ function operation(method, endpoint, fields, validateResult, prepare = value =>
     const url = `https://api.attention.tech/v2/${endpoint.replace("{id}", resource || "")}`;
     if (method === "GET") return { method, url: withQuery(url, body) };
     if (method === "DELETE") return { method, url: new URL(url).href };
-    if (!Object.keys(body).length) throw new ConnectorError("connector_input_invalid", "Supply at least one change.", { statusCode: 422 });
+    if (!Object.keys(body).length) throw new ConnectorError("connector_input_invalid", "Supply at least one change.", { statusCode: 422, messageCode: "connectors.shared.supplyLeastChange" });
     return { method, url: new URL(url).href, body };
   }, validateResult);
 }
@@ -54,7 +54,7 @@ const attentionProvider = Object.freeze({
     "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; }),
+    }, 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, messageCode: "connectors.attention.endTimeMustFollowStart" }); 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 } }) },

package/src/server/aws-athena.js

@@ -25,7 +25,7 @@ const awsAthenaProvider = Object.freeze({
     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 });
+      if (result.WorkGroup?.Name !== settings.workgroup) throw new ConnectorError("connector_response_invalid", "Athena returned a different workgroup.", { statusCode: 502, messageCode: "connectors.awsAthena.returnedDifferentWorkgroup" });
       return result;
     }
     if (body.command === "ListDataCatalogs") return send(new ListDataCatalogsCommand(body.input));
@@ -34,10 +34,10 @@ const awsAthenaProvider = Object.freeze({
     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 });
+      throw new ConnectorError("connector_response_invalid", "Athena returned an unexpected query.", { statusCode: 502, messageCode: "connectors.awsAthena.returnedUnexpectedQuery" });
     }
     if (query.QueryExecution.WorkGroup !== settings.workgroup) {
-      throw new ConnectorError("connector_access_denied", "This query belongs to a different workgroup.", { statusCode: 403 });
+      throw new ConnectorError("connector_access_denied", "This query belongs to a different workgroup.", { statusCode: 403, messageCode: "connectors.awsAthena.queryBelongsDifferentWorkgroup" });
     }
     if (body.command === "GetQueryExecution") return query;
     if (body.command === "GetQueryResults") return send(new GetQueryResultsCommand(body.input));

package/src/server/aws-s3.js

@@ -17,7 +17,7 @@ const awsS3Provider = Object.freeze({
     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 });
+        throw new ConnectorError("connector_response_invalid", "S3 returned an unexpected bucket or page size.", { statusCode: 502, messageCode: "connectors.awsS3.returnedUnexpectedBucketPageSize" });
       }
       return result;
     }

package/src/server/awsTransport.js

@@ -28,16 +28,16 @@ function awsExchange(service, Client, execute) {
         (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.");
+      throw new ConnectorError("connector_binding_missing", "Provide the AWS access key ID, secret access key and any required session token bindings.", { messageCode: "connectors.aws.provideAccessKeyIdSecret" });
     }
     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.");
+    if (new URL(endpoint).origin !== origin) throw new ConnectorError("connector_destination_invalid", "The AWS region does not match the operation destination.", { messageCode: "connectors.aws.regionDoesNotMatchOperation" });
     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.");
+          if (new URL(request.url).origin !== origin) throw new ConnectorError("connector_destination_invalid", "The AWS SDK selected an unexpected destination.", { messageCode: "connectors.aws.sdkSelectedUnexpectedDestination" });
           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" });
@@ -55,17 +55,17 @@ function awsExchange(service, Client, execute) {
       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 });
+        throw new ConnectorError("connector_reconnect_required", "Renew the AWS credential bindings and connect again.", { statusCode: 401, messageCode: "connectors.aws.renewCredentialBindingsConnectAgain" });
       }
       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 });
+        throw new ConnectorError("connector_rate_limited", "The AWS request limit was reached.", { statusCode: 429, messageCode: "connectors.aws.requestLimitReached" });
       }
-      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 === 403) throw new ConnectorError("connector_permission_denied", "AWS denied this operation. Check IAM, resource and database permissions.", { statusCode: 403, messageCode: "connectors.aws.deniedOperationCheckIamResource" });
+      if (status === 404 || error.name === "ResourceNotFoundException") throw new ConnectorError("connector_not_found", "The AWS resource was not found.", { statusCode: 404, messageCode: "connectors.aws.resourceNotFound" });
       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_configuration_invalid", "Check the AWS region, resource and operation settings.", { statusCode: 422, messageCode: "connectors.aws.checkRegionResourceOperationSettings" });
       }
-      throw new ConnectorError("connector_provider_failed", "The AWS request failed or returned an unreadable response.", { statusCode: 502 });
+      throw new ConnectorError("connector_provider_failed", "The AWS request failed or returned an unreadable response.", { statusCode: 502, messageCode: "connectors.aws.requestFailedReturnedUnreadableResponse" });
     } finally {
       client.destroy();
     }

package/src/server/brevo.js

@@ -24,12 +24,12 @@ function operation(method, endpoint, fields, validateResult, prepare = value =>
   }, 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 });
+  if (Object.keys(value).every(key => key === "resource")) throw new ConnectorError("connector_input_invalid", "Supply at least one change.", { statusCode: 422, messageCode: "connectors.shared.supplyLeastChange" });
   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 });
+    throw new ConnectorError("connector_input_invalid", "Choose a template or provide a subject and email content.", { statusCode: 422, messageCode: "connectors.brevo.chooseTemplateProvideSubjectEmail" });
   }
   return value;
 };
@@ -49,7 +49,7 @@ const brevoProvider = Object.freeze({
       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;
+      if ((value.content === undefined) === (value.templateId === undefined)) throw new ConnectorError("connector_input_invalid", "Choose SMS content or a template, not both.", { statusCode: 422, messageCode: "connectors.brevo.smsContentOrTemplate" }); return value;
     }),
     "contacts.get": operation("GET", "contacts/{resource}", { resource: { ...email, required: true } }, record),
     "contacts.create": operation("POST", "contacts", { email: { ...email, required: true }, ...contact,

package/src/server/calendly.js

@@ -35,12 +35,12 @@ const calendlyProvider = Object.freeze({
       start_time: { ...date, required: true }, end_time: { ...date, required: true }
     }, "availability:read", result => Array.isArray(result?.collection), value => {
       const span = Date.parse(value.end_time) - Date.parse(value.start_time);
-      if (span <= 0 || span > 31 * 86400000) throw new ConnectorError("connector_input_invalid", "Choose a positive range of at most 31 days.", { statusCode: 422 }); return value;
+      if (span <= 0 || span > 31 * 86400000) throw new ConnectorError("connector_input_invalid", "Choose a positive range of at most 31 days.", { statusCode: 422, messageCode: "connectors.calendly.choosePositiveRangeMost31" }); return value;
     }),
     "events.list": operation("GET", "scheduled_events", { user: uri("users"), organization: uri("organizations"), group: uri("groups"),
       invitee_email: email, status, ...page, sort: { type: "string", enum: ["start_time:asc", "start_time:desc"] }, min_start_time: date, max_start_time: date
     }, "scheduled_events:read", collection, value => {
-      if (!(value.user || value.organization || value.group)) throw new ConnectorError("connector_input_invalid", "Choose the user, organization or group whose events to read.", { statusCode: 422 }); return value;
+      if (!(value.user || value.organization || value.group)) throw new ConnectorError("connector_input_invalid", "Choose the user, organization or group whose events to read.", { statusCode: 422, messageCode: "connectors.calendly.chooseEventOwner" }); return value;
     }),
     "events.get": operation("GET", "scheduled_events/{uuid}", { uuid: id }, "scheduled_events:read", record),
     "events.cancel": operation("POST", "scheduled_events/{uuid}/cancellation", { uuid: id, reason: { ...text, maxLength: 10000 } },

package/src/server/chargebee.js

@@ -36,7 +36,7 @@ const chargebeeProvider = Object.freeze({
   apiOrigins: (settings) => [origin(settings)],
   apiKey: { headers: (key) => {
     if (/[:\s\p{Cc}]/u.test(key)) {
-      throw new ConnectorError("connector_binding_missing", "Use the Chargebee API key without spaces, control characters or colons.");
+      throw new ConnectorError("connector_binding_missing", "Use the Chargebee API key without spaces, control characters or colons.", { messageCode: "connectors.shared.apiKeyFormat", messageParams: { provider: "Chargebee" } });
     }
     return { Authorization: `Basic ${Buffer.from(`${key}:`).toString("base64")}` };
   } },

package/src/server/databricks.js

@@ -31,7 +31,7 @@ const databricksProvider = Object.freeze({
       if (!Number.isSafeInteger(value?.expires_in) || value.expires_in <= 40 ||
         (value.scope !== undefined && (typeof value.scope !== "string" || !/^[^\s]+(?: [^\s]+)*$/u.test(value.scope))) ||
         (value.refresh_token !== undefined && (typeof value.refresh_token !== "string" || !value.refresh_token.trim()))) {
-        throw new ConnectorError("connector_response_invalid", "Databricks returned an invalid token grant.", { statusCode: 502 });
+        throw new ConnectorError("connector_response_invalid", "Databricks returned an invalid token grant.", { statusCode: 502, messageCode: "connectors.shared.invalidTokenGrant", messageParams: { provider: "Databricks" } });
       }
     }
     return response;
@@ -47,7 +47,7 @@ const databricksProvider = Object.freeze({
     if (response.status !== 200 || !object(result) || result.error_code || result.error ||
       (url.pathname.endsWith("/list") && result?.jobs?.length > Number(url.searchParams.get("limit"))) ||
       (url.pathname.endsWith("/get") && result?.job_id !== Number(url.searchParams.get("job_id")))) {
-      throw new ConnectorError("connector_response_invalid", "Databricks returned an unexpected job response.", { statusCode: 502 });
+      throw new ConnectorError("connector_response_invalid", "Databricks returned an unexpected job response.", { statusCode: 502, messageCode: "connectors.databricks.returnedUnexpectedJobResponse" });
     }
     return result;
   }

package/src/server/dbt-semantic-layer.js

@@ -30,7 +30,7 @@ const dbtSemanticLayerProvider = Object.freeze({
   ...dbtSemanticLayerDefinition,
   apiOrigins: (settings) => [origin(settings)],
   apiKey: { headers: (key) => {
-    if (/[\s\p{Cc}]/u.test(key)) throw new ConnectorError("connector_binding_missing", "Use a dbt service token without spaces or control characters.");
+    if (/[\s\p{Cc}]/u.test(key)) throw new ConnectorError("connector_binding_missing", "Use a dbt service token without spaces or control characters.", { messageCode: "connectors.dbtSemanticLayer.useServiceTokenWithoutSpaces" });
     return { Authorization: `Bearer ${key}` };
   } },
   checkOperation: "environment.read",
@@ -64,29 +64,29 @@ const dbtSemanticLayerProvider = Object.freeze({
   async exchange(address, options, { request }) {
     const result = await request(address, options);
     if (Array.isArray(result?.errors) && result.errors.length > 0) {
-      throw new ConnectorError("connector_provider_failed", "dbt could not complete the requested operation. Check the environment and service token permissions.", { statusCode: 502 });
+      throw new ConnectorError("connector_provider_failed", "dbt could not complete the requested operation. Check the environment and service token permissions.", { statusCode: 502, messageCode: "connectors.dbtSemanticLayer.couldNotCompleteRequestedOperation" });
     }
     const queryResult = result?.data?.query;
     if (queryResult) {
       if (queryResult.status === "FAILED") {
-        throw new ConnectorError("connector_provider_failed", "dbt query failed. Inspect its status in dbt; do not automatically submit it again.", { statusCode: 502 });
+        throw new ConnectorError("connector_provider_failed", "dbt query failed. Inspect its status in dbt; do not automatically submit it again.", { statusCode: 502, messageCode: "connectors.dbtSemanticLayer.queryFailedInspectStatusDo" });
       }
       if (queryResult.jsonResult !== null && queryResult.jsonResult !== undefined) {
         if (typeof queryResult.jsonResult !== "string" || Buffer.byteLength(queryResult.jsonResult) > 5 * 1024 * 1024) {
-          throw new ConnectorError("connector_response_invalid", "dbt returned an invalid or oversized JSON result page.", { statusCode: 502 });
+          throw new ConnectorError("connector_response_invalid", "dbt returned an invalid or oversized JSON result page.", { statusCode: 502, messageCode: "connectors.dbtSemanticLayer.returnedInvalidOversizedJsonResult" });
         }
         try { queryResult.jsonResult = JSON.parse(queryResult.jsonResult); }
-        catch { throw new ConnectorError("connector_response_invalid", "dbt returned an invalid JSON result page.", { statusCode: 502 }); }
+        catch { throw new ConnectorError("connector_response_invalid", "dbt returned an invalid JSON result page.", { statusCode: 502, messageCode: "connectors.dbtSemanticLayer.returnedInvalidJsonResultPage" }); }
         if (!Array.isArray(queryResult.jsonResult?.data) || queryResult.jsonResult.data.length > 1024 || !Array.isArray(queryResult.jsonResult?.schema?.fields)) {
-          throw new ConnectorError("connector_response_invalid", "dbt returned an invalid JSON table.", { statusCode: 502 });
+          throw new ConnectorError("connector_response_invalid", "dbt returned an invalid JSON table.", { statusCode: 502, messageCode: "connectors.dbtSemanticLayer.returnedInvalidJsonTable" });
         }
       } else if (queryResult.status === "SUCCESSFUL") {
-        throw new ConnectorError("connector_response_invalid", "dbt completed without a JSON result table.", { statusCode: 502 });
+        throw new ConnectorError("connector_response_invalid", "dbt completed without a JSON result table.", { statusCode: 502, messageCode: "connectors.dbtSemanticLayer.completedWithoutJsonResultTable" });
       }
     }
     const page = result?.data?.metricsPaginated || result?.data?.dimensionsPaginated || result?.data?.savedQueriesPaginated;
     if (page && (page.pageNum !== options.body.variables.pageNum || page.pageSize !== options.body.variables.pageSize || page.items?.length > options.body.variables.pageSize)) {
-      throw new ConnectorError("connector_response_invalid", "dbt returned an unexpected metadata page.", { statusCode: 502 });
+      throw new ConnectorError("connector_response_invalid", "dbt returned an unexpected metadata page.", { statusCode: 502, messageCode: "connectors.dbtSemanticLayer.returnedUnexpectedMetadataPage" });
     }
     return result;
   }

package/src/server/elevenlabs.js

@@ -39,18 +39,18 @@ const elevenlabsProvider = Object.freeze({
     if (!response.ok) { await response.body?.cancel(); throw Object.assign(new Error("ElevenLabs speech request failed."), { status: response.status }); }
     const contentType = response.headers.get("content-type")?.split(";")[0] || "application/octet-stream";
     if (!contentType.startsWith("audio/") && contentType !== "application/octet-stream") {
-      await response.body?.cancel(); throw new ConnectorError("connector_response_invalid", "ElevenLabs did not return audio.", { statusCode: 502 });
+      await response.body?.cancel(); throw new ConnectorError("connector_response_invalid", "ElevenLabs did not return audio.", { statusCode: 502, messageCode: "connectors.elevenlabs.didNotReturnAudio" });
     }
     const reader = response.body?.getReader(); const chunks = []; let size = 0;
     if (reader) try {
       while (true) {
         const { done, value } = await reader.read(); if (done) break;
         size += value.byteLength;
-        if (size > 16 * 1024 * 1024) { await reader.cancel(); throw new ConnectorError("connector_response_too_large", "Use native streaming for audio above 16 MiB.", { statusCode: 413 }); }
+        if (size > 16 * 1024 * 1024) { await reader.cancel(); throw new ConnectorError("connector_response_too_large", "Use native streaming for audio above 16 MiB.", { statusCode: 413, messageCode: "connectors.elevenlabs.useNativeStreamingAudioAbove" }); }
         chunks.push(value);
       }
     } finally { reader.releaseLock(); }
-    if (!size) throw new ConnectorError("connector_response_invalid", "ElevenLabs returned empty audio.", { statusCode: 502 });
+    if (!size) throw new ConnectorError("connector_response_invalid", "ElevenLabs returned empty audio.", { statusCode: 502, messageCode: "connectors.elevenlabs.returnedEmptyAudio" });
     return { bodyBase64: Buffer.concat(chunks).toString("base64"), contentType, size };
   },
   operations: {
@@ -63,7 +63,7 @@ const elevenlabsProvider = Object.freeze({
       const body = new FormData(); let total = 0;
       for (const file of files) {
         const bytes = Buffer.from(file.base64, "base64"); total += bytes.byteLength;
-        if (total > 16 * 1024 * 1024) throw new ConnectorError("connector_input_invalid", "Audio samples must total at most 16 MiB.", { statusCode: 422 });
+        if (total > 16 * 1024 * 1024) throw new ConnectorError("connector_input_invalid", "Audio samples must total at most 16 MiB.", { statusCode: 422, messageCode: "connectors.elevenlabs.audioSamplesMustTotalMost" });
         body.append("files", new Blob([bytes], { type: file.contentType }), file.name);
       }
       for (const [key, value] of Object.entries(values)) body.append(key, String(value));

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

@@ -8,7 +8,7 @@ import { jsonOperation } from "./jsonOperation.js";
 const tokenUrl = "https://oauth2.googleapis.com/token";
 const endpoint = ({ projectId }) => `https://fcm.googleapis.com/v1/projects/${projectId}/messages:send`;
 const credentialSchema = createSchema({ project_id: firebaseProjectId });
-const invalidCredential = () => new ConnectorError("connector_binding_missing", "Use a valid Firebase service-account JSON credential for the default Google API domain.");
+const invalidCredential = () => new ConnectorError("connector_binding_missing", "Use a valid Firebase service-account JSON credential for the default Google API domain.", { messageCode: "connectors.firebaseCloudMessaging.useValidServiceAccountJson" });
 
 async function serviceAccountGrant({ credential, scopes, fetchImpl, signal, now }) {
   let account, key;
@@ -33,16 +33,16 @@ async function serviceAccountGrant({ credential, scopes, fetchImpl, signal, now
     body: new URLSearchParams({ grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer", assertion }).toString()
   });
   if (response.redirected || (response.status >= 300 && response.status < 400)) {
-    throw new ConnectorError("connector_response_invalid", "Google returned an unexpected token redirect.", { statusCode: 502 });
+    throw new ConnectorError("connector_response_invalid", "Google returned an unexpected token redirect.", { statusCode: 502, messageCode: "connectors.firebaseCloudMessaging.returnedUnexpectedTokenRedirect" });
   }
   let value;
   try { value = await response.json(); } catch {
-    throw new ConnectorError("connector_response_invalid", "Google returned an invalid token response.", { statusCode: 502 });
+    throw new ConnectorError("connector_response_invalid", "Google returned an invalid token response.", { statusCode: 502, messageCode: "connectors.shared.invalidTokenResponse", messageParams: { provider: "Google" } });
   }
   if (!response.ok) {
     const denied = response.status === 401 || ["invalid_grant", "invalid_client"].includes(value?.error);
     throw new ConnectorError(denied ? "connector_reconnect_required" : response.status === 403 ? "connector_permission_denied" : response.status === 429 ? "connector_rate_limited" : "connector_provider_failed",
-      "Google could not authorize the service account. Check the credential and project permissions.", { statusCode: denied ? 401 : [403, 429].includes(response.status) ? response.status : 502 });
+      "Google could not authorize the service account. Check the credential and project permissions.", { statusCode: denied ? 401 : [403, 429].includes(response.status) ? response.status : 502, messageCode: "connectors.firebaseCloudMessaging.couldNotAuthorizeServiceAccount" });
   }
   return value;
 }
@@ -89,20 +89,20 @@ const firebaseCloudMessagingProvider = Object.freeze({
       headers: { ...options.headers, "Content-Type": "application/json" } });
     let result;
     try { result = await response.json(); }
-    catch { throw new ConnectorError("connector_response_invalid", "Firebase returned invalid message JSON.", { statusCode: 502 }); }
+    catch { throw new ConnectorError("connector_response_invalid", "Firebase returned invalid message JSON.", { statusCode: 502, messageCode: "connectors.firebaseCloudMessaging.returnedInvalidMessageJson" }); }
     if (!response.ok) {
       const details = result?.error?.details;
       const fcmError = Array.isArray(details) ? details.find(detail => detail?.["@type"] === "type.googleapis.com/google.firebase.fcm.v1.FcmError")?.errorCode : undefined;
       if (response.status === 404 && fcmError === "UNREGISTERED" && (options.body.message.token || options.body.message.fid)) {
-        throw new ConnectorError("connector_recipient_unregistered", "This Firebase recipient is no longer registered. Remove its association and wait for client registration again.", { statusCode: 410 });
+        throw new ConnectorError("connector_recipient_unregistered", "This Firebase recipient is no longer registered. Remove its association and wait for client registration again.", { statusCode: 410, messageCode: "connectors.firebaseCloudMessaging.recipientNoLongerRegisteredRemove" });
       }
       if (response.status === 400) {
-        throw new ConnectorError("connector_message_invalid", "Firebase rejected the message or target. Do not delete a registration unless the payload is known to be valid.", { statusCode: 422 });
+        throw new ConnectorError("connector_message_invalid", "Firebase rejected the message or target. Do not delete a registration unless the payload is known to be valid.", { statusCode: 422, messageCode: "connectors.firebaseCloudMessaging.rejectedMessageTargetDoNot" });
       }
       throw Object.assign(new Error("Firebase message request failed."), { status: response.status });
     }
     if (!receipt(result) || !result.name.startsWith(`projects/${settings.projectId}/messages/`)) {
-      throw new ConnectorError("connector_response_invalid", "Firebase returned an unexpected message receipt.", { statusCode: 502 });
+      throw new ConnectorError("connector_response_invalid", "Firebase returned an unexpected message receipt.", { statusCode: 502, messageCode: "connectors.firebaseCloudMessaging.returnedUnexpectedMessageReceipt" });
     }
     return result;
   }

package/src/server/firecrawl.js

@@ -43,8 +43,8 @@ const firecrawlProvider = Object.freeze({
     } }), result => result?.success === true && typeof result.id === "string"),
     "crawls.get": validatedOperation({ id: jobId, next: { type: "string", maxLength: 8192 } }, ({ id, next }) => {
       const expected = `https://api.firecrawl.dev/v2/crawl/${id}`;
-      let url; try { url = new URL(next || expected); } catch { throw new ConnectorError("connector_input_invalid", "Use the returned next-page URL for this crawl.", { statusCode: 422 }); }
-      if (url.origin + url.pathname !== expected || url.username || url.password || url.hash) throw new ConnectorError("connector_input_invalid", "Use the returned next-page URL for this crawl.", { statusCode: 422 });
+      let url; try { url = new URL(next || expected); } catch { throw new ConnectorError("connector_input_invalid", "Use the returned next-page URL for this crawl.", { statusCode: 422, messageCode: "connectors.firecrawl.useReturnedNextPageUrl" }); }
+      if (url.origin + url.pathname !== expected || url.username || url.password || url.hash) throw new ConnectorError("connector_input_invalid", "Use the returned next-page URL for this crawl.", { statusCode: 422, messageCode: "connectors.firecrawl.useReturnedNextPageUrl" });
       return { method: "GET", url: url.href };
     }, result => typeof result?.status === "string" && Array.isArray(result.data) && Number.isInteger(result.total) && result.total >= 0 && Number.isInteger(result.completed) && result.completed >= 0),
     "crawls.errors": validatedOperation({ id: jobId }, ({ id }) => ({ method: "GET", url: `https://api.firecrawl.dev/v2/crawl/${id}/errors` }), result => Array.isArray(result?.errors)),

package/src/server/gatewayapi.js

@@ -34,14 +34,14 @@ const gatewayApiProvider = Object.freeze({
 // Call at the application's webhook route before trusting or persisting its body.
 function verifyGatewayApiEvent({ rawBody, signature, secret }) {
   if (!(rawBody instanceof Uint8Array) || rawBody.byteLength > 1048576 || typeof secret !== "string" || secret.length < 1 || typeof signature !== "string" || !/^v1=[a-fA-F0-9]{64}$/.test(signature)) {
-    throw new ConnectorError("connector_webhook_invalid", "Invalid GatewayAPI webhook signature.", { statusCode: 401 });
+    throw new ConnectorError("connector_webhook_invalid", "Invalid GatewayAPI webhook signature.", { statusCode: 401, messageCode: "connectors.shared.invalidWebhookSignature", messageParams: { provider: "GatewayAPI" } });
   }
   const expected = createHmac("sha256", secret).update(rawBody).digest();
-  if (!timingSafeEqual(expected, Buffer.from(signature.slice(3), "hex"))) throw new ConnectorError("connector_webhook_invalid", "Invalid GatewayAPI webhook signature.", { statusCode: 401 });
+  if (!timingSafeEqual(expected, Buffer.from(signature.slice(3), "hex"))) throw new ConnectorError("connector_webhook_invalid", "Invalid GatewayAPI webhook signature.", { statusCode: 401, messageCode: "connectors.shared.invalidWebhookSignature", messageParams: { provider: "GatewayAPI" } });
   let event;
-  try { event = JSON.parse(Buffer.from(rawBody).toString("utf8")); } catch { throw new ConnectorError("connector_webhook_invalid", "Invalid GatewayAPI webhook event.", { statusCode: 401 }); }
+  try { event = JSON.parse(Buffer.from(rawBody).toString("utf8")); } catch { throw new ConnectorError("connector_webhook_invalid", "Invalid GatewayAPI webhook event.", { statusCode: 401, messageCode: "connectors.gatewayapi.invalidWebhookEvent" }); }
   if (typeof event?.event_id !== "string" || !event.event_id || typeof event.event_type !== "string" || !Number.isFinite(Date.parse(event.timestamp)) || !event.event || typeof event.event !== "object" || Array.isArray(event.event)) {
-    throw new ConnectorError("connector_webhook_invalid", "Invalid GatewayAPI webhook event.", { statusCode: 401 });
+    throw new ConnectorError("connector_webhook_invalid", "Invalid GatewayAPI webhook event.", { statusCode: 401, messageCode: "connectors.gatewayapi.invalidWebhookEvent" });
   }
   return event;
 }

package/src/server/github-api.js

@@ -8,11 +8,11 @@ async function normalizeTokenResponse(response) {
   if (!response.ok) return response;
   let value;
   try { value = await response.clone().json(); } catch {
-    throw new ConnectorError("connector_response_invalid", "GitHub returned an invalid token response.", { statusCode: 502 });
+    throw new ConnectorError("connector_response_invalid", "GitHub returned an invalid token response.", { statusCode: 502, messageCode: "connectors.shared.invalidTokenResponse", messageParams: { provider: "GitHub" } });
   }
   if (value.error || value.scope === undefined) return response;
   if (typeof value.scope !== "string" || !/^[a-zA-Z0-9_:.-]*(?:,[a-zA-Z0-9_:.-]+)*$/u.test(value.scope)) {
-    throw new ConnectorError("connector_response_invalid", "GitHub returned an invalid permission grant.", { statusCode: 502 });
+    throw new ConnectorError("connector_response_invalid", "GitHub returned an invalid permission grant.", { statusCode: 502, messageCode: "connectors.shared.invalidPermissionGrant", messageParams: { provider: "GitHub" } });
   }
   return Response.json({ ...value, scope: value.scope.replaceAll(",", " ") }, { status: response.status });
 }
@@ -34,7 +34,7 @@ function repositoryOperation(suffix, fields, validateResult, method = "GET") {
       for (const [key, value] of Object.entries(values)) url.searchParams.set(key, String(value));
       return { method, url: url.href };
     }
-    if (!Object.keys(values).length) throw new ConnectorError("connector_input_invalid", "Supply at least one change.", { statusCode: 422 });
+    if (!Object.keys(values).length) throw new ConnectorError("connector_input_invalid", "Supply at least one change.", { statusCode: 422, messageCode: "connectors.shared.supplyLeastChange" });
     return { method, url: url.href, body: values };
   }, validateResult };
 }

package/src/server/gitlab-api.js

@@ -21,7 +21,7 @@ function projectOperation(suffix, fields, validateResult, method = "GET") {
       for (const [key, value] of Object.entries(values)) url.searchParams.set(key, String(value));
       return { method, url: url.href };
     }
-    if (!Object.keys(values).length) throw new ConnectorError("connector_input_invalid", "Supply at least one change.", { statusCode: 422 });
+    if (!Object.keys(values).length) throw new ConnectorError("connector_input_invalid", "Supply at least one change.", { statusCode: 422, messageCode: "connectors.shared.supplyLeastChange" });
     return { method, url: url.href, body: values };
   }, validateResult };
 }

package/src/server/gmail.js

@@ -25,7 +25,7 @@ const gmailProvider = Object.freeze({ ...googleProvider(gmailDefinition, origin,
   "attachments.get": googleRead(contentScopes, { messageId: documentId, id: documentId }, ({ messageId, id }) => ({ url: `${origin}/gmail/v1/users/me/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(id)}` }), value => Number.isInteger(value?.size) && typeof value.data === "string"),
   "messages.send": gmailWrite(["gmail.send", ...composeScopes], { raw: rawField, threadId: { ...documentId, required: false } }, body => ({ path: "/messages/send", body }), messageResult),
   "messages.modify": gmailWrite(modifyScopes, { id: documentId, addLabelIds: labelIds, removeLabelIds: labelIds }, ({ id, ...body }) => {
-    if (!body.addLabelIds?.length && !body.removeLabelIds?.length) throw new ConnectorError("connector_input_invalid", "Supply labels to add or remove.", { statusCode: 422 });
+    if (!body.addLabelIds?.length && !body.removeLabelIds?.length) throw new ConnectorError("connector_input_invalid", "Supply labels to add or remove.", { statusCode: 422, messageCode: "connectors.gmail.supplyLabelsAddRemove" });
     return { path: `/messages/${encodeURIComponent(id)}/modify`, body };
   }, messageResult),
   "messages.trash": gmailWrite(modifyScopes, { id: documentId }, ({ id }) => ({ path: `/messages/${encodeURIComponent(id)}/trash` }), messageResult),