@slates/provider 1.0.0-rc.16 → 1.0.0-rc.18

package/dist/index.module.js

@@ -54,6 +54,130 @@ var SlateAction = class {
   get docs() {
     return this._params.docs;
   }
+  get adapter() {
+    return this._params.adapter ?? null;
+  }
+  get isPublic() {
+    return this._params.isPublic === true;
+  }
+};
+
+// src/error/api.ts
+import { badRequestError, ServiceError } from "@lowerdeck/error";
+var DEFAULT_DETAIL_KEYS = ["message", "detail", "error", "error_description", "code"];
+var DEFAULT_NESTED_KEYS = ["errors"];
+var isApiErrorRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var pushDetail = (details, value, options = {}) => {
+  if (typeof value !== "string" && (options.includeNumbers === false || typeof value !== "number")) {
+    return;
+  }
+  let detail = String(value).trim();
+  if (detail && !details.includes(detail)) {
+    details.push(detail);
+  }
+};
+var collectApiErrorDetails = (value, details, options = {}) => {
+  if (Array.isArray(value)) {
+    for (let item of value) {
+      collectApiErrorDetails(item, details, options);
+    }
+    return;
+  }
+  if (!isApiErrorRecord(value)) {
+    pushDetail(details, value, options);
+    return;
+  }
+  for (let key of options.detailKeys ?? DEFAULT_DETAIL_KEYS) {
+    pushDetail(details, value[key], options);
+  }
+  for (let key of options.nestedKeys ?? DEFAULT_NESTED_KEYS) {
+    collectApiErrorDetails(value[key], details, options);
+  }
+};
+var getSlateErrorResponse = (error) => {
+  if (error.name !== "SlateError" || !isApiErrorRecord(error.data)) {
+    return void 0;
+  }
+  let data = error.data;
+  let upstream = isApiErrorRecord(data.upstream) ? data.upstream : void 0;
+  let status = upstream?.status ?? data.status;
+  return typeof status === "number" || typeof status === "string" ? { status } : void 0;
+};
+var getApiErrorResponse = (error) => {
+  if (!isApiErrorRecord(error)) {
+    return void 0;
+  }
+  if (!isApiErrorRecord(error.response)) {
+    return getSlateErrorResponse(error);
+  }
+  let response = error.response;
+  return {
+    status: typeof response.status === "number" || typeof response.status === "string" ? response.status : void 0,
+    statusText: typeof response.statusText === "string" ? response.statusText : void 0,
+    data: response.data
+  };
+};
+var getApiErrorStatus = (error) => getApiErrorResponse(error)?.status;
+var statusLabelForApiError = (status, statusText) => status !== void 0 ? `HTTP ${status}${statusText ? ` ${statusText}` : ""}: ` : "";
+var extractApiErrorMessage = (error, options = {}) => {
+  let details = [];
+  let response = options.response ?? getApiErrorResponse(error);
+  collectApiErrorDetails(response?.data, details, options);
+  if (details.length > 0) {
+    return details.join(options.separator ?? " - ");
+  }
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return options.fallbackMessage ?? "Unknown error";
+};
+var createApiServiceError = (message, options = {}) => {
+  let error = new ServiceError(badRequestError({ message }));
+  if (options.reason !== void 0) {
+    error.data.reason = options.reason;
+  }
+  if ("upstreamStatus" in options) {
+    error.data.upstreamStatus = options.upstreamStatus;
+  }
+  if ("upstreamCode" in options) {
+    error.data.upstreamCode = options.upstreamCode;
+  }
+  if (options.parent instanceof Error) {
+    error.setParent(options.parent);
+  }
+  return error;
+};
+var helpers = {
+  collectDetails: collectApiErrorDetails,
+  extractMessage: extractApiErrorMessage,
+  getResponse: getApiErrorResponse,
+  getStatus: getApiErrorStatus,
+  isRecord: isApiErrorRecord,
+  statusLabelFor: statusLabelForApiError
+};
+var buildApiServiceError = (error, options) => {
+  if (error instanceof ServiceError) {
+    return error;
+  }
+  let operation = options.operation ?? "request";
+  let response = options.extractResponse?.(error, helpers) ?? getApiErrorResponse(error);
+  let status = options.extractStatus?.(error, response, helpers) ?? response?.status;
+  let message = options.extractMessage?.(error, helpers) ?? extractApiErrorMessage(error, { ...options, response });
+  let statusLabel = statusLabelForApiError(status, response?.statusText);
+  let fullMessage = options.formatMessage?.({
+    providerLabel: options.providerLabel,
+    operation,
+    statusLabel,
+    message,
+    response,
+    status
+  }) ?? `${options.providerLabel} API ${operation} failed: ${statusLabel}${message}`;
+  return createApiServiceError(fullMessage, {
+    reason: options.reason,
+    upstreamStatus: status,
+    upstreamCode: options.extractUpstreamCode?.(error, response, helpers),
+    parent: options.parent ?? error
+  });
 };
 
 // src/error/axios.ts
@@ -680,11 +804,12 @@ var isScopes = (value) => typeof value === "object" && value !== null && "AND" i
 
 // src/action/builder.ts
 var SlateActionBuilder = class {
-  constructor(type, spec2, params, factory) {
+  constructor(type, spec2, params, factory, isPublicTool = false) {
     this.type = type;
     this.spec = spec2;
     this.params = params;
     this.factory = factory;
+    this.isPublicTool = isPublicTool;
     this.#configSchema = spec2.configSchema;
     this.#authSchema = spec2.authSchema;
   }
@@ -692,6 +817,7 @@ var SlateActionBuilder = class {
   spec;
   params;
   factory;
+  isPublicTool;
   #configSchema;
   #authSchema;
   #inputSchema = null;
@@ -700,20 +826,34 @@ var SlateActionBuilder = class {
   #authMethods;
   #toolParams = null;
   #triggerParams = null;
+  #interfaceLocked = false;
   input(schema) {
+    if (this.#interfaceLocked) {
+      throw new SlateDeclarationError("Adapter contract input schema cannot be changed");
+    }
     this.#inputSchema = schema;
     return this;
   }
   output(schema) {
+    if (this.#interfaceLocked) {
+      throw new SlateDeclarationError("Adapter contract output schema cannot be changed");
+    }
     this.#outputSchema = schema;
     return this;
   }
+  lockInterface() {
+    this.#interfaceLocked = true;
+    return this;
+  }
   scopes(scopes) {
     validateScopes(scopes);
     this.#scopes = scopes;
     return this;
   }
   authMethods(authMethods) {
+    if (this.isPublicTool) {
+      throw new SlateDeclarationError("Public tools cannot require authentication methods");
+    }
     this.#authMethods = this.validateAuthMethods(authMethods);
     return this;
   }
@@ -745,7 +885,8 @@ var SlateActionBuilder = class {
       handleEvent: props.handleEvent,
       handleRequest: props.handleRequest,
       autoRegisterWebhook: props.autoRegisterWebhook,
-      autoUnregisterWebhook: props.autoUnregisterWebhook
+      autoUnregisterWebhook: props.autoUnregisterWebhook,
+      http: props.http
     };
     return this;
   }
@@ -768,6 +909,9 @@ var SlateActionBuilder = class {
       validateScopes(scopes);
     }
     let authMethods = this.validateAuthMethods(this.#authMethods ?? this.params.authMethods);
+    if (this.isPublicTool && authMethods) {
+      throw new SlateDeclarationError("Public tools cannot require authentication methods");
+    }
     if (!this.#inputSchema) {
       throw new SlateDeclarationError("Input schema is not defined");
     }
@@ -784,6 +928,7 @@ var SlateActionBuilder = class {
       ...this.params,
       scopes,
       authMethods,
+      isPublic: this.isPublicTool === true,
       configSchema: this.#configSchema,
       authSchema: this.#authSchema,
       inputSchema: this.#inputSchema,
@@ -803,16 +948,40 @@ var SlateTool = class _SlateTool extends SlateAction {
   }
   static create(spec2, params) {
     return new SlateActionBuilder("tool", spec2, params, (params2) => {
-      if (params2.type !== "tool") throw new Error("Invalid action type for tool");
-      return new _SlateTool(spec2, params2.inputSchema, params2.outputSchema, params2);
+      return _SlateTool.fromCreateParameters(spec2, params2);
     });
   }
+  static fromCreateParameters(spec2, params) {
+    if (params.type !== "tool") throw new Error("Invalid action type for tool");
+    return new _SlateTool(spec2, params.inputSchema, params.outputSchema, params);
+  }
   get handleInvocation() {
     return this.#handleInvocation;
   }
 };
 var tool = (spec2, params) => SlateTool.create(spec2, params);
 
+// src/action/publicTool.ts
+var SlatePublicTool = class {
+  constructor() {
+  }
+  static create(spec2, params) {
+    return new SlateActionBuilder(
+      "tool",
+      spec2,
+      params,
+      (params2) => {
+        return SlateTool.fromCreateParameters(spec2, {
+          ...params2,
+          isPublic: true
+        });
+      },
+      true
+    );
+  }
+};
+var publicTool = (spec2, params) => SlatePublicTool.create(spec2, params);
+
 // src/action/trigger.ts
 var SlateDefaultPollingIntervalSeconds = 60 * 10;
 var SlateTrigger = class _SlateTrigger extends SlateAction {
@@ -820,6 +989,7 @@ var SlateTrigger = class _SlateTrigger extends SlateAction {
   #polling;
   #handleEvent;
   #handleRequest;
+  #http;
   #pollEvents;
   #autoRegisterWebhook;
   #autoUnregisterWebhook;
@@ -831,6 +1001,7 @@ var SlateTrigger = class _SlateTrigger extends SlateAction {
     };
     this.#handleEvent = params.handleEvent;
     this.#handleRequest = params.handleRequest;
+    this.#http = params.http;
     this.#pollEvents = params.pollEvents;
     this.#autoRegisterWebhook = params.autoRegisterWebhook;
     this.#autoUnregisterWebhook = params.autoUnregisterWebhook;
@@ -853,6 +1024,9 @@ var SlateTrigger = class _SlateTrigger extends SlateAction {
   get handleRequest() {
     return this.#handleRequest;
   }
+  get http() {
+    return this.#http;
+  }
   get pollEvents() {
     return this.#pollEvents;
   }
@@ -890,6 +1064,135 @@ var createTextAttachment = (content, mimeType) => ({
   }
 });
 
+// src/adapter/adapter.ts
+var SlateAdapter = class {
+  constructor(_spec, _tools, _triggers) {
+    this._spec = _spec;
+    this._tools = _tools;
+    this._triggers = _triggers;
+  }
+  _spec;
+  _tools;
+  _triggers;
+  get spec() {
+    return this._spec;
+  }
+  get id() {
+    return this._spec.id;
+  }
+  get name() {
+    return this._spec.name;
+  }
+  get capabilities() {
+    return this._spec.capabilities;
+  }
+  get tools() {
+    return this._tools;
+  }
+  get triggers() {
+    return this._triggers;
+  }
+  get actions() {
+    return [...this._triggers, ...this._tools];
+  }
+};
+
+// src/adapter/spec.ts
+var SlateAdapterSpec = class _SlateAdapterSpec {
+  constructor(_params) {
+    this._params = _params;
+  }
+  _params;
+  static create(params) {
+    let id = params.id?.trim();
+    let name = params.name?.trim();
+    if (!id) {
+      throw new SlateDeclarationError("Adapter id must be a non-empty string");
+    }
+    if (!name) {
+      throw new SlateDeclarationError("Adapter name must be a non-empty string");
+    }
+    return new _SlateAdapterSpec({
+      id,
+      name,
+      capabilities: validateCapabilities(params.capabilities ?? [])
+    });
+  }
+  get id() {
+    return this._params.id;
+  }
+  get name() {
+    return this._params.name;
+  }
+  get capabilities() {
+    return this._params.capabilities;
+  }
+  get parameters() {
+    return this._params;
+  }
+  tool(spec2, params) {
+    return SlateTool.create(spec2, this.linkAction(params));
+  }
+  publicTool(spec2, params) {
+    return SlatePublicTool.create(spec2, this.linkAction(params));
+  }
+  trigger(spec2, params) {
+    return SlateTrigger.create(spec2, this.linkAction(params));
+  }
+  register(params) {
+    let actions = [...params.tools, ...params.triggers];
+    let seenKeys = /* @__PURE__ */ new Set();
+    for (let action of actions) {
+      if (action.adapter && action.adapter !== this.id) {
+        throw new SlateDeclarationError(
+          `Action "${action.key}" is linked to adapter "${action.adapter}", not "${this.id}"`
+        );
+      }
+      if (!action.adapter) {
+        throw new SlateDeclarationError(
+          `Action "${action.key}" must be created with this adapter's tool(), publicTool(), or trigger() helpers`
+        );
+      }
+      if (seenKeys.has(action.key)) {
+        throw new SlateDeclarationError(
+          `Adapter "${this.id}" already has an action with key "${action.key}"`
+        );
+      }
+      seenKeys.add(action.key);
+    }
+    return new SlateAdapter(this, params.tools, params.triggers);
+  }
+  linkAction(params) {
+    if (params.adapter != null && params.adapter !== this.id) {
+      throw new SlateDeclarationError(
+        `Action "${params.key}" cannot be linked to adapter "${this.id}" because it is already linked to "${params.adapter}"`
+      );
+    }
+    return {
+      ...params,
+      adapter: this.id
+    };
+  }
+};
+var adapterSpec = (params) => SlateAdapterSpec.create(params);
+var validateCapabilities = (capabilities) => {
+  let seenIds = /* @__PURE__ */ new Set();
+  return capabilities.map((capability) => {
+    let id = capability.id?.trim();
+    if (!id) {
+      throw new SlateDeclarationError("Adapter capability ids must be non-empty strings");
+    }
+    if (seenIds.has(id)) {
+      throw new SlateDeclarationError(`Adapter capability "${id}" is defined more than once`);
+    }
+    seenIds.add(id);
+    return {
+      id,
+      value: capability.value
+    };
+  });
+};
+
 // src/auth/auth.ts
 var SlateAuth = class _SlateAuth {
   #outputSchema = null;
@@ -947,6 +1250,90 @@ var SlateAuth = class _SlateAuth {
 };
 var auth = () => SlateAuth.create();
 
+// src/auth/oauth.ts
+var isOAuthTokenResponse = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var formatOAuthTokenResponseMessage = (fieldLabel, providerLabel = "OAuth provider", operation = "token response") => `${providerLabel} OAuth ${operation} did not return ${fieldLabel}.`;
+var getOAuthExpiresAtFromExpiresIn = (expiresIn, options = {}) => {
+  let {
+    nowMs = Date.now(),
+    providerLabel,
+    operation,
+    required = false,
+    expiresInType = "numberLike",
+    message
+  } = options;
+  if (expiresIn === void 0 || expiresIn === null || expiresIn === "") {
+    if (required) {
+      throw createApiServiceError(
+        message ?? formatOAuthTokenResponseMessage(
+          "a valid expires_in value",
+          providerLabel,
+          operation
+        ),
+        { reason: "oauth_token_response" }
+      );
+    }
+    return void 0;
+  }
+  let seconds = typeof expiresIn === "number" ? expiresIn : expiresInType === "numberLike" && typeof expiresIn === "string" ? Number(expiresIn) : Number.NaN;
+  if (!Number.isFinite(seconds)) {
+    throw createApiServiceError(
+      message ?? formatOAuthTokenResponseMessage("a valid expires_in value", providerLabel, operation),
+      { reason: "oauth_token_response" }
+    );
+  }
+  return new Date(nowMs + seconds * 1e3).toISOString();
+};
+var getRefreshToken = (refreshToken, previousRefreshToken, fallbackMode) => {
+  if (typeof refreshToken === "string") {
+    if (fallbackMode === "falsy" && !refreshToken) {
+      return previousRefreshToken;
+    }
+    return refreshToken;
+  }
+  if (fallbackMode === "falsy" && !refreshToken) {
+    return previousRefreshToken;
+  }
+  return refreshToken === void 0 || refreshToken === null ? previousRefreshToken : void 0;
+};
+var normalizeOAuthTokenResponse = (data, options = {}) => {
+  let {
+    providerLabel,
+    operation,
+    previousRefreshToken,
+    refreshTokenFallbackMode = "nullish",
+    accessTokenMessage,
+    expiresInMessage,
+    ...expiresAtOptions
+  } = options;
+  if (!isOAuthTokenResponse(data)) {
+    throw createApiServiceError(
+      accessTokenMessage ?? formatOAuthTokenResponseMessage("a token response object", providerLabel, operation),
+      { reason: "oauth_token_response" }
+    );
+  }
+  if (typeof data.access_token !== "string" || !data.access_token) {
+    throw createApiServiceError(
+      accessTokenMessage ?? formatOAuthTokenResponseMessage("an access token", providerLabel, operation),
+      { reason: "oauth_token_response" }
+    );
+  }
+  return {
+    token: data.access_token,
+    refreshToken: getRefreshToken(
+      data.refresh_token,
+      previousRefreshToken,
+      refreshTokenFallbackMode
+    ),
+    expiresAt: getOAuthExpiresAtFromExpiresIn(data.expires_in, {
+      ...expiresAtOptions,
+      providerLabel,
+      operation,
+      message: expiresInMessage
+    })
+  };
+};
+
 // src/axios/index.ts
 import baseAxios, { getAdapter, isAxiosError as isAxiosError2 } from "axios";
 
@@ -1530,6 +1917,35 @@ var createAxios = (config2) => {
   applySlateInterceptors(instance, errorMapping);
   return instance;
 };
+var createAuthenticatedAxios = (config2) => {
+  let { authHeader, contentType = "application/json", errorAdapter, ...axiosConfig } = config2;
+  let instance = createAxios({
+    ...axiosConfig,
+    headers: {
+      ...contentType === false ? {} : { "Content-Type": contentType },
+      ...authHeader ? { [authHeader.name ?? "Authorization"]: authHeader.value } : {},
+      ...axiosConfig.headers
+    }
+  });
+  if (errorAdapter) {
+    instance.interceptors.response.use(
+      (response) => response,
+      (error) => Promise.reject(errorAdapter(error))
+    );
+  }
+  return instance;
+};
+var requestAxios = async (operation, request, errorAdapter) => {
+  try {
+    return await request();
+  } catch (error) {
+    throw errorAdapter(error, operation);
+  }
+};
+var requestAxiosData = async (operation, request, errorAdapter) => {
+  let response = await requestAxios(operation, request, errorAdapter);
+  return response.data;
+};
 var axios = createAxios();
 
 // src/config/config.ts
@@ -1576,26 +1992,19 @@ var SlateConfig = class _SlateConfig {
 var config = (schema) => SlateConfig.create(schema);
 
 // src/context/context.ts
-var SlateContext = class {
-  constructor(config2, input, auth2, spec2, logger) {
+var SlatePublicContext = class {
+  constructor(input, spec2, logger) {
     this.spec = spec2;
     this.logger = logger;
-    this.#config = config2;
     this.#input = input;
-    this.#auth = auth2;
   }
   spec;
   logger;
-  #config;
   #input;
-  #auth;
   #httpTraces = [];
   get specification() {
     return this.spec;
   }
-  get config() {
-    return Object.freeze(this.#config);
-  }
   get input() {
     return Object.freeze(this.#input);
   }
@@ -1608,8 +2017,10 @@ var SlateContext = class {
   get request() {
     return Object.freeze(this.#input.request);
   }
-  get auth() {
-    return Object.freeze(this.#auth);
+  get registrationDetails() {
+    return Object.freeze(
+      this.#input.registrationDetails
+    );
   }
   recordHttpTrace(trace) {
     this.#httpTraces.push(trace);
@@ -1645,6 +2056,60 @@ var SlateContext = class {
     this.logger.progress(message);
   }
 };
+var SlateContext = class extends SlatePublicContext {
+  #config;
+  #auth;
+  constructor(config2, input, auth2, spec2, logger) {
+    super(input, spec2, logger);
+    this.#config = config2;
+    this.#auth = auth2;
+  }
+  get config() {
+    return Object.freeze(this.#config);
+  }
+  get auth() {
+    return Object.freeze(this.#auth);
+  }
+};
+
+// src/crypto/hmac.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var createHmacSignature = ({
+  secret,
+  payload,
+  algorithm = "sha256",
+  digest,
+  prefix = ""
+}) => `${prefix}${createHmac(algorithm, secret).update(payload).digest(digest)}`;
+var verifyHmacSignature = (options) => {
+  let expected = createHmacSignature(options);
+  let expectedBytes = Buffer.from(expected);
+  let signatureBytes = Buffer.from(options.signature);
+  let lengthsMatch = signatureBytes.length === expectedBytes.length;
+  let comparableSignature = lengthsMatch ? signatureBytes : Buffer.alloc(expectedBytes.length);
+  return timingSafeEqual(comparableSignature, expectedBytes) && lengthsMatch;
+};
+
+// src/file/index.ts
+var getResponseHeaderValue = (headers, name) => {
+  if (!headers) return void 0;
+  if (typeof headers.get === "function") {
+    let value = headers.get(name);
+    return typeof value === "string" ? value : void 0;
+  }
+  if (typeof headers !== "object") return void 0;
+  let lowerName = name.toLowerCase();
+  for (let [headerName, value] of Object.entries(headers)) {
+    if (headerName.toLowerCase() !== lowerName) continue;
+    if (Array.isArray(value)) {
+      let first = value.find((item) => typeof item === "string");
+      return typeof first === "string" ? first : void 0;
+    }
+    return typeof value === "string" ? value : void 0;
+  }
+  return void 0;
+};
+var getBase64ByteLength = (contentBase64) => Buffer.from(contentBase64, "base64").byteLength;
 
 // src/logger/logger.ts
 import { encode } from "@toon-format/toon";
@@ -1741,16 +2206,53 @@ var SlateLogger = class {
   }
 };
 
+// src/object/index.ts
+var pickDefined = (value) => Object.fromEntries(
+  Object.entries(value).filter(([, child]) => child !== void 0)
+);
+var setIfDefined = (target, key, value) => {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+  return target;
+};
+
 // src/specification/slate.ts
 var Slate = class _Slate {
-  constructor(_spec, _actions) {
+  constructor(_spec, _actions, _adapters) {
     this._spec = _spec;
     this._actions = _actions;
+    this._adapters = _adapters;
   }
   _spec;
   _actions;
+  _adapters;
   static create(params) {
-    return new _Slate(params.spec, [...params.triggers, ...params.tools]);
+    let adapters = params.adapters ?? [];
+    let actions = [...params.triggers, ...params.tools];
+    let seenAdapterIds = /* @__PURE__ */ new Set();
+    let seenActionKeys = new Map(actions.map((action) => [action.key, action]));
+    for (let adapter of adapters) {
+      if (seenAdapterIds.has(adapter.id)) {
+        throw new SlateDeclarationError(
+          `Adapter "${adapter.id}" is registered more than once`
+        );
+      }
+      seenAdapterIds.add(adapter.id);
+      for (let action of adapter.actions) {
+        let existing = seenActionKeys.get(action.key);
+        if (existing && existing !== action) {
+          throw new SlateDeclarationError(
+            `Adapter "${adapter.id}" action "${action.key}" conflicts with another action`
+          );
+        }
+        if (!existing) {
+          actions.push(action);
+          seenActionKeys.set(action.key, action);
+        }
+      }
+    }
+    return new _Slate(params.spec, actions, adapters);
   }
   get spec() {
     return this._spec;
@@ -1758,6 +2260,9 @@ var Slate = class _Slate {
   get actions() {
     return this._actions;
   }
+  get adapters() {
+    return this._adapters;
+  }
 };
 
 // src/specification/specification.ts
@@ -1803,9 +2308,65 @@ var SlateSpecification = class _SlateSpecification {
   }
 };
 var spec = (params) => SlateSpecification.create(params);
+
+// src/webhook/graph.ts
+var graphWebhookHttp = {
+  methods: ["POST"],
+  sync: {
+    mode: "match",
+    match: [{ hasQueryParam: "validationToken" }]
+  }
+};
+var getGraphWebhookValidationResponse = (request) => {
+  let validationToken = new URL(request.url).searchParams.get("validationToken");
+  if (validationToken === null) return null;
+  return {
+    status: 200,
+    headers: { "content-type": "text/plain" },
+    body: validationToken
+  };
+};
+
+// src/webhook/meta.ts
+var metaWebhookHttp = {
+  methods: ["GET", "POST"],
+  sync: {
+    mode: "match",
+    match: [{ method: "GET", hasQueryParam: "hub.mode" }]
+  }
+};
+var getMetaWebhookVerificationResponse = (request, expectedVerifyToken) => {
+  if (request.method !== "GET") return null;
+  let url = new URL(request.url);
+  let mode = url.searchParams.get("hub.mode");
+  let verifyToken = url.searchParams.get("hub.verify_token");
+  let challenge = url.searchParams.get("hub.challenge");
+  if (mode !== "subscribe" || challenge === null) {
+    return {
+      status: 400,
+      headers: { "content-type": "text/plain" },
+      body: "invalid webhook verification request"
+    };
+  }
+  if (expectedVerifyToken !== void 0 && verifyToken !== expectedVerifyToken) {
+    return {
+      status: 403,
+      headers: { "content-type": "text/plain" },
+      body: "invalid verify token"
+    };
+  }
+  return {
+    status: 200,
+    headers: { "content-type": "text/plain" },
+    body: challenge
+  };
+};
 export {
   Slate,
   SlateAction,
+  SlateActionBuilder,
+  SlateAdapter,
+  SlateAdapterSpec,
   SlateAuth,
   SlateConfig,
   SlateContext,
@@ -1813,31 +2374,58 @@ export {
   SlateDefaultPollingIntervalSeconds,
   SlateError,
   SlateLogger,
+  SlatePublicContext,
+  SlatePublicTool,
   SlateSpecification,
   SlateTool,
   SlateTrigger,
+  adapterSpec,
   allOf,
   anyOf,
   auth,
   axios,
+  buildApiServiceError,
+  collectApiErrorDetails,
   config,
+  createApiServiceError,
+  createAuthenticatedAxios,
   createAxios,
   createBase64Attachment,
+  createHmacSignature,
   createSlateError,
   createTextAttachment,
   createUrlAttachment,
+  extractApiErrorMessage,
+  getApiErrorResponse,
+  getApiErrorStatus,
+  getBase64ByteLength,
   getCurrentContext,
+  getGraphWebhookValidationResponse,
+  getMetaWebhookVerificationResponse,
+  getOAuthExpiresAtFromExpiresIn,
+  getResponseHeaderValue,
   getServiceErrorData,
+  graphWebhookHttp,
   inferSlateErrorFromAxios,
+  isApiErrorRecord,
   isAxiosErrorLike,
   isServiceErrorData,
   mapServiceErrorCode,
   mapServiceErrorToSlateErrorInput,
   mergeScopes,
+  metaWebhookHttp,
+  normalizeOAuthTokenResponse,
+  pickDefined,
+  publicTool,
+  requestAxios,
+  requestAxiosData,
   runWithContext,
   scopeClause,
+  setIfDefined,
   spec,
+  statusLabelForApiError,
   tool,
   trigger,
-  validateScopes
+  validateScopes,
+  verifyHmacSignature
 };