@botpress/sdk 3.4.0 → 3.5.0

package/dist/package.d.ts

@@ -40,6 +40,7 @@ type PluginPackageDefinition = NameVersion & {
     recurringEvents?: Record<string, plugin.RecurringEventDefinition>;
     actions?: Record<string, plugin.ActionDefinition>;
     tables?: Record<string, plugin.TableDefinition>;
+    workflows?: Record<string, plugin.WorkflowDefinition>;
 };
 export type IntegrationPackage = PackageReference & {
     type: 'integration';

package/dist/plugin/common/generic.d.ts

@@ -6,114 +6,18 @@ export type BaseAction = {
     output: any;
 };
 export type BaseTable = {
-    /**
-     * Required. This name is used to identify your table.
-     */
-    name: string;
-    /**
-     * The 'factor' multiplies the row's data storage limit by 4KB and its quota count, but can only be set at table creation and not modified later. For instance, a factor of 2 increases storage to 8KB but counts as 2 rows in your quota. The default factor is 1.
-     */
-    factor?: number;
-    /**
-     * A table designated as "frozen" is immutable in terms of its name and schema structure; modifications to its schema or a renaming operation are not permitted. The only action that can be taken on such a table is deletion. The schema established at the time of creation is locked in as the final structure. To implement any changes, the table must be duplicated with the desired alterations.
-     */
-    frozen?: boolean;
-    schema: {
-        $schema?: string;
-        /**
-         * List of keys/columns in the table.
-         */
-        properties: {
-            [k: string]: {
-                type: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'null';
-                format?: 'date-time';
-                description?: string;
-                /**
-                 * String properties must match this pattern
-                 */
-                pattern?: string;
-                /**
-                 * String properties must be one of these values
-                 */
-                enum?: string[];
-                /**
-                 * Defines the shape of items in an array
-                 */
-                items?: {
-                    type: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'null';
-                    [k: string]: any;
-                };
-                nullable?: boolean;
-                properties?: {
-                    [k: string]: {
-                        type: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'null';
-                        [k: string]: any;
-                    };
-                };
-                'x-zui': {
-                    index: number;
-                    /**
-                     * Indicates if the column is vectorized and searchable.
-                     */
-                    searchable?: boolean;
-                    /**
-                     * Indicates if the field is hidden in the UI
-                     */
-                    hidden?: boolean;
-                    /**
-                     * Order of the column in the UI
-                     */
-                    order?: number;
-                    /**
-                     * Width of the column in the UI
-                     */
-                    width?: number;
-                    computed?: {
-                        action: 'ai' | 'code' | 'workflow';
-                        dependencies?: string[];
-                        /**
-                         * Prompt when action is "ai"
-                         */
-                        prompt?: string;
-                        /**
-                         * Code to execute when action is "code"
-                         */
-                        code?: string;
-                        /**
-                         * Model to use when action is "ai"
-                         */
-                        model?: string;
-                        /**
-                         * ID of Workflow to execute when action is "workflow"
-                         */
-                        workflowId?: string;
-                        enabled?: boolean;
-                    };
-                };
-            };
-        };
-        /**
-         * Additional properties can be provided, but they will be ignored if no column matches.
-         */
-        additionalProperties: true;
-        /**
-         * Array of required properties.
-         */
-        required?: string[];
-        type: 'object';
-    };
-    /**
-     * Optional tags to help organize your tables. These should be passed here as an object representing key/value pairs.
-     */
+    [k: string]: any;
+};
+export type BaseWorkflow = {
+    input: any;
+    output: any;
     tags?: {
         [k: string]: string;
     };
-    /**
-     * Indicates if the table is enabled for computation.
-     */
-    isComputeEnabled?: boolean;
 };
 export type BasePlugin = {
+    name: string;
+    version: string;
     configuration: any;
     integrations: Record<string, BaseIntegration>;
     interfaces: Record<string, BaseInterface>;
@@ -121,14 +25,18 @@ export type BasePlugin = {
     states: Record<string, any>;
     actions: Record<string, BaseAction>;
     tables: Record<string, BaseTable>;
+    workflows: Record<string, BaseWorkflow>;
 };
 export type InputBasePlugin = utils.DeepPartial<BasePlugin>;
 export type DefaultPlugin<B extends utils.DeepPartial<BasePlugin>> = {
+    name: utils.Default<B['name'], BasePlugin['name']>;
+    version: utils.Default<B['version'], BasePlugin['version']>;
     configuration: utils.Default<B['configuration'], BasePlugin['configuration']>;
     events: utils.Default<B['events'], BasePlugin['events']>;
     states: utils.Default<B['states'], BasePlugin['states']>;
     actions: utils.Default<B['actions'], BasePlugin['actions']>;
     tables: utils.Default<B['tables'], BasePlugin['tables']>;
+    workflows: utils.Default<B['workflows'], BasePlugin['workflows']>;
     integrations: undefined extends B['integrations'] ? BasePlugin['integrations'] : {
         [K in keyof B['integrations']]: DefaultIntegration<utils.Cast<B['integrations'][K], InputBaseIntegration>>;
     };

package/dist/plugin/definition.d.ts

@@ -1,7 +1,7 @@
-import { StateDefinition, RecurringEventDefinition, EventDefinition, ConfigurationDefinition, UserDefinition, ConversationDefinition, MessageDefinition, ActionDefinition, TableDefinition } from '../bot/definition';
+import { StateDefinition, RecurringEventDefinition, EventDefinition, ConfigurationDefinition, UserDefinition, ConversationDefinition, MessageDefinition, ActionDefinition, TableDefinition, WorkflowDefinition } from '../bot/definition';
 import { IntegrationPackage, InterfacePackage } from '../package';
 import { ZuiObjectSchema } from '../zui';
-export { StateDefinition, RecurringEventDefinition, EventDefinition, ConfigurationDefinition, UserDefinition, ConversationDefinition, MessageDefinition, ActionDefinition, TableDefinition, IntegrationConfigInstance, } from '../bot/definition';
+export { StateDefinition, RecurringEventDefinition, EventDefinition, ConfigurationDefinition, UserDefinition, ConversationDefinition, MessageDefinition, ActionDefinition, TableDefinition, IntegrationConfigInstance, WorkflowDefinition, } from '../bot/definition';
 type BaseConfig = ZuiObjectSchema;
 type BaseStates = Record<string, ZuiObjectSchema>;
 type BaseEvents = Record<string, ZuiObjectSchema>;
@@ -9,7 +9,8 @@ type BaseActions = Record<string, ZuiObjectSchema>;
 type BaseInterfaces = Record<string, any>;
 type BaseIntegrations = Record<string, any>;
 type BaseTables = Record<string, ZuiObjectSchema>;
-export type PluginDefinitionProps<TName extends string = string, TVersion extends string = string, TConfig extends BaseConfig = BaseConfig, TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TInterfaces extends BaseInterfaces = BaseInterfaces, TIntegrations extends BaseIntegrations = BaseIntegrations, TTables extends BaseTables = BaseTables> = {
+type BaseWorkflows = Record<string, ZuiObjectSchema>;
+export type PluginDefinitionProps<TName extends string = string, TVersion extends string = string, TConfig extends BaseConfig = BaseConfig, TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TInterfaces extends BaseInterfaces = BaseInterfaces, TIntegrations extends BaseIntegrations = BaseIntegrations, TTables extends BaseTables = BaseTables, TWorkflows extends BaseWorkflows = BaseWorkflows> = {
     name: TName;
     version: TVersion;
     title?: string;
@@ -39,9 +40,16 @@ export type PluginDefinitionProps<TName extends string = string, TVersion extend
     tables?: {
         [K in keyof TTables]: TableDefinition<TTables[K]>;
     };
+    /**
+     * # EXPERIMENTAL
+     * This API is experimental and may change in the future.
+     */
+    workflows?: {
+        [K in keyof TWorkflows]: WorkflowDefinition<TWorkflows[K]>;
+    };
 };
-export declare class PluginDefinition<TName extends string = string, TVersion extends string = string, TConfig extends BaseConfig = BaseConfig, TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TInterfaces extends BaseInterfaces = BaseInterfaces, TIntegrations extends BaseIntegrations = BaseIntegrations, TTables extends BaseTables = BaseTables> {
-    readonly props: PluginDefinitionProps<TName, TVersion, TConfig, TStates, TEvents, TActions, TInterfaces, TIntegrations, TTables>;
+export declare class PluginDefinition<TName extends string = string, TVersion extends string = string, TConfig extends BaseConfig = BaseConfig, TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TInterfaces extends BaseInterfaces = BaseInterfaces, TIntegrations extends BaseIntegrations = BaseIntegrations, TTables extends BaseTables = BaseTables, TWorkflows extends BaseWorkflows = BaseWorkflows> {
+    readonly props: PluginDefinitionProps<TName, TVersion, TConfig, TStates, TEvents, TActions, TInterfaces, TIntegrations, TTables, TWorkflows>;
     readonly name: this['props']['name'];
     readonly version: this['props']['version'];
     readonly title: this['props']['title'];
@@ -59,5 +67,6 @@ export declare class PluginDefinition<TName extends string = string, TVersion ex
     readonly recurringEvents: this['props']['recurringEvents'];
     readonly actions: this['props']['actions'];
     readonly tables: this['props']['tables'];
-    constructor(props: PluginDefinitionProps<TName, TVersion, TConfig, TStates, TEvents, TActions, TInterfaces, TIntegrations, TTables>);
+    readonly workflows: this['props']['workflows'];
+    constructor(props: PluginDefinitionProps<TName, TVersion, TConfig, TStates, TEvents, TActions, TInterfaces, TIntegrations, TTables, TWorkflows>);
 }

package/dist/plugin/implementation.d.ts

@@ -1,13 +1,23 @@
-import { MessageHandlersMap as BotMessageHandlersMap, EventHandlersMap as BotEventHandlersMap, StateExpiredHandlersMap as BotStateExpiredHandlersMap, HookHandlersMap as BotHookHandlersMap, ActionHandlers as BotActionHandlers, BotHandlers } from '../bot';
+import type { MessageHandlersMap as BotMessageHandlersMap, EventHandlersMap as BotEventHandlersMap, StateExpiredHandlersMap as BotStateExpiredHandlersMap, HookHandlersMap as BotHookHandlersMap, ActionHandlers as BotActionHandlers, BotHandlers, WorkflowHandlersMap as BotWorkflowHandlersMap, WorkflowHandlersFnMap as BotWorkflowHandlersFnMap } from '../bot';
+import { WorkflowProxy } from '../bot/workflow-proxy';
+import { ActionProxy } from './action-proxy';
 import { BasePlugin, PluginInterfaceExtensions } from './common';
 import { MessageHandlersMap, MessageHandlers, EventHandlersMap, EventHandlers, StateExpiredHandlersMap, StateExpiredHandlers, HookData, HookHandlers, ActionHandlers, PluginConfiguration } from './server/types';
 export type PluginImplementationProps<TPlugin extends BasePlugin = BasePlugin> = {
     actions: ActionHandlers<TPlugin>;
 };
 export type PluginRuntimeProps<TPlugin extends BasePlugin = BasePlugin> = {
+    alias?: string;
     configuration: PluginConfiguration<TPlugin>;
     interfaces: PluginInterfaceExtensions<TPlugin>;
 };
+type Tools<TPlugin extends BasePlugin = BasePlugin> = {
+    configuration: PluginConfiguration<TPlugin>;
+    interfaces: PluginInterfaceExtensions<TPlugin>;
+    actions: ActionProxy<TPlugin>;
+    workflows: WorkflowProxy<TPlugin>;
+    alias?: string;
+};
 export declare class PluginImplementation<TPlugin extends BasePlugin = BasePlugin> implements BotHandlers<TPlugin> {
     readonly props: PluginImplementationProps<TPlugin>;
     private _runtimeProps;
@@ -16,8 +26,9 @@ export declare class PluginImplementation<TPlugin extends BasePlugin = BasePlugi
     private _eventHandlers;
     private _stateExpiredHandlers;
     private _hookHandlers;
+    private _workflowHandlers;
     constructor(props: PluginImplementationProps<TPlugin>);
-    initialize(config: PluginRuntimeProps<TPlugin>): this;
+    initialize(props: PluginRuntimeProps<TPlugin>): this;
     private get _runtime();
     private _getTools;
     get actionHandlers(): BotActionHandlers<TPlugin>;
@@ -25,8 +36,14 @@ export declare class PluginImplementation<TPlugin extends BasePlugin = BasePlugi
     get eventHandlers(): BotEventHandlersMap<TPlugin>;
     get stateExpiredHandlers(): BotStateExpiredHandlersMap<TPlugin>;
     get hookHandlers(): BotHookHandlersMap<TPlugin>;
+    get workflowHandlers(): BotWorkflowHandlersMap<TPlugin>;
     readonly on: {
         message: <T extends keyof MessageHandlersMap<TPlugin>>(type: T, handler: MessageHandlers<TPlugin>[T]) => void;
+        /**
+         * # EXPERIMENTAL
+         * This API is experimental and may change in the future.
+         */
+        workflows: BotWorkflowHandlersFnMap<TPlugin, Tools<TPlugin>>;
         event: <T extends keyof EventHandlersMap<TPlugin>>(type: T, handler: EventHandlers<TPlugin>[T]) => void;
         stateExpired: <T extends keyof StateExpiredHandlersMap<TPlugin>>(type: T, handler: StateExpiredHandlers<TPlugin>[T]) => void;
         beforeIncomingEvent: <T extends keyof HookData<TPlugin>["before_incoming_event"]>(type: T, handler: HookHandlers<TPlugin>["before_incoming_event"][T]) => void;
@@ -42,4 +59,6 @@ export declare class PluginImplementation<TPlugin extends BasePlugin = BasePlugi
      * checks if the actual event resolves to the target event
      */
     private _eventResolvesTo;
+    private _stripAliasPrefix;
 }
+export {};

package/dist/plugin/server/types.d.ts

@@ -1,7 +1,8 @@
 import * as client from '@botpress/client';
 import * as bot from '../../bot';
+import * as workflowProxy from '../../bot/workflow-proxy';
 import * as utils from '../../utils/type-utils';
-import * as proxy from '../action-proxy';
+import * as actionProxy from '../action-proxy';
 import * as common from '../common';
 type EnumeratePluginEvents<TPlugin extends common.BasePlugin> = bot.EnumerateEvents<TPlugin> & common.EnumerateInterfaceEvents<TPlugin>;
 type _IncomingEvents<TPlugin extends common.BasePlugin> = {
@@ -82,7 +83,13 @@ export type CommonHandlerProps<TPlugin extends common.BasePlugin> = {
     client: PluginClient<TPlugin>;
     configuration: PluginConfiguration<TPlugin>;
     interfaces: common.PluginInterfaceExtensions<TPlugin>;
-    actions: proxy.ActionProxy<TPlugin>;
+    actions: actionProxy.ActionProxy<TPlugin>;
+    /**
+     * # EXPERIMENTAL
+     * This API is experimental and may change in the future.
+     */
+    workflows: workflowProxy.WorkflowProxy<TPlugin>;
+    alias: string;
 };
 export type MessagePayloads<TPlugin extends common.BasePlugin> = {
     [K in keyof IncomingMessages<TPlugin>]: CommonHandlerProps<TPlugin> & {

package/dist/utils/record-utils.d.ts

@@ -1,5 +1,6 @@
 export declare const pairs: <K extends string, V>(obj: Record<K, V>) => [K, V][];
 export declare const values: <K extends string, V>(obj: Record<K, V>) => V[];
 export declare const mapValues: <K extends string, V, R>(obj: Record<K, V>, fn: (value: V, key: K) => R) => Record<K, R>;
+export declare const mapKeys: <K1 extends string, K2 extends string, V>(obj: Record<K1, V>, fn: (key: K1) => K2) => Record<K2, V>;
 export declare const stripUndefinedProps: <K extends string, V>(obj: Record<K, V | undefined>) => Record<K, V>;
 export declare const mergeRecords: <K extends string, V>(a: Record<K, V>, b: Record<K, V>, merge: (v1: V, v2: V) => V) => Record<K, V>;

package/dist/utils/type-utils.d.ts

@@ -7,12 +7,12 @@ export type Writable<T> = {
 };
 export type Default<T, U> = undefined extends T ? U : T;
 export type AtLeastOne<T> = [T, ...T[]];
-export type AtLeastOneProperty<T> = {
+export type AtLeastOneProperty<T> = T extends undefined ? {} : {
     [K in keyof T]?: T[K];
 } & {
     [K in keyof T]: Pick<T, K>;
 }[keyof T];
-export type ExactlyOneProperty<T> = {
+export type ExactlyOneProperty<T> = T extends undefined ? {} : {
     [K in keyof T]: {
         [P in K]: T[P];
     } & {
@@ -45,4 +45,5 @@ type DeepPartialObject<T extends object> = T extends infer O ? {
 } : never;
 export type DeepPartial<T> = T extends (...args: infer A) => infer R ? (...args: DeepPartial<A>) => DeepPartial<R> : T extends Array<infer E> ? Array<DeepPartial<E>> : T extends ReadonlyArray<infer E> ? ReadonlyArray<DeepPartial<E>> : T extends Promise<infer R> ? Promise<DeepPartial<R>> : T extends Buffer ? Buffer : T extends object ? DeepPartialObject<T> : T;
 export type SafeOmit<T, K extends keyof T> = Omit<T, K>;
+export type StringKeys<T> = Extract<keyof T, string>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botpress/sdk",
-  "version": "3.4.0",
+  "version": "3.5.0",
   "description": "Botpress SDK",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -16,7 +16,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@botpress/client": "0.47.0",
+    "@botpress/client": "0.48.0",
     "browser-or-node": "^2.1.1"
   },
   "devDependencies": {