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

package/dist/index.module.js

@@ -7,7 +7,10 @@ import {
 } from "@lowerdeck/error";
 import {
   createSlatesProviderProtoHandler,
-  SLATES_PROTOCOL_VERSION
+  SLATES_PROTOCOL_VERSION,
+  slatesTriggerGroupWebhookDeliveryAuthentication,
+  slatesTriggerGroupWebhookExpansionResult,
+  slatesTriggerGroupWebhookRegistrationResult
 } from "@slates/proto";
 import {
   AuthConfigSecretRedactor,
@@ -61,7 +64,8 @@ var validate = (schema, data, entity, message) => {
   }
   return result.data;
 };
-var toJsonSchema = (schema) => schema.toJSONSchema({
+var toJsonSchema = (schema, io = "output") => schema.toJSONSchema({
+  io,
   unrepresentable: "any",
   override: (ctx) => {
     let def = ctx.zodSchema._zod.def;
@@ -224,15 +228,30 @@ var getWebhookAutoRegistration = (group) => {
   return group.webhook.autoRegistration;
 };
 var getWebhookManualRegistration = (group) => {
-  if (group.source !== "webhook" || !group.webhook?.manualRegistration) {
+  let registration = group.source === "webhook" ? group.webhook?.manualRegistration ?? group.webhook?.deliveryConfig : void 0;
+  if (!registration) {
     throw new ServiceError2(
       badRequestError({
         message: `Trigger group does not support manual webhook registration: ${group.key}`
       })
     );
   }
-  return group.webhook.manualRegistration;
+  return registration;
 };
+var getWebhookDeliveryConfig = (group) => {
+  if (group.source !== "webhook" || !group.webhook?.deliveryConfig) {
+    throw new ServiceError2(
+      badRequestError({
+        message: `Trigger group does not support webhook delivery authentication: ${group.key}`
+      })
+    );
+  }
+  return group.webhook.deliveryConfig;
+};
+var mapWebhookConfigSchemas = (config) => ({
+  userConfigSchema: toJsonSchema(config.userConfigSchema),
+  fullConfigSchema: toJsonSchema(config.fullConfigSchema)
+});
 var mapToolCategory = (category) => ({
   id: category.key,
   name: category.name,
@@ -252,20 +271,24 @@ var mapTriggerGroup = (group) => ({
   name: group.name,
   description: group.description,
   metadata: group.metadata,
+  ...group.selectionSchema ? { selectionSchema: toJsonSchema(group.selectionSchema, "input") } : {},
   invocation: group.source === "polling" ? {
     type: "polling",
     intervalSeconds: group.polling?.intervalSeconds ?? SlateDefaultPollingIntervalSeconds
   } : group.source === "gateway" ? { type: "gateway" } : {
     type: "webhook",
+    ...group.webhook?.expandWebhook ? { supportsExpansion: true } : {},
+    ...group.webhook?.autoRegistration?.webhookRenew ? { supportsRenewal: true } : {},
+    ...group.webhook?.reconcileIntervalSeconds !== void 0 ? { reconcileIntervalSeconds: group.webhook.reconcileIntervalSeconds } : {},
     registration: group.webhook?.manualRegistration ? {
       mode: "manual",
-      userConfigSchema: toJsonSchema(
-        group.webhook.manualRegistration.userConfigSchema
-      ),
-      fullConfigSchema: toJsonSchema(
-        group.webhook.manualRegistration.fullConfigSchema
-      )
-    } : { mode: "auto" }
+      ...mapWebhookConfigSchemas(group.webhook.manualRegistration)
+    } : {
+      mode: "auto",
+      ...group.webhook?.deliveryConfig ? {
+        deliveryConfig: mapWebhookConfigSchemas(group.webhook.deliveryConfig)
+      } : {}
+    }
   }
 });
 
@@ -342,6 +365,23 @@ var serializeWebhookHttpResponse = async (response) => {
 
 // src/index.ts
 var DEFAULT_MAX_ATTACHMENT_SIZE_BYTES = 1e8;
+var validateTriggerGroupSelection = (group, selection) => group.selectionSchema ? validate(
+  group.selectionSchema,
+  selection === void 0 ? {} : selection,
+  "trigger_group.selection",
+  `Invalid selection for trigger group "${group.key}"`
+) : selection ?? {};
+var validateWebhookRegistration = (result) => validate(
+  slatesTriggerGroupWebhookRegistrationResult,
+  result,
+  "trigger_group.webhook.registration",
+  "Webhook registration returned an invalid result"
+);
+var toWebhookRequest = (params) => new Request(params.url, {
+  method: params.method,
+  headers: params.headers,
+  body: params.body ? Uint8Array.from(atob(params.body.content), (c) => c.charCodeAt(0)) : null
+});
 var routeAttachmentsThroughDirectUpload = async (attachments, live) => {
   if (!attachments || attachments.length === 0 || !live) return attachments;
   let contentEntries = attachments.map((attachment, index) => ({ attachment, index })).filter((entry) => entry.attachment.content.type === "content");
@@ -438,6 +478,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
   let liveInvocation = new State(
     null
   );
+  let runtimeInfo = new State(null);
   let getLiveInvocation = () => {
     let directUpload = hubCapabilities.get()?.attachments?.directUpload;
     let live = liveInvocation.get();
@@ -527,8 +568,17 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     };
   };
   let getAuthConfig = () => config.get()?.value ?? {};
-  let getEmptyContext = () => new SlateContext({}, {}, {}, slate.spec, logger);
-  let getAuthContext = () => new SlateContext(getAuthConfig(), {}, {}, slate.spec, logger);
+  let createContext = (config2, input, auth2, liveInvocationInfo = null) => new SlateContext(
+    config2,
+    input,
+    auth2,
+    slate.spec,
+    logger,
+    liveInvocationInfo,
+    runtimeInfo.get()
+  );
+  let getEmptyContext = () => createContext({}, {}, {});
+  let getAuthContext = () => createContext(getAuthConfig(), {}, {});
   let withRequestTraces = (context, result) => {
     let requestTraces = context.getHttpTraces();
     return requestTraces.length > 0 ? { ...result, requestTraces } : result;
@@ -635,11 +685,15 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
       baseUrl: params.baseUrl
     });
   });
+  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: (slate.triggerGroups?.length ?? 0) > 0 && (slate.actions ?? []).every(isMappableTrigger),
@@ -1198,19 +1252,18 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     };
     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 }) => {
     let ctx = getContextFull();
@@ -1221,7 +1274,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
       "input",
       `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",
@@ -1293,12 +1346,13 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     let ctx = getContextFull();
     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(
       {
@@ -1328,16 +1382,17 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     let ctx = getContextFull();
     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(
       {
@@ -1352,26 +1407,66 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
           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 ServiceError4(
+        badRequestError3({
+          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 }) => {
     let ctx = getContextFull();
     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(
       {
@@ -1394,13 +1489,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     getContextBasic();
     let group = getTriggerGroup(slate, params.triggerGroupId);
     let manualRegistration = getWebhookManualRegistration(group);
-    let context = new SlateContext(
-      {},
-      { webhookUrl: params.webhookUrl },
-      {},
-      slate.spec,
-      logger
-    );
+    let context = createContext({}, { webhookUrl: params.webhookUrl }, {});
     let res = await traceProviderCall(
       {
         component: "action",
@@ -1431,16 +1520,14 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
         })
       );
     }
-    let context = new SlateContext(
+    let context = createContext(
       {},
       {
         webhookUrl: params.webhookUrl,
         partialWebhookRegistrationPayload: params.partialWebhookRegistrationPayload,
         userWebhookRegistrationPayload: params.userWebhookRegistrationPayload
       },
-      {},
-      slate.spec,
-      logger
+      {}
     );
     let res = await traceProviderCall(
       {
@@ -1469,20 +1556,13 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
         })
       );
     }
-    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,
-      logger
+      {}
     );
     let res = await traceProviderCall(
       {
@@ -1520,16 +1600,110 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
         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 : void 0;
+    if (!expand) {
+      throw new ServiceError4(
+        badRequestError3({
+          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 !== void 0 ? { 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",
@@ -1559,12 +1733,13 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
         })
       );
     }
-    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(
       {
@@ -1608,13 +1783,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
   manager.onRequest("slates/trigger_group.gateway.connect", async ({ params }) => {
     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",
@@ -1635,12 +1804,10 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
   manager.onRequest("slates/trigger_group.gateway.receive", async ({ params }) => {
     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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider-handler",
-  "version": "1.0.0-rc.42",
+  "version": "1.0.0-rc.44",
   "publishConfig": {
     "access": "public"
   },
@@ -32,8 +32,8 @@
   },
   "dependencies": {
     "@lowerdeck/error": "^1.1.0",
-    "@slates/proto": "1.0.0-rc.27",
-    "@slates/provider": "1.0.0-rc.32",
+    "@slates/proto": "1.0.0-rc.29",
+    "@slates/provider": "1.0.0-rc.34",
     "p-queue": "^6.6.2",
     "zod": "^4.2.1"
   },