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

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/directUpload.test.ts

@@ -50,7 +50,9 @@ describe('uploadAttachmentDirect', () => {
         'content-length': '5'
       }
     });
-    expect(upload[1]!.body).toEqual(new Uint8Array([1, 2, 3, 4, 5]));
+    expect(new Uint8Array(upload[1]!.body as ArrayBuffer)).toEqual(
+      new Uint8Array([1, 2, 3, 4, 5])
+    );
     expect(upload[1]).not.toHaveProperty('duplex');
   });
 

package/src/action/directUpload.ts

@@ -16,12 +16,15 @@ export interface SlateDirectUploadInput {
 let bufferAttachmentBody = async (
   body: SlateDirectUploadInput['body'],
   maxSizeBytes: number
-) => {
+): Promise<ArrayBuffer> => {
   if (body instanceof Uint8Array) {
     if (body.byteLength > maxSizeBytes) {
       throw new Error(`Attachment exceeds the maximum size of ${maxSizeBytes} bytes`);
     }
-    return body;
+
+    let buffered = new ArrayBuffer(body.byteLength);
+    new Uint8Array(buffered).set(body);
+    return buffered;
   }
 
   let reader = body.getReader();
@@ -41,10 +44,11 @@ let bufferAttachmentBody = async (
     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;

package/src/action/getFileUrlTool.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { AuthConfigSecretRedactor } from '../auth/redact';
 import type { SlateContext } from '../context/context';
 import type { SlateSpecification } from '../specification/specification';
 import { tool } from './tool';
@@ -34,8 +35,17 @@ export let getFileUrlTool = <ConfigType extends {}, AuthType extends {}>(
   })
     .input(getFileUrlToolInputSchema)
     .output(getFileUrlToolOutputSchema)
-    .handleInvocation(async ctx => ({
-      output: await handleGetFileUrl(ctx),
-      message: 'ok'
-    }))
+    .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();

package/src/action/index.ts

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

package/src/action/trigger.ts

@@ -3,17 +3,11 @@ import type { SlateSpecification } from '../specification/specification';
 import {
   SlateAction,
   type SlateActionParameters,
-  type SlatePollingOptions,
   type SlateTriggerMappingHandler,
-  type SlateTriggerPollingHandler,
-  type SlateTriggerWebhookAutoRegistrationHandler,
-  type SlateTriggerWebhookAutoUnregistrationHandler,
-  type SlateTriggerWebhookRequestHandler,
-  type SlateWebhookHttpOptions
+  type SlateTriggerMatchesHandler
 } from './action';
 import { SlateActionBuilder } from './builder';
-
-export let SlateDefaultPollingIntervalSeconds = 60 * 10;
+import type { SlateTriggerGroup } from './triggerGroup';
 
 export interface SlateTriggerParameters<
   ConfigType extends {},
@@ -24,14 +18,9 @@ export interface SlateTriggerParameters<
   }
 > extends SlateActionParameters {
   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 class SlateTrigger<
@@ -42,14 +31,9 @@ export class SlateTrigger<
     type: string;
   }
 > extends SlateAction<'trigger', ConfigType, AuthType, InputType, OutputType> {
-  #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>;
 
   private constructor(
     spec: SlateSpecification<ConfigType, AuthType>,
@@ -59,16 +43,9 @@ export class SlateTrigger<
   ) {
     super('trigger', spec, 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<ConfigType extends {}, AuthType extends {}>(
@@ -81,36 +58,16 @@ export class SlateTrigger<
     });
   }
 
-  get polling() {
-    return this.#polling;
-  }
-
-  get source() {
-    return this.#source;
-  }
-
-  get handleEvent() {
-    return this.#handleEvent;
-  }
-
-  get handleRequest() {
-    return this.#handleRequest;
-  }
-
-  get http() {
-    return this.#http;
-  }
-
-  get pollEvents() {
-    return this.#pollEvents;
+  get triggerGroup() {
+    return this.#triggerGroup;
   }
 
-  get autoRegisterWebhook() {
-    return this.#autoRegisterWebhook;
+  get matches() {
+    return this.#matches;
   }
 
-  get autoUnregisterWebhook() {
-    return this.#autoUnregisterWebhook;
+  get map() {
+    return this.#map;
   }
 }
 

package/src/action/triggerGroup.ts

@@ -0,0 +1,296 @@
+import type z from 'zod';
+import { SlateDeclarationError } from '../error';
+import type { SlateSpecification } from '../specification/specification';
+import type { SlateContext } from '../context';
+import type { SlateWebhookHttpResponseInit } from './action';
+
+export let SlateDefaultPollingIntervalSeconds = 60 * 10;
+
+export type SlateTriggerRoutingMatcher = Record<string, any>;
+
+export type SlateWebhookTargetOwnership = 'single_user' | 'multi_user';
+
+export interface SlateWebhookTarget {
+  webhookTargetIdentifier: string;
+  name: string;
+  description?: string;
+  metadata: Record<string, any>;
+  webhookTargetPayload: any;
+  targetOwnership: SlateWebhookTargetOwnership;
+}
+
+export type SlateTriggerGroupRoutingMatchersHandler<ConfigType extends {}, AuthType extends {}> = (
+  context: SlateContext<ConfigType, AuthType, {}>
+) => Promise<SlateTriggerRoutingMatcher[]>;
+
+export type SlateTriggerGroupPollHandler<ConfigType extends {}, AuthType extends {}> = (
+  context: SlateContext<ConfigType, AuthType, { state: any | null }>
+) => Promise<{
+  events: { payload: any; idempotencyKey?: string }[];
+  updatedState?: any;
+}>;
+
+export type SlateWebhookTargetListHandler<ConfigType extends {}, AuthType extends {}> = (
+  context: SlateContext<ConfigType, AuthType, { pageToken: any | null }>
+) => Promise<{
+  targets: SlateWebhookTarget[];
+  nextPageToken: any | null;
+}>;
+
+export type SlateWebhookRegisterHandler<ConfigType extends {}, AuthType extends {}> = (
+  context: SlateContext<
+    ConfigType,
+    AuthType,
+    {
+      webhookTargetIdentifier: string;
+      webhookTargetPayload: any;
+      webhookUrl: string;
+    }
+  >
+) => Promise<{
+  webhookRegistrationIdentifier: string;
+  webhookRegistrationPayload: any;
+}>;
+
+export type SlateWebhookUnregisterHandler<ConfigType extends {}, AuthType extends {}> = (
+  context: SlateContext<
+    ConfigType,
+    AuthType,
+    {
+      webhookRegistrationIdentifier: string;
+      webhookRegistrationPayload: any;
+    }
+  >
+) => Promise<unknown>;
+
+export type SlateWebhookManualSetupHandler<FullConfigSchema extends z.ZodType<any> = z.ZodType<any>> =
+  (
+    context: SlateContext<{}, {}, { webhookUrl: string }>
+  ) => Promise<{
+    webhookSetupDocument: string;
+    partialWebhookRegistrationPayload: Partial<z.infer<FullConfigSchema>>;
+  }>;
+
+export type SlateWebhookManualFinishHandler<
+  UserConfigSchema extends z.ZodType<any> = z.ZodType<any>,
+  FullConfigSchema extends z.ZodType<any> = z.ZodType<any>
+> = (
+  context: SlateContext<
+    {},
+    {},
+    {
+      webhookUrl: string;
+      partialWebhookRegistrationPayload: Partial<z.infer<FullConfigSchema>>;
+      userWebhookRegistrationPayload: z.infer<UserConfigSchema>;
+    }
+  >
+) => Promise<{
+  webhookRegistrationPayload: z.infer<FullConfigSchema>;
+}>;
+
+export type SlateWebhookProcessHandler = (
+  context: SlateContext<
+    {},
+    {},
+    {
+      request: Request;
+      webhookRegistrationPayload: any;
+    }
+  >
+) => Promise<{
+  events: {
+    matchers: SlateTriggerRoutingMatcher[];
+    payload: any;
+    idempotencyKey?: string;
+  }[];
+  response?: Response | SlateWebhookHttpResponseInit;
+}>;
+
+export interface SlateTriggerGroupPollingParameters<ConfigType extends {}, AuthType extends {}> {
+  intervalSeconds: number;
+  pollEvents: SlateTriggerGroupPollHandler<ConfigType, AuthType>;
+}
+
+export interface SlateTriggerGroupWebhookAutoRegistrationParameters<
+  ConfigType extends {},
+  AuthType extends {}
+> {
+  webhookTargetList: SlateWebhookTargetListHandler<ConfigType, AuthType>;
+  webhookRegister: SlateWebhookRegisterHandler<ConfigType, AuthType>;
+  webhookUnregister: SlateWebhookUnregisterHandler<ConfigType, AuthType>;
+}
+
+export interface SlateTriggerGroupWebhookManualRegistrationParameters<
+  UserConfigSchema extends z.ZodType<any> = z.ZodType<any>,
+  FullConfigSchema extends z.ZodType<any> = z.ZodType<any>
+> {
+  userConfigSchema: UserConfigSchema;
+  fullConfigSchema: FullConfigSchema;
+  setup: SlateWebhookManualSetupHandler<FullConfigSchema>;
+  finish?: SlateWebhookManualFinishHandler<UserConfigSchema, FullConfigSchema>;
+}
+
+export interface SlateTriggerGroupWebhookParameters<ConfigType extends {}, AuthType extends {}> {
+  autoRegistration?: SlateTriggerGroupWebhookAutoRegistrationParameters<ConfigType, AuthType>;
+  manualRegistration?: SlateTriggerGroupWebhookManualRegistrationParameters<any, any>;
+  process: SlateWebhookProcessHandler;
+}
+
+export interface SlateTriggerGroupCreateParameters {
+  key: string;
+  name: string;
+  description?: string;
+  metadata?: Record<string, any>;
+}
+
+export interface SlateTriggerGroupParameters<ConfigType extends {}, AuthType extends {}>
+  extends SlateTriggerGroupCreateParameters {
+  source: 'polling' | 'webhook';
+  polling?: SlateTriggerGroupPollingParameters<ConfigType, AuthType>;
+  webhook?: SlateTriggerGroupWebhookParameters<ConfigType, AuthType>;
+  routingMatchers: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>;
+}
+
+export class SlateTriggerGroup<ConfigType extends {}, AuthType extends {}> {
+  private constructor(
+    private readonly _spec: SlateSpecification<ConfigType, AuthType>,
+    private readonly _params: SlateTriggerGroupParameters<ConfigType, AuthType>
+  ) {}
+
+  static create<ConfigType extends {}, AuthType extends {}>(
+    spec: SlateSpecification<ConfigType, AuthType>,
+    params: SlateTriggerGroupCreateParameters
+  ) {
+    return new SlateTriggerGroupBuilder(spec, params, p => new SlateTriggerGroup(spec, 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._params.source;
+  }
+
+  get polling() {
+    return this._params.polling;
+  }
+
+  get webhook() {
+    return this._params.webhook;
+  }
+
+  get routingMatchers() {
+    return this._params.routingMatchers;
+  }
+}
+
+export class SlateTriggerGroupBuilder<ConfigType extends {}, AuthType extends {}> {
+  #source: 'polling' | 'webhook' | null = null;
+  #polling: SlateTriggerGroupPollingParameters<ConfigType, AuthType> | null = null;
+  #webhook: SlateTriggerGroupWebhookParameters<ConfigType, AuthType> | null = null;
+  #routingMatchers: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType> | null = null;
+
+  constructor(
+    private readonly spec: SlateSpecification<ConfigType, AuthType>,
+    private readonly params: SlateTriggerGroupCreateParameters,
+    private readonly factory: (
+      params: SlateTriggerGroupParameters<ConfigType, AuthType>
+    ) => SlateTriggerGroup<ConfigType, AuthType>
+  ) {}
+
+  polling(props: {
+    intervalSeconds?: number;
+    pollEvents: SlateTriggerGroupPollHandler<ConfigType, AuthType>;
+  }): SlateTriggerGroupBuilder<ConfigType, AuthType> {
+    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<
+    UserConfigSchema extends z.ZodType<any> = z.ZodType<any>,
+    FullConfigSchema extends z.ZodType<any> = z.ZodType<any>
+  >(props: {
+    autoRegistration?: SlateTriggerGroupWebhookAutoRegistrationParameters<ConfigType, AuthType>;
+    manualRegistration?: SlateTriggerGroupWebhookManualRegistrationParameters<
+      UserConfigSchema,
+      FullConfigSchema
+    >;
+    process: SlateWebhookProcessHandler;
+  }): SlateTriggerGroupBuilder<ConfigType, AuthType> {
+    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;
+  }
+
+  routingMatchers(
+    handler: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>
+  ): SlateTriggerGroupBuilder<ConfigType, AuthType> {
+    this.#routingMatchers = handler;
+    return this;
+  }
+
+  build(): SlateTriggerGroup<ConfigType, AuthType> {
+    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 ?? undefined,
+      webhook: this.#webhook ?? undefined,
+      routingMatchers: this.#routingMatchers
+    });
+  }
+}
+
+export let triggerGroup = <ConfigType extends {}, AuthType extends {}>(
+  spec: SlateSpecification<ConfigType, AuthType>,
+  params: SlateTriggerGroupCreateParameters
+) => SlateTriggerGroup.create(spec, params);