@botpress/sdk 3.4.0 → 3.5.1

package/.turbo/turbo-build.log

@@ -1,18 +1,18 @@
 
-> @botpress/sdk@3.4.0 build /home/runner/work/botpress/botpress/packages/sdk
+> @botpress/sdk@3.5.1 build /home/runner/work/botpress/botpress/packages/sdk
 > pnpm build:type && pnpm build:node && pnpm build:browser
 
 
-> @botpress/sdk@3.4.0 build:type /home/runner/work/botpress/botpress/packages/sdk
+> @botpress/sdk@3.5.1 build:type /home/runner/work/botpress/botpress/packages/sdk
 > tsc --emitDeclarationOnly --declaration
 
 
-> @botpress/sdk@3.4.0 build:node /home/runner/work/botpress/botpress/packages/sdk
+> @botpress/sdk@3.5.1 build:node /home/runner/work/botpress/botpress/packages/sdk
 > ts-node -T ./build.ts --node
 
 Done
 
-> @botpress/sdk@3.4.0 build:browser /home/runner/work/botpress/botpress/packages/sdk
+> @botpress/sdk@3.5.1 build:browser /home/runner/work/botpress/botpress/packages/sdk
 > ts-node -T ./build.ts --browser
 
 Done

package/dist/bot/client/index.d.ts

@@ -49,6 +49,11 @@ export declare class BotSpecificClient<TBot extends common.BaseBot> implements t
     deleteTableRows: types.DeleteTableRows<TBot>;
     updateTableRows: types.UpdateTableRows<TBot>;
     upsertTableRows: types.UpsertTableRows<TBot>;
+    createWorkflow: types.CreateWorkflow<TBot>;
+    getWorkflow: types.GetWorkflow<TBot>;
+    updateWorkflow: types.UpdateWorkflow<TBot>;
+    deleteWorkflow: types.DeleteWorkflow<TBot>;
+    listWorkflows: types.ListWorkflows<TBot>;
     /**
      * @deprecated Use `callAction` to delegate the conversation creation to an integration.
      */

package/dist/bot/client/types.d.ts

@@ -90,6 +90,22 @@ export type ListFiles<_TBot extends common.BaseBot> = client.Client['listFiles']
 export type GetFile<_TBot extends common.BaseBot> = client.Client['getFile'];
 export type UpdateFileMetadata<_TBot extends common.BaseBot> = client.Client['updateFileMetadata'];
 export type SearchFiles<_TBot extends common.BaseBot> = client.Client['searchFiles'];
