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

package/dist/index.module.js

@@ -825,7 +825,9 @@ var SlateActionBuilder = class {
   #scopes;
   #authMethods;
   #toolParams = null;
-  #triggerParams = null;
+  #triggerGroup = null;
+  #triggerMatches = null;
+  #triggerMap = null;
   #interfaceLocked = false;
   input(schema) {
     if (this.#interfaceLocked) {
@@ -875,32 +877,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() {
@@ -921,9 +916,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,
@@ -934,7 +941,7 @@ var SlateActionBuilder = class {
       inputSchema: this.#inputSchema,
       outputSchema: this.#outputSchema,
       ...this.#toolParams,
-      ...this.#triggerParams
+      ...triggerParams
     });
   }
 };
@@ -942,6 +949,91 @@ var SlateActionBuilder = class {
 // src/action/getFileUrlTool.ts
 import { z } from "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;
@@ -980,10 +1072,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 {
@@ -1007,28 +1107,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) => {
@@ -1036,32 +1123,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 = {}) => {
@@ -1106,7 +1283,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 = [];
@@ -1122,10 +1301,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;
@@ -1446,76 +1626,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
 import baseAxios, { getAdapter, isAxiosError as isAxiosError2 } from "axios";
 
@@ -2555,14 +2665,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];
@@ -2588,7 +2700,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;
@@ -2599,6 +2729,9 @@ var Slate = class _Slate {
   get adapters() {
     return this._adapters;
   }
+  get triggerGroups() {
+    return this._triggerGroups;
+  }
 };
 
 // src/specification/specification.ts
@@ -2718,6 +2851,8 @@ export {
   SlateSpecification,
   SlateTool,
   SlateTrigger,
+  SlateTriggerGroup,
+  SlateTriggerGroupBuilder,
   adapterSpec,
   allOf,
   anyOf,
@@ -2769,6 +2904,7 @@ export {
   statusLabelForApiError,
   tool,
   trigger,
+  triggerGroup,
   uploadAttachmentDirect,
   validateScopes,
   verifyHmacSignature

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider",
-  "version": "1.0.0-rc.21",
+  "version": "1.0.0-rc.23",
   "publishConfig": {
     "access": "public"
   },

package/src/action/action.ts

@@ -3,6 +3,7 @@ import type { SlateContext, SlatePublicContext } from '../context';
 import type { SlateActionDocsReference } from '../docs';
 import type { SlateSpecification } from '../specification/specification';
 import type { SlateAttachment } from './attachment';
+import type { SlateTriggerGroup } from './triggerGroup';
 
 export type SlateActionType = 'tool' | 'trigger';
 
@@ -52,6 +53,8 @@ export type SlatePublicToolInvocationHandler<InputType extends {}, OutputType ex
   attachments?: SlateAttachment[];
 }>;
 
+export type SlateTriggerMatchesHandler = (payload: unknown) => boolean;
+
 export type SlateTriggerMappingHandler<
   ConfigType extends {},
   AuthType extends {},
@@ -63,88 +66,12 @@ export type SlateTriggerMappingHandler<
   output: OutputType;
 }>;
 
-export type SlateTriggerPollingHandler<
-  ConfigType extends {},
-  AuthType extends {},
-  InputType extends {}
-> = (context: SlateContext<ConfigType, AuthType, { state: any | null }>) => Promise<{
-  inputs: InputType[];
-  updatedState?: any;
-}>;
-
 export interface SlateWebhookHttpResponseInit {
   status?: number;
   headers?: Record<string, string>;
   body?: string | Uint8Array | null;
 }
 
-export type SlateWebhookHttpMethod =
-  | 'GET'
-  | 'POST'
-  | 'PUT'
-  | 'PATCH'
-  | 'DELETE'
-  | 'HEAD'
-  | 'OPTIONS';
-
-export interface SlateWebhookRequestMatcher {
-  method?: string;
-  hasQueryParam?: string;
-  hasHeader?: string;
-  jsonBodyField?: {
-    path: string;
-    equals?: string;
-  };
-  formBodyField?: {
-    path: string;
-    equals?: string;
-  };
-}
-
-export interface SlateWebhookHttpOptions {
-  methods?: SlateWebhookHttpMethod[];
-  sync?: {
-    mode: 'never' | 'match' | 'always';
-    match?: SlateWebhookRequestMatcher[];
-    timeoutMs?: number;
-  };
-}
-
-export type SlateTriggerWebhookRequestHandler<
-  ConfigType extends {},
-  AuthType extends {},
-  InputType extends {}
-> = (
-  context: SlateContext<
-    ConfigType,
-    AuthType,
-    { request: Request; state: any | null; registrationDetails: any | null }
-  >
-) => Promise<{
-  inputs: InputType[];
-  updatedState?: any;
-  response?: Response | SlateWebhookHttpResponseInit;
-}>;
-
-export type SlateTriggerWebhookAutoRegistrationHandler<
-  ConfigType extends {},
-  AuthType extends {}
-> = (context: SlateContext<ConfigType, AuthType, { webhookBaseUrl: string }>) => Promise<{
-  registrationDetails: any;
-  state?: any;
-}>;
-
-export type SlateTriggerWebhookAutoUnregistrationHandler<
-  ConfigType extends {},
-  AuthType extends {}
-> = (
-  context: SlateContext<
-    ConfigType,
-    AuthType,
-    { webhookBaseUrl: string; registrationDetails: any; state: any | null }
-  >
-) => Promise<unknown>;
-
 export interface SlateActionParametersTool<
   ConfigType extends {},
   AuthType extends {},
@@ -155,10 +82,6 @@ export interface SlateActionParametersTool<
   handleInvocation: SlateToolInvocationHandler<ConfigType, AuthType, InputType, OutputType>;
 }
 
-export interface SlatePollingOptions {
-  intervalInSeconds?: number;
-}
-
 export interface SlateActionParametersTrigger<
   ConfigType extends {},
   AuthType extends {},
@@ -166,14 +89,9 @@ export interface SlateActionParametersTrigger<
   OutputType extends {}
 > {
   type: 'trigger';
-  source: 'polling' | 'webhook';
-  polling?: SlatePollingOptions;
-  handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
-  handleRequest?: SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType>;
-  http?: SlateWebhookHttpOptions;
-  pollEvents?: SlateTriggerPollingHandler<ConfigType, AuthType, InputType>;
-  autoRegisterWebhook?: SlateTriggerWebhookAutoRegistrationHandler<ConfigType, AuthType>;
-  autoUnregisterWebhook?: SlateTriggerWebhookAutoUnregistrationHandler<ConfigType, AuthType>;
+  triggerGroup: SlateTriggerGroup<ConfigType, AuthType>;
+  matches: SlateTriggerMatchesHandler;
+  map: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
 }
 
 export type SlateActionParametersAny<