@slates/provider-handler 1.0.0-rc.42 → 1.0.0-rc.44

package/src/index.ts

@@ -9,7 +9,12 @@ import {
   SLATES_PROTOCOL_VERSION,
   type SlatesMessageAuthAdminCallbackHandleRequest,
   type SlatesMessageAuthAuthorizationUrlGetRequest,
-  type SlatesParticipant
+  type SlatesMessageTriggerGroupWebhookProcessRequest,
+  type SlatesParticipant,
+  type SlatesRuntimeInfo,
+  slatesTriggerGroupWebhookDeliveryAuthentication,
+  slatesTriggerGroupWebhookExpansionResult,
+  slatesTriggerGroupWebhookRegistrationResult
 } from '@slates/proto';
 import {
   AuthConfigSecretRedactor,
@@ -22,6 +27,8 @@ import {
   SlateLogger,
   type SlateLogListener,
   SlatePublicContext,
+  type SlateRuntimeInfo,
+  type SlateTriggerGroup,
   uploadAttachmentDirect
 } from '@slates/provider';
 import { PQueue } from './pQueue';
@@ -36,6 +43,7 @@ import {
   getExposedTriggerGroups,
   getTriggerGroup,
   getWebhookAutoRegistration,
+  getWebhookDeliveryConfig,
   getWebhookManualRegistration,
   isMappableTrigger,
   mapAction,
@@ -50,6 +58,39 @@ import { serializeWebhookHttpResponse } from './webhook';
 
 let DEFAULT_MAX_ATTACHMENT_SIZE_BYTES = 100_000_000;
 
+let validateTriggerGroupSelection = (
+  group: SlateTriggerGroup<any, any>,
+  selection: Record<string, any> | undefined
+) =>
+  group.selectionSchema
+    ? validate(
+        group.selectionSchema,
+        selection === undefined ? {} : selection,
+        'trigger_group.selection',
+        `Invalid selection for trigger group "${group.key}"`
+      )
+    : (selection ?? {});
+
+let validateWebhookRegistration = (result: unknown) =>
+  validate(
+    slatesTriggerGroupWebhookRegistrationResult,
+    result,
+    'trigger_group.webhook.registration',
+    'Webhook registration returned an invalid result'
+  );
+
+let toWebhookRequest = (
+  params: Pick<
+    SlatesMessageTriggerGroupWebhookProcessRequest['params'],
+    'url' | 'method' | 'headers' | 'body'
+  >
+) =>
+  new Request(params.url, {
+    method: params.method,
+    headers: params.headers,
+    body: params.body ? Uint8Array.from(atob(params.body.content), c => c.charCodeAt(0)) : null
+  });
+
 let routeAttachmentsThroughDirectUpload = async (
   attachments: SlateAttachment[] | undefined,
   live: SlateLiveInvocationInfo | null
@@ -189,6 +230,14 @@ let resolveTraceMessage = <ResultType>(
   result: ResultType
 ) => (typeof message === 'function' ? message(result) : message);
 
+// Build fails if SlateRuntimeInfo drifts from the proto schema.
+true satisfies [SlateRuntimeInfo, SlatesRuntimeInfo] extends [
+  SlatesRuntimeInfo,
+  SlateRuntimeInfo
+]
+  ? true
+  : false;
+
 export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
   slate: Slate<ConfigType, AuthType>,
   listeners: SlateLogListener[]
@@ -209,6 +258,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
     let liveInvocation = new State<Pick<SlateLiveInvocationInfo, 'token' | 'baseUrl'> | null>(
       null
     );
+    let runtimeInfo = new State<SlateRuntimeInfo | null>(null);
 
     let getLiveInvocation = (): SlateLiveInvocationInfo | null => {
       let directUpload = hubCapabilities.get()?.attachments?.directUpload;
@@ -335,9 +385,24 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
 
     let getAuthConfig = (): Record<string, any> => config.get()?.value ?? {};
 
-    let getEmptyContext = () => new SlateContext({}, {}, {}, slate.spec as any, logger);
-    let getAuthContext = () =>
-      new SlateContext(getAuthConfig(), {}, {}, slate.spec as any, logger);
+    let createContext = <ConfigType extends {}, InputType extends {}, AuthType extends {}>(
+      config: ConfigType,
+      input: InputType,
+      auth: AuthType,
+      liveInvocationInfo: SlateLiveInvocationInfo | null = null
+    ) =>
+      new SlateContext(
+        config,
+        input,
+        auth,
+        slate.spec as any,
+        logger,
+        liveInvocationInfo,
+        runtimeInfo.get()
+      );
+
+    let getEmptyContext = () => createContext({}, {}, {});
+    let getAuthContext = () => createContext(getAuthConfig(), {}, {});
     let withRequestTraces = <Result extends Record<string, any>>(
       context: SlatePublicContext<any>,
       result: Result
@@ -481,11 +546,16 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       });
     });
 
+    manager.onNotification('slates/hub.runtime_info.set', async ({ params }) => {
+      runtimeInfo.set(params.runtimeInfo);
+    });
+
     manager.onRequest('slates/provider.capabilities.get', async () => ({
       capabilities: {
         hub: {
           capabilitiesNotification: true,
-          liveInvocation: true
+          liveInvocation: true,
+          runtimeInfo: true
         },
         provider: {
           triggerGroups:
@@ -1131,20 +1201,19 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
 
       if (action.isPublic) {
         getContextBasic();
-        return invoke(new SlatePublicContext(input, slate.spec, logger, getLiveInvocation()));
+        return invoke(
+          new SlatePublicContext(
+            input,
+            slate.spec,
+            logger,
+            getLiveInvocation(),
+            runtimeInfo.get()
+          )
+        );
       }
 
       let ctx = getContextFull();
-      return invoke(
-        new SlateContext(
-          ctx.config,
-          input,
-          ctx.auth?.output!,
-          slate.spec,
-          logger,
-          getLiveInvocation()
-        )
-      );
+      return invoke(createContext(ctx.config, input, ctx.auth?.output!, getLiveInvocation()));
     });
 
     manager.onRequest('slates/action.trigger.map_event', async ({ params }) => {
@@ -1158,7 +1227,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         `Invalid event for trigger ID: ${params.actionId}`
       );
 
-      let context = new SlateContext(ctx.config, input, ctx.auth?.output!, slate.spec, logger);
+      let context = createContext(ctx.config, input, ctx.auth?.output!);
       let res = await traceProviderCall(
         {
           component: 'action',
@@ -1246,12 +1315,13 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let group = getTriggerGroup(slate, params.triggerGroupId);
       let autoRegistration = getWebhookAutoRegistration(group);
 
-      let context = new SlateContext(
+      let context = createContext(
         ctx.config,
-        { pageToken: params.pageToken ?? null },
-        ctx.auth?.output!,
-        slate.spec,
-        logger
+        {
+          pageToken: params.pageToken ?? null,
+          selection: validateTriggerGroupSelection(group, params.selection)
+        },
+        ctx.auth?.output!
       );
       let res = await traceProviderCall(
         {
@@ -1285,16 +1355,17 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let group = getTriggerGroup(slate, params.triggerGroupId);
       let autoRegistration = getWebhookAutoRegistration(group);
 
-      let context = new SlateContext(
+      let context = createContext(
         ctx.config,
         {
           webhookTargetIdentifier: params.webhookTargetIdentifier,
           webhookTargetPayload: params.webhookTargetPayload,
-          webhookUrl: params.webhookUrl
+          webhookUrl: params.webhookUrl,
+          operationId: params.operationId,
+          selection: validateTriggerGroupSelection(group, params.selection),
+          deliveryConfig: params.deliveryConfig
         },
-        ctx.auth?.output!,
-        slate.spec,
-        logger
+        ctx.auth?.output!
       );
       let res = await traceProviderCall(
         {
@@ -1309,13 +1380,58 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
             webhookTargetIdentifier: params.webhookTargetIdentifier
           }
         },
-        () => runWithContext(context, () => autoRegistration.webhookRegister(context))
+        () =>
+          runWithContext(context, async () =>
+            validateWebhookRegistration(await autoRegistration.webhookRegister(context))
+          )
       );
 
-      return withRequestTraces(context, {
-        webhookRegistrationIdentifier: res.webhookRegistrationIdentifier,
-        webhookRegistrationPayload: res.webhookRegistrationPayload
-      });
+      return withRequestTraces(context, res);
+    });
+
+    manager.onRequest('slates/trigger_group.webhook.renew', async ({ params }) => {
+      let ctx = getContextFull();
+      let group = getTriggerGroup(slate, params.triggerGroupId);
+      let autoRegistration = getWebhookAutoRegistration(group);
+      let renew = autoRegistration.webhookRenew;
+      if (!renew) {
+        throw new ServiceError(
+          badRequestError({
+            message: `Trigger group does not support webhook renewal: ${params.triggerGroupId}`
+          })
+        );
+      }
+
+      let context = createContext(
+        ctx.config,
+        {
+          webhookRegistrationIdentifier: params.webhookRegistrationIdentifier,
+          webhookRegistrationPayload: params.webhookRegistrationPayload,
+          webhookUrl: params.webhookUrl,
+          webhookTargetIdentifier: params.webhookTargetIdentifier,
+          webhookTargetPayload: params.webhookTargetPayload,
+          operationId: params.operationId,
+          selection: validateTriggerGroupSelection(group, params.selection),
+          deliveryConfig: params.deliveryConfig
+        },
+        ctx.auth?.output!
+      );
+      let res = await traceProviderCall(
+        {
+          component: 'action',
+          functionName: 'webhookRenew',
+          message: `Renewing webhook for trigger group ${formatEntityLabel(group.name, group.key)}`,
+          successMessage: `Renewed webhook for trigger group ${formatEntityLabel(group.name, group.key)}`,
+          errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while renewing a webhook`,
+          metadata: { triggerGroupId: group.key, triggerGroupName: group.name }
+        },
+        () =>
+          runWithContext(context, async () =>
+            validateWebhookRegistration(await renew(context))
+          )
+      );
+
+      return withRequestTraces(context, res);
     });
 
     manager.onRequest('slates/trigger_group.webhook.unregister', async ({ params }) => {
@@ -1323,15 +1439,13 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let group = getTriggerGroup(slate, params.triggerGroupId);
       let autoRegistration = getWebhookAutoRegistration(group);
 
-      let context = new SlateContext(
+      let context = createContext(
         ctx.config,
         {
           webhookRegistrationIdentifier: params.webhookRegistrationIdentifier,
           webhookRegistrationPayload: params.webhookRegistrationPayload
         },
-        ctx.auth?.output!,
-        slate.spec,
-        logger
+        ctx.auth?.output!
       );
       await traceProviderCall(
         {
@@ -1357,13 +1471,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let group = getTriggerGroup(slate, params.triggerGroupId);
       let manualRegistration = getWebhookManualRegistration(group);
 
-      let context = new SlateContext(
-        {},
-        { webhookUrl: params.webhookUrl },
-        {},
-        slate.spec as any,
-        logger
-      );
+      let context = createContext({}, { webhookUrl: params.webhookUrl }, {});
       let res = await traceProviderCall(
         {
           component: 'action',
@@ -1398,16 +1506,14 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         );
       }
 
-      let context = new SlateContext(
+      let context = createContext(
         {},
         {
           webhookUrl: params.webhookUrl,
           partialWebhookRegistrationPayload: params.partialWebhookRegistrationPayload,
           userWebhookRegistrationPayload: params.userWebhookRegistrationPayload
         },
-        {},
-        slate.spec as any,
-        logger
+        {}
       );
       let res = await traceProviderCall(
         {
@@ -1439,23 +1545,13 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         );
       }
 
-      let req = new Request(params.url, {
-        method: params.method,
-        headers: params.headers,
-        body: params.body
-          ? Uint8Array.from(atob(params.body.content), c => c.charCodeAt(0))
-          : null
-      });
-
-      let context = new SlateContext(
+      let context = createContext(
         {},
         {
-          request: req,
+          request: toWebhookRequest(params),
           webhookRegistrationPayload: params.webhookRegistrationPayload
         },
-        {},
-        slate.spec as any,
-        logger
+        {}
       );
       let res = await traceProviderCall(
         {
@@ -1500,18 +1596,126 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
           matchers: event.matchers,
           payload: event.payload,
           idempotencyKey: event.idempotencyKey,
-          triggerIds: evaluateTriggerMatches(slate, group.key, event.payload)
+          triggerIds: group.webhook?.expandWebhook
+            ? []
+            : evaluateTriggerMatches(slate, group.key, event.payload)
         })),
+        ...(group.webhook?.expandWebhook ? { requiresExpansion: true } : {}),
         response,
         skipped: res.skipped ?? null
       });
     });
 
+    manager.onRequest(
+      'slates/trigger_group.webhook.delivery_authenticate',
+      async ({ params }) => {
+        let group = getTriggerGroup(slate, params.triggerGroupId);
+        let deliveryConfig = getWebhookDeliveryConfig(group);
+
+        let context = createContext(
+          {},
+          {
+            request: toWebhookRequest(params),
+            deliveryConfig: params.deliveryConfig
+          },
+          {}
+        );
+        let res = await traceProviderCall(
+          {
+            component: 'action',
+            functionName: 'webhookDeliveryAuthenticate',
+            message: `Authenticating a delivery for trigger group ${formatEntityLabel(group.name, group.key)}`,
+            successMessage: result =>
+              result.rejected
+                ? `Rejected a delivery with status ${result.rejected.status} for trigger group ${formatEntityLabel(group.name, group.key)}`
+                : `Authenticated a delivery for ${result.routingKeys.length} routing key(s) for trigger group ${formatEntityLabel(group.name, group.key)}`,
+            errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while authenticating a delivery`,
+            metadata: {
+              triggerGroupId: group.key,
+              triggerGroupName: group.name,
+              requestMethod: params.method,
+              hasRequestBody: !!params.body
+            },
+            onSuccess: result => ({
+              routingKeyCount: result.routingKeys.length,
+              rejectedStatus: result.rejected?.status ?? null
+            })
+          },
+          () =>
+            runWithContext(context, async () => {
+              let authentication = await deliveryConfig.authenticate(context);
+              return validate(
+                slatesTriggerGroupWebhookDeliveryAuthentication,
+                authentication.rejected
+                  ? { routingKeys: [], rejected: authentication.rejected }
+                  : { routingKeys: authentication.routingKeys, rejected: null },
+                'trigger_group.webhook.delivery_authentication',
+                'Webhook delivery authentication returned an invalid result'
+              );
+            })
+        );
+
+        return withRequestTraces(context, res);
+      }
+    );
+
+    manager.onRequest('slates/trigger_group.webhook.expand', async ({ params }) => {
+      let ctx = getContextFull();
+      let group = getTriggerGroup(slate, params.triggerGroupId);
+      let expand = group.source === 'webhook' ? group.webhook?.expandWebhook : undefined;
+      if (!expand) {
+        throw new ServiceError(
+          badRequestError({
+            message: `Trigger group does not support webhook expansion: ${params.triggerGroupId}`
+          })
+        );
+      }
+
+      let context = createContext(
+        ctx.config,
+        {
+          payload: params.payload,
+          state: params.state ?? null,
+          selection: validateTriggerGroupSelection(group, params.selection),
+          deliveryId: params.deliveryId,
+          webhookRegistrationPayload: params.webhookRegistrationPayload
+        },
+        ctx.auth?.output!
+      );
+      let res = await traceProviderCall(
+        {
+          component: 'action',
+          functionName: 'expandWebhook',
+          message: `Expanding webhook delivery for trigger group ${formatEntityLabel(group.name, group.key)}`,
+          successMessage: `Expanded webhook delivery for trigger group ${formatEntityLabel(group.name, group.key)}`,
+          errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while expanding a webhook delivery`,
+          metadata: { triggerGroupId: group.key, triggerGroupName: group.name }
+        },
+        () =>
+          runWithContext(context, async () =>
+            validate(
+              slatesTriggerGroupWebhookExpansionResult,
+              await expand(context),
+              'trigger_group.webhook.expansion',
+              'Webhook expansion returned an invalid result'
+            )
+          )
+      );
+
+      return withRequestTraces(context, {
+        ...(res.updatedState !== undefined ? { updatedState: res.updatedState } : {}),
+        events: res.events.map(event => ({
+          ...event,
+          triggerIds: evaluateTriggerMatches(slate, group.key, event.payload)
+        }))
+      });
+    });
+
     manager.onRequest('slates/trigger_group.routing_matchers.get', async ({ params }) => {
       let ctx = getContextFull();
       let group = getTriggerGroup(slate, params.triggerGroupId);
 
-      let context = new SlateContext(ctx.config, {}, ctx.auth?.output!, slate.spec, logger);
+      let context = createContext(ctx.config, {}, ctx.auth?.output!);
       let matchers = await traceProviderCall(
         {
           component: 'action',
@@ -1545,12 +1749,13 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         );
       }
 
-      let context = new SlateContext(
+      let context = createContext(
         ctx.config,
-        { state: params.state },
-        ctx.auth?.output!,
-        slate.spec,
-        logger
+        {
+          state: params.state,
+          selection: validateTriggerGroupSelection(group, params.selection)
+        },
+        ctx.auth?.output!
       );
       let res = await traceProviderCall(
         {
@@ -1599,13 +1804,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let ctx = getContextFull();
       let { group, gateway } = getGatewayTriggerGroup(params.triggerGroupId);
 
-      let context = new SlateContext(
-        ctx.config,
-        { state: params.state },
-        ctx.auth?.output!,
-        slate.spec,
-        logger
-      );
+      let context = createContext(ctx.config, { state: params.state }, ctx.auth?.output!);
       let res = await traceProviderCall(
         {
           component: 'action',
@@ -1630,12 +1829,10 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let ctx = getContextFull();
       let { group, gateway } = getGatewayTriggerGroup(params.triggerGroupId);
 
-      let context = new SlateContext(
+      let context = createContext(
         ctx.config,
         { state: params.state, frames: params.frames, closed: params.closed ?? null },
-        ctx.auth?.output!,
-        slate.spec,
-        logger
+        ctx.auth?.output!
       );
       let res = await traceProviderCall(
         {

package/src/runtimeInfo.test.ts

@@ -0,0 +1,129 @@
+import { SLATES_PROTOCOL_VERSION, SlatesProviderProtoHandlerManager } from '@slates/proto';
+import {
+  getRuntimeInfo,
+  Slate,
+  SlateAuth,
+  SlateConfig,
+  SlatePublicTool,
+  SlateSpecification
+} from '@slates/provider';
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import { createProviderHandler } from './index';
+
+let runtimeInfo = {
+  metorial: {
+    apiUrl: 'https://api-us1.metorial.test',
+    region: 'us1',
+    environment: 'staging'
+  }
+};
+
+let createManager = async () => {
+  let spec = SlateSpecification.create({
+    key: 'runtime-info-test',
+    name: 'Runtime Info Test',
+    config: SlateConfig.create(z.object({ apiUrl: z.string().nullable() })).getDefaultConfig(
+      () => ({ apiUrl: getRuntimeInfo()?.metorial?.apiUrl ?? null })
+    ),
+    auth: SlateAuth.create().output(z.object({}))
+  });
+  let tool = SlatePublicTool.create(spec, {
+    key: 'read_runtime_info',
+    name: 'Read Runtime Info'
+  })
+    .input(z.object({}))
+    .output(z.object({ fromContext: z.any(), fromHelper: z.any() }))
+    .handleInvocation(async ctx => ({
+      output: { fromContext: ctx.runtimeInfo, fromHelper: getRuntimeInfo() },
+      message: 'ok'
+    }))
+    .build();
+  let slate = Slate.create({ spec, triggers: [], tools: [tool] });
+  let manager = await createProviderHandler(slate, []).run();
+
+  await SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    method: 'slates/hello',
+    params: { protocol: SLATES_PROTOCOL_VERSION }
+  });
+  await SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    method: 'slates/participant.set',
+    params: {
+      participants: [
+        { type: 'consumer', id: 'consumer', name: 'Consumer' },
+        { type: 'hub', id: 'hub', name: 'Hub' }
+      ]
+    }
+  });
+
+  return manager;
+};
+
+let setRuntimeInfo = (manager: SlatesProviderProtoHandlerManager) =>
+  SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    method: 'slates/hub.runtime_info.set',
+    params: { runtimeInfo }
+  });
+
+let invokeTool = (manager: SlatesProviderProtoHandlerManager) =>
+  SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    id: 'tool',
+    method: 'slates/action.tool.invoke',
+    params: { actionId: 'read_runtime_info', input: {} }
+  });
+
+let getDefaultConfig = (manager: SlatesProviderProtoHandlerManager) =>
+  SlatesProviderProtoHandlerManager.handleInput(manager, {
+    jsonrpc: '2.0',
+    id: 'config',
+    method: 'slates/config.get_default',
+    params: {}
+  });
+
+describe('hub runtime info', () => {
+  it('advertises the runtime info capability', async () => {
+    let response = await SlatesProviderProtoHandlerManager.handleInput(await createManager(), {
+      jsonrpc: '2.0',
+      id: 'capabilities',
+      method: 'slates/provider.capabilities.get',
+      params: {}
+    });
+
+    expect(response).toMatchObject({
+      result: { capabilities: { hub: { runtimeInfo: true } } }
+    });
+  });
+
+  it('exposes runtime info to tools through ctx and the context helper', async () => {
+    let manager = await createManager();
+    await setRuntimeInfo(manager);
+
+    expect(await invokeTool(manager)).toMatchObject({
+      result: { output: { fromContext: runtimeInfo, fromHelper: runtimeInfo } }
+    });
+  });
+
+  it('exposes runtime info to handlers that receive no ctx argument', async () => {
+    let manager = await createManager();
+    await setRuntimeInfo(manager);
+
+    expect(await getDefaultConfig(manager)).toMatchObject({
+      result: { config: { apiUrl: runtimeInfo.metorial.apiUrl } }
+    });
+  });
+
+  it('returns null when the host sent no runtime info', async () => {
+    let manager = await createManager();
+
+    expect(await invokeTool(manager)).toMatchObject({
+      result: { output: { fromContext: null, fromHelper: null } }
+    });
+    expect(await getDefaultConfig(manager)).toMatchObject({
+      result: { config: { apiUrl: null } }
+    });
+  });
+});