@slates/provider 1.0.0-rc.22 → 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
     });
   }
 };
@@ -1100,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) => {
@@ -1129,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;
+  }
+  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 autoRegisterWebhook() {
-    return this.#autoRegisterWebhook;
+  routingMatchers(handler) {
+    this.#routingMatchers = handler;
+    return this;
   }
-  get autoUnregisterWebhook() {
-    return this.#autoUnregisterWebhook;
+  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 = {}) => {
@@ -2581,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];
@@ -2614,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;
@@ -2625,6 +2729,9 @@ var Slate = class _Slate {
   get adapters() {
     return this._adapters;
   }
+  get triggerGroups() {
+    return this._triggerGroups;
+  }
 };
 
 // src/specification/specification.ts
@@ -2744,6 +2851,8 @@ export {
   SlateSpecification,
   SlateTool,
   SlateTrigger,
+  SlateTriggerGroup,
+  SlateTriggerGroupBuilder,
   adapterSpec,
   allOf,
   anyOf,
@@ -2795,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.22",
+  "version": "1.0.0-rc.23",
   "publishConfig": {
     "access": "public"
   },
@@ -43,4 +43,4 @@
     "typescript": "5.8.2",
     "vitest": "^3.1.2"
   }
-}
+}

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<

package/src/action/builder.ts

@@ -9,17 +9,13 @@ import type {
   SlateActionParametersTrigger,
   SlateActionScopes,
   SlateActionType,
-  SlatePollingOptions,
   SlatePublicToolInvocationHandler,
   SlateToolInvocationHandler,
   SlateTriggerMappingHandler,
-  SlateTriggerPollingHandler,
-  SlateTriggerWebhookAutoRegistrationHandler,
-  SlateTriggerWebhookAutoUnregistrationHandler,
-  SlateTriggerWebhookRequestHandler,
-  SlateWebhookHttpOptions
+  SlateTriggerMatchesHandler
 } from './action';
 import { validateScopes } from './scopes';
+import type { SlateTriggerGroup } from './triggerGroup';
 
 export class SlateActionBuilder<
   Type extends SlateActionType,
@@ -39,12 +35,10 @@ export class SlateActionBuilder<
 
   #toolParams: SlateActionParametersTool<ConfigType, AuthType, InputType, OutputType> | null =
     null;
-  #triggerParams: SlateActionParametersTrigger<
-    ConfigType,
-    AuthType,
-    InputType,
-    OutputType
-  > | null = null;
+  #triggerGroup: SlateTriggerGroup<ConfigType, AuthType> | null = null;
+  #triggerMatches: SlateTriggerMatchesHandler | null = null;
+  #triggerMap: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType> | null =
+    null;
   #interfaceLocked = false;
 
   constructor(
@@ -163,47 +157,36 @@ export class SlateActionBuilder<
     return this;
   }
 
-  webhook(props: {
-    handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
-    handleRequest: SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType>;
-    autoRegisterWebhook?: SlateTriggerWebhookAutoRegistrationHandler<ConfigType, AuthType>;
-    autoUnregisterWebhook?: SlateTriggerWebhookAutoUnregistrationHandler<ConfigType, AuthType>;
-    http?: SlateWebhookHttpOptions;
-  }): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result, IsPublic> {
+  triggerGroup(
+    group: SlateTriggerGroup<ConfigType, AuthType>
+  ): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result, IsPublic> {
     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: {
-    options?: SlatePollingOptions;
-    pollEvents?: SlateTriggerPollingHandler<ConfigType, AuthType, InputType>;
-    handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
-  }): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result, IsPublic> {
+  matches(
+    handler: SlateTriggerMatchesHandler
+  ): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result, IsPublic> {
     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: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>
+  ): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result, IsPublic> {
+    if (this.type !== 'trigger') {
+      throw new SlateDeclarationError('map can only be set for trigger actions');
+    }
+
+    this.#triggerMap = handler;
     return this;
   }
 
@@ -227,9 +210,30 @@ export class SlateActionBuilder<
     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: SlateActionParametersTrigger<
+      ConfigType,
+      AuthType,
+      InputType,
+      OutputType & { type: string }
+    > | null =
+      this.type === 'trigger'
+        ? {
+            type: 'trigger',
+            triggerGroup: this.#triggerGroup!,
+            matches: this.#triggerMatches!,
+            map: this.#triggerMap! as any
+          }
+        : null;
 
     return this.factory({
       ...this.params,
@@ -242,7 +246,7 @@ export class SlateActionBuilder<
       outputSchema: this.#outputSchema,
 
       ...this.#toolParams!,
-      ...this.#triggerParams!
+      ...(triggerParams as any)!
     }) as Result;
   }
 }

package/src/action/index.ts

@@ -5,3 +5,4 @@ export * from './publicTool';
 export * from './scopes';
 export * from './tool';
 export * from './trigger';
+export * from './triggerGroup';