@slates/provider-handler 1.0.0-rc.17 → 1.0.0-rc.19

package/dist/index.cjs

@@ -33,7 +33,7 @@ __export(index_exports, {
   createProviderHandler: () => createProviderHandler
 });
 module.exports = __toCommonJS(index_exports);
-var import_error3 = require("@lowerdeck/error");
+var import_error4 = require("@lowerdeck/error");
 var import_proto = require("@slates/proto");
 var import_provider2 = require("@slates/provider");
 
@@ -139,6 +139,7 @@ var mapAction = (_slate, a) => {
     tags: a.tags,
     metadata: a.metadata,
     scopes: a.scopes,
+    authMethods: a.authMethods,
     docs: a.docs ?? [],
     inputSchema: toJsonSchema(a.inputSchema),
     outputSchema: toJsonSchema(a.outputSchema)
@@ -160,7 +161,8 @@ var mapAction = (_slate, a) => {
     } : {
       type: "webhook",
       autoRegistration: !!a.autoRegisterWebhook,
-      autoUnregistration: !!a.autoUnregisterWebhook
+      autoUnregistration: !!a.autoUnregisterWebhook,
+      http: a.http
     }
   };
 };
@@ -182,6 +184,60 @@ var State = class {
   }
 };
 
+// src/webhook.ts
+var import_error3 = require("@lowerdeck/error");
+var SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES = 1024 * 1024;
+var serializeBody = (body) => {
+  if (body === null) return null;
+  if (body.byteLength > SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES) {
+    throw new import_error3.ServiceError(
+      (0, import_error3.badRequestError)({
+        message: `Webhook response body exceeds the ${SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES}-byte limit`
+      })
+    );
+  }
+  return {
+    encoding: "base64",
+    content: Buffer.from(body).toString("base64")
+  };
+};
+var headersToObject = (headers) => {
+  let result = {};
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+};
+var validateStatus = (status) => {
+  if (!Number.isInteger(status) || status < 100 || status > 599) {
+    throw new import_error3.ServiceError(
+      (0, import_error3.badRequestError)({
+        message: "Webhook response status must be an integer between 100 and 599"
+      })
+    );
+  }
+};
+var serializeWebhookHttpResponse = async (response) => {
+  if (response instanceof Response) {
+    validateStatus(response.status);
+    return {
+      status: response.status,
+      headers: headersToObject(response.headers),
+      body: serializeBody(
+        response.body === null ? null : new Uint8Array(await response.arrayBuffer())
+      )
+    };
+  }
+  let status = response.status ?? 200;
+  validateStatus(status);
+  let body = typeof response.body === "string" ? new TextEncoder().encode(response.body) : response.body ?? null;
+  return {
+    status,
+    headers: response.headers ?? {},
+    body: serializeBody(body)
+  };
+};
+
 // src/index.ts
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var getObjectKeyCount = (value) => isRecord(value) ? Object.keys(value).length : void 0;
@@ -293,8 +349,8 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
     let currentProtocol = protocol.get();
     let currentParticipants = participants.get();
     if (!currentProtocol || !currentParticipants) {
-      throw new import_error3.ServiceError(
-        (0, import_error3.preconditionFailedError)({
+      throw new import_error4.ServiceError(
+        (0, import_error4.preconditionFailedError)({
           message: "Connection context has not been initialized"
         })
       );
@@ -310,8 +366,8 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
     let currentSession = session.get();
     let currentAuth = auth.get();
     if (!currentConfig || !currentSession || !currentAuth && slate.spec.auth.authStack.length > 0) {
-      throw new import_error3.ServiceError(
-        (0, import_error3.preconditionFailedError)({
+      throw new import_error4.ServiceError(
+        (0, import_error4.preconditionFailedError)({
           message: "Session context has not been initialized"
         })
       );
@@ -325,6 +381,7 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
   };
   let getAuthConfig = () => config.get()?.value ?? {};
   let getEmptyContext = () => new import_provider2.SlateContext({}, {}, {}, slate.spec, logger);
+  let getAuthContext = () => new import_provider2.SlateContext(getAuthConfig(), {}, {}, slate.spec, logger);
   let withRequestTraces = (context, result) => {
     let requestTraces = context.getHttpTraces();
     return requestTraces.length > 0 ? { ...result, requestTraces } : result;
@@ -334,8 +391,8 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
   });
   manager.onNotification("slates/participant.set", async ({ params }) => {
     if (!protocol.get()) {
-      throw new import_error3.ServiceError(
-        (0, import_error3.preconditionFailedError)({ message: "Connection protocol has not been initialized" })
+      throw new import_error4.ServiceError(
+        (0, import_error4.preconditionFailedError)({ message: "Connection protocol has not been initialized" })
       );
     }
     participants.set(params.participants);
@@ -542,7 +599,7 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
       );
     }
     if ("getOutput" in authMethod) {
-      let context = getEmptyContext();
+      let context = getAuthContext();
       let outputRes = await traceProviderCall(
         {
           component: "auth",
@@ -555,12 +612,22 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
             inputKeyCount: getObjectKeyCount(input)
           },
           onSuccess: (result) => ({
-            outputKeyCount: getObjectKeyCount(result.output)
+            outputKeyCount: getObjectKeyCount(result.output),
+            scopeCount: result.scopes?.length ?? 0
           })
         },
-        () => (0, import_provider2.runWithContext)(context, () => authMethod.getOutput({ input }))
+        () => (0, import_provider2.runWithContext)(
+          context,
+          () => authMethod.getOutput({
+            input,
+            config: getAuthConfig()
+          })
+        )
       );
-      return withRequestTraces(context, { output: outputRes.output });
+      return withRequestTraces(context, {
+        output: outputRes.output,
+        scopes: outputRes.scopes
+      });
     }
     return { output: input };
   });
@@ -609,8 +676,8 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
         scopes: callbackRes.scopes
       });
     }
-    throw new import_error3.ServiceError(
-      (0, import_error3.preconditionFailedError)({
+    throw new import_error4.ServiceError(
+      (0, import_error4.preconditionFailedError)({
         message: `Authentication method does not support authorization callback handling: ${params.authenticationMethodId}`
       })
     );
@@ -656,8 +723,8 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
         callbackState: urlRes.callbackState
       });
     }
-    throw new import_error3.ServiceError(
-      (0, import_error3.preconditionFailedError)({
+    throw new import_error4.ServiceError(
+      (0, import_error4.preconditionFailedError)({
         message: `Authentication method does not support authorization URL retrieval: ${params.authenticationMethodId}`
       })
     );
@@ -666,7 +733,7 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
     getContextBasic();
     let authMethod = getAuthMethod(slate, params.authenticationMethodId);
     if (authMethod.getProfile) {
-      let context = getEmptyContext();
+      let context = getAuthContext();
       let profileRes = await traceProviderCall(
         {
           component: "auth",
@@ -695,7 +762,9 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
           }
           return authMethod.getProfile({
             output: params.output,
-            input: params.input
+            input: params.input,
+            scopes: params.scopes,
+            config: getAuthConfig()
           });
         })
       );
@@ -703,8 +772,8 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
         profile: profileRes.profile
       });
     }
-    throw new import_error3.ServiceError(
-      (0, import_error3.preconditionFailedError)({
+    throw new import_error4.ServiceError(
+      (0, import_error4.preconditionFailedError)({
         message: `Authentication method does not support profile retrieval: ${params.authenticationMethodId}`
       })
     );
@@ -713,7 +782,7 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
     getContextBasic();
     let authMethod = getAuthMethod(slate, params.authenticationMethodId);
     if ("handleTokenRefresh" in authMethod && authMethod.handleTokenRefresh) {
-      let context = getEmptyContext();
+      let context = getAuthContext();
       let refreshRes = await traceProviderCall(
         {
           component: "auth",
@@ -748,7 +817,8 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
             input: params.input,
             clientId: params.clientId,
             clientSecret: params.clientSecret,
-            scopes: params.scopes
+            scopes: params.scopes,
+            config: getAuthConfig()
           });
         })
       );
@@ -757,8 +827,8 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
         input: refreshRes.input
       });
     }
-    throw new import_error3.ServiceError(
-      (0, import_error3.preconditionFailedError)({
+    throw new import_error4.ServiceError(
+      (0, import_error4.preconditionFailedError)({
         message: `Authentication method does not support token refresh handling: ${params.authenticationMethodId}`
       })
     );
@@ -851,8 +921,8 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
     let ctx = getContextFull();
     let action = getActionWithType(slate, "trigger", params.actionId);
     if (!action.pollEvents) {
-      throw new import_error3.ServiceError(
-        (0, import_error3.badRequestError)({
+      throw new import_error4.ServiceError(
+        (0, import_error4.badRequestError)({
           message: `Trigger action does not support polling: ${params.actionId}`
         })
       );
@@ -893,8 +963,8 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
     let ctx = getContextFull();
     let action = getActionWithType(slate, "trigger", params.actionId);
     if (!action.handleRequest) {
-      throw new import_error3.ServiceError(
-        (0, import_error3.badRequestError)({
+      throw new import_error4.ServiceError(
+        (0, import_error4.badRequestError)({
           message: `Trigger action does not support webhook requests: ${params.actionId}`
         })
       );
@@ -906,7 +976,11 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
     });
     let context = new import_provider2.SlateContext(
       ctx.config,
-      { request: req, state: params.state },
+      {
+        request: req,
+        state: params.state,
+        registrationDetails: params.registrationDetails ?? null
+      },
       ctx.auth?.output,
       slate.spec,
       logger
@@ -928,22 +1002,25 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
         },
         onSuccess: (result) => ({
           inputCount: result.inputs.length,
-          hasUpdatedState: result.updatedState !== void 0
+          hasUpdatedState: result.updatedState !== void 0,
+          hasResponse: result.response !== void 0
         })
       },
       () => (0, import_provider2.runWithContext)(context, () => action.handleRequest(context))
     );
+    let response = res.response === void 0 ? void 0 : await serializeWebhookHttpResponse(res.response);
     return withRequestTraces(context, {
       inputs: res.inputs,
-      updatedState: res.updatedState
+      updatedState: res.updatedState,
+      response
     });
   });
   manager.onRequest("slates/action.trigger.webhook_register", async ({ params }) => {
     let ctx = getContextFull();
     let action = getActionWithType(slate, "trigger", params.actionId);
     if (!action.autoRegisterWebhook) {
-      throw new import_error3.ServiceError(
-        (0, import_error3.badRequestError)({
+      throw new import_error4.ServiceError(
+        (0, import_error4.badRequestError)({
           message: `Trigger action does not support webhook auto-registration: ${params.actionId}`
         })
       );
@@ -983,8 +1060,8 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
     let ctx = getContextFull();
     let action = getActionWithType(slate, "trigger", params.actionId);
     if (!action.autoUnregisterWebhook) {
-      throw new import_error3.ServiceError(
-        (0, import_error3.badRequestError)({
+      throw new import_error4.ServiceError(
+        (0, import_error4.badRequestError)({
           message: `Trigger action does not support webhook auto-unregistration: ${params.actionId}`
         })
       );

package/dist/index.module.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { badRequestError as badRequestError2, preconditionFailedError, ServiceError as ServiceError3 } from "@lowerdeck/error";
+import { badRequestError as badRequestError3, preconditionFailedError, ServiceError as ServiceError4 } from "@lowerdeck/error";
 import {
   createSlatesProviderProtoHandler,
   SLATES_PROTOCOL_VERSION
@@ -112,6 +112,7 @@ var mapAction = (_slate, a) => {
     tags: a.tags,
     metadata: a.metadata,
     scopes: a.scopes,
+    authMethods: a.authMethods,
     docs: a.docs ?? [],
     inputSchema: toJsonSchema(a.inputSchema),
     outputSchema: toJsonSchema(a.outputSchema)
@@ -133,7 +134,8 @@ var mapAction = (_slate, a) => {
     } : {
       type: "webhook",
       autoRegistration: !!a.autoRegisterWebhook,
-      autoUnregistration: !!a.autoUnregisterWebhook
+      autoUnregistration: !!a.autoUnregisterWebhook,
+      http: a.http
     }
   };
 };
@@ -155,6 +157,60 @@ var State = class {
   }
 };
 
+// src/webhook.ts
+import { badRequestError as badRequestError2, ServiceError as ServiceError3 } from "@lowerdeck/error";
+var SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES = 1024 * 1024;
+var serializeBody = (body) => {
+  if (body === null) return null;
+  if (body.byteLength > SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES) {
+    throw new ServiceError3(
+      badRequestError2({
+        message: `Webhook response body exceeds the ${SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES}-byte limit`
+      })
+    );
+  }
+  return {
+    encoding: "base64",
+    content: Buffer.from(body).toString("base64")
+  };
+};
+var headersToObject = (headers) => {
+  let result = {};
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+};
+var validateStatus = (status) => {
+  if (!Number.isInteger(status) || status < 100 || status > 599) {
+    throw new ServiceError3(
+      badRequestError2({
+        message: "Webhook response status must be an integer between 100 and 599"
+      })
+    );
+  }
+};
+var serializeWebhookHttpResponse = async (response) => {
+  if (response instanceof Response) {
+    validateStatus(response.status);
+    return {
+      status: response.status,
+      headers: headersToObject(response.headers),
+      body: serializeBody(
+        response.body === null ? null : new Uint8Array(await response.arrayBuffer())
+      )
+    };
+  }
+  let status = response.status ?? 200;
+  validateStatus(status);
+  let body = typeof response.body === "string" ? new TextEncoder().encode(response.body) : response.body ?? null;
+  return {
+    status,
+    headers: response.headers ?? {},
+    body: serializeBody(body)
+  };
+};
+
 // src/index.ts
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var getObjectKeyCount = (value) => isRecord(value) ? Object.keys(value).length : void 0;
@@ -266,7 +322,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     let currentProtocol = protocol.get();
     let currentParticipants = participants.get();
     if (!currentProtocol || !currentParticipants) {
-      throw new ServiceError3(
+      throw new ServiceError4(
         preconditionFailedError({
           message: "Connection context has not been initialized"
         })
@@ -283,7 +339,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     let currentSession = session.get();
     let currentAuth = auth.get();
     if (!currentConfig || !currentSession || !currentAuth && slate.spec.auth.authStack.length > 0) {
-      throw new ServiceError3(
+      throw new ServiceError4(
         preconditionFailedError({
           message: "Session context has not been initialized"
         })
@@ -298,6 +354,7 @@ 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 withRequestTraces = (context, result) => {
     let requestTraces = context.getHttpTraces();
     return requestTraces.length > 0 ? { ...result, requestTraces } : result;
@@ -307,7 +364,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
   });
   manager.onNotification("slates/participant.set", async ({ params }) => {
     if (!protocol.get()) {
-      throw new ServiceError3(
+      throw new ServiceError4(
         preconditionFailedError({ message: "Connection protocol has not been initialized" })
       );
     }
@@ -515,7 +572,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
       );
     }
     if ("getOutput" in authMethod) {
-      let context = getEmptyContext();
+      let context = getAuthContext();
       let outputRes = await traceProviderCall(
         {
           component: "auth",
@@ -528,12 +585,22 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
             inputKeyCount: getObjectKeyCount(input)
           },
           onSuccess: (result) => ({
-            outputKeyCount: getObjectKeyCount(result.output)
+            outputKeyCount: getObjectKeyCount(result.output),
+            scopeCount: result.scopes?.length ?? 0
           })
         },
-        () => runWithContext(context, () => authMethod.getOutput({ input }))
+        () => runWithContext(
+          context,
+          () => authMethod.getOutput({
+            input,
+            config: getAuthConfig()
+          })
+        )
       );
-      return withRequestTraces(context, { output: outputRes.output });
+      return withRequestTraces(context, {
+        output: outputRes.output,
+        scopes: outputRes.scopes
+      });
     }
     return { output: input };
   });
@@ -582,7 +649,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
         scopes: callbackRes.scopes
       });
     }
-    throw new ServiceError3(
+    throw new ServiceError4(
       preconditionFailedError({
         message: `Authentication method does not support authorization callback handling: ${params.authenticationMethodId}`
       })
@@ -629,7 +696,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
         callbackState: urlRes.callbackState
       });
     }
-    throw new ServiceError3(
+    throw new ServiceError4(
       preconditionFailedError({
         message: `Authentication method does not support authorization URL retrieval: ${params.authenticationMethodId}`
       })
@@ -639,7 +706,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     getContextBasic();
     let authMethod = getAuthMethod(slate, params.authenticationMethodId);
     if (authMethod.getProfile) {
-      let context = getEmptyContext();
+      let context = getAuthContext();
       let profileRes = await traceProviderCall(
         {
           component: "auth",
@@ -668,7 +735,9 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
           }
           return authMethod.getProfile({
             output: params.output,
-            input: params.input
+            input: params.input,
+            scopes: params.scopes,
+            config: getAuthConfig()
           });
         })
       );
@@ -676,7 +745,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
         profile: profileRes.profile
       });
     }
-    throw new ServiceError3(
+    throw new ServiceError4(
       preconditionFailedError({
         message: `Authentication method does not support profile retrieval: ${params.authenticationMethodId}`
       })
@@ -686,7 +755,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     getContextBasic();
     let authMethod = getAuthMethod(slate, params.authenticationMethodId);
     if ("handleTokenRefresh" in authMethod && authMethod.handleTokenRefresh) {
-      let context = getEmptyContext();
+      let context = getAuthContext();
       let refreshRes = await traceProviderCall(
         {
           component: "auth",
@@ -721,7 +790,8 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
             input: params.input,
             clientId: params.clientId,
             clientSecret: params.clientSecret,
-            scopes: params.scopes
+            scopes: params.scopes,
+            config: getAuthConfig()
           });
         })
       );
@@ -730,7 +800,7 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
         input: refreshRes.input
       });
     }
-    throw new ServiceError3(
+    throw new ServiceError4(
       preconditionFailedError({
         message: `Authentication method does not support token refresh handling: ${params.authenticationMethodId}`
       })
@@ -824,8 +894,8 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     let ctx = getContextFull();
     let action = getActionWithType(slate, "trigger", params.actionId);
     if (!action.pollEvents) {
-      throw new ServiceError3(
-        badRequestError2({
+      throw new ServiceError4(
+        badRequestError3({
           message: `Trigger action does not support polling: ${params.actionId}`
         })
       );
@@ -866,8 +936,8 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     let ctx = getContextFull();
     let action = getActionWithType(slate, "trigger", params.actionId);
     if (!action.handleRequest) {
-      throw new ServiceError3(
-        badRequestError2({
+      throw new ServiceError4(
+        badRequestError3({
           message: `Trigger action does not support webhook requests: ${params.actionId}`
         })
       );
@@ -879,7 +949,11 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     });
     let context = new SlateContext(
       ctx.config,
-      { request: req, state: params.state },
+      {
+        request: req,
+        state: params.state,
+        registrationDetails: params.registrationDetails ?? null
+      },
       ctx.auth?.output,
       slate.spec,
       logger
@@ -901,22 +975,25 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
         },
         onSuccess: (result) => ({
           inputCount: result.inputs.length,
-          hasUpdatedState: result.updatedState !== void 0
+          hasUpdatedState: result.updatedState !== void 0,
+          hasResponse: result.response !== void 0
         })
       },
       () => runWithContext(context, () => action.handleRequest(context))
     );
+    let response = res.response === void 0 ? void 0 : await serializeWebhookHttpResponse(res.response);
     return withRequestTraces(context, {
       inputs: res.inputs,
-      updatedState: res.updatedState
+      updatedState: res.updatedState,
+      response
     });
   });
   manager.onRequest("slates/action.trigger.webhook_register", async ({ params }) => {
     let ctx = getContextFull();
     let action = getActionWithType(slate, "trigger", params.actionId);
     if (!action.autoRegisterWebhook) {
-      throw new ServiceError3(
-        badRequestError2({
+      throw new ServiceError4(
+        badRequestError3({
           message: `Trigger action does not support webhook auto-registration: ${params.actionId}`
         })
       );
@@ -956,8 +1033,8 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
     let ctx = getContextFull();
     let action = getActionWithType(slate, "trigger", params.actionId);
     if (!action.autoUnregisterWebhook) {
-      throw new ServiceError3(
-        badRequestError2({
+      throw new ServiceError4(
+        badRequestError3({
           message: `Trigger action does not support webhook auto-unregistration: ${params.actionId}`
         })
       );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider-handler",
-  "version": "1.0.0-rc.17",
+  "version": "1.0.0-rc.19",
   "publishConfig": {
     "access": "public"
   },
@@ -32,8 +32,8 @@
   },
   "dependencies": {
     "@lowerdeck/error": "^1.1.0",
-    "@slates/proto": "1.0.0-rc.11",
-    "@slates/provider": "1.0.0-rc.15",
+    "@slates/proto": "1.0.0-rc.13",
+    "@slates/provider": "1.0.0-rc.17",
     "zod": "^4.2.1"
   },
   "devDependencies": {

package/src/index.ts

@@ -15,6 +15,7 @@ import {
 import { getAction, getActionWithType, getAuthMethod, mapAction, mapAuthMethod } from './spec';
 import { State } from './state';
 import { toJsonSchema, validate } from './validation';
+import { serializeWebhookHttpResponse } from './webhook';
 
 let isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -228,6 +229,8 @@ 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 withRequestTraces = <Result extends Record<string, any>>(
       context: SlateContext<any, any, any>,
       result: Result
@@ -487,7 +490,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       }
 
       if ('getOutput' in authMethod) {
-        let context = getEmptyContext();
+        let context = getAuthContext();
         let outputRes = await traceProviderCall(
           {
             component: 'auth',
@@ -500,12 +503,22 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
               inputKeyCount: getObjectKeyCount(input)
             },
             onSuccess: result => ({
-              outputKeyCount: getObjectKeyCount(result.output)
+              outputKeyCount: getObjectKeyCount(result.output),
+              scopeCount: result.scopes?.length ?? 0
             })
           },
-          () => runWithContext(context, () => authMethod.getOutput({ input }))
+          () =>
+            runWithContext(context, () =>
+              authMethod.getOutput({
+                input,
+                config: getAuthConfig()
+              })
+            )
         );
-        return withRequestTraces(context, { output: outputRes.output });
+        return withRequestTraces(context, {
+          output: outputRes.output,
+          scopes: outputRes.scopes
+        });
       }
 
       return { output: input as any };
@@ -622,7 +635,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let authMethod = getAuthMethod(slate, params.authenticationMethodId);
 
       if (authMethod.getProfile) {
-        let context = getEmptyContext();
+        let context = getAuthContext();
         let profileRes = await traceProviderCall(
           {
             component: 'auth',
@@ -653,7 +666,9 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
 
               return authMethod.getProfile!({
                 output: params.output as any,
-                input: params.input
+                input: params.input,
+                scopes: params.scopes,
+                config: getAuthConfig()
               })!;
             })
         );
@@ -675,7 +690,7 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
       let authMethod = getAuthMethod(slate, params.authenticationMethodId);
 
       if ('handleTokenRefresh' in authMethod && authMethod.handleTokenRefresh) {
-        let context = getEmptyContext();
+        let context = getAuthContext();
         let refreshRes = await traceProviderCall(
           {
             component: 'auth',
@@ -712,7 +727,8 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
                 input: params.input,
                 clientId: params.clientId,
                 clientSecret: params.clientSecret,
-                scopes: params.scopes
+                scopes: params.scopes,
+                config: getAuthConfig()
               });
             })
         );
@@ -896,7 +912,11 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
 
       let context = new SlateContext(
         ctx.config,
-        { request: req, state: params.state },
+        {
+          request: req,
+          state: params.state,
+          registrationDetails: params.registrationDetails ?? null
+        },
         ctx.auth?.output!,
         slate.spec,
         logger
@@ -919,15 +939,22 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
           },
           onSuccess: result => ({
             inputCount: result.inputs.length,
-            hasUpdatedState: result.updatedState !== undefined
+            hasUpdatedState: result.updatedState !== undefined,
+            hasResponse: result.response !== undefined
           })
         },
         () => runWithContext(context, () => action.handleRequest!(context))
       );
 
+      let response =
+        res.response === undefined
+          ? undefined
+          : await serializeWebhookHttpResponse(res.response);
+
       return withRequestTraces(context, {
         inputs: res.inputs,
-        updatedState: res.updatedState
+        updatedState: res.updatedState,
+        response
       });
     });
 

package/src/spec.ts

@@ -101,6 +101,7 @@ export let mapAction = <ConfigType extends {}, AuthType extends {}>(
     tags: a.tags,
     metadata: a.metadata,
     scopes: a.scopes,
+    authMethods: a.authMethods,
     docs: a.docs ?? [],
 
     inputSchema: toJsonSchema(a.inputSchema),
@@ -129,7 +130,8 @@ export let mapAction = <ConfigType extends {}, AuthType extends {}>(
         : {
             type: 'webhook',
             autoRegistration: !!a.autoRegisterWebhook,
-            autoUnregistration: !!a.autoUnregisterWebhook
+            autoUnregistration: !!a.autoUnregisterWebhook,
+            http: a.http
           }
   };
 };

package/src/webhook.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest';
+import {
+  SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES,
+  serializeWebhookHttpResponse
+} from './webhook';
+
+describe('serializeWebhookHttpResponse', () => {
+  it('serializes a Response with status, headers, and body', async () => {
+    await expect(
+      serializeWebhookHttpResponse(
+        new Response('created', {
+          status: 201,
+          headers: {
+            'content-type': 'text/plain',
+            'x-webhook-result': 'accepted'
+          }
+        })
+      )
+    ).resolves.toEqual({
+      status: 201,
+      headers: {
+        'content-type': 'text/plain',
+        'x-webhook-result': 'accepted'
+      },
+      body: {
+        encoding: 'base64',
+        content: Buffer.from('created').toString('base64')
+      }
+    });
+  });
+
+  it('applies defaults to a plain response init', async () => {
+    await expect(serializeWebhookHttpResponse({ body: 'ok' })).resolves.toEqual({
+      status: 200,
+      headers: {},
+      body: {
+        encoding: 'base64',
+        content: Buffer.from('ok').toString('base64')
+      }
+    });
+  });
+
+  it('serializes binary response bodies without changing their bytes', async () => {
+    await expect(
+      serializeWebhookHttpResponse({
+        status: 202,
+        body: new Uint8Array([0, 127, 128, 255])
+      })
+    ).resolves.toMatchObject({
+      status: 202,
+      body: {
+        encoding: 'base64',
+        content: Buffer.from([0, 127, 128, 255]).toString('base64')
+      }
+    });
+  });
+
+  it('rejects bodies larger than one MiB', async () => {
+    await expect(
+      serializeWebhookHttpResponse({
+        body: new Uint8Array(SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES + 1)
+      })
+    ).rejects.toThrow('Webhook response body exceeds');
+  });
+});

package/src/webhook.ts

@@ -0,0 +1,69 @@
+import { badRequestError, ServiceError } from '@lowerdeck/error';
+import type { SlatesWebhookHttpResponse } from '@slates/proto';
+import type { SlateWebhookHttpResponseInit } from '@slates/provider';
+
+export let SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES = 1024 * 1024;
+
+let serializeBody = (body: Uint8Array | null): SlatesWebhookHttpResponse['body'] => {
+  if (body === null) return null;
+
+  if (body.byteLength > SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES) {
+    throw new ServiceError(
+      badRequestError({
+        message: `Webhook response body exceeds the ${SLATE_WEBHOOK_RESPONSE_MAX_BODY_BYTES}-byte limit`
+      })
+    );
+  }
+
+  return {
+    encoding: 'base64',
+    content: Buffer.from(body).toString('base64')
+  };
+};
+
+let headersToObject = (headers: Headers) => {
+  let result: Record<string, string> = {};
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+};
+
+let validateStatus = (status: number) => {
+  if (!Number.isInteger(status) || status < 100 || status > 599) {
+    throw new ServiceError(
+      badRequestError({
+        message: 'Webhook response status must be an integer between 100 and 599'
+      })
+    );
+  }
+};
+
+export let serializeWebhookHttpResponse = async (
+  response: Response | SlateWebhookHttpResponseInit
+): Promise<SlatesWebhookHttpResponse> => {
+  if (response instanceof Response) {
+    validateStatus(response.status);
+    return {
+      status: response.status,
+      headers: headersToObject(response.headers),
+      body: serializeBody(
+        response.body === null ? null : new Uint8Array(await response.arrayBuffer())
+      )
+    };
+  }
+
+  let status = response.status ?? 200;
+  validateStatus(status);
+
+  let body =
+    typeof response.body === 'string'
+      ? new TextEncoder().encode(response.body)
+      : (response.body ?? null);
+
+  return {
+    status,
+    headers: response.headers ?? {},
+    body: serializeBody(body)
+  };
+};