@botpress/sdk 3.1.0 → 3.3.0

package/.turbo/turbo-build.log

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

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

@@ -1,5 +1,5 @@
 import * as client from '@botpress/client';
-import * as common from '../types';
+import * as common from '../common';
 import * as types from './types';
 export * from './types';
 /**

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

@@ -1,6 +1,6 @@
 import * as client from '@botpress/client';
 import * as utils from '../../utils/type-utils';
-import * as common from '../types';
+import * as common from '../common';
 type Arg<F extends (...args: any[]) => any> = Parameters<F>[number];
 type Res<F extends (...args: any[]) => any> = ReturnType<F>;
 type EventResponse<TBot extends common.BaseBot> = {

package/dist/bot/{types → common}/generic.d.ts

@@ -1,6 +1,6 @@
-import { BaseIntegration, DefaultIntegration, InputBaseIntegration } from '../../integration/types/generic';
+import { BaseIntegration, DefaultIntegration, InputBaseIntegration } from '../../integration/common/generic';
 import * as utils from '../../utils/type-utils';
-export * from '../../integration/types/generic';
+export * from '../../integration/common/generic';
 export type BaseAction = {
     input: any;
     output: any;

package/dist/bot/{types → common}/index.d.ts

@@ -1,2 +1,2 @@
 export * from './generic';
-export * from './common';
+export * from './types';

package/dist/bot/implementation.d.ts

@@ -1,7 +1,7 @@
 import type { Server } from 'node:http';
 import { BasePlugin, PluginImplementation } from '../plugin';
+import { BaseBot } from './common';
 import { MessageHandlersMap, MessageHandlers, EventHandlersMap, EventHandlers, StateExpiredHandlersMap, StateExpiredHandlers, HookHandlersMap, HookData, HookHandlers, ActionHandlers, BotHandlers, UnimplementedActionHandlers } from './server';
-import { BaseBot } from './types';
 export type BotImplementationProps<TBot extends BaseBot = BaseBot, TPlugins extends Record<string, BasePlugin> = {}> = {
     actions: UnimplementedActionHandlers<TBot, TPlugins>;
     plugins: {

package/dist/bot/index.d.ts

@@ -2,5 +2,5 @@ export * from './definition';
 export * from './implementation';
 export * from './client';
 export * from './server';
-export * from './types';
+export * from './common';
 export * from './bot-logger';

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

@@ -1,5 +1,5 @@
 import { Request, Response } from '../../serve';
-import * as common from '../types';
+import * as common from '../common';
 import * as types from './types';
 export * from './types';
 export declare const botHandler: (bot: types.BotHandlers<common.BaseBot>) => (req: Request) => Promise<Response | void>;

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

@@ -3,7 +3,7 @@ import * as plugin from '../../plugin';
 import * as utils from '../../utils/type-utils';
 import { type BotLogger } from '../bot-logger';
 import { BotSpecificClient } from '../client';
-import * as types from '../types';
+import * as common from '../common';
 export type BotOperation = 'event_received' | 'register' | 'unregister' | 'ping' | 'action_triggered';
 export type BotContext = {
     botId: string;
@@ -13,83 +13,83 @@ export type BotContext = {
         payload: string;
     };
 };
-type _IncomingEvents<TBot extends types.BaseBot> = {
-    [K in keyof types.EnumerateEvents<TBot>]: utils.Merge<client.Event, {
+type _IncomingEvents<TBot extends common.BaseBot> = {
+    [K in keyof common.EnumerateEvents<TBot>]: utils.Merge<client.Event, {
         type: K;
-        payload: types.EnumerateEvents<TBot>[K];
+        payload: common.EnumerateEvents<TBot>[K];
     }>;
 };
-type _IncomingMessages<TBot extends types.BaseBot> = {
-    [K in keyof types.GetMessages<TBot>]: utils.Merge<client.Message, {
+type _IncomingMessages<TBot extends common.BaseBot> = {
+    [K in keyof common.GetMessages<TBot>]: utils.Merge<client.Message, {
         type: K;
-        payload: types.GetMessages<TBot>[K];
+        payload: common.GetMessages<TBot>[K];
     }>;
 };
-type _IncomingStates<TBot extends types.BaseBot> = {
-    [K in keyof types.EnumerateStates<TBot>]: utils.Merge<client.State, {
+type _IncomingStates<TBot extends common.BaseBot> = {
+    [K in keyof common.EnumerateStates<TBot>]: utils.Merge<client.State, {
         name: K;
-        payload: types.EnumerateStates<TBot>[K];
+        payload: common.EnumerateStates<TBot>[K];
     }>;
 };
-type _OutgoingMessageRequests<TBot extends types.BaseBot> = {
-    [K in keyof types.GetMessages<TBot>]: utils.Merge<client.ClientInputs['createMessage'], {
+type _OutgoingMessageRequests<TBot extends common.BaseBot> = {
+    [K in keyof common.GetMessages<TBot>]: utils.Merge<client.ClientInputs['createMessage'], {
         type: K;
-        payload: types.GetMessages<TBot>[K];
+        payload: common.GetMessages<TBot>[K];
     }>;
 };
-type _OutgoingMessageResponses<TBot extends types.BaseBot> = {
-    [K in keyof types.GetMessages<TBot>]: utils.Merge<client.ClientOutputs['createMessage'], {
+type _OutgoingMessageResponses<TBot extends common.BaseBot> = {
+    [K in keyof common.GetMessages<TBot>]: utils.Merge<client.ClientOutputs['createMessage'], {
         message: utils.Merge<client.Message, {
             type: K;
-            payload: types.GetMessages<TBot>[K];
+            payload: common.GetMessages<TBot>[K];
         }>;
     }>;
 };
-type _OutgoingCallActionRequests<TBot extends types.BaseBot> = {
-    [K in keyof types.EnumerateActionInputs<TBot>]: utils.Merge<client.ClientInputs['callAction'], {
+type _OutgoingCallActionRequests<TBot extends common.BaseBot> = {
+    [K in keyof common.EnumerateActionInputs<TBot>]: utils.Merge<client.ClientInputs['callAction'], {
         type: K;
-        input: types.EnumerateActionInputs<TBot>[K];
+        input: common.EnumerateActionInputs<TBot>[K];
     }>;
 };
-type _OutgoingCallActionResponses<TBot extends types.BaseBot> = {
-    [K in keyof types.EnumerateActionOutputs<TBot>]: utils.Merge<client.ClientOutputs['callAction'], {
-        output: types.EnumerateActionOutputs<TBot>[K];
+type _OutgoingCallActionResponses<TBot extends common.BaseBot> = {
+    [K in keyof common.EnumerateActionOutputs<TBot>]: utils.Merge<client.ClientOutputs['callAction'], {
+        output: common.EnumerateActionOutputs<TBot>[K];
     }>;
 };
-export type AnyIncomingEvent<TBot extends types.BaseBot> = utils.ValueOf<_IncomingEvents<TBot>>;
-export type AnyIncomingMessage<TBot extends types.BaseBot> = utils.ValueOf<_IncomingMessages<TBot>>;
-export type AnyOutgoingMessageRequest<TBot extends types.BaseBot> = utils.ValueOf<_OutgoingMessageRequests<TBot>>;
-export type AnyOutgoingMessageResponse<TBot extends types.BaseBot> = utils.ValueOf<_OutgoingMessageResponses<TBot>>;
-export type AnyOutgoingCallActionRequest<TBot extends types.BaseBot> = utils.ValueOf<_OutgoingCallActionRequests<TBot>>;
-export type AnyOutgoingCallActionResponse<TBot extends types.BaseBot> = utils.ValueOf<_OutgoingCallActionResponses<TBot>>;
-export type IncomingEvents<TBot extends types.BaseBot> = _IncomingEvents<TBot> & {
+export type AnyIncomingEvent<TBot extends common.BaseBot> = utils.ValueOf<_IncomingEvents<TBot>>;
+export type AnyIncomingMessage<TBot extends common.BaseBot> = utils.ValueOf<_IncomingMessages<TBot>>;
+export type AnyOutgoingMessageRequest<TBot extends common.BaseBot> = utils.ValueOf<_OutgoingMessageRequests<TBot>>;
+export type AnyOutgoingMessageResponse<TBot extends common.BaseBot> = utils.ValueOf<_OutgoingMessageResponses<TBot>>;
+export type AnyOutgoingCallActionRequest<TBot extends common.BaseBot> = utils.ValueOf<_OutgoingCallActionRequests<TBot>>;
+export type AnyOutgoingCallActionResponse<TBot extends common.BaseBot> = utils.ValueOf<_OutgoingCallActionResponses<TBot>>;
+export type IncomingEvents<TBot extends common.BaseBot> = _IncomingEvents<TBot> & {
     '*': AnyIncomingEvent<TBot>;
 };
-export type IncomingMessages<TBot extends types.BaseBot> = _IncomingMessages<TBot> & {
+export type IncomingMessages<TBot extends common.BaseBot> = _IncomingMessages<TBot> & {
     '*': AnyIncomingMessage<TBot>;
 };
-export type IncomingStates<_TBot extends types.BaseBot> = _IncomingStates<_TBot> & {
+export type IncomingStates<_TBot extends common.BaseBot> = _IncomingStates<_TBot> & {
     '*': client.State;
 };
-export type OutgoingMessageRequests<TBot extends types.BaseBot> = _OutgoingMessageRequests<TBot> & {
+export type OutgoingMessageRequests<TBot extends common.BaseBot> = _OutgoingMessageRequests<TBot> & {
     '*': AnyOutgoingMessageRequest<TBot>;
 };
-export type OutgoingMessageResponses<TBot extends types.BaseBot> = _OutgoingMessageResponses<TBot> & {
+export type OutgoingMessageResponses<TBot extends common.BaseBot> = _OutgoingMessageResponses<TBot> & {
     '*': AnyOutgoingMessageResponse<TBot>;
 };
-export type OutgoingCallActionRequests<TBot extends types.BaseBot> = _OutgoingCallActionRequests<TBot> & {
+export type OutgoingCallActionRequests<TBot extends common.BaseBot> = _OutgoingCallActionRequests<TBot> & {
     '*': AnyOutgoingCallActionRequest<TBot>;
 };
-export type OutgoingCallActionResponses<TBot extends types.BaseBot> = _OutgoingCallActionResponses<TBot> & {
+export type OutgoingCallActionResponses<TBot extends common.BaseBot> = _OutgoingCallActionResponses<TBot> & {
     '*': AnyOutgoingCallActionResponse<TBot>;
 };
-export type BotClient<TBot extends types.BaseBot> = BotSpecificClient<TBot>;
-export type CommonHandlerProps<TBot extends types.BaseBot> = {
+export type BotClient<TBot extends common.BaseBot> = BotSpecificClient<TBot>;
+export type CommonHandlerProps<TBot extends common.BaseBot> = {
     ctx: BotContext;
     logger: BotLogger;
     client: BotClient<TBot>;
 };
-export type MessagePayloads<TBot extends types.BaseBot> = {
+export type MessagePayloads<TBot extends common.BaseBot> = {
     [K in keyof IncomingMessages<TBot>]: CommonHandlerProps<TBot> & {
         message: IncomingMessages<TBot>[K];
         user: client.User;
@@ -103,32 +103,32 @@ export type MessagePayloads<TBot extends types.BaseBot> = {
         };
     };
 };
-export type MessageHandlers<TBot extends types.BaseBot> = {
+export type MessageHandlers<TBot extends common.BaseBot> = {
     [K in keyof IncomingMessages<TBot>]: (args: MessagePayloads<TBot>[K]) => Promise<void>;
 };
-export type EventPayloads<TBot extends types.BaseBot> = {
+export type EventPayloads<TBot extends common.BaseBot> = {
     [K in keyof IncomingEvents<TBot>]: CommonHandlerProps<TBot> & {
         event: IncomingEvents<TBot>[K];
     };
 };
-export type EventHandlers<TBot extends types.BaseBot> = {
+export type EventHandlers<TBot extends common.BaseBot> = {
     [K in keyof IncomingEvents<TBot>]: (args: EventPayloads<TBot>[K]) => Promise<void>;
 };
-export type StateExpiredPayloads<TBot extends types.BaseBot> = {
+export type StateExpiredPayloads<TBot extends common.BaseBot> = {
     [K in keyof IncomingStates<TBot>]: CommonHandlerProps<TBot> & {
         state: IncomingStates<TBot>[K];
     };
 };
-export type StateExpiredHandlers<TBot extends types.BaseBot> = {
+export type StateExpiredHandlers<TBot extends common.BaseBot> = {
     [K in keyof IncomingStates<TBot>]: (args: StateExpiredPayloads<TBot>[K]) => Promise<void>;
 };
-export type ActionHandlerPayloads<TBot extends types.BaseBot> = {
+export type ActionHandlerPayloads<TBot extends common.BaseBot> = {
     [K in keyof TBot['actions']]: CommonHandlerProps<TBot> & {
         type?: K;
         input: TBot['actions'][K]['input'];
     };
 };
-export type ActionHandlers<TBot extends types.BaseBot> = {
+export type ActionHandlers<TBot extends common.BaseBot> = {
     [K in keyof TBot['actions']]: (props: ActionHandlerPayloads<TBot>[K]) => Promise<TBot['actions'][K]['output']>;
 };
 type BaseHookDefinition = {
@@ -145,7 +145,7 @@ type HookDefinition<THookDef extends BaseHookDefinition = BaseHookDefinition> =
  *   - before_incoming_call_action
  *   - after_incoming_call_action
  */
-export type HookDefinitions<TBot extends types.BaseBot> = {
+export type HookDefinitions<TBot extends common.BaseBot> = {
     before_incoming_event: HookDefinition<{
         stoppable: true;
         data: _IncomingEvents<TBot> & {
@@ -195,19 +195,19 @@ export type HookDefinitions<TBot extends types.BaseBot> = {
         };
     }>;
 };
-export type HookData<TBot extends types.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];
     };
 };
-export type HookInputs<TBot extends types.BaseBot> = {
+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];
         };
     };
 };
-export type HookOutputs<TBot extends types.BaseBot> = {
+export type HookOutputs<TBot extends common.BaseBot> = {
     [H in keyof HookData<TBot>]: {
         [T in keyof HookData<TBot>[H]]: {
             data?: HookData<TBot>[H][T];
@@ -216,21 +216,21 @@ export type HookOutputs<TBot extends types.BaseBot> = {
         } : {});
     };
 };
-export type HookHandlers<TBot extends types.BaseBot> = {
+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>;
     };
 };
-export type MessageHandlersMap<TBot extends types.BaseBot> = {
+export type MessageHandlersMap<TBot extends common.BaseBot> = {
     [T in keyof IncomingMessages<TBot>]?: MessageHandlers<TBot>[T][];
 };
-export type EventHandlersMap<TBot extends types.BaseBot> = {
+export type EventHandlersMap<TBot extends common.BaseBot> = {
     [T in keyof IncomingEvents<TBot>]?: EventHandlers<TBot>[T][];
 };
-export type StateExpiredHandlersMap<TBot extends types.BaseBot> = {
+export type StateExpiredHandlersMap<TBot extends common.BaseBot> = {
     [T in keyof IncomingStates<TBot>]?: StateExpiredHandlers<TBot>[T][];
 };
-export type HookHandlersMap<TBot extends types.BaseBot> = {
+export type HookHandlersMap<TBot extends common.BaseBot> = {
     [H in keyof HookData<TBot>]: {
         [T in keyof HookData<TBot>[H]]?: HookHandlers<TBot>[H][T][];
     };
@@ -240,21 +240,21 @@ export type HookHandlersMap<TBot extends types.BaseBot> = {
  * the consumer of this type shouldnt be able to access "*" directly;
  * "*" is meant the user who registers an handler, not for the user who calls the handler
  */
-export type BotHandlers<TBot extends types.BaseBot> = {
+export type BotHandlers<TBot extends common.BaseBot> = {
     actionHandlers: ActionHandlers<TBot>;
     messageHandlers: MessageHandlersMap<TBot>;
     eventHandlers: EventHandlersMap<TBot>;
     stateExpiredHandlers: StateExpiredHandlersMap<TBot>;
     hookHandlers: HookHandlersMap<TBot>;
 };
-type ImplementedActions<_TBot extends types.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = utils.UnionToIntersection<utils.ValueOf<{
+type ImplementedActions<_TBot extends common.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = utils.UnionToIntersection<utils.ValueOf<{
     [K in keyof TPlugins]: TPlugins[K]['actions'];
 }>>;
-type UnimplementedActions<TBot extends types.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = Omit<TBot['actions'], keyof ImplementedActions<TBot, TPlugins>>;
-export type ImplementedActionHandlers<TBot extends types.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = {
+type UnimplementedActions<TBot extends common.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = Omit<TBot['actions'], keyof 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>>];
 };
-export type UnimplementedActionHandlers<TBot extends types.BaseBot, TPlugins extends Record<string, plugin.BasePlugin>> = {
+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>>];
 };
 export {};

package/dist/fixtures.d.ts

@@ -1,6 +1,6 @@
-import { DefaultBot } from './bot/types/generic';
-import { DefaultChannel, DefaultIntegration } from './integration/types/generic';
-import { DefaultPlugin } from './plugin/types/generic';
+import { DefaultBot } from './bot/common/generic';
+import { DefaultChannel, DefaultIntegration } from './integration/common/generic';
+import { DefaultPlugin } from './plugin/common/generic';
 type _FooBarBazIntegration = {
     actions: {
         doFoo: {
@@ -46,6 +46,20 @@ type _FooBarBazIntegration = {
                     foo: string;
                 };
             };
+            message: {
+                tags: {
+                    fooMessageTag1: '';
+                    fooMessageTag2: '';
+                    fooMessageTag3: '';
+                };
+            };
+            conversation: {
+                tags: {
+                    fooConversationTag1: '';
+                    fooConversationTag2: '';
+                    fooConversationTag3: '';
+                };
+            };
         }>;
         channelBar: DefaultChannel<{
             messages: {
@@ -53,6 +67,20 @@ type _FooBarBazIntegration = {
                     bar: number;
                 };
             };
+            message: {
+                tags: {
+                    barMessageTag1: '';
+                    barMessageTag2: '';
+                    barMessageTag3: '';
+                };
+            };
+            conversation: {
+                tags: {
+                    barConversationTag1: '';
+                    barConversationTag2: '';
+                    barConversationTag3: '';
+                };
+            };
         }>;
         channelBaz: DefaultChannel<{
             messages: {
@@ -60,8 +88,29 @@ type _FooBarBazIntegration = {
                     baz: boolean;
                 };
             };
+            message: {
+                tags: {
+                    bazMessageTag1: '';
+                    bazMessageTag2: '';
+                    bazMessageTag3: '';
+                };
+            };
+            conversation: {
+                tags: {
+                    bazConversationTag1: '';
+                    bazConversationTag2: '';
+                    bazConversationTag3: '';
+                };
+            };
         }>;
     };
+    user: {
+        tags: {
+            fooUserTag1: '';
+            fooUserTag2: '';
+            fooUserTag3: '';
+        };
+    };
 };
 type _TotoTutuTataInterface = {
     actions: {