@slates/provider 1.0.0-rc.32 → 1.0.0-rc.34

package/dist/index.d.ts

@@ -459,6 +459,13 @@ declare class SlateSpecification<ConfigType extends {}, AuthType extends {}> {
 }
 declare let spec: <ConfigType extends {}, AuthType extends {}>(params: SlateSpecificationCreateParameters<ConfigType, AuthType>) => SlateSpecification<ConfigType, AuthType>;
 
+interface SlateRuntimeInfo {
+    metorial?: {
+        apiUrl: string;
+        region?: string | null;
+        environment?: string | null;
+    };
+}
 type SlateAddAttachmentContent = Buffer | Uint8Array | ArrayBuffer | ReadableStream<Uint8Array> | NodeJS.ReadableStream | Response;
 type SlateAddAttachmentInput = {
     type: 'url';
@@ -479,7 +486,8 @@ declare class SlatePublicContext<InputType extends {}> {
     #private;
     private readonly spec;
     private readonly logger;
-    constructor(input: InputType, spec: SlateSpecification<any, any>, logger: SlateLogger, liveInvocation?: SlateLiveInvocationInfo | null);
+    constructor(input: InputType, spec: SlateSpecification<any, any>, logger: SlateLogger, liveInvocation?: SlateLiveInvocationInfo | null, runtimeInfo?: SlateRuntimeInfo | null);
+    get runtimeInfo(): Readonly<SlateRuntimeInfo> | null;
     get specification(): SlateSpecification<any, any>;
     get input(): Readonly<InputType>;
     get event(): Readonly<InputType>;
@@ -517,7 +525,7 @@ declare class SlatePublicContext<InputType extends {}> {
 }
 declare class SlateContext<ConfigType extends {}, AuthType extends {}, InputType extends {}> extends SlatePublicContext<InputType> {
     #private;
-    constructor(config: ConfigType, input: InputType, auth: AuthType, spec: SlateSpecification<ConfigType, AuthType>, logger: SlateLogger, liveInvocation?: SlateLiveInvocationInfo | null);
+    constructor(config: ConfigType, input: InputType, auth: AuthType, spec: SlateSpecification<ConfigType, AuthType>, logger: SlateLogger, liveInvocation?: SlateLiveInvocationInfo | null, runtimeInfo?: SlateRuntimeInfo | null);
     get config(): Readonly<ConfigType>;
     get auth(): Readonly<AuthType>;
     _getAuthConfigForRedaction(): Record<string, unknown> | undefined;
@@ -525,9 +533,11 @@ declare class SlateContext<ConfigType extends {}, AuthType extends {}, InputType
 
 declare let runWithContext: <InputType extends {}, RV>(context: SlatePublicContext<InputType>, fn: () => Promise<RV>) => Promise<RV>;
 declare let getCurrentContext: <ConfigType extends {}, AuthType extends {}, InputType extends {}>() => SlateContext<ConfigType, AuthType, InputType>;
+declare let getRuntimeInfo: () => Readonly<SlateRuntimeInfo> | null;
 
 declare let SlateDefaultPollingIntervalSeconds: number;
 type SlateTriggerRoutingMatcher = Record<string, any>;
+type SlateTriggerGroupSelection = Record<string, any>;
 type SlateWebhookTargetOwnership = 'single_user' | 'multi_user';
 interface SlateWebhookTarget {
     webhookTargetIdentifier: string;
@@ -540,6 +550,7 @@ interface SlateWebhookTarget {
 type SlateTriggerGroupRoutingMatchersHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {}>) => Promise<SlateTriggerRoutingMatcher[]>;
 type SlateTriggerGroupPollHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {
     state: any | null;
+    selection?: SlateTriggerGroupSelection;
 }>) => Promise<{
     events: {
         payload: any;
@@ -584,6 +595,7 @@ type SlateTriggerGroupGatewayReceiveHandler<ConfigType extends {}, AuthType exte
 }>;
 type SlateWebhookTargetListHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {
     pageToken: any | null;
+    selection?: SlateTriggerGroupSelection;
 }>) => Promise<{
     targets: SlateWebhookTarget[];
     nextPageToken: any | null;
@@ -593,9 +605,40 @@ type SlateWebhookRegisterHandler<ConfigType extends {}, AuthType extends {}> = (
     webhookTargetIdentifier: string;
     webhookTargetPayload: any;
     webhookUrl: string;
-}>) => Promise<{
+    operationId?: string;
+    selection?: SlateTriggerGroupSelection;
+    deliveryConfig?: unknown;
+}>) => Promise<SlateWebhookRegistrationResult>;
+interface SlateWebhookRegistrationResult {
+    webhookRegistrationIdentifier: string;
+    webhookRegistrationPayload: any;
+    expiresAt?: string | null;
+    renewAfter?: string | null;
+    /** Identities of this registration on a delivery channel shared with other registrations. */
+    routingKeys?: string[];
+}
+type SlateWebhookRenewHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {
     webhookRegistrationIdentifier: string;
     webhookRegistrationPayload: any;
+    webhookUrl: string;
+    webhookTargetIdentifier: string;
+    webhookTargetPayload: any;
+    operationId: string;
+    selection?: SlateTriggerGroupSelection;
+    deliveryConfig?: unknown;
+}>) => Promise<SlateWebhookRegistrationResult>;
+type SlateWebhookExpandHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {
+    payload: unknown | null;
+    state: any | null;
+    selection?: SlateTriggerGroupSelection;
+    deliveryId: string;
+    webhookRegistrationPayload: any;
+}>) => Promise<{
+    events: {
+        payload: any;
+        idempotencyKey?: string;
+    }[];
+    updatedState?: any;
 }>;
 type SlateWebhookUnregisterHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {
     webhookRegistrationIdentifier: string;
@@ -629,6 +672,23 @@ type SlateWebhookProcessHandler = (context: SlateContext<{}, {}, {
 interface SlateWebhookSkipped {
     reason: string;
 }
+/**
+ * Routing keys name the registrations a request addresses; an empty list acknowledges it
+ * without handing it to any. A rejection answers the sender with its status.
+ */
+type SlateWebhookDeliveryAuthentication = {
+    routingKeys: string[];
+    rejected?: undefined;
+} | {
+    rejected: {
+        status: number;
+    };
+    routingKeys?: undefined;
+};
+type SlateWebhookDeliveryAuthenticateHandler = (context: SlateContext<{}, {}, {
+    request: Request;
+    deliveryConfig: unknown;
+}>) => Promise<SlateWebhookDeliveryAuthentication>;
 interface SlateTriggerGroupPollingParameters<ConfigType extends {}, AuthType extends {}> {
     intervalSeconds: number;
     pollEvents: SlateTriggerGroupPollHandler<ConfigType, AuthType>;
@@ -640,6 +700,7 @@ interface SlateTriggerGroupGatewayParameters<ConfigType extends {}, AuthType ext
 interface SlateTriggerGroupWebhookAutoRegistrationParameters<ConfigType extends {}, AuthType extends {}> {
     webhookTargetList: SlateWebhookTargetListHandler<ConfigType, AuthType>;
     webhookRegister: SlateWebhookRegisterHandler<ConfigType, AuthType>;
+    webhookRenew?: SlateWebhookRenewHandler<ConfigType, AuthType>;
     webhookUnregister: SlateWebhookUnregisterHandler<ConfigType, AuthType>;
 }
 interface SlateTriggerGroupWebhookManualRegistrationParameters<UserConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>, FullConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>> {
@@ -648,10 +709,18 @@ interface SlateTriggerGroupWebhookManualRegistrationParameters<UserConfigSchema
     setup: SlateWebhookManualSetupHandler<FullConfigSchema>;
     finish?: SlateWebhookManualFinishHandler<UserConfigSchema, FullConfigSchema>;
 }
+/** A delivery setup a person completes once for an automatically registered group. */
+type SlateTriggerGroupWebhookDeliveryConfigParameters<UserConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>, FullConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>> = SlateTriggerGroupWebhookManualRegistrationParameters<UserConfigSchema, FullConfigSchema> & {
+    finish: SlateWebhookManualFinishHandler<UserConfigSchema, FullConfigSchema>;
+    authenticate: SlateWebhookDeliveryAuthenticateHandler;
+};
 interface SlateTriggerGroupWebhookParameters<ConfigType extends {}, AuthType extends {}> {
     autoRegistration?: SlateTriggerGroupWebhookAutoRegistrationParameters<ConfigType, AuthType>;
     manualRegistration?: SlateTriggerGroupWebhookManualRegistrationParameters<any, any>;
+    deliveryConfig?: SlateTriggerGroupWebhookDeliveryConfigParameters<any, any>;
     process: SlateWebhookProcessHandler;
+    expandWebhook?: SlateWebhookExpandHandler<ConfigType, AuthType>;
+    reconcileIntervalSeconds?: number;
 }
 interface SlateTriggerGroupCreateParameters<InputType extends {} = Record<string, unknown>> {
     key: string;
@@ -659,6 +728,7 @@ interface SlateTriggerGroupCreateParameters<InputType extends {} = Record<string
     description?: string;
     metadata?: Record<string, any>;
     eventSchema?: z$1.ZodType<InputType>;
+    selectionSchema?: z$1.ZodType<SlateTriggerGroupSelection>;
 }
 interface SlateTriggerGroupParameters<ConfigType extends {}, AuthType extends {}, InputType extends {} = Record<string, unknown>> extends SlateTriggerGroupCreateParameters<InputType> {
     source: 'polling' | 'webhook' | 'gateway';
@@ -679,6 +749,7 @@ declare class SlateTriggerGroup<ConfigType extends {}, AuthType extends {}, Inpu
     get metadata(): Record<string, any> | undefined;
     get eventSchema(): z$1.ZodType<InputType, unknown, z$1.core.$ZodTypeInternals<InputType, unknown>>;
     get source(): "polling" | "webhook" | "gateway";
+    get selectionSchema(): z$1.ZodType<SlateTriggerGroupSelection, unknown, z$1.core.$ZodTypeInternals<SlateTriggerGroupSelection, unknown>> | undefined;
     get polling(): SlateTriggerGroupPollingParameters<ConfigType, AuthType> | undefined;
     get webhook(): SlateTriggerGroupWebhookParameters<ConfigType, AuthType> | undefined;
     get gateway(): SlateTriggerGroupGatewayParameters<ConfigType, AuthType> | undefined;
@@ -697,7 +768,10 @@ declare class SlateTriggerGroupBuilder<ConfigType extends {}, AuthType extends {
     webhook<UserConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>, FullConfigSchema extends z$1.ZodType<any> = z$1.ZodType<any>>(props: {
         autoRegistration?: SlateTriggerGroupWebhookAutoRegistrationParameters<ConfigType, AuthType>;
         manualRegistration?: SlateTriggerGroupWebhookManualRegistrationParameters<UserConfigSchema, FullConfigSchema>;
+        deliveryConfig?: SlateTriggerGroupWebhookDeliveryConfigParameters<UserConfigSchema, FullConfigSchema>;
         process: SlateWebhookProcessHandler;
+        expandWebhook?: SlateWebhookExpandHandler<ConfigType, AuthType>;
+        reconcileIntervalSeconds?: number;
     }): SlateTriggerGroupBuilder<ConfigType, AuthType, InputType>;
     /** Receive events over a platform-managed persistent connection (e.g. a WebSocket gateway). */
     gateway(props: SlateTriggerGroupGatewayParameters<ConfigType, AuthType>): SlateTriggerGroupBuilder<ConfigType, AuthType, InputType>;
@@ -1000,6 +1074,8 @@ declare let isApiErrorRecord: (value: unknown) => value is Record<string, unknow
 declare let collectApiErrorDetails: (value: unknown, details: string[], options?: ApiErrorDetailOptions) => void;
 declare let getApiErrorResponse: (error: unknown) => ApiErrorResponse | undefined;
 declare let getApiErrorStatus: (error: unknown) => ApiErrorStatus | undefined;
+/** Upstream HTTP status of an HTTP client error or a ServiceError with `upstreamStatus`. */
+declare let getUpstreamErrorStatus: (error: unknown) => number | undefined;
 declare let getApiErrorResponseWithBody: (error: unknown) => ApiErrorResponse | undefined;
 declare let API_ERROR_MAX_DETAILS: number;
 declare let API_ERROR_MAX_MESSAGE_LENGTH: number;
@@ -1109,6 +1185,11 @@ declare class SlateDeclarationError extends SlateError {
     static is(error: unknown): error is SlateDeclarationError;
 }
 
+/** Parses a saved or received value, throwing a user-facing `ServiceError` on mismatch. */
+declare let parseWithServiceError: <T extends z$1.ZodType>(schema: T, value: unknown, message: string, options?: {
+    reason?: string;
+}) => z$1.output<T>;
+
 declare let mapServiceErrorCode: (code: string, status?: number) => string;
 declare let isServiceErrorData: (value: unknown) => value is SlateServiceErrorData;
 declare let getServiceErrorData: (error: unknown) => SlateServiceErrorData | null;
@@ -1143,14 +1224,38 @@ interface VerifyHmacSignatureOptions extends CreateHmacSignatureOptions {
     signature: string;
 }
 declare let createHmacSignature: ({ secret, payload, algorithm, digest, prefix }: CreateHmacSignatureOptions) => string;
+/** Constant-time secret comparison; an empty expected secret matches nothing. */
+declare let timingSafeStringEqual: (expected: string, received: string | null | undefined) => boolean;
 declare let verifyHmacSignature: (options: VerifyHmacSignatureOptions) => boolean;
 
+/** An event a poller already reported, saved so an overlapping read can skip it. */
+declare let seenEntrySchema: z$1.ZodObject<{
+    key: z$1.ZodString;
+    at: z$1.ZodNumber;
+}, z$1.core.$strip>;
+type SeenEntry = z$1.infer<typeof seenEntrySchema>;
+/** A short stable key for an idempotency key, so remembered events cost little state. */
+declare let seenEntryKey: (idempotencyKey: string) => string;
+/** Keeps entries at or after `cutoff` (or `retain`), newest first, at most `maxEntries`. */
+declare let pruneSeenEntries: (entries: Iterable<SeenEntry & {
+    retain?: boolean;
+}>, options: {
+    cutoff: number;
+    maxEntries: number;
+    onOverflow?: (dropped: number) => void;
+}) => SeenEntry[];
+
 declare let getResponseHeaderValue: (headers: unknown, name: string) => string | undefined;
 declare let getBase64ByteLength: (contentBase64: string) => number;
 
 declare let pickDefined: <T extends object>(value: T) => Partial<T> & Record<string, unknown>;
 declare let setIfDefined: (target: Record<string, unknown>, key: string, value: unknown) => Record<string, unknown>;
 
+/** Records a page token in `seen`; `false` means it repeated and following it would loop. */
+declare let rememberPageToken: (seen: Set<string>, token: string) => boolean;
+/** Throws `repeated()` when a listing returns a page token it already returned. */
+declare let assertNewPageToken: (seen: Set<string>, token: string | null | undefined, repeated: () => unknown) => void;
+
 declare class Slate<ConfigType extends {}, AuthType extends {}> {
     private readonly _spec;
     private readonly _actions;
@@ -1206,4 +1311,4 @@ declare let skipWebhook: (reason: string, response?: Response | SlateWebhookHttp
     response: Response | SlateWebhookHttpResponseInit;
 };
 
-export { API_ERROR_MAX_DETAILS, API_ERROR_MAX_MESSAGE_LENGTH, API_ERROR_TRUNCATED_PLACEHOLDER, AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX, type ApiErrorBuildHelpers, type ApiErrorDetailOptions, type ApiErrorResponse, type ApiErrorStatus, type ApiErrorTextOptions, type ApiServiceError, type AuthConfigSecretFilter, AuthConfigSecretRedactor, type BoundedApiErrorDetailOptions, type BuildApiServiceErrorOptions, type CreateHmacSignatureOptions, type DecodeApiErrorBodyOptions, GET_FILE_URL_TOOL_ID, type GetFileUrlHandler, type GetFileUrlToolInput, type GetFileUrlToolOutput, type NormalizeOAuthTokenResponseOptions, type OAuthExpiresAtOptions, type OAuthRefreshTokenFallbackMode, type OAuthTokenResponse, Slate, SlateAction, SlateActionBuilder, type SlateActionCreateParameters, type SlateActionDocsReference, type SlateActionParameters, type SlateActionParametersAny, type SlateActionParametersTool, type SlateActionParametersTrigger, type SlateActionScopeClause, type SlateActionScopeClauseInput, type SlateActionScopeValue, type SlateActionScopes, type SlateActionScopesInput, type SlateActionType, SlateAdapter, type SlateAdapterCapability, SlateAdapterSpec, type SlateAdapterSpecParameters, type SlateAddAttachmentContent, type SlateAddAttachmentInput, type SlateAttachment, type SlateAttachmentInlineContent, type SlateAttachmentUploadReferenceContent, type SlateAttachmentUrlContent, SlateAuth, type SlateAuthDocsReference, type SlateAuthType, type SlateAuthWithCustomData, type SlateAuthWithNone, type SlateAuthWithOauth, type SlateAuthWithServiceAccount, type SlateAuthWithToken, type SlateAuthenticatedAxiosDefaults, type SlateAxiosDefaults, type SlateAxiosErrorAdapter, type SlateAxiosErrorOptions, SlateConfig, type SlateConfigDocsReference, SlateContext, SlateDeclarationError, SlateDefaultPollingIntervalSeconds, type SlateDirectUploadInput, type SlateDocsReference, SlateError, type SlateErrorInput, type SlateErrorIssue, type SlateErrorKind, type SlateErrorProviderInfo, type SlateErrorResponse, type SlateErrorUpstreamInfo, type SlateGatewayEvent, type SlateLiveInvocationInfo, type SlateLogEntry, type SlateLogFields, type SlateLogListener, type SlateLogMessageInput, type SlateLogType, SlateLogger, type SlateProviderDocsReference, SlatePublicContext, SlatePublicTool, type SlatePublicToolInvocationHandler, type SlatePublicToolParameters, type SlateServiceErrorData, SlateSpecification, type SlateSpecificationCreateParameters, type SlateSpecificationParameters, SlateTool, SlateToolCategory, type SlateToolCategoryParameters, type SlateToolInvocationHandler, type SlateToolParameters, SlateTrigger, SlateTriggerGroup, SlateTriggerGroupBuilder, type SlateTriggerGroupCreateParameters, type SlateTriggerGroupGatewayConnectHandler, type SlateTriggerGroupGatewayParameters, type SlateTriggerGroupGatewayReceiveHandler, type SlateTriggerGroupParameters, type SlateTriggerGroupPollHandler, type SlateTriggerGroupPollingParameters, type SlateTriggerGroupRoutingMatchersHandler, type SlateTriggerGroupWebhookAutoRegistrationParameters, type SlateTriggerGroupWebhookManualRegistrationParameters, type SlateTriggerGroupWebhookParameters, type SlateTriggerMappingHandler, type SlateTriggerMatchesHandler, type SlateTriggerParameters, type SlateTriggerRoutingMatcher, type SlateTypedDocsReference, type SlateWebhookHttpResponseInit, type SlateWebhookManualFinishHandler, type SlateWebhookManualSetupHandler, type SlateWebhookProcessHandler, type SlateWebhookRegisterHandler, type SlateWebhookSkipped, type SlateWebhookTarget, type SlateWebhookTargetListHandler, type SlateWebhookTargetOwnership, type SlateWebhookUnregisterHandler, type VerifyHmacSignatureOptions, adapterSpec, allOf, anyOf, auth, axios, buildApiServiceError, collectApiErrorDetails, config, createApiServiceError, createAuthenticatedAxios, createAxios, createBase64Attachment, createHmacSignature, createSlateError, createTextAttachment, createUrlAttachment, decodeApiErrorBody, extractApiErrorMessage, getApiErrorResponse, getApiErrorResponseWithBody, getApiErrorStatus, getBase64ByteLength, getCurrentContext, getFileUrlTool, getFileUrlToolInputSchema, getFileUrlToolOutputSchema, getGraphWebhookValidationResponse, getMetaWebhookVerificationResponse, getOAuthExpiresAtFromExpiresIn, getResponseHeaderValue, getServiceErrorData, graphWebhookHttp, inferSlateErrorFromAxios, isApiErrorRecord, isAxiosErrorLike, isServiceErrorData, isUrlEmbeddedCredential, looksLikeHtmlErrorBody, mapServiceErrorCode, mapServiceErrorToSlateErrorInput, mergeScopes, metaWebhookHttp, normalizeOAuthTokenResponse, pickDefined, publicTool, pushBoundedApiErrorDetail, readApiErrorText, redactUrlAttachmentSecrets, requestAxios, requestAxiosData, runWithContext, scopeClause, setIfDefined, skipWebhook, spec, statusLabelForApiError, tool, toolCategory, trigger, triggerGroup, truncateApiErrorMessage, uploadAttachmentDirect, validateScopes, verifyHmacSignature };
+export { API_ERROR_MAX_DETAILS, API_ERROR_MAX_MESSAGE_LENGTH, API_ERROR_TRUNCATED_PLACEHOLDER, AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX, type ApiErrorBuildHelpers, type ApiErrorDetailOptions, type ApiErrorResponse, type ApiErrorStatus, type ApiErrorTextOptions, type ApiServiceError, type AuthConfigSecretFilter, AuthConfigSecretRedactor, type BoundedApiErrorDetailOptions, type BuildApiServiceErrorOptions, type CreateHmacSignatureOptions, type DecodeApiErrorBodyOptions, GET_FILE_URL_TOOL_ID, type GetFileUrlHandler, type GetFileUrlToolInput, type GetFileUrlToolOutput, type NormalizeOAuthTokenResponseOptions, type OAuthExpiresAtOptions, type OAuthRefreshTokenFallbackMode, type OAuthTokenResponse, type SeenEntry, Slate, SlateAction, SlateActionBuilder, type SlateActionCreateParameters, type SlateActionDocsReference, type SlateActionParameters, type SlateActionParametersAny, type SlateActionParametersTool, type SlateActionParametersTrigger, type SlateActionScopeClause, type SlateActionScopeClauseInput, type SlateActionScopeValue, type SlateActionScopes, type SlateActionScopesInput, type SlateActionType, SlateAdapter, type SlateAdapterCapability, SlateAdapterSpec, type SlateAdapterSpecParameters, type SlateAddAttachmentContent, type SlateAddAttachmentInput, type SlateAttachment, type SlateAttachmentInlineContent, type SlateAttachmentUploadReferenceContent, type SlateAttachmentUrlContent, SlateAuth, type SlateAuthDocsReference, type SlateAuthType, type SlateAuthWithCustomData, type SlateAuthWithNone, type SlateAuthWithOauth, type SlateAuthWithServiceAccount, type SlateAuthWithToken, type SlateAuthenticatedAxiosDefaults, type SlateAxiosDefaults, type SlateAxiosErrorAdapter, type SlateAxiosErrorOptions, SlateConfig, type SlateConfigDocsReference, SlateContext, SlateDeclarationError, SlateDefaultPollingIntervalSeconds, type SlateDirectUploadInput, type SlateDocsReference, SlateError, type SlateErrorInput, type SlateErrorIssue, type SlateErrorKind, type SlateErrorProviderInfo, type SlateErrorResponse, type SlateErrorUpstreamInfo, type SlateGatewayEvent, type SlateLiveInvocationInfo, type SlateLogEntry, type SlateLogFields, type SlateLogListener, type SlateLogMessageInput, type SlateLogType, SlateLogger, type SlateProviderDocsReference, SlatePublicContext, SlatePublicTool, type SlatePublicToolInvocationHandler, type SlatePublicToolParameters, type SlateRuntimeInfo, type SlateServiceErrorData, SlateSpecification, type SlateSpecificationCreateParameters, type SlateSpecificationParameters, SlateTool, SlateToolCategory, type SlateToolCategoryParameters, type SlateToolInvocationHandler, type SlateToolParameters, SlateTrigger, SlateTriggerGroup, SlateTriggerGroupBuilder, type SlateTriggerGroupCreateParameters, type SlateTriggerGroupGatewayConnectHandler, type SlateTriggerGroupGatewayParameters, type SlateTriggerGroupGatewayReceiveHandler, type SlateTriggerGroupParameters, type SlateTriggerGroupPollHandler, type SlateTriggerGroupPollingParameters, type SlateTriggerGroupRoutingMatchersHandler, type SlateTriggerGroupSelection, type SlateTriggerGroupWebhookAutoRegistrationParameters, type SlateTriggerGroupWebhookDeliveryConfigParameters, type SlateTriggerGroupWebhookManualRegistrationParameters, type SlateTriggerGroupWebhookParameters, type SlateTriggerMappingHandler, type SlateTriggerMatchesHandler, type SlateTriggerParameters, type SlateTriggerRoutingMatcher, type SlateTypedDocsReference, type SlateWebhookDeliveryAuthenticateHandler, type SlateWebhookDeliveryAuthentication, type SlateWebhookExpandHandler, type SlateWebhookHttpResponseInit, type SlateWebhookManualFinishHandler, type SlateWebhookManualSetupHandler, type SlateWebhookProcessHandler, type SlateWebhookRegisterHandler, type SlateWebhookRegistrationResult, type SlateWebhookRenewHandler, type SlateWebhookSkipped, type SlateWebhookTarget, type SlateWebhookTargetListHandler, type SlateWebhookTargetOwnership, type SlateWebhookUnregisterHandler, type VerifyHmacSignatureOptions, adapterSpec, allOf, anyOf, assertNewPageToken, auth, axios, buildApiServiceError, collectApiErrorDetails, config, createApiServiceError, createAuthenticatedAxios, createAxios, createBase64Attachment, createHmacSignature, createSlateError, createTextAttachment, createUrlAttachment, decodeApiErrorBody, extractApiErrorMessage, getApiErrorResponse, getApiErrorResponseWithBody, getApiErrorStatus, getBase64ByteLength, getCurrentContext, getFileUrlTool, getFileUrlToolInputSchema, getFileUrlToolOutputSchema, getGraphWebhookValidationResponse, getMetaWebhookVerificationResponse, getOAuthExpiresAtFromExpiresIn, getResponseHeaderValue, getRuntimeInfo, getServiceErrorData, getUpstreamErrorStatus, graphWebhookHttp, inferSlateErrorFromAxios, isApiErrorRecord, isAxiosErrorLike, isServiceErrorData, isUrlEmbeddedCredential, looksLikeHtmlErrorBody, mapServiceErrorCode, mapServiceErrorToSlateErrorInput, mergeScopes, metaWebhookHttp, normalizeOAuthTokenResponse, parseWithServiceError, pickDefined, pruneSeenEntries, publicTool, pushBoundedApiErrorDetail, readApiErrorText, redactUrlAttachmentSecrets, rememberPageToken, requestAxios, requestAxiosData, runWithContext, scopeClause, seenEntryKey, seenEntrySchema, setIfDefined, skipWebhook, spec, statusLabelForApiError, timingSafeStringEqual, tool, toolCategory, trigger, triggerGroup, truncateApiErrorMessage, uploadAttachmentDirect, validateScopes, verifyHmacSignature };

package/dist/index.module.js

@@ -899,6 +899,7 @@ var getCurrentContext = () => {
   }
   return context;
 };
+var getRuntimeInfo = () => asyncLocalStorage.getStore()?.runtimeInfo ?? null;
 
 // src/error/defaults.ts
 var DEFAULT_CODE = "internal.unexpected";
@@ -1265,6 +1266,11 @@ var getApiErrorResponse = (error) => {
   };
 };
 var getApiErrorStatus = (error) => getApiErrorResponse(error)?.status;
+var getUpstreamErrorStatus = (error) => {
+  let value = error instanceof ServiceError ? error.data.upstreamStatus : getApiErrorStatus(error);
+  let status = Number(value);
+  return Number.isInteger(status) && status >= 100 && status <= 599 ? status : void 0;
+};
 var getApiErrorResponseWithBody = (error) => {
   let response = getApiErrorResponse(error);
   if (response?.data !== void 0) return response;
@@ -1772,6 +1778,13 @@ var SlateDeclarationError = class _SlateDeclarationError extends SlateError {
   }
 };
 
+// src/error/parse.ts
+var parseWithServiceError = (schema, value, message, options = {}) => {
+  let result = schema.safeParse(value);
+  if (!result.success) throw createApiServiceError(message, options);
+  return result.data;
+};
+
 // src/action/scopes.ts
 var scopeClause = (...scopes) => {
   assertScopeValues(scopes);
@@ -2149,6 +2162,9 @@ var SlateTriggerGroup = class _SlateTriggerGroup {
   get source() {
     return this._params.source;
   }
+  get selectionSchema() {
+    return this._params.selectionSchema;
+  }
   get polling() {
     return this._params.polling;
   }
@@ -2196,11 +2212,41 @@ var SlateTriggerGroupBuilder = class {
         "Webhook trigger groups require exactly one of autoRegistration or manualRegistration"
       );
     }
+    if (props.deliveryConfig !== void 0) {
+      if (!props.autoRegistration) {
+        throw new SlateDeclarationError(
+          "A webhook delivery config requires automatic webhook registration"
+        );
+      }
+      if (!props.deliveryConfig.finish) {
+        throw new SlateDeclarationError("A webhook delivery config requires a finish handler");
+      }
+      if (!props.deliveryConfig.authenticate) {
+        throw new SlateDeclarationError(
+          "A webhook delivery config requires an authenticate handler"
+        );
+      }
+    }
+    if (props.reconcileIntervalSeconds !== void 0) {
+      if (!Number.isSafeInteger(props.reconcileIntervalSeconds) || props.reconcileIntervalSeconds < 900) {
+        throw new SlateDeclarationError(
+          "Webhook reconciliation interval must be an integer of at least 900 seconds"
+        );
+      }
+      if (!props.expandWebhook) {
+        throw new SlateDeclarationError(
+          "Webhook reconciliation requires an expandWebhook handler"
+        );
+      }
+    }
     this.#source = "webhook";
     this.#webhook = {
       autoRegistration: props.autoRegistration,
       manualRegistration: props.manualRegistration,
-      process: props.process
+      deliveryConfig: props.deliveryConfig,
+      process: props.process,
+      expandWebhook: props.expandWebhook,
+      reconcileIntervalSeconds: props.reconcileIntervalSeconds
     };
     return this;
   }
@@ -2769,6 +2815,10 @@ var resolveDefaultExport = (value) => {
 var PQueue = resolveDefaultExport(PQueueImport);
 
 // src/context/context.ts
+var freezeRuntimeInfo = (runtimeInfo) => Object.freeze({
+  ...runtimeInfo,
+  ...runtimeInfo.metorial ? { metorial: Object.freeze({ ...runtimeInfo.metorial }) } : {}
+});
 var isBufferLike = (value) => value instanceof Uint8Array || value instanceof ArrayBuffer;
 var toUint8Array = (value) => value instanceof ArrayBuffer ? new Uint8Array(value) : value;
 var isReadableStream = (value) => typeof ReadableStream !== "undefined" && value instanceof ReadableStream;
@@ -2785,17 +2835,19 @@ var readStreamToBuffer = async (stream) => {
   return Buffer.concat(chunks);
 };
 var SlatePublicContext = class {
-  constructor(input, spec2, logger, liveInvocation = null) {
+  constructor(input, spec2, logger, liveInvocation = null, runtimeInfo = null) {
     this.spec = spec2;
     this.logger = logger;
     this.#input = input;
     this.#liveInvocation = liveInvocation;
+    this.#runtimeInfo = runtimeInfo && freezeRuntimeInfo(runtimeInfo);
   }
   spec;
   logger;
   #input;
   #httpTraces = [];
   #liveInvocation;
+  #runtimeInfo;
   #attachmentsDisabled = false;
   #attachments = [];
   #pendingUploads = [];
@@ -2806,6 +2858,9 @@ var SlatePublicContext = class {
     }
     return this.#uploadQueue;
   }
+  get runtimeInfo() {
+    return this.#runtimeInfo;
+  }
   get specification() {
     return this.spec;
   }
@@ -2946,8 +3001,8 @@ var SlatePublicContext = class {
 var SlateContext = class extends SlatePublicContext {
   #config;
   #auth;
-  constructor(config2, input, auth2, spec2, logger, liveInvocation = null) {
-    super(input, spec2, logger, liveInvocation);
+  constructor(config2, input, auth2, spec2, logger, liveInvocation = null, runtimeInfo = null) {
+    super(input, spec2, logger, liveInvocation, runtimeInfo);
     this.#config = config2;
     this.#auth = auth2;
   }
@@ -2971,13 +3026,29 @@ var createHmacSignature = ({
   digest,
   prefix = ""
 }) => `${prefix}${createHmac(algorithm, secret).update(payload).digest(digest)}`;
-var verifyHmacSignature = (options) => {
-  let expected = createHmacSignature(options);
+var timingSafeStringEqual = (expected, received) => {
   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;
+  let receivedBytes = Buffer.from(received ?? "");
+  let lengthsMatch = receivedBytes.length === expectedBytes.length;
+  let comparable = lengthsMatch ? receivedBytes : Buffer.alloc(expectedBytes.length);
+  return timingSafeEqual(comparable, expectedBytes) && lengthsMatch && expectedBytes.length > 0;
+};
+var verifyHmacSignature = (options) => timingSafeStringEqual(createHmacSignature(options), options.signature);
+
+// src/dedup/index.ts
+import { createHash } from "crypto";
+import { z as z3 } from "zod";
+var seenEntrySchema = z3.object({ key: z3.string().min(1), at: z3.number().finite() });
+var seenEntryKey = (idempotencyKey) => createHash("sha256").update(idempotencyKey).digest("base64url").slice(0, 16);
+var pruneSeenEntries = (entries, options) => {
+  let kept = [];
+  for (let { key, at, retain } of entries) {
+    if (retain || at >= options.cutoff) kept.push({ key, at });
+  }
+  kept.sort((a, b) => b.at - a.at || (a.key < b.key ? -1 : 1));
+  if (kept.length <= options.maxEntries) return kept;
+  options.onOverflow?.(kept.length - options.maxEntries);
+  return kept.slice(0, options.maxEntries);
 };
 
 // src/file/index.ts
@@ -3107,6 +3178,16 @@ var setIfDefined = (target, key, value) => {
   return target;
 };
 
+// src/pagination/index.ts
+var rememberPageToken = (seen, token) => {
+  if (seen.has(token)) return false;
+  seen.add(token);
+  return true;
+};
+var assertNewPageToken = (seen, token, repeated) => {
+  if (token && !rememberPageToken(seen, token)) throw repeated();
+};
+
 // src/specification/slate.ts
 var Slate = class _Slate {
   constructor(_spec, _actions, _adapters, _triggerGroups, _toolCategories, _toolCategoryKeysByActionKey) {
@@ -3158,12 +3239,12 @@ var Slate = class _Slate {
       }
       seenTriggerGroupKeys.add(group.key);
     }
-    let manualWebhookTriggerGroups = triggerGroups.filter(
-      (group) => group.source === "webhook" && group.webhook?.manualRegistration
+    let configuredWebhookTriggerGroups = triggerGroups.filter(
+      (group) => group.source === "webhook" && (group.webhook?.manualRegistration || group.webhook?.deliveryConfig)
     );
-    if (manualWebhookTriggerGroups.length > 1) {
+    if (configuredWebhookTriggerGroups.length > 1) {
       throw new SlateDeclarationError(
-        `Only one trigger group may use manual webhook registration, but found: ${manualWebhookTriggerGroups.map((group) => group.key).join(", ")}`
+        `Only one trigger group may use manual webhook registration or a delivery config, but found: ${configuredWebhookTriggerGroups.map((group) => group.key).join(", ")}`
       );
     }
     let toolCategories = params.toolCategories ?? [];
@@ -3265,7 +3346,7 @@ var resolveToolCategoryMembership = (toolCategories, actions) => {
 };
 
 // src/specification/specification.ts
-import z3 from "zod";
+import z4 from "zod";
 var SlateSpecification = class _SlateSpecification {
   constructor(_config, _auth, _params) {
     this._config = _config;
@@ -3282,7 +3363,7 @@ var SlateSpecification = class _SlateSpecification {
     return this._config.configSchema;
   }
   get authSchema() {
-    return "outputSchema" in this._auth ? this._auth.outputSchema : z3.object({});
+    return "outputSchema" in this._auth ? this._auth.outputSchema : z4.object({});
   }
   get config() {
     return this._config;
@@ -3397,6 +3478,7 @@ export {
   adapterSpec,
   allOf,
   anyOf,
+  assertNewPageToken,
   auth,
   axios,
   buildApiServiceError,
@@ -3424,7 +3506,9 @@ export {
   getMetaWebhookVerificationResponse,
   getOAuthExpiresAtFromExpiresIn,
   getResponseHeaderValue,
+  getRuntimeInfo,
   getServiceErrorData,
+  getUpstreamErrorStatus,
   graphWebhookHttp,
   inferSlateErrorFromAxios,
   isApiErrorRecord,
@@ -3437,19 +3521,25 @@ export {
   mergeScopes,
   metaWebhookHttp,
   normalizeOAuthTokenResponse,
+  parseWithServiceError,
   pickDefined,
+  pruneSeenEntries,
   publicTool,
   pushBoundedApiErrorDetail,
   readApiErrorText,
   redactUrlAttachmentSecrets,
+  rememberPageToken,
   requestAxios,
   requestAxiosData,
   runWithContext,
   scopeClause,
+  seenEntryKey,
+  seenEntrySchema,
   setIfDefined,
   skipWebhook,
   spec,
   statusLabelForApiError,
+  timingSafeStringEqual,
   tool,
   toolCategory,
   trigger,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider",
-  "version": "1.0.0-rc.32",
+  "version": "1.0.0-rc.34",
   "publishConfig": {
     "access": "public"
   },

package/src/action/triggerGroup.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import { SlateAuth } from '../auth';
+import { SlateConfig } from '../config';
+import { SlateSpecification } from '../specification/specification';
+import { triggerGroup } from './triggerGroup';
+
+let spec = SlateSpecification.create({
+  key: 'demo',
+  name: 'Demo',
+  config: SlateConfig.create(z.object({})),
+  auth: SlateAuth.create<{}>().output(z.object({}))
+});
+
+let autoRegistration = {
+  webhookTargetList: async () => ({ targets: [], nextPageToken: null }),
+  webhookRegister: async () => ({
+    webhookRegistrationIdentifier: 'reg',
+    webhookRegistrationPayload: {}
+  }),
+  webhookUnregister: async () => {}
+};
+let setup = async () => ({ webhookSetupDocument: '', partialWebhookRegistrationPayload: {} });
+let manualRegistration = {
+  userConfigSchema: z.object({}),
+  fullConfigSchema: z.object({}),
+  setup
+};
+let deliveryConfig = {
+  ...manualRegistration,
+  finish: async () => ({ webhookRegistrationPayload: {} }),
+  authenticate: async () => ({ routingKeys: [] })
+};
+
+type WebhookProps = Parameters<ReturnType<typeof triggerGroup>['webhook']>[0];
+
+let build = (props: Omit<WebhookProps, 'process'>) =>
+  triggerGroup(spec, { key: 'group', name: 'Group' })
+    .webhook({ ...props, process: async () => ({ events: [] }) })
+    .routingMatchers(async () => [])
+    .build();
+
+describe('webhook trigger group declaration', () => {
+  it('builds plain automatic and manual groups as before', () => {
+    expect(build({ autoRegistration }).webhook).toMatchObject({
+      autoRegistration,
+      manualRegistration: undefined,
+      deliveryConfig: undefined
+    });
+    expect(build({ manualRegistration }).webhook).toMatchObject({
+      autoRegistration: undefined,
+      manualRegistration,
+      deliveryConfig: undefined
+    });
+  });
+
+  it('requires exactly one of automatic or manual registration', () => {
+    let message =
+      'Webhook trigger groups require exactly one of autoRegistration or manualRegistration';
+    expect(() => build({})).toThrow(message);
+    expect(() => build({ deliveryConfig })).toThrow(message);
+    expect(() => build({ autoRegistration, manualRegistration })).toThrow(message);
+  });
+
+  it('allows a delivery config only with automatic registration and its handlers', () => {
+    expect(build({ autoRegistration, deliveryConfig }).webhook?.deliveryConfig).toBe(
+      deliveryConfig
+    );
+    expect(() => build({ manualRegistration, deliveryConfig })).toThrow(
+      'A webhook delivery config requires automatic webhook registration'
+    );
+    let { finish: _, ...withoutFinish } = deliveryConfig;
+    expect(() =>
+      build({
+        autoRegistration,
+        deliveryConfig: withoutFinish as unknown as typeof deliveryConfig
+      })
+    ).toThrow('A webhook delivery config requires a finish handler');
+  });
+
+  it('requires a delivery config to authenticate the requests it receives', () => {
+    let { authenticate: _, ...withoutAuthenticate } = deliveryConfig;
+    expect(() =>
+      build({
+        autoRegistration,
+        deliveryConfig: withoutAuthenticate as unknown as typeof deliveryConfig
+      })
+    ).toThrow('A webhook delivery config requires an authenticate handler');
+  });
+});