+export type CreateWorkflow<TBot extends common.BaseBot> = <TWorkflowName extends utils.StringKeys<TBot['workflows']>>(x: utils.Merge<Arg<client.Client['createWorkflow']>, {
+    name: utils.Cast<TWorkflowName, string>;
+    input: utils.Cast<TBot['workflows'][TWorkflowName], common.IntegrationInstanceActionDefinition>['input'];
+    tags?: utils.AtLeastOneProperty<TBot['workflows'][TWorkflowName]['tags']>;
+}>) => Promise<Readonly<{
+    workflow: utils.Merge<Awaited<Res<client.Client['createWorkflow']>>['workflow'], {
+        name: NoInfer<TWorkflowName>;
+    }>;
+}>>;
+export type GetWorkflow<_TBot extends common.BaseBot> = client.Client['getWorkflow'];
+export type UpdateWorkflow<_TBot extends common.BaseBot> = client.Client['updateWorkflow'];
+export type DeleteWorkflow<_TBot extends common.BaseBot> = client.Client['deleteWorkflow'];
+export type ListWorkflows<TBot extends common.BaseBot> = <TWorkflowName extends utils.StringKeys<TBot['workflows']>>(x: utils.Merge<Arg<client.Client['listWorkflows']>, {
+    name?: utils.Cast<TWorkflowName, string>;
+    tags?: utils.AtLeastOneProperty<TBot['workflows'][TWorkflowName]['tags']>;
+}>) => Promise<Readonly<Awaited<Res<client.Client['listWorkflows']>>>>;
 export type GetTableRow<TBot extends common.BaseBot> = <TableName extends keyof common.EnumerateTables<TBot>, Columns = utils.Cast<common.EnumerateTables<TBot>[TableName], Record<string, any>>>(x: utils.Merge<Arg<client.Client['getTableRow']>, {
     table: utils.Cast<TableName, string>;
     id: client.Row['id'];

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

@@ -8,12 +8,20 @@ export type BaseAction = {
 export type BaseTable = {
     [k: string]: any;
 };
+export type BaseWorkflow = {
+    input: any;
+    output: any;
+    tags?: {
+        [k: string]: string;
+    };
+};
 export type BaseBot = {
     integrations: Record<string, BaseIntegration>;
     events: Record<string, any>;
     states: Record<string, any>;
     actions: Record<string, BaseAction>;
     tables: Record<string, BaseTable>;
+    workflows: Record<string, BaseWorkflow>;
 };
 export type InputBaseBot = utils.DeepPartial<BaseBot>;
 export type DefaultBot<B extends InputBaseBot> = {
@@ -24,4 +32,5 @@ export type DefaultBot<B extends InputBaseBot> = {
         [K in keyof B['integrations']]: DefaultIntegration<utils.Cast<B['integrations'][K], InputBaseIntegration>>;
     };
     tables: utils.Default<B['tables'], BaseBot['tables']>;
+    workflows: utils.Default<B['workflows'], BaseBot['workflows']>;
 };

package/dist/bot/definition.d.ts

@@ -9,6 +9,7 @@ type BaseStates = Record<string, ZuiObjectSchema>;
 type BaseEvents = Record<string, ZuiObjectSchema>;
 type BaseActions = Record<string, ZuiObjectSchema>;
 type BaseTables = Record<string, ZuiObjectSchema>;
+type BaseWorkflows = Record<string, ZuiObjectSchema>;
 export type TagDefinition = {
     title?: string;
     description?: string;
@@ -44,6 +45,13 @@ export type ActionDefinition<TAction extends BaseActions[string] = BaseActions[s
     input: SchemaDefinition<TAction>;
     output: SchemaDefinition<ZuiObjectSchema>;
 };
+export type WorkflowDefinition<TWorkflow extends BaseWorkflows[string] = BaseWorkflows[string]> = {
+    title?: string;
+    description?: string;
+    input: SchemaDefinition<TWorkflow>;
+    output: SchemaDefinition<ZuiObjectSchema>;
+    tags?: Record<string, TagDefinition>;
+};
 export type TableDefinition<TTable extends BaseTables[string] = BaseTables[string]> = Merge<Omit<Table, 'id' | 'createdAt' | 'updatedAt' | 'name'>, {
     schema: TTable;
 }>;
@@ -59,6 +67,7 @@ export type IntegrationConfigInstance<I extends IntegrationPackage = Integration
     };
 }>);
 export type PluginConfigInstance<P extends PluginPackage = PluginPackage> = {
+    alias?: string;
     configuration: z.infer<NonNullable<P['definition']['configuration']>['schema']>;
     interfaces: {
         [I in keyof NonNullable<P['definition']['interfaces']>]: PluginInterfaceExtension;
@@ -66,7 +75,7 @@ export type PluginConfigInstance<P extends PluginPackage = PluginPackage> = {
 };
 export type IntegrationInstance = IntegrationPackage & IntegrationConfigInstance;
 export type PluginInstance = PluginPackage & PluginConfigInstance;
-export type BotDefinitionProps<TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TTables extends BaseTables = BaseTables> = {
+export type BotDefinitionProps<TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TTables extends BaseTables = BaseTables, TWorkflows extends BaseWorkflows = BaseWorkflows> = {
     integrations?: {
         [K: string]: IntegrationInstance;
     };
@@ -90,9 +99,16 @@ export type BotDefinitionProps<TStates extends BaseStates = BaseStates, TEvents
     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 BotDefinition<TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TTables extends BaseTables = BaseTables> {
-    readonly props: BotDefinitionProps<TStates, TEvents, TActions, TTables>;
+export declare class BotDefinition<TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TTables extends BaseTables = BaseTables, TWorkflows extends BaseWorkflows = BaseWorkflows> {
+    readonly props: BotDefinitionProps<TStates, TEvents, TActions, TTables, TWorkflows>;
     readonly integrations: this['props']['integrations'];
     readonly plugins: this['props']['plugins'];
     readonly user: this['props']['user'];
@@ -104,7 +120,8 @@ export declare class BotDefinition<TStates extends BaseStates = BaseStates, TEve
     readonly recurringEvents: this['props']['recurringEvents'];
     readonly actions: this['props']['actions'];
     readonly tables: this['props']['tables'];
-    constructor(props: BotDefinitionProps<TStates, TEvents, TActions, TTables>);
+    readonly workflows: this['props']['workflows'];
+    constructor(props: BotDefinitionProps<TStates, TEvents, TActions, TTables, TWorkflows>);
     addIntegration<I extends IntegrationPackage>(integrationPkg: I, config: IntegrationConfigInstance<I>): this;
     addPlugin<P extends PluginPackage>(pluginPkg: P, config: PluginConfigInstance<P>): this;
     private _mergeUser;
@@ -115,5 +132,7 @@ export declare class BotDefinition<TStates extends BaseStates = BaseStates, TEve
     private _mergeRecurringEvents;
     private _mergeActions;
     private _mergeTables;
+    private _mergeWorkflows;
+    private _prefixKeys;
 }
 export {};

package/dist/bot/implementation.d.ts

@@ -1,11 +1,12 @@
 import type { Server } from 'node:http';
 import { BasePlugin, PluginImplementation } from '../plugin';
+import * as utils from '../utils';
 import { BaseBot } from './common';
-import { MessageHandlersMap, MessageHandlers, EventHandlersMap, EventHandlers, StateExpiredHandlersMap, StateExpiredHandlers, HookHandlersMap, HookData, HookHandlers, ActionHandlers, BotHandlers, UnimplementedActionHandlers } from './server';
+import { ActionHandlers, MessageHandlers, EventHandlers, StateExpiredHandlers, HookHandlers, WorkflowHandlers, MessageHandlersMap, EventHandlersMap, StateExpiredHandlersMap, HookHandlersMap, WorkflowHandlersMap, BotHandlers, UnimplementedActionHandlers } from './server';
 export type BotImplementationProps<TBot extends BaseBot = BaseBot, TPlugins extends Record<string, BasePlugin> = {}> = {
     actions: UnimplementedActionHandlers<TBot, TPlugins>;
     plugins: {
-        [K in keyof TPlugins]: PluginImplementation<TPlugins[K]>;
+        [K in utils.types.StringKeys<TPlugins>]: PluginImplementation<TPlugins[K]>;
     };
 };
 export declare class BotImplementation<TBot extends BaseBot = BaseBot, TPlugins extends Record<string, BasePlugin> = {}> implements BotHandlers<TBot> {
@@ -15,25 +16,43 @@ export declare class BotImplementation<TBot extends BaseBot = BaseBot, TPlugins
     private _eventHandlers;
     private _stateExpiredHandlers;
     private _hookHandlers;
+    private _workflowHandlers;
     private _plugins;
+    private _registerOrder;
     constructor(props: BotImplementationProps<TBot, TPlugins>);
     get actionHandlers(): ActionHandlers<TBot>;
     get messageHandlers(): MessageHandlersMap<TBot>;
     get eventHandlers(): EventHandlersMap<TBot>;
     get stateExpiredHandlers(): StateExpiredHandlersMap<TBot>;
     get hookHandlers(): HookHandlersMap<TBot>;
+    get workflowHandlers(): WorkflowHandlersMap<TBot>;
     readonly on: {
-        message: <T extends keyof MessageHandlersMap<TBot>>(type: T, handler: MessageHandlers<TBot>[T]) => void;
-        event: <T extends keyof EventHandlersMap<TBot>>(type: T, handler: EventHandlers<TBot>[T]) => void;
-        stateExpired: <T extends keyof StateExpiredHandlersMap<TBot>>(type: T, handler: StateExpiredHandlers<TBot>[T]) => void;
-        beforeIncomingEvent: <T extends keyof HookData<TBot>["before_incoming_event"]>(type: T, handler: HookHandlers<TBot>["before_incoming_event"][T]) => void;
-        beforeIncomingMessage: <T extends keyof HookData<TBot>["before_incoming_message"]>(type: T, handler: HookHandlers<TBot>["before_incoming_message"][T]) => void;
-        beforeOutgoingMessage: <T extends keyof HookData<TBot>["before_outgoing_message"]>(type: T, handler: HookHandlers<TBot>["before_outgoing_message"][T]) => void;
-        beforeOutgoingCallAction: <T extends keyof HookData<TBot>["before_outgoing_call_action"]>(type: T, handler: HookHandlers<TBot>["before_outgoing_call_action"][T]) => void;
-        afterIncomingEvent: <T extends keyof HookData<TBot>["after_incoming_event"]>(type: T, handler: HookHandlers<TBot>["after_incoming_event"][T]) => void;
-        afterIncomingMessage: <T extends keyof HookData<TBot>["after_incoming_message"]>(type: T, handler: HookHandlers<TBot>["after_incoming_message"][T]) => void;
-        afterOutgoingMessage: <T extends keyof HookData<TBot>["after_outgoing_message"]>(type: T, handler: HookHandlers<TBot>["after_outgoing_message"][T]) => void;
-        afterOutgoingCallAction: <T extends keyof HookData<TBot>["after_outgoing_call_action"]>(type: T, handler: HookHandlers<TBot>["after_outgoing_call_action"][T]) => void;
+        message: <T extends utils.types.StringKeys<MessageHandlersMap<TBot>>>(type: T, handler: MessageHandlers<TBot>[T]) => void;
+        event: <T extends utils.types.StringKeys<EventHandlersMap<TBot>>>(type: T, handler: EventHandlers<TBot>[T]) => void;
+        stateExpired: <T extends utils.types.StringKeys<StateExpiredHandlersMap<TBot>>>(type: T, handler: StateExpiredHandlers<TBot>[T]) => void;
+        beforeIncomingEvent: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["before_incoming_event"]>>(type: T, handler: HookHandlers<TBot>["before_incoming_event"][T]) => void;
+        beforeIncomingMessage: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["before_incoming_message"]>>(type: T, handler: HookHandlers<TBot>["before_incoming_message"][T]) => void;
+        beforeOutgoingMessage: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["before_outgoing_message"]>>(type: T, handler: HookHandlers<TBot>["before_outgoing_message"][T]) => void;
+        beforeOutgoingCallAction: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["before_outgoing_call_action"]>>(type: T, handler: HookHandlers<TBot>["before_outgoing_call_action"][T]) => void;
+        afterIncomingEvent: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["after_incoming_event"]>>(type: T, handler: HookHandlers<TBot>["after_incoming_event"][T]) => void;
+        afterIncomingMessage: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["after_incoming_message"]>>(type: T, handler: HookHandlers<TBot>["after_incoming_message"][T]) => void;
+        afterOutgoingMessage: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["after_outgoing_message"]>>(type: T, handler: HookHandlers<TBot>["after_outgoing_message"][T]) => void;
+        afterOutgoingCallAction: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["after_outgoing_call_action"]>>(type: T, handler: HookHandlers<TBot>["after_outgoing_call_action"][T]) => void;
+        /**
+         * # EXPERIMENTAL
+         * This API is experimental and may change in the future.
+         */
+        workflowStart: <T extends utils.types.StringKeys<WorkflowHandlersMap<TBot>["started"]>>(type: T, handler: WorkflowHandlers<TBot>[T]) => void;
+        /**
+         * # EXPERIMENTAL
+         * This API is experimental and may change in the future.
+         */
+        workflowContinue: <T extends utils.types.StringKeys<WorkflowHandlersMap<TBot>["continued"]>>(type: T, handler: WorkflowHandlers<TBot>[T]) => void;
+        /**
+         * # EXPERIMENTAL
+         * This API is experimental and may change in the future.
+         */
+        workflowTimeout: <T extends utils.types.StringKeys<WorkflowHandlersMap<TBot>["timed_out"]>>(type: T, handler: WorkflowHandlers<TBot>[T]) => void;
     };
     readonly handler: (req: import("../serve").Request) => Promise<import("../serve").Response | void>;
     readonly start: (port?: number) => Promise<Server>;

package/dist/bot/server/responses.d.ts

@@ -0,0 +1,3 @@
+export declare const SUCCESS_RESPONSE: {
+    readonly status: 200;
+};

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

@@ -1,9 +1,11 @@
 import * as client from '@botpress/client';
 import * as plugin from '../../plugin';
+import type { Request } from '../../serve';
 import * as utils from '../../utils/type-utils';
 import { type BotLogger } from '../bot-logger';
 import { BotSpecificClient } from '../client';
 import * as common from '../common';
+import type * as workflowProxy from '../workflow-proxy/types';
 export type BotOperation = 'event_received' | 'register' | 'unregister' | 'ping' | 'action_triggered';
 export type BotContext = {
     botId: string;
@@ -14,31 +16,31 @@ export type BotContext = {
     };
 };
 type _IncomingEvents<TBot extends common.BaseBot> = {
-    [K in keyof common.EnumerateEvents<TBot>]: utils.Merge<client.Event, {
+    [K in utils.StringKeys<common.EnumerateEvents<TBot>>]: utils.Merge<client.Event, {
         type: K;
         payload: common.EnumerateEvents<TBot>[K];
     }>;
 };
 type _IncomingMessages<TBot extends common.BaseBot> = {
-    [K in keyof common.GetMessages<TBot>]: utils.Merge<client.Message, {
+    [K in utils.StringKeys<common.GetMessages<TBot>>]: utils.Merge<client.Message, {
         type: K;
         payload: common.GetMessages<TBot>[K];
     }>;
 };
 type _IncomingStates<TBot extends common.BaseBot> = {
-    [K in keyof common.EnumerateStates<TBot>]: utils.Merge<client.State, {
+    [K in utils.StringKeys<common.EnumerateStates<TBot>>]: utils.Merge<client.State, {
         name: K;
         payload: common.EnumerateStates<TBot>[K];
     }>;
 };
 type _OutgoingMessageRequests<TBot extends common.BaseBot> = {
-    [K in keyof common.GetMessages<TBot>]: utils.Merge<client.ClientInputs['createMessage'], {
+    [K in utils.StringKeys<common.GetMessages<TBot>>]: utils.Merge<client.ClientInputs['createMessage'], {
         type: K;
         payload: common.GetMessages<TBot>[K];
     }>;
 };
 type _OutgoingMessageResponses<TBot extends common.BaseBot> = {
-    [K in keyof common.GetMessages<TBot>]: utils.Merge<client.ClientOutputs['createMessage'], {
+    [K in utils.StringKeys<common.GetMessages<TBot>>]: utils.Merge<client.ClientOutputs['createMessage'], {
         message: utils.Merge<client.Message, {
             type: K;
             payload: common.GetMessages<TBot>[K];
@@ -46,13 +48,13 @@ type _OutgoingMessageResponses<TBot extends common.BaseBot> = {
     }>;
 };
 type _OutgoingCallActionRequests<TBot extends common.BaseBot> = {
-    [K in keyof common.EnumerateActionInputs<TBot>]: utils.Merge<client.ClientInputs['callAction'], {
+    [K in utils.StringKeys<common.EnumerateActionInputs<TBot>>]: utils.Merge<client.ClientInputs['callAction'], {
         type: K;
         input: common.EnumerateActionInputs<TBot>[K];
     }>;
 };
 type _OutgoingCallActionResponses<TBot extends common.BaseBot> = {
-    [K in keyof common.EnumerateActionOutputs<TBot>]: utils.Merge<client.ClientOutputs['callAction'], {
+    [K in utils.StringKeys<common.EnumerateActionOutputs<TBot>>]: utils.Merge<client.ClientOutputs['callAction'], {
         output: common.EnumerateActionOutputs<TBot>[K];
     }>;
 };
@@ -88,15 +90,20 @@ export type CommonHandlerProps<TBot extends common.BaseBot> = {
     ctx: BotContext;
     logger: BotLogger;
     client: BotClient<TBot>;
+    /**
+     * # EXPERIMENTAL
+     * This API is experimental and may change in the future.
+     */
+    workflows: workflowProxy.WorkflowProxy<TBot>;
 };
 export type MessagePayloads<TBot extends common.BaseBot> = {
-    [K in keyof IncomingMessages<TBot>]: CommonHandlerProps<TBot> & {
-        message: IncomingMessages<TBot>[K];
+    [TMessageName in utils.StringKeys<IncomingMessages<TBot>>]: CommonHandlerProps<TBot> & {
+        message: IncomingMessages<TBot>[TMessageName];
         user: client.User;
         conversation: client.Conversation;
         event: client.Event;
         states: {
-            [TState in keyof TBot['states']]: {
+            [TState in utils.StringKeys<TBot['states']>]: {
                 type: 'user' | 'conversation' | 'bot';
                 payload: TBot['states'][TState];
             };
@@ -104,32 +111,58 @@ export type MessagePayloads<TBot extends common.BaseBot> = {
     };
 };
 export type MessageHandlers<TBot extends common.BaseBot> = {
-    [K in keyof IncomingMessages<TBot>]: (args: MessagePayloads<TBot>[K]) => Promise<void>;
+    [TMessageName in utils.StringKeys<IncomingMessages<TBot>>]: (args: MessagePayloads<TBot>[TMessageName]) => Promise<void>;
 };
 export type EventPayloads<TBot extends common.BaseBot> = {
-    [K in keyof IncomingEvents<TBot>]: CommonHandlerProps<TBot> & {
-        event: IncomingEvents<TBot>[K];
+    [TEventName in utils.StringKeys<IncomingEvents<TBot>>]: CommonHandlerProps<TBot> & {
+        event: IncomingEvents<TBot>[TEventName];
     };
 };
 export type EventHandlers<TBot extends common.BaseBot> = {
-    [K in keyof IncomingEvents<TBot>]: (args: EventPayloads<TBot>[K]) => Promise<void>;
+    [TEventName in utils.StringKeys<IncomingEvents<TBot>>]: (args: EventPayloads<TBot>[TEventName]) => Promise<void>;
 };
 export type StateExpiredPayloads<TBot extends common.BaseBot> = {
-    [K in keyof IncomingStates<TBot>]: CommonHandlerProps<TBot> & {
-        state: IncomingStates<TBot>[K];
+    [TSateName in utils.StringKeys<IncomingStates<TBot>>]: CommonHandlerProps<TBot> & {
+        state: IncomingStates<TBot>[TSateName];
     };
 };
 export type StateExpiredHandlers<TBot extends common.BaseBot> = {
-    [K in keyof IncomingStates<TBot>]: (args: StateExpiredPayloads<TBot>[K]) => Promise<void>;
+    [TSateName in utils.StringKeys<IncomingStates<TBot>>]: (args: StateExpiredPayloads<TBot>[TSateName]) => Promise<void>;
 };
 export type ActionHandlerPayloads<TBot extends common.BaseBot> = {
-    [K in keyof TBot['actions']]: CommonHandlerProps<TBot> & {
-        type?: K;
-        input: TBot['actions'][K]['input'];
+    [TActionName in utils.StringKeys<TBot['actions']>]: CommonHandlerProps<TBot> & {
+        type?: TActionName;
+        input: TBot['actions'][TActionName]['input'];
     };
 };
 export type ActionHandlers<TBot extends common.BaseBot> = {
-    [K in keyof TBot['actions']]: (props: ActionHandlerPayloads<TBot>[K]) => Promise<TBot['actions'][K]['output']>;
+    [TActionName in utils.StringKeys<TBot['actions']>]: (props: ActionHandlerPayloads<TBot>[TActionName]) => Promise<TBot['actions'][TActionName]['output']>;
+};
+export type BridgeWorkflowUpdateType = 'child_workflow_deleted' | 'child_workflow_finished' | 'workflow_timedout' | 'workflow_started' | 'workflow_continued';
+export type WorkflowUpdateEventPayload = {
+    type: BridgeWorkflowUpdateType;
+    childWorkflow?: client.Workflow;
+    workflow: client.Workflow;
+    conversation?: client.Conversation;
+    user?: client.User;
+};
+export type WorkflowUpdateEvent = utils.Merge<client.Event, {
+    type: 'workflow_update';
+    payload: WorkflowUpdateEventPayload;
+}>;
+export type WorkflowPayloads<TBot extends common.BaseBot> = {
+    [TWorkflowName in utils.StringKeys<TBot['workflows']>]: CommonHandlerProps<TBot> & {
+        conversation?: client.Conversation;
+        user?: client.User;
+        /**
+         * # EXPERIMENTAL
+         * This API is experimental and may change in the future.
+         */
+        workflow: workflowProxy.WorkflowWithUtilities<TBot, TWorkflowName>;
+    };
+};
+export type WorkflowHandlers<TBot extends common.BaseBot> = {
+    [TWorkflowName in utils.StringKeys<TBot['workflows']>]: (props: WorkflowPayloads<TBot>[TWorkflowName]) => Promise<void>;
 };
 type BaseHookDefinition = {
     stoppable?: boolean;
@@ -196,43 +229,83 @@ export type HookDefinitions<TBot extends common.BaseBot> = {
     }>;
 };
 export type HookData<TBot extends common.BaseBot> = {
-    [H in keyof HookDefinitions<TBot>]: {
-        [T in keyof HookDefinitions<TBot>[H]['data']]: HookDefinitions<TBot>[H]['data'][T];
+    [THookType in utils.StringKeys<HookDefinitions<TBot>>]: {
+        [THookDataName in utils.StringKeys<HookDefinitions<TBot>[THookType]['data']>]: HookDefinitions<TBot>[THookType]['data'][THookDataName];
     };
 };
 export type HookInputs<TBot extends common.BaseBot> = {
-    [H in keyof HookData<TBot>]: {
-        [T in keyof HookData<TBot>[H]]: CommonHandlerProps<TBot> & {
-            data: HookData<TBot>[H][T];
+    [THookType in utils.StringKeys<HookData<TBot>>]: {
+        [THookDataName in utils.StringKeys<HookData<TBot>[THookType]>]: CommonHandlerProps<TBot> & {
+            data: HookData<TBot>[THookType][THookDataName];
         };
     };
 };
 export type HookOutputs<TBot extends common.BaseBot> = {
-    [H in keyof HookData<TBot>]: {
-        [T in keyof HookData<TBot>[H]]: {
-            data?: HookData<TBot>[H][T];
-        } & (HookDefinitions<TBot>[H]['stoppable'] extends true ? {
+    [THookType in utils.StringKeys<HookData<TBot>>]: {
+        [THookDataName in utils.StringKeys<HookData<TBot>[THookType]>]: {
+            data?: HookData<TBot>[THookType][THookDataName];
+        } & (HookDefinitions<TBot>[THookType]['stoppable'] extends true ? {
             stop?: boolean;
         } : {});
     };
 };
 export type HookHandlers<TBot extends common.BaseBot> = {
-    [H in keyof HookData<TBot>]: {
-        [T in keyof HookData<TBot>[H]]: (input: HookInputs<TBot>[H][T]) => Promise<HookOutputs<TBot>[H][T] | undefined>;
+    [THookType in utils.StringKeys<HookData<TBot>>]: {
+        [THookDataName in utils.StringKeys<HookData<TBot>[THookType]>]: (input: HookInputs<TBot>[THookType][THookDataName]) => Promise<HookOutputs<TBot>[THookType][THookDataName] | undefined>;
     };
 };
 export type MessageHandlersMap<TBot extends common.BaseBot> = {
-    [T in keyof IncomingMessages<TBot>]?: MessageHandlers<TBot>[T][];
+    [TMessageName in utils.StringKeys<IncomingMessages<TBot>>]?: MessageHandlers<TBot>[TMessageName][];
 };
 export type EventHandlersMap<TBot extends common.BaseBot> = {
-    [T in keyof IncomingEvents<TBot>]?: EventHandlers<TBot>[T][];
+    [TEventName in utils.StringKeys<IncomingEvents<TBot>>]?: EventHandlers<TBot>[TEventName][];
 };
 export type StateExpiredHandlersMap<TBot extends common.BaseBot> = {
-    [T in keyof IncomingStates<TBot>]?: StateExpiredHandlers<TBot>[T][];
+    [TStateName in utils.StringKeys<IncomingStates<TBot>>]?: StateExpiredHandlers<TBot>[TStateName][];
 };
 export type HookHandlersMap<TBot extends common.BaseBot> = {
-    [H in keyof HookData<TBot>]: {
-        [T in keyof HookData<TBot>[H]]?: HookHandlers<TBot>[H][T][];
+    [THookType in utils.StringKeys<HookData<TBot>>]: {
+        [THookDataName in utils.StringKeys<HookData<TBot>[THookType]>]?: HookHandlers<TBot>[THookType][THookDataName][];
+    };
+};
+export type WorkflowUpdateType = 'started' | 'continued' | 'timed_out';
+export type WorkflowHandlersMap<TBot extends common.BaseBot> = {
+    [TWorkflowUpdateType in WorkflowUpdateType]: {
+        [TWorkflowName in utils.StringKeys<TBot['workflows']>]?: WorkflowHandlers<TBot>[TWorkflowName][];
+    };
+};
+export type OrderedMessageHandlersMap<TBot extends common.BaseBot> = {
+    [TMessageName in utils.StringKeys<IncomingMessages<TBot>>]?: {
+        handler: MessageHandlers<TBot>[TMessageName];
+        order: number;
+    }[];
+};
+export type OrderedEventHandlersMap<TBot extends common.BaseBot> = {
+    [TEventName in utils.StringKeys<IncomingEvents<TBot>>]?: {
+        handler: EventHandlers<TBot>[TEventName];
+        order: number;
+    }[];
+};
+export type OrderedStateExpiredHandlersMap<TBot extends common.BaseBot> = {
+    [TStateName in utils.StringKeys<IncomingStates<TBot>>]?: {
+        handler: StateExpiredHandlers<TBot>[TStateName];
+        order: number;
+    }[];
+};
+export type OrderedHookHandlersMap<TBot extends common.BaseBot> = {
+    [THookType in utils.StringKeys<HookData<TBot>>]: {
+        [THookDataName in utils.StringKeys<HookData<TBot>[THookType]>]?: {
+            handler: HookHandlers<TBot>[THookType][THookDataName];
+            order: number;
+        }[];
+    };
+};
+export type OrderedWorkflowHandlersMap<TBot extends common.BaseBot> = {
+    [TWorkflowUpdateType in WorkflowUpdateType]: {
+        [TWorkflowName in utils.StringKeys<TBot['workflows']>]?: {
+            handler: WorkflowHandlers<TBot>[TWorkflowName];
+            order: number;
+        }[];
     };
 };
 /**
@@ -246,15 +319,23 @@ export type BotHandlers<TBot extends common.BaseBot> = {
     eventHandlers: EventHandlersMap<TBot>;
     stateExpiredHandlers: StateExpiredHandlersMap<TBot>;
     hookHandlers: HookHandlersMap<TBot>;
+    workflowHandlers: WorkflowHandlersMap<TBot>;
 };
+type _GetPluginPrefix<TKey extends string, TPlugin extends plugin.BasePlugin> = TKey extends TPlugin['name'] ? '' : `${TKey}#`;
 type ImplementedActions<_TBot extends common.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = utils.UnionToIntersection<utils.ValueOf<{
-    [K in keyof TPlugins]: TPlugins[K]['actions'];
+    [TPlugin in utils.StringKeys<TPlugins>]: {
+        [TAction in utils.StringKeys<TPlugins[TPlugin]['actions']> as `${_GetPluginPrefix<utils.Cast<TPlugin, string>, TPlugins[TPlugin]>}${utils.Cast<TAction, string>}`]: TPlugins[TPlugin]['actions'][TAction];
+    };
 }>>;
-type UnimplementedActions<TBot extends common.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = Omit<TBot['actions'], keyof ImplementedActions<TBot, TPlugins>>;
+type UnimplementedActions<TBot extends common.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = Omit<TBot['actions'], utils.StringKeys<ImplementedActions<TBot, TPlugins>>>;
 export type ImplementedActionHandlers<TBot extends common.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = {
-    [K in keyof ImplementedActions<TBot, TPlugins>]: ActionHandlers<TBot>[utils.Cast<K, keyof ActionHandlers<TBot>>];
+    [K in utils.StringKeys<ImplementedActions<TBot, TPlugins>>]: ActionHandlers<TBot>[utils.Cast<K, keyof ActionHandlers<TBot>>];
 };
 export type UnimplementedActionHandlers<TBot extends common.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = {
-    [K in keyof UnimplementedActions<TBot, TPlugins>]: ActionHandlers<TBot>[utils.Cast<K, keyof ActionHandlers<TBot>>];
+    [K in utils.StringKeys<UnimplementedActions<TBot, TPlugins>>]: ActionHandlers<TBot>[utils.Cast<K, keyof ActionHandlers<TBot>>];
+};
+export type ServerProps = Omit<CommonHandlerProps<common.BaseBot>, 'workflows'> & {
+    req: Request;
+    self: BotHandlers<common.BaseBot>;
 };
 export {};

package/dist/bot/server/workflows/update-handler.d.ts

@@ -0,0 +1,3 @@
+import { Response } from '../../../serve';
+import * as types from '../types';
+export declare const handleWorkflowUpdateEvent: (props: types.ServerProps, event: types.WorkflowUpdateEvent) => Promise<Response>;

package/dist/bot/server/workflows/update-type-conv.d.ts

@@ -0,0 +1,2 @@
+import * as types from '../types';
+export declare const bridgeUpdateTypeToSnakeCase: (updateType: types.BridgeWorkflowUpdateType) => types.WorkflowUpdateType;

package/dist/bot/workflow-proxy/index.d.ts

@@ -0,0 +1,2 @@
+export * from './proxy';
+export * from './types';

package/dist/bot/workflow-proxy/proxy.d.ts

@@ -0,0 +1,10 @@
+import type * as client from '@botpress/client';
+import type { BotSpecificClient } from '../../bot';
+import type * as typeUtils from '../../utils/type-utils';
+import type { BaseBot } from '../common';
+import type { WorkflowProxy, WorkflowWithUtilities } from './types';
+export declare const proxyWorkflows: <TBot extends BaseBot>(client: BotSpecificClient<TBot> | client.Client) => WorkflowProxy<TBot>;
+export declare const wrapWorkflowInstance: <TBot extends BaseBot, TWorkflowName extends typeUtils.StringKeys<TBot["workflows"]>>(props: {
+    client: BotSpecificClient<TBot> | client.Client;
+    workflow: client.Workflow;
+}) => WorkflowWithUtilities<TBot, TWorkflowName>;

package/dist/bot/workflow-proxy/types.d.ts

@@ -0,0 +1,64 @@
+import type * as client from '@botpress/client';
+import type * as typeUtils from '../../utils/type-utils';
+import type * as commonTypes from '../common';
+export type WorkflowProxy<TBot extends commonTypes.BaseBot = commonTypes.BaseBot> = Readonly<{
+    [TWorkflowName in typeUtils.StringKeys<TBot['workflows']>]: Readonly<{
+        startNewInstance: (x: Pick<client.ClientInputs['createWorkflow'], 'conversationId' | 'userId' | 'timeoutAt'> & {
+            tags?: typeUtils.AtLeastOneProperty<TBot['workflows'][TWorkflowName]['tags']>;
+            input: TBot['workflows'][TWorkflowName]['input'];
+        }) => Promise<Readonly<Omit<client.ClientOutputs['createWorkflow'], 'workflow'> & {
+            workflow: WorkflowWithUtilities<TBot, TWorkflowName>;
+        }>>;
+        listInstances: Readonly<{
+            all: _ListInstances<TBot, TWorkflowName>;
+            running: _ListInstances<TBot, TWorkflowName>;
+            scheduled: _ListInstances<TBot, TWorkflowName>;
+            allFinished: _ListInstances<TBot, TWorkflowName>;
+            succeeded: _ListInstances<TBot, TWorkflowName>;
+            cancelled: _ListInstances<TBot, TWorkflowName>;
+            timedOut: _ListInstances<TBot, TWorkflowName>;
+            failed: _ListInstances<TBot, TWorkflowName>;
+        }>;
+    }>;
+}>;
+type _ListInstances<TBot extends commonTypes.BaseBot, TWorkflowName extends typeUtils.StringKeys<TBot['workflows']>> = (x?: Pick<client.ClientInputs['listWorkflows'], 'nextToken' | 'conversationId' | 'userId'> & {
+    tags?: typeUtils.AtLeastOneProperty<TBot['workflows'][TWorkflowName]['tags']>;
+}) => Promise<Readonly<Omit<client.ClientOutputs['listWorkflows'], 'workflows'> & {
+    workflows: WorkflowWithUtilities<TBot, TWorkflowName>[];
+}>>;
+export type WorkflowWithUtilities<TBot extends commonTypes.BaseBot, TWorkflowName extends typeUtils.StringKeys<TBot['workflows']>> = Readonly<client.Workflow & {
+    name: TWorkflowName;
+    input: typeUtils.Cast<TBot['workflows'][TWorkflowName], commonTypes.IntegrationInstanceActionDefinition>['input'];
+    output: Partial<typeUtils.Cast<TBot['workflows'][TWorkflowName], commonTypes.IntegrationInstanceActionDefinition>['output']>;
+    tags: Partial<TBot['workflows'][TWorkflowName]['tags']>;
+    /**
+     * Updates the current workflow instance
+     */
+    update(x: typeUtils.AtLeastOneProperty<Pick<client.ClientInputs['updateWorkflow'], 'userId' | 'timeoutAt'> & {
+        tags?: typeUtils.AtLeastOneProperty<TBot['workflows'][TWorkflowName]['tags']>;
+        output?: typeUtils.Cast<TBot['workflows'][TWorkflowName], commonTypes.IntegrationInstanceActionDefinition>['output'];
+    }>): Promise<{
+        workflow: WorkflowWithUtilities<TBot, TWorkflowName>;
+    }>;
+    /**
+     * Marks the current workflow instance as failed and stops execution
+     */
+    setFailed(x: Required<Pick<client.ClientInputs['updateWorkflow'], 'failureReason'>>): Promise<{
+        workflow: WorkflowWithUtilities<TBot, TWorkflowName>;
+    }>;
+    /**
+     * Marks the current workflow instance as completed and stops execution
+     */
+    setCompleted(x?: {
+        output?: typeUtils.Cast<TBot['workflows'][TWorkflowName], commonTypes.IntegrationInstanceActionDefinition>['output'];
+    }): Promise<{
+        workflow: WorkflowWithUtilities<TBot, TWorkflowName>;
+    }>;
+    /**
+     * Discards all output data and cancels the current workflow instance
+     */
+    cancel(): Promise<{
+        workflow: WorkflowWithUtilities<TBot, TWorkflowName>;
+    }>;
+}>;
+export {};

package/dist/bot/workflow-proxy/types.test.d.ts

@@ -0,0 +1 @@
+export {};