@slates/provider 1.0.0-rc.21 → 1.0.0-rc.23

package/dist/index.cjs

@@ -50,6 +50,8 @@ __export(index_exports, {
   SlateSpecification: () => SlateSpecification,
   SlateTool: () => SlateTool,
   SlateTrigger: () => SlateTrigger,
+  SlateTriggerGroup: () => SlateTriggerGroup,
+  SlateTriggerGroupBuilder: () => SlateTriggerGroupBuilder,
   adapterSpec: () => adapterSpec,
   allOf: () => allOf,
   anyOf: () => anyOf,
@@ -101,6 +103,7 @@ __export(index_exports, {
   statusLabelForApiError: () => statusLabelForApiError,
   tool: () => tool,
   trigger: () => trigger,
+  triggerGroup: () => triggerGroup,
   uploadAttachmentDirect: () => uploadAttachmentDirect,
   validateScopes: () => validateScopes,
   verifyHmacSignature: () => verifyHmacSignature
@@ -934,7 +937,9 @@ var SlateActionBuilder = class {
   #scopes;
   #authMethods;
   #toolParams = null;
-  #triggerParams = null;
+  #triggerGroup = null;
+  #triggerMatches = null;
+  #triggerMap = null;
   #interfaceLocked = false;
   input(schema) {
     if (this.#interfaceLocked) {
@@ -984,32 +989,25 @@ var SlateActionBuilder = class {
     };
     return this;
   }
-  webhook(props) {
+  triggerGroup(group) {
     if (this.type !== "trigger") {
-      throw new SlateDeclarationError("handleEvent can only be set for trigger actions");
+      throw new SlateDeclarationError("triggerGroup can only be set for trigger actions");
     }
-    this.#triggerParams = {
-      type: "trigger",
-      source: "webhook",
-      handleEvent: props.handleEvent,
-      handleRequest: props.handleRequest,
-      autoRegisterWebhook: props.autoRegisterWebhook,
-      autoUnregisterWebhook: props.autoUnregisterWebhook,
-      http: props.http
-    };
+    this.#triggerGroup = group;
     return this;
   }
-  polling(props) {
+  matches(handler) {
     if (this.type !== "trigger") {
-      throw new SlateDeclarationError("handleEvent can only be set for trigger actions");
+      throw new SlateDeclarationError("matches can only be set for trigger actions");
     }
-    this.#triggerParams = {
-      type: "trigger",
-      source: "polling",
-      polling: props.options,
-      pollEvents: props.pollEvents,
-      handleEvent: props.handleEvent
-    };
+    this.#triggerMatches = handler;
+    return this;
+  }
+  map(handler) {
+    if (this.type !== "trigger") {
+      throw new SlateDeclarationError("map can only be set for trigger actions");
+    }
+    this.#triggerMap = handler;
     return this;
   }
   build() {
@@ -1030,9 +1028,21 @@ var SlateActionBuilder = class {
     if (this.type === "tool" && !this.#toolParams) {
       throw new SlateDeclarationError("Tool invocation handler is not defined");
     }
-    if (this.type === "trigger" && !this.#triggerParams) {
-      throw new SlateDeclarationError("Trigger event handlers are not defined");
+    if (this.type === "trigger" && !this.#triggerGroup) {
+      throw new SlateDeclarationError("Trigger group is not defined");
+    }
+    if (this.type === "trigger" && !this.#triggerMatches) {
+      throw new SlateDeclarationError("Trigger matches handler is not defined");
+    }
+    if (this.type === "trigger" && !this.#triggerMap) {
+      throw new SlateDeclarationError("Trigger map handler is not defined");
     }
+    let triggerParams = this.type === "trigger" ? {
+      type: "trigger",
+      triggerGroup: this.#triggerGroup,
+      matches: this.#triggerMatches,
+      map: this.#triggerMap
+    } : null;
     return this.factory({
       ...this.params,
       scopes,
@@ -1043,7 +1053,7 @@ var SlateActionBuilder = class {
       inputSchema: this.#inputSchema,
       outputSchema: this.#outputSchema,
       ...this.#toolParams,
-      ...this.#triggerParams
+      ...triggerParams
     });
   }
 };
@@ -1051,6 +1061,91 @@ var SlateActionBuilder = class {
 // src/action/getFileUrlTool.ts
 var import_zod = require("zod");
 
+// src/auth/redact.ts
+var AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX = "$$MT$secret$authConfig$";
+var AuthConfigSecretRedactor = class {
+  secretToPlaceholder = /* @__PURE__ */ new Map();
+  constructor(authConfig) {
+    if (authConfig) this.buildSecretMap(authConfig);
+  }
+  redact(value) {
+    return this.transform(value, (stringValue) => {
+      return this.secretToPlaceholder.get(stringValue) ?? stringValue;
+    });
+  }
+  redactEmbedded(value) {
+    if (this.secretToPlaceholder.size === 0) return value;
+    let pattern = new RegExp(
+      [...this.secretToPlaceholder.keys()].sort((a, b) => b.length - a.length).map((secret) => secret.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"),
+      "g"
+    );
+    return this.transform(value, (stringValue) => {
+      let exactPlaceholder = this.secretToPlaceholder.get(stringValue);
+      if (exactPlaceholder) return exactPlaceholder;
+      return stringValue.replace(
+        pattern,
+        (secret) => `${this.secretToPlaceholder.get(secret)}$$`
+      );
+    });
+  }
+  buildSecretMap(value, path = []) {
+    if (typeof value === "string") {
+      if (value.length === 0) return;
+      this.secretToPlaceholder.set(
+        value,
+        `${AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX}${path.join(".")}`
+      );
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        this.buildSecretMap(item, [...path, String(index)]);
+      });
+      return;
+    }
+    if (this.isPlainObject(value)) {
+      Object.entries(value).forEach(([key, nestedValue]) => {
+        this.buildSecretMap(nestedValue, [...path, key]);
+      });
+    }
+  }
+  transform(value, transformString) {
+    if (typeof value === "string") {
+      return transformString(value);
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.transform(item, transformString));
+    }
+    if (this.isPlainObject(value)) {
+      let result = {};
+      Object.entries(value).forEach(([key, nestedValue]) => {
+        result[key] = this.transform(nestedValue, transformString);
+      });
+      return result;
+    }
+    return value;
+  }
+  isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+};
+var redactUrlAttachmentSecrets = (attachments, authConfig) => {
+  if (!authConfig || !attachments) return attachments;
+  let redactor = new AuthConfigSecretRedactor(authConfig);
+  return attachments.map((attachment) => {
+    if (attachment.content.type !== "url") return attachment;
+    if (!attachment.content.headers && !attachment.content.query) return attachment;
+    return {
+      ...attachment,
+      content: {
+        ...attachment.content,
+        headers: attachment.content.headers ? redactor.redactEmbedded(attachment.content.headers) : void 0,
+        query: attachment.content.query ? redactor.redactEmbedded(attachment.content.query) : void 0
+      }
+    };
+  });
+};
+
 // src/action/tool.ts
 var SlateTool = class _SlateTool extends SlateAction {
   #handleInvocation;
@@ -1089,10 +1184,18 @@ var getFileUrlTool = (spec2, handleGetFileUrl) => tool(spec2, {
   key: GET_FILE_URL_TOOL_ID,
   name: "Get File URL",
   description: "Reserved: refreshes an expiring attachment download URL. Hub-internal only."
-}).input(getFileUrlToolInputSchema).output(getFileUrlToolOutputSchema).handleInvocation(async (ctx) => ({
-  output: await handleGetFileUrl(ctx),
-  message: "ok"
-})).build();
+}).input(getFileUrlToolInputSchema).output(getFileUrlToolOutputSchema).handleInvocation(async (ctx) => {
+  let output = await handleGetFileUrl(ctx);
+  let redactor = new AuthConfigSecretRedactor(ctx._getAuthConfigForRedaction());
+  return {
+    output: {
+      ...output,
+      ...output.headers ? { headers: redactor.redactEmbedded(output.headers) } : {},
+      ...output.query ? { query: redactor.redactEmbedded(output.query) } : {}
+    },
+    message: "ok"
+  };
+}).build();
 
 // src/action/publicTool.ts
 var SlatePublicTool = class {
@@ -1116,28 +1219,15 @@ var SlatePublicTool = class {
 var publicTool = (spec2, params) => SlatePublicTool.create(spec2, params);
 
 // src/action/trigger.ts
-var SlateDefaultPollingIntervalSeconds = 60 * 10;
 var SlateTrigger = class _SlateTrigger extends SlateAction {
-  #source;
-  #polling;
-  #handleEvent;
-  #handleRequest;
-  #http;
-  #pollEvents;
-  #autoRegisterWebhook;
-  #autoUnregisterWebhook;
+  #triggerGroup;
+  #matches;
+  #map;
   constructor(spec2, inputSchema, outputSchema, params) {
     super("trigger", spec2, inputSchema, outputSchema, params);
-    this.#source = params.source;
-    this.#polling = params.polling || {
-      intervalInSeconds: SlateDefaultPollingIntervalSeconds
-    };
-    this.#handleEvent = params.handleEvent;
-    this.#handleRequest = params.handleRequest;
-    this.#http = params.http;
-    this.#pollEvents = params.pollEvents;
-    this.#autoRegisterWebhook = params.autoRegisterWebhook;
-    this.#autoUnregisterWebhook = params.autoUnregisterWebhook;
+    this.#triggerGroup = params.triggerGroup;
+    this.#matches = params.matches;
+    this.#map = params.map;
   }
   static create(spec2, params) {
     return new SlateActionBuilder("trigger", spec2, params, (params2) => {
@@ -1145,32 +1235,122 @@ var SlateTrigger = class _SlateTrigger extends SlateAction {
       return new _SlateTrigger(spec2, params2.inputSchema, params2.outputSchema, params2);
     });
   }
-  get polling() {
-    return this.#polling;
+  get triggerGroup() {
+    return this.#triggerGroup;
+  }
+  get matches() {
+    return this.#matches;
+  }
+  get map() {
+    return this.#map;
+  }
+};
+var trigger = (spec2, params) => SlateTrigger.create(spec2, params);
+
+// src/action/triggerGroup.ts
+var SlateDefaultPollingIntervalSeconds = 60 * 10;
+var SlateTriggerGroup = class _SlateTriggerGroup {
+  constructor(_spec, _params) {
+    this._spec = _spec;
+    this._params = _params;
+  }
+  _spec;
+  _params;
+  static create(spec2, params) {
+    return new SlateTriggerGroupBuilder(spec2, params, (p) => new _SlateTriggerGroup(spec2, p));
+  }
+  get spec() {
+    return this._spec;
+  }
+  get key() {
+    return this._params.key;
+  }
+  get name() {
+    return this._params.name;
+  }
+  get description() {
+    return this._params.description;
+  }
+  get metadata() {
+    return this._params.metadata;
   }
   get source() {
-    return this.#source;
+    return this._params.source;
   }
-  get handleEvent() {
-    return this.#handleEvent;
+  get polling() {
+    return this._params.polling;
   }
-  get handleRequest() {
-    return this.#handleRequest;
+  get webhook() {
+    return this._params.webhook;
   }
-  get http() {
-    return this.#http;
+  get routingMatchers() {
+    return this._params.routingMatchers;
   }
-  get pollEvents() {
-    return this.#pollEvents;
+};
+var SlateTriggerGroupBuilder = class {
+  constructor(spec2, params, factory) {
+    this.spec = spec2;
+    this.params = params;
+    this.factory = factory;
   }
-  get autoRegisterWebhook() {
-    return this.#autoRegisterWebhook;
+  spec;
+  params;
+  factory;
+  #source = null;
+  #polling = null;
+  #webhook = null;
+  #routingMatchers = null;
+  polling(props) {
+    if (this.#source) {
+      throw new SlateDeclarationError("Trigger group invocation is already defined");
+    }
+    this.#source = "polling";
+    this.#polling = {
+      intervalSeconds: props.intervalSeconds ?? SlateDefaultPollingIntervalSeconds,
+      pollEvents: props.pollEvents
+    };
+    return this;
+  }
+  webhook(props) {
+    if (this.#source) {
+      throw new SlateDeclarationError("Trigger group invocation is already defined");
+    }
+    if (!!props.autoRegistration === !!props.manualRegistration) {
+      throw new SlateDeclarationError(
+        "Webhook trigger groups require exactly one of autoRegistration or manualRegistration"
+      );
+    }
+    this.#source = "webhook";
+    this.#webhook = {
+      autoRegistration: props.autoRegistration,
+      manualRegistration: props.manualRegistration,
+      process: props.process
+    };
+    return this;
   }
-  get autoUnregisterWebhook() {
-    return this.#autoUnregisterWebhook;
+  routingMatchers(handler) {
+    this.#routingMatchers = handler;
+    return this;
+  }
+  build() {
+    if (!this.#source) {
+      throw new SlateDeclarationError(
+        "Trigger group invocation (polling or webhook) is not defined"
+      );
+    }
+    if (!this.#routingMatchers) {
+      throw new SlateDeclarationError("Trigger group routing matchers handler is not defined");
+    }
+    return this.factory({
+      ...this.params,
+      source: this.#source,
+      polling: this.#polling ?? void 0,
+      webhook: this.#webhook ?? void 0,
+      routingMatchers: this.#routingMatchers
+    });
   }
 };
-var trigger = (spec2, params) => SlateTrigger.create(spec2, params);
+var triggerGroup = (spec2, params) => SlateTriggerGroup.create(spec2, params);
 
 // src/action/attachment.ts
 var createUrlAttachment = (url, opts = {}) => {
@@ -1215,7 +1395,9 @@ var bufferAttachmentBody = async (body, maxSizeBytes) => {
     if (body.byteLength > maxSizeBytes) {
       throw new Error(`Attachment exceeds the maximum size of ${maxSizeBytes} bytes`);
     }
-    return body;
+    let buffered2 = new ArrayBuffer(body.byteLength);
+    new Uint8Array(buffered2).set(body);
+    return buffered2;
   }
   let reader = body.getReader();
   let chunks = [];
@@ -1231,10 +1413,11 @@ var bufferAttachmentBody = async (body, maxSizeBytes) => {
     }
     chunks.push(value);
   }
-  let buffered = new Uint8Array(sizeBytes);
+  let buffered = new ArrayBuffer(sizeBytes);
+  let bufferedView = new Uint8Array(buffered);
   let offset = 0;
   for (let chunk of chunks) {
-    buffered.set(chunk, offset);
+    bufferedView.set(chunk, offset);
     offset += chunk.byteLength;
   }
   return buffered;
@@ -1555,76 +1738,6 @@ var normalizeOAuthTokenResponse = (data, options = {}) => {
   };
 };
 
-// src/auth/redact.ts
-var AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX = "$$MT$secret$authConfig$";
-var AuthConfigSecretRedactor = class {
-  secretToPlaceholder = /* @__PURE__ */ new Map();
-  constructor(authConfig) {
-    if (authConfig) this.buildSecretMap(authConfig);
-  }
-  redact(value) {
-    return this.transform(value, (stringValue) => {
-      return this.secretToPlaceholder.get(stringValue) ?? stringValue;
-    });
-  }
-  buildSecretMap(value, path = []) {
-    if (typeof value === "string") {
-      if (value.length === 0) return;
-      this.secretToPlaceholder.set(
-        value,
-        `${AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX}${path.join(".")}`
-      );
-      return;
-    }
-    if (Array.isArray(value)) {
-      value.forEach((item, index) => {
-        this.buildSecretMap(item, [...path, String(index)]);
-      });
-      return;
-    }
-    if (this.isPlainObject(value)) {
-      Object.entries(value).forEach(([key, nestedValue]) => {
-        this.buildSecretMap(nestedValue, [...path, key]);
-      });
-    }
-  }
-  transform(value, transformString) {
-    if (typeof value === "string") {
-      return transformString(value);
-    }
-    if (Array.isArray(value)) {
-      return value.map((item) => this.transform(item, transformString));
-    }
-    if (this.isPlainObject(value)) {
-      let result = {};
-      Object.entries(value).forEach(([key, nestedValue]) => {
-        result[key] = this.transform(nestedValue, transformString);
-      });
-      return result;
-    }
-    return value;
-  }
-  isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-  }
-};
-var redactUrlAttachmentSecrets = (attachments, authConfig) => {
-  if (!authConfig || !attachments) return attachments;
-  let redactor = new AuthConfigSecretRedactor(authConfig);
-  return attachments.map((attachment) => {
-    if (attachment.content.type !== "url") return attachment;
-    if (!attachment.content.headers && !attachment.content.query) return attachment;
-    return {
-      ...attachment,
-      content: {
-        ...attachment.content,
-        headers: attachment.content.headers ? redactor.redact(attachment.content.headers) : void 0,
-        query: attachment.content.query ? redactor.redact(attachment.content.query) : void 0
-      }
-    };
-  });
-};
-
 // src/axios/index.ts
 var import_axios3 = __toESM(require("axios"), 1);
 
@@ -2664,14 +2777,16 @@ var setIfDefined = (target, key, value) => {
 
 // src/specification/slate.ts
 var Slate = class _Slate {
-  constructor(_spec, _actions, _adapters) {
+  constructor(_spec, _actions, _adapters, _triggerGroups) {
     this._spec = _spec;
     this._actions = _actions;
     this._adapters = _adapters;
+    this._triggerGroups = _triggerGroups;
   }
   _spec;
   _actions;
   _adapters;
+  _triggerGroups;
   static create(params) {
     let adapters = params.adapters ?? [];
     let actions = [...params.triggers, ...params.tools];
@@ -2697,7 +2812,25 @@ var Slate = class _Slate {
         }
       }
     }
-    return new _Slate(params.spec, actions, adapters);
+    let triggerGroups = params.triggerGroups ?? [];
+    let seenTriggerGroupKeys = /* @__PURE__ */ new Set();
+    for (let group of triggerGroups) {
+      if (seenTriggerGroupKeys.has(group.key)) {
+        throw new SlateDeclarationError(
+          `Trigger group "${group.key}" is registered more than once`
+        );
+      }
+      seenTriggerGroupKeys.add(group.key);
+    }
+    let manualWebhookTriggerGroups = triggerGroups.filter(
+      (group) => group.source === "webhook" && group.webhook?.manualRegistration
+    );
+    if (manualWebhookTriggerGroups.length > 1) {
+      throw new SlateDeclarationError(
+        `Only one trigger group may use manual webhook registration, but found: ${manualWebhookTriggerGroups.map((group) => group.key).join(", ")}`
+      );
+    }
+    return new _Slate(params.spec, actions, adapters, triggerGroups);
   }
   get spec() {
     return this._spec;
@@ -2708,6 +2841,9 @@ var Slate = class _Slate {
   get adapters() {
     return this._adapters;
   }
+  get triggerGroups() {
+    return this._triggerGroups;
+  }
 };
 
 // src/specification/specification.ts
@@ -2828,6 +2964,8 @@ var getMetaWebhookVerificationResponse = (request, expectedVerifyToken) => {
   SlateSpecification,
   SlateTool,
   SlateTrigger,
+  SlateTriggerGroup,
+  SlateTriggerGroupBuilder,
   adapterSpec,
   allOf,
   anyOf,
@@ -2879,6 +3017,7 @@ var getMetaWebhookVerificationResponse = (request, expectedVerifyToken) => {
   statusLabelForApiError,
   tool,
   trigger,
+  triggerGroup,
   uploadAttachmentDirect,
   validateScopes,
   verifyHmacSignature