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

package/dist/index.cjs

@@ -119,6 +119,12 @@ var SlateAction = class {
   get scopes() {
     return this._params.scopes;
   }
+  get authMethods() {
+    return this._params.authMethods;
+  }
+  get docs() {
+    return this._params.docs;
+  }
 };
 
 // src/error/axios.ts
@@ -762,6 +768,7 @@ var SlateActionBuilder = class {
   #inputSchema = null;
   #outputSchema = null;
   #scopes;
+  #authMethods;
   #toolParams = null;
   #triggerParams = null;
   input(schema) {
@@ -777,6 +784,18 @@ var SlateActionBuilder = class {
     this.#scopes = scopes;
     return this;
   }
+  authMethods(authMethods) {
+    this.#authMethods = this.validateAuthMethods(authMethods);
+    return this;
+  }
+  validateAuthMethods(authMethods) {
+    if (!authMethods) return void 0;
+    let normalized = [...new Set(authMethods.map((authMethod) => authMethod.trim()))];
+    if (normalized.some((authMethod) => !authMethod)) {
+      throw new SlateDeclarationError("Auth method IDs must be non-empty strings");
+    }
+    return normalized;
+  }
   handleInvocation(handler) {
     if (this.type !== "tool") {
       throw new SlateDeclarationError("handleInvocation can only be set for tool actions");
@@ -819,6 +838,7 @@ var SlateActionBuilder = class {
     if (scopes) {
       validateScopes(scopes);
     }
+    let authMethods = this.validateAuthMethods(this.#authMethods ?? this.params.authMethods);
     if (!this.#inputSchema) {
       throw new SlateDeclarationError("Input schema is not defined");
     }
@@ -834,6 +854,7 @@ var SlateActionBuilder = class {
     return this.factory({
       ...this.params,
       scopes,
+      authMethods,
       configSchema: this.#configSchema,
       authSchema: this.#authSchema,
       inputSchema: this.#inputSchema,
@@ -1585,6 +1606,7 @@ var axios = createAxios();
 // src/config/config.ts
 var SlateConfig = class _SlateConfig {
   #configSchema;
+  #docs;
   #configChanged = null;
   #getDefaultConfig = null;
   constructor(schema) {
@@ -1597,6 +1619,10 @@ var SlateConfig = class _SlateConfig {
     this.#configSchema = schema;
     return this;
   }
+  docs(docs) {
+    this.#docs = docs;
+    return this;
+  }
   onConfigChanged(handler) {
     this.#configChanged = handler;
     return this;
@@ -1608,6 +1634,9 @@ var SlateConfig = class _SlateConfig {
   get configSchema() {
     return this.#configSchema;
   }
+  get docsReferences() {
+    return this.#docs;
+  }
   get handlers() {
     return {
       configChanged: this.#configChanged,
@@ -1840,6 +1869,9 @@ var SlateSpecification = class _SlateSpecification {
   get description() {
     return this._params.description;
   }
+  get docs() {
+    return this._params.docs;
+  }
 };
 var spec = (params) => SlateSpecification.create(params);
 // Annotate the CommonJS export names for ESM import in node:

package/dist/index.d.cts

@@ -50,6 +50,18 @@ declare class SlateLogger {
     progress(...message: SlateLogMessageInput[]): void;
 }
 
+interface SlateDocsReference {
+    name: string;
+    url: string;
+}
+interface SlateTypedDocsReference<Type extends string> extends SlateDocsReference {
+    type?: Type;
+}
+type SlateProviderDocsReference = SlateDocsReference;
+type SlateConfigDocsReference = SlateTypedDocsReference<'docs.config.general'>;
+type SlateActionDocsReference = SlateTypedDocsReference<'docs.action.general'>;
+type SlateAuthDocsReference = SlateTypedDocsReference<'docs.auth.oauth' | 'docs.auth.oauth_scopes' | 'docs.auth.token' | 'docs.auth.service_account' | 'docs.auth.custom'>;
+
 type SlateAuthCallbackConfig = Record<string, any>;
 type SlateAuthWithOauth<InputType extends {}, OutputType extends {
     token: string;
@@ -65,10 +77,7 @@ type SlateAuthWithOauth<InputType extends {}, OutputType extends {
         defaultChecked?: boolean;
         scope: string;
     }[];
-    docs?: {
-        oauthDocsLink?: string;
-        oauthScopesLink?: string;
-    };
+    docs?: SlateAuthDocsReference[];
     inputSchema?: z.ZodType<InputType>;
     onInputChanged?: (params: {
         previousInput: InputType | null;
@@ -133,13 +142,12 @@ type SlateAuthWithToken<InputType extends {}, OutputType extends {
     name: string;
     key: string;
     inputSchema?: z.ZodType<InputType>;
-    docs?: {
-        tokenDocsLink?: string;
-    };
+    docs?: SlateAuthDocsReference[];
     getOutput: (ctx: {
         input: InputType;
     }) => Promise<{
         output: OutputType;
+        scopes?: string[];
     }>;
     onInputChanged?: (params: {
         previousInput: InputType;
@@ -160,13 +168,12 @@ type SlateAuthWithServiceAccount<InputType extends {}, OutputType extends {}> =
     name: string;
     key: string;
     inputSchema?: z.ZodType<InputType>;
-    docs?: {
-        serviceAccountDocsLink?: string;
-    };
+    docs?: SlateAuthDocsReference[];
     getOutput: (ctx: {
         input: InputType;
     }) => Promise<{
         output: OutputType;
+        scopes?: string[];
     }>;
     onInputChanged?: (params: {
         previousInput: InputType;
@@ -187,13 +194,12 @@ type SlateAuthWithCustomData<InputType extends {}, OutputType extends {}> = {
     name: string;
     key: string;
     inputSchema?: z.ZodType<InputType>;
-    docs?: {
-        customAuthDocsLink?: string;
-    };
+    docs?: SlateAuthDocsReference[];
     getOutput: (ctx: {
         input: InputType;
     }) => Promise<{
         output: OutputType;
+        scopes?: string[];
     }>;
     handleTokenRefresh?: (ctx: {
         output: OutputType;
@@ -263,6 +269,7 @@ declare class SlateConfig<ConfigType extends {}> {
     private constructor();
     static create<ConfigType extends {}>(schema: z.ZodType<ConfigType>): SlateConfig<ConfigType>;
     config<NewConfigType extends {}>(schema: z.ZodType<NewConfigType>): SlateConfig<NewConfigType>;
+    docs(docs: SlateConfigDocsReference[]): SlateConfig<ConfigType>;
     onConfigChanged(handler: (params: {
         previousConfig: ConfigType | null;
         newConfig: ConfigType;
@@ -271,6 +278,7 @@ declare class SlateConfig<ConfigType extends {}> {
     } | undefined): SlateConfig<ConfigType>;
     getDefaultConfig(getter: () => ConfigType): SlateConfig<ConfigType>;
     get configSchema(): z.ZodType<ConfigType, unknown, z.core.$ZodTypeInternals<ConfigType, unknown>>;
+    get docsReferences(): SlateConfigDocsReference[] | undefined;
     get handlers(): {
         configChanged: ((params: {
             previousConfig: ConfigType | null;
@@ -287,6 +295,7 @@ interface SlateSpecificationParameters {
     key: string;
     name: string;
     description?: string;
+    docs?: SlateProviderDocsReference[];
     metadata?: Record<string, any>;
 }
 interface SlateSpecificationCreateParameters<ConfigType extends {}, AuthType extends {}> extends SlateSpecificationParameters {
@@ -307,6 +316,7 @@ declare class SlateSpecification<ConfigType extends {}, AuthType extends {}> {
     get key(): string;
     get name(): string;
     get description(): string | undefined;
+    get docs(): SlateDocsReference[] | undefined;
 }
 declare let spec: <ConfigType extends {}, AuthType extends {}>(params: SlateSpecificationCreateParameters<ConfigType, AuthType>) => SlateSpecification<ConfigType, AuthType>;
 
@@ -389,6 +399,8 @@ interface SlateActionParameters {
     };
     metadata?: Record<string, any>;
     scopes?: SlateActionScopes;
+    authMethods?: string[];
+    docs?: SlateActionDocsReference[];
 }
 type SlateToolInvocationHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = (context: SlateContext<ConfigType, AuthType, InputType>) => Promise<{
     output: OutputType;
@@ -471,6 +483,8 @@ declare abstract class SlateAction<Type extends SlateActionType, ConfigType exte
     get constraints(): string[] | undefined;
     get metadata(): Record<string, any> | undefined;
     get scopes(): SlateActionScopes | undefined;
+    get authMethods(): string[] | undefined;
+    get docs(): SlateActionDocsReference[] | undefined;
 }
 
 declare class SlateActionBuilder<Type extends SlateActionType, ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}, Result extends SlateAction<Type, ConfigType, AuthType, any, any>> {
@@ -483,6 +497,8 @@ declare class SlateActionBuilder<Type extends SlateActionType, ConfigType extend
     input<NewInputType extends {}>(schema: z.ZodType<NewInputType>): SlateActionBuilder<Type, ConfigType, AuthType, NewInputType, OutputType, Result>;
     output<NewOutputType extends {}>(schema: z.ZodType<NewOutputType>): SlateActionBuilder<Type, ConfigType, AuthType, InputType, NewOutputType, Result>;
     scopes(scopes: SlateActionScopes): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result>;
+    authMethods(authMethods: string[]): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result>;
+    private validateAuthMethods;
     handleInvocation(handler: SlateToolInvocationHandler<ConfigType, AuthType, InputType, OutputType>): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result>;
     webhook(props: {
         handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
@@ -648,4 +664,4 @@ declare class Slate<ConfigType extends {}, AuthType extends {}> {
     get actions(): (SlateTrigger<ConfigType, AuthType, any, any> | SlateTool<ConfigType, AuthType, any, any>)[];
 }
 
-export { Slate, SlateAction, SlateActionBuilder, type SlateActionCreateParameters, type SlateActionParameters, type SlateActionParametersAny, type SlateActionParametersTool, type SlateActionParametersTrigger, type SlateActionScopeClause, type SlateActionScopeClauseInput, type SlateActionScopeValue, type SlateActionScopes, type SlateActionScopesInput, type SlateActionType, type SlateAttachment, type SlateAttachmentInlineContent, type SlateAttachmentUrlContent, SlateAuth, type SlateAuthType, type SlateAuthWithCustomData, type SlateAuthWithNone, type SlateAuthWithOauth, type SlateAuthWithServiceAccount, type SlateAuthWithToken, type SlateAxiosDefaults, type SlateAxiosErrorOptions, SlateConfig, SlateContext, SlateDeclarationError, SlateDefaultPollingIntervalSeconds, SlateError, type SlateErrorInput, type SlateErrorIssue, type SlateErrorKind, type SlateErrorProviderInfo, type SlateErrorResponse, type SlateErrorUpstreamInfo, type SlateLogEntry, type SlateLogFields, type SlateLogListener, type SlateLogMessageInput, type SlateLogType, SlateLogger, type SlatePollingOptions, type SlateServiceErrorData, SlateSpecification, type SlateSpecificationCreateParameters, type SlateSpecificationParameters, SlateTool, type SlateToolInvocationHandler, type SlateToolParameters, SlateTrigger, type SlateTriggerMappingHandler, type SlateTriggerParameters, type SlateTriggerPollingHandler, type SlateTriggerWebhookAutoRegistrationHandler, type SlateTriggerWebhookAutoUnregistrationHandler, type SlateTriggerWebhookRequestHandler, allOf, anyOf, auth, axios, config, createAxios, createBase64Attachment, createSlateError, createTextAttachment, createUrlAttachment, getCurrentContext, getServiceErrorData, inferSlateErrorFromAxios, isAxiosErrorLike, isServiceErrorData, mapServiceErrorCode, mapServiceErrorToSlateErrorInput, mergeScopes, runWithContext, scopeClause, spec, tool, trigger, validateScopes };
+export { 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, type SlateAttachment, type SlateAttachmentInlineContent, type SlateAttachmentUrlContent, SlateAuth, type SlateAuthDocsReference, type SlateAuthType, type SlateAuthWithCustomData, type SlateAuthWithNone, type SlateAuthWithOauth, type SlateAuthWithServiceAccount, type SlateAuthWithToken, type SlateAxiosDefaults, type SlateAxiosErrorOptions, SlateConfig, type SlateConfigDocsReference, SlateContext, SlateDeclarationError, SlateDefaultPollingIntervalSeconds, type SlateDocsReference, SlateError, type SlateErrorInput, type SlateErrorIssue, type SlateErrorKind, type SlateErrorProviderInfo, type SlateErrorResponse, type SlateErrorUpstreamInfo, type SlateLogEntry, type SlateLogFields, type SlateLogListener, type SlateLogMessageInput, type SlateLogType, SlateLogger, type SlatePollingOptions, type SlateProviderDocsReference, type SlateServiceErrorData, SlateSpecification, type SlateSpecificationCreateParameters, type SlateSpecificationParameters, SlateTool, type SlateToolInvocationHandler, type SlateToolParameters, SlateTrigger, type SlateTriggerMappingHandler, type SlateTriggerParameters, type SlateTriggerPollingHandler, type SlateTriggerWebhookAutoRegistrationHandler, type SlateTriggerWebhookAutoUnregistrationHandler, type SlateTriggerWebhookRequestHandler, type SlateTypedDocsReference, allOf, anyOf, auth, axios, config, createAxios, createBase64Attachment, createSlateError, createTextAttachment, createUrlAttachment, getCurrentContext, getServiceErrorData, inferSlateErrorFromAxios, isAxiosErrorLike, isServiceErrorData, mapServiceErrorCode, mapServiceErrorToSlateErrorInput, mergeScopes, runWithContext, scopeClause, spec, tool, trigger, validateScopes };

package/dist/index.d.ts

@@ -50,6 +50,18 @@ declare class SlateLogger {
     progress(...message: SlateLogMessageInput[]): void;
 }
 
+interface SlateDocsReference {
+    name: string;
+    url: string;
+}
+interface SlateTypedDocsReference<Type extends string> extends SlateDocsReference {
+    type?: Type;
+}
+type SlateProviderDocsReference = SlateDocsReference;
+type SlateConfigDocsReference = SlateTypedDocsReference<'docs.config.general'>;
+type SlateActionDocsReference = SlateTypedDocsReference<'docs.action.general'>;
+type SlateAuthDocsReference = SlateTypedDocsReference<'docs.auth.oauth' | 'docs.auth.oauth_scopes' | 'docs.auth.token' | 'docs.auth.service_account' | 'docs.auth.custom'>;
+
 type SlateAuthCallbackConfig = Record<string, any>;
 type SlateAuthWithOauth<InputType extends {}, OutputType extends {
     token: string;
@@ -65,10 +77,7 @@ type SlateAuthWithOauth<InputType extends {}, OutputType extends {
         defaultChecked?: boolean;
         scope: string;
     }[];
-    docs?: {
-        oauthDocsLink?: string;
-        oauthScopesLink?: string;
-    };
+    docs?: SlateAuthDocsReference[];
     inputSchema?: z.ZodType<InputType>;
     onInputChanged?: (params: {
         previousInput: InputType | null;
@@ -133,13 +142,12 @@ type SlateAuthWithToken<InputType extends {}, OutputType extends {
     name: string;
     key: string;
     inputSchema?: z.ZodType<InputType>;
-    docs?: {
-        tokenDocsLink?: string;
-    };
+    docs?: SlateAuthDocsReference[];
     getOutput: (ctx: {
         input: InputType;
     }) => Promise<{
         output: OutputType;
+        scopes?: string[];
     }>;
     onInputChanged?: (params: {
         previousInput: InputType;
@@ -160,13 +168,12 @@ type SlateAuthWithServiceAccount<InputType extends {}, OutputType extends {}> =
     name: string;
     key: string;
     inputSchema?: z.ZodType<InputType>;
-    docs?: {
-        serviceAccountDocsLink?: string;
-    };
+    docs?: SlateAuthDocsReference[];
     getOutput: (ctx: {
         input: InputType;
     }) => Promise<{
         output: OutputType;
+        scopes?: string[];
     }>;
     onInputChanged?: (params: {
         previousInput: InputType;
@@ -187,13 +194,12 @@ type SlateAuthWithCustomData<InputType extends {}, OutputType extends {}> = {
     name: string;
     key: string;
     inputSchema?: z.ZodType<InputType>;
-    docs?: {
-        customAuthDocsLink?: string;
-    };
+    docs?: SlateAuthDocsReference[];
     getOutput: (ctx: {
         input: InputType;
     }) => Promise<{
         output: OutputType;
+        scopes?: string[];
     }>;
     handleTokenRefresh?: (ctx: {
         output: OutputType;
@@ -263,6 +269,7 @@ declare class SlateConfig<ConfigType extends {}> {
     private constructor();
     static create<ConfigType extends {}>(schema: z.ZodType<ConfigType>): SlateConfig<ConfigType>;
     config<NewConfigType extends {}>(schema: z.ZodType<NewConfigType>): SlateConfig<NewConfigType>;
+    docs(docs: SlateConfigDocsReference[]): SlateConfig<ConfigType>;
     onConfigChanged(handler: (params: {
         previousConfig: ConfigType | null;
         newConfig: ConfigType;
@@ -271,6 +278,7 @@ declare class SlateConfig<ConfigType extends {}> {
     } | undefined): SlateConfig<ConfigType>;
     getDefaultConfig(getter: () => ConfigType): SlateConfig<ConfigType>;
     get configSchema(): z.ZodType<ConfigType, unknown, z.core.$ZodTypeInternals<ConfigType, unknown>>;
+    get docsReferences(): SlateConfigDocsReference[] | undefined;
     get handlers(): {
         configChanged: ((params: {
             previousConfig: ConfigType | null;
@@ -287,6 +295,7 @@ interface SlateSpecificationParameters {
     key: string;
     name: string;
     description?: string;
+    docs?: SlateProviderDocsReference[];
     metadata?: Record<string, any>;
 }
 interface SlateSpecificationCreateParameters<ConfigType extends {}, AuthType extends {}> extends SlateSpecificationParameters {
@@ -307,6 +316,7 @@ declare class SlateSpecification<ConfigType extends {}, AuthType extends {}> {
     get key(): string;
     get name(): string;
     get description(): string | undefined;
+    get docs(): SlateDocsReference[] | undefined;
 }
 declare let spec: <ConfigType extends {}, AuthType extends {}>(params: SlateSpecificationCreateParameters<ConfigType, AuthType>) => SlateSpecification<ConfigType, AuthType>;
 
@@ -389,6 +399,8 @@ interface SlateActionParameters {
     };
     metadata?: Record<string, any>;
     scopes?: SlateActionScopes;
+    authMethods?: string[];
+    docs?: SlateActionDocsReference[];
 }
 type SlateToolInvocationHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = (context: SlateContext<ConfigType, AuthType, InputType>) => Promise<{
     output: OutputType;
@@ -471,6 +483,8 @@ declare abstract class SlateAction<Type extends SlateActionType, ConfigType exte
     get constraints(): string[] | undefined;
     get metadata(): Record<string, any> | undefined;
     get scopes(): SlateActionScopes | undefined;
+    get authMethods(): string[] | undefined;
+    get docs(): SlateActionDocsReference[] | undefined;
 }
 
 declare class SlateActionBuilder<Type extends SlateActionType, ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}, Result extends SlateAction<Type, ConfigType, AuthType, any, any>> {
@@ -483,6 +497,8 @@ declare class SlateActionBuilder<Type extends SlateActionType, ConfigType extend
     input<NewInputType extends {}>(schema: z.ZodType<NewInputType>): SlateActionBuilder<Type, ConfigType, AuthType, NewInputType, OutputType, Result>;
     output<NewOutputType extends {}>(schema: z.ZodType<NewOutputType>): SlateActionBuilder<Type, ConfigType, AuthType, InputType, NewOutputType, Result>;
     scopes(scopes: SlateActionScopes): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result>;
+    authMethods(authMethods: string[]): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result>;
+    private validateAuthMethods;
     handleInvocation(handler: SlateToolInvocationHandler<ConfigType, AuthType, InputType, OutputType>): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result>;
     webhook(props: {
         handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
@@ -648,4 +664,4 @@ declare class Slate<ConfigType extends {}, AuthType extends {}> {
     get actions(): (SlateTrigger<ConfigType, AuthType, any, any> | SlateTool<ConfigType, AuthType, any, any>)[];
 }
 
-export { Slate, SlateAction, SlateActionBuilder, type SlateActionCreateParameters, type SlateActionParameters, type SlateActionParametersAny, type SlateActionParametersTool, type SlateActionParametersTrigger, type SlateActionScopeClause, type SlateActionScopeClauseInput, type SlateActionScopeValue, type SlateActionScopes, type SlateActionScopesInput, type SlateActionType, type SlateAttachment, type SlateAttachmentInlineContent, type SlateAttachmentUrlContent, SlateAuth, type SlateAuthType, type SlateAuthWithCustomData, type SlateAuthWithNone, type SlateAuthWithOauth, type SlateAuthWithServiceAccount, type SlateAuthWithToken, type SlateAxiosDefaults, type SlateAxiosErrorOptions, SlateConfig, SlateContext, SlateDeclarationError, SlateDefaultPollingIntervalSeconds, SlateError, type SlateErrorInput, type SlateErrorIssue, type SlateErrorKind, type SlateErrorProviderInfo, type SlateErrorResponse, type SlateErrorUpstreamInfo, type SlateLogEntry, type SlateLogFields, type SlateLogListener, type SlateLogMessageInput, type SlateLogType, SlateLogger, type SlatePollingOptions, type SlateServiceErrorData, SlateSpecification, type SlateSpecificationCreateParameters, type SlateSpecificationParameters, SlateTool, type SlateToolInvocationHandler, type SlateToolParameters, SlateTrigger, type SlateTriggerMappingHandler, type SlateTriggerParameters, type SlateTriggerPollingHandler, type SlateTriggerWebhookAutoRegistrationHandler, type SlateTriggerWebhookAutoUnregistrationHandler, type SlateTriggerWebhookRequestHandler, allOf, anyOf, auth, axios, config, createAxios, createBase64Attachment, createSlateError, createTextAttachment, createUrlAttachment, getCurrentContext, getServiceErrorData, inferSlateErrorFromAxios, isAxiosErrorLike, isServiceErrorData, mapServiceErrorCode, mapServiceErrorToSlateErrorInput, mergeScopes, runWithContext, scopeClause, spec, tool, trigger, validateScopes };
+export { 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, type SlateAttachment, type SlateAttachmentInlineContent, type SlateAttachmentUrlContent, SlateAuth, type SlateAuthDocsReference, type SlateAuthType, type SlateAuthWithCustomData, type SlateAuthWithNone, type SlateAuthWithOauth, type SlateAuthWithServiceAccount, type SlateAuthWithToken, type SlateAxiosDefaults, type SlateAxiosErrorOptions, SlateConfig, type SlateConfigDocsReference, SlateContext, SlateDeclarationError, SlateDefaultPollingIntervalSeconds, type SlateDocsReference, SlateError, type SlateErrorInput, type SlateErrorIssue, type SlateErrorKind, type SlateErrorProviderInfo, type SlateErrorResponse, type SlateErrorUpstreamInfo, type SlateLogEntry, type SlateLogFields, type SlateLogListener, type SlateLogMessageInput, type SlateLogType, SlateLogger, type SlatePollingOptions, type SlateProviderDocsReference, type SlateServiceErrorData, SlateSpecification, type SlateSpecificationCreateParameters, type SlateSpecificationParameters, SlateTool, type SlateToolInvocationHandler, type SlateToolParameters, SlateTrigger, type SlateTriggerMappingHandler, type SlateTriggerParameters, type SlateTriggerPollingHandler, type SlateTriggerWebhookAutoRegistrationHandler, type SlateTriggerWebhookAutoUnregistrationHandler, type SlateTriggerWebhookRequestHandler, type SlateTypedDocsReference, allOf, anyOf, auth, axios, config, createAxios, createBase64Attachment, createSlateError, createTextAttachment, createUrlAttachment, getCurrentContext, getServiceErrorData, inferSlateErrorFromAxios, isAxiosErrorLike, isServiceErrorData, mapServiceErrorCode, mapServiceErrorToSlateErrorInput, mergeScopes, runWithContext, scopeClause, spec, tool, trigger, validateScopes };

package/dist/index.module.js

@@ -48,6 +48,12 @@ var SlateAction = class {
   get scopes() {
     return this._params.scopes;
   }
+  get authMethods() {
+    return this._params.authMethods;
+  }
+  get docs() {
+    return this._params.docs;
+  }
 };
 
 // src/error/axios.ts
@@ -691,6 +697,7 @@ var SlateActionBuilder = class {
   #inputSchema = null;
   #outputSchema = null;
   #scopes;
+  #authMethods;
   #toolParams = null;
   #triggerParams = null;
   input(schema) {
@@ -706,6 +713,18 @@ var SlateActionBuilder = class {
     this.#scopes = scopes;
     return this;
   }
+  authMethods(authMethods) {
+    this.#authMethods = this.validateAuthMethods(authMethods);
+    return this;
+  }
+  validateAuthMethods(authMethods) {
+    if (!authMethods) return void 0;
+    let normalized = [...new Set(authMethods.map((authMethod) => authMethod.trim()))];
+    if (normalized.some((authMethod) => !authMethod)) {
+      throw new SlateDeclarationError("Auth method IDs must be non-empty strings");
+    }
+    return normalized;
+  }
   handleInvocation(handler) {
     if (this.type !== "tool") {
       throw new SlateDeclarationError("handleInvocation can only be set for tool actions");
@@ -748,6 +767,7 @@ var SlateActionBuilder = class {
     if (scopes) {
       validateScopes(scopes);
     }
+    let authMethods = this.validateAuthMethods(this.#authMethods ?? this.params.authMethods);
     if (!this.#inputSchema) {
       throw new SlateDeclarationError("Input schema is not defined");
     }
@@ -763,6 +783,7 @@ var SlateActionBuilder = class {
     return this.factory({
       ...this.params,
       scopes,
+      authMethods,
       configSchema: this.#configSchema,
       authSchema: this.#authSchema,
       inputSchema: this.#inputSchema,
@@ -1514,6 +1535,7 @@ var axios = createAxios();
 // src/config/config.ts
 var SlateConfig = class _SlateConfig {
   #configSchema;
+  #docs;
   #configChanged = null;
   #getDefaultConfig = null;
   constructor(schema) {
@@ -1526,6 +1548,10 @@ var SlateConfig = class _SlateConfig {
     this.#configSchema = schema;
     return this;
   }
+  docs(docs) {
+    this.#docs = docs;
+    return this;
+  }
   onConfigChanged(handler) {
     this.#configChanged = handler;
     return this;
@@ -1537,6 +1563,9 @@ var SlateConfig = class _SlateConfig {
   get configSchema() {
     return this.#configSchema;
   }
+  get docsReferences() {
+    return this.#docs;
+  }
   get handlers() {
     return {
       configChanged: this.#configChanged,
@@ -1769,6 +1798,9 @@ var SlateSpecification = class _SlateSpecification {
   get description() {
     return this._params.description;
   }
+  get docs() {
+    return this._params.docs;
+  }
 };
 var spec = (params) => SlateSpecification.create(params);
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider",
-  "version": "1.0.0-rc.14",
+  "version": "1.0.0-rc.16",
   "publishConfig": {
     "access": "public"
   },
@@ -42,4 +42,4 @@
     "typescript": "5.8.2",
     "vitest": "^3.1.2"
   }
-}
+}

package/src/action/action.ts

@@ -1,5 +1,6 @@
 import type { z } from 'zod';
 import type { SlateContext } from '../context';
+import type { SlateActionDocsReference } from '../docs';
 import type { SlateSpecification } from '../specification/specification';
 import type { SlateAttachment } from './attachment';
 
@@ -26,6 +27,8 @@ export interface SlateActionParameters {
   };
   metadata?: Record<string, any>;
   scopes?: SlateActionScopes;
+  authMethods?: string[];
+  docs?: SlateActionDocsReference[];
 }
 
 export type SlateToolInvocationHandler<
@@ -203,4 +206,12 @@ export abstract class SlateAction<
   get scopes() {
     return this._params.scopes;
   }
+
+  get authMethods() {
+    return this._params.authMethods;
+  }
+
+  get docs() {
+    return this._params.docs;
+  }
 }

package/src/action/builder.ts

@@ -32,6 +32,7 @@ export class SlateActionBuilder<
   #inputSchema: z.ZodType<InputType> | null = null;
   #outputSchema: z.ZodType<OutputType> | null = null;
   #scopes: SlateActionScopes | undefined;
+  #authMethods: string[] | undefined;
 
   #toolParams: SlateActionParametersTool<ConfigType, AuthType, InputType, OutputType> | null =
     null;
@@ -76,6 +77,24 @@ export class SlateActionBuilder<
     return this;
   }
 
+  authMethods(
+    authMethods: string[]
+  ): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result> {
+    this.#authMethods = this.validateAuthMethods(authMethods);
+    return this;
+  }
+
+  private validateAuthMethods(authMethods: string[] | undefined) {
+    if (!authMethods) return undefined;
+
+    let normalized = [...new Set(authMethods.map(authMethod => authMethod.trim()))];
+    if (normalized.some(authMethod => !authMethod)) {
+      throw new SlateDeclarationError('Auth method IDs must be non-empty strings');
+    }
+
+    return normalized;
+  }
+
   handleInvocation(
     handler: SlateToolInvocationHandler<ConfigType, AuthType, InputType, OutputType>
   ): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result> {
@@ -138,6 +157,7 @@ export class SlateActionBuilder<
     if (scopes) {
       validateScopes(scopes);
     }
+    let authMethods = this.validateAuthMethods(this.#authMethods ?? this.params.authMethods);
 
     if (!this.#inputSchema) {
       throw new SlateDeclarationError('Input schema is not defined');
@@ -155,6 +175,7 @@ export class SlateActionBuilder<
     return this.factory({
       ...this.params,
       scopes,
+      authMethods,
       configSchema: this.#configSchema,
       authSchema: this.#authSchema,
       inputSchema: this.#inputSchema,

package/src/auth/types.ts

@@ -1,4 +1,5 @@
 import type z from 'zod';
+import type { SlateAuthDocsReference } from '../docs';
 
 type SlateAuthCallbackConfig = Record<string, any>;
 
@@ -22,10 +23,7 @@ export type SlateAuthWithOauth<
     scope: string;
   }[];
 
-  docs?: {
-    oauthDocsLink?: string;
-    oauthScopesLink?: string;
-  };
+  docs?: SlateAuthDocsReference[];
 
   inputSchema?: z.ZodType<InputType>;
 
@@ -97,11 +95,12 @@ export type SlateAuthWithToken<InputType extends {}, OutputType extends { token?
 
   inputSchema?: z.ZodType<InputType>;
 
-  docs?: {
-    tokenDocsLink?: string;
-  };
+  docs?: SlateAuthDocsReference[];
 
-  getOutput: (ctx: { input: InputType }) => Promise<{ output: OutputType }>;
+  getOutput: (ctx: { input: InputType }) => Promise<{
+    output: OutputType;
+    scopes?: string[];
+  }>;
 
   onInputChanged?: (params: {
     previousInput: InputType;
@@ -123,11 +122,12 @@ export type SlateAuthWithServiceAccount<InputType extends {}, OutputType extends
 
   inputSchema?: z.ZodType<InputType>;
 
-  docs?: {
-    serviceAccountDocsLink?: string;
-  };
+  docs?: SlateAuthDocsReference[];
 
-  getOutput: (ctx: { input: InputType }) => Promise<{ output: OutputType }>;
+  getOutput: (ctx: { input: InputType }) => Promise<{
+    output: OutputType;
+    scopes?: string[];
+  }>;
 
   onInputChanged?: (params: {
     previousInput: InputType;
@@ -149,11 +149,12 @@ export type SlateAuthWithCustomData<InputType extends {}, OutputType extends {}>
 
   inputSchema?: z.ZodType<InputType>;
 
-  docs?: {
-    customAuthDocsLink?: string;
-  };
+  docs?: SlateAuthDocsReference[];
 
-  getOutput: (ctx: { input: InputType }) => Promise<{ output: OutputType }>;
+  getOutput: (ctx: { input: InputType }) => Promise<{
+    output: OutputType;
+    scopes?: string[];
+  }>;
 
   handleTokenRefresh?: (ctx: {
     output: OutputType;

package/src/config/config.ts

@@ -1,7 +1,9 @@
 import type z from 'zod';
+import type { SlateConfigDocsReference } from '../docs';
 
 export class SlateConfig<ConfigType extends {}> {
   #configSchema: z.ZodType<ConfigType>;
+  #docs: SlateConfigDocsReference[] | undefined;
   #configChanged:
     | ((params: {
         previousConfig: ConfigType | null;
@@ -25,6 +27,11 @@ export class SlateConfig<ConfigType extends {}> {
     return this as any as SlateConfig<NewConfigType>;
   }
 
+  docs(docs: SlateConfigDocsReference[]): SlateConfig<ConfigType> {
+    this.#docs = docs;
+    return this;
+  }
+
   onConfigChanged(
     handler: (params: {
       previousConfig: ConfigType | null;
@@ -44,6 +51,10 @@ export class SlateConfig<ConfigType extends {}> {
     return this.#configSchema;
   }
 
+  get docsReferences() {
+    return this.#docs;
+  }
+
   get handlers() {
     return {
       configChanged: this.#configChanged,

package/src/docs.ts

@@ -0,0 +1,22 @@
+export interface SlateDocsReference {
+  name: string;
+  url: string;
+}
+
+export interface SlateTypedDocsReference<Type extends string> extends SlateDocsReference {
+  type?: Type;
+}
+
+export type SlateProviderDocsReference = SlateDocsReference;
+
+export type SlateConfigDocsReference = SlateTypedDocsReference<'docs.config.general'>;
+
+export type SlateActionDocsReference = SlateTypedDocsReference<'docs.action.general'>;
+
+export type SlateAuthDocsReference = SlateTypedDocsReference<
+  | 'docs.auth.oauth'
+  | 'docs.auth.oauth_scopes'
+  | 'docs.auth.token'
+  | 'docs.auth.service_account'
+  | 'docs.auth.custom'
+>;

package/src/index.ts

@@ -4,6 +4,7 @@ export * from './auth';
 export * from './axios';
 export * from './config';
 export * from './context';
+export * from './docs';
 export * from './error';
 export * from './logger';
 export * from './specification';

package/src/specification/specification.ts

@@ -1,11 +1,13 @@
 import z from 'zod';
 import type { SlateAuth } from '../auth';
 import type { SlateConfig } from '../config';
+import type { SlateProviderDocsReference } from '../docs';
 
 export interface SlateSpecificationParameters {
   key: string;
   name: string;
   description?: string;
+  docs?: SlateProviderDocsReference[];
   metadata?: Record<string, any>;
 }
 
@@ -61,6 +63,10 @@ export class SlateSpecification<ConfigType extends {}, AuthType extends {}> {
   get description() {
     return this._params.description;
   }
+
+  get docs() {
+    return this._params.docs;
+  }
 }
 
 export let spec = <ConfigType extends {}, AuthType extends {}>(