@botpress/sdk 4.21.0 → 5.0.1

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

@@ -1,4 +1,5 @@
 import * as client from '@botpress/client';
+import type { commonTypes } from '../../common';
 import * as utils from '../../utils/type-utils';
 import * as common from '../common';
 import { EnumerateMessages, ConversationTags, GetChannelByName, GetMessageByName, MessageTags } from './sub-types';
@@ -8,26 +9,26 @@ type ConversationResponse<TIntegration extends common.BaseIntegration, ChannelNa
     [TChannelName in ChannelName]: {
         conversation: utils.Merge<Awaited<Res<client.Client['getConversation']>>['conversation'], {
             channel: TChannelName;
-            tags: common.ToTags<keyof TIntegration['channels'][TChannelName]['conversation']['tags']>;
+            tags: commonTypes.ToTags<keyof TIntegration['channels'][TChannelName]['conversation']['tags']>;
         }>;
     };
 }>;
 export type CreateConversation<TIntegration extends common.BaseIntegration> = <ChannelName extends keyof TIntegration['channels']>(x: {
     channel: utils.Cast<ChannelName, string>;
-    tags: common.ToTags<keyof GetChannelByName<TIntegration, ChannelName>['conversation']['tags']>;
+    tags: commonTypes.ToTags<keyof GetChannelByName<TIntegration, ChannelName>['conversation']['tags']>;
 }) => Promise<ConversationResponse<TIntegration, ChannelName>>;
 export type GetConversation<TIntegration extends common.BaseIntegration> = (x: Arg<client.Client['getConversation']>) => Promise<ConversationResponse<TIntegration>>;
 export type ListConversations<TIntegration extends common.BaseIntegration> = <ChannelName extends keyof TIntegration['channels']>(x: utils.Merge<Arg<client.Client['listConversations']>, {
     channel?: utils.Cast<ChannelName, string>;
-    tags?: common.ToTags<keyof GetChannelByName<TIntegration, ChannelName>['conversation']['tags']>;
+    tags?: commonTypes.ToTags<keyof GetChannelByName<TIntegration, ChannelName>['conversation']['tags']>;
 }>) => Res<client.Client['listConversations']>;
 export type GetOrCreateConversation<TIntegration extends common.BaseIntegration> = <ChannelName extends keyof TIntegration['channels'], TTags extends keyof GetChannelByName<TIntegration, ChannelName>['conversation']['tags']>(x: utils.Merge<Arg<client.Client['getOrCreateConversation']>, {
     channel: utils.Cast<ChannelName, string>;
-    tags: common.ToTags<TTags>;
+    tags: commonTypes.ToTags<TTags>;
     discriminateByTags?: NoInfer<utils.Cast<TTags[], string[]>>;
 }>) => Promise<ConversationResponse<TIntegration, ChannelName>>;
 export type UpdateConversation<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['updateConversation']>, {
-    tags?: common.ToTags<ConversationTags<TIntegration>>;
+    tags?: commonTypes.ToTags<ConversationTags<TIntegration>>;
 }>) => Promise<ConversationResponse<TIntegration>>;
 export type DeleteConversation<_TIntegration extends common.BaseIntegration> = client.Client['deleteConversation'];
 export type ListParticipants<_TIntegration extends common.BaseIntegration> = client.Client['listParticipants'];
@@ -56,40 +57,40 @@ type MessageResponse<TIntegration extends common.BaseIntegration, TMessage exten
 export type CreateMessage<TIntegration extends common.BaseIntegration> = <TMessage extends keyof EnumerateMessages<TIntegration>>(x: utils.Merge<Arg<client.Client['createMessage']>, {
     type: utils.Cast<TMessage, string>;
     payload: GetMessageByName<TIntegration, TMessage>['payload'];
-    tags: common.ToTags<keyof GetMessageByName<TIntegration, TMessage>['tags']>;
+    tags: commonTypes.ToTags<keyof GetMessageByName<TIntegration, TMessage>['tags']>;
 }>) => Promise<MessageResponse<TIntegration, TMessage>>;
 export type GetOrCreateMessage<TIntegration extends common.BaseIntegration> = <TMessage extends keyof EnumerateMessages<TIntegration>, TTags extends keyof GetMessageByName<TIntegration, TMessage>['tags']>(x: utils.Merge<Arg<client.Client['getOrCreateMessage']>, {
     type: utils.Cast<TMessage, string>;
     payload: GetMessageByName<TIntegration, TMessage>['payload'];
-    tags: common.ToTags<TTags>;
+    tags: commonTypes.ToTags<TTags>;
     discriminateByTags?: NoInfer<utils.Cast<TTags[], string[]>>;
 }>) => Promise<MessageResponse<TIntegration, TMessage>>;
 export type GetMessage<TIntegration extends common.BaseIntegration> = (x: Arg<client.Client['getMessage']>) => Promise<MessageResponse<TIntegration>>;
 export type UpdateMessage<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['updateMessage']>, {
-    tags: common.ToTags<MessageTags<TIntegration>>;
+    tags: commonTypes.ToTags<MessageTags<TIntegration>>;
 }>) => Promise<MessageResponse<TIntegration>>;
 export type ListMessages<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['listMessages']>, {
-    tags?: common.ToTags<MessageTags<TIntegration>>;
+    tags?: commonTypes.ToTags<MessageTags<TIntegration>>;
 }>) => Res<client.Client['listMessages']>;
 export type DeleteMessage<_TIntegration extends common.BaseIntegration> = client.Client['deleteMessage'];
 type UserResponse<TIntegration extends common.BaseIntegration> = {
     user: utils.Merge<Awaited<Res<client.Client['getUser']>>['user'], {
-        tags: common.ToTags<keyof TIntegration['user']['tags']>;
+        tags: commonTypes.ToTags<keyof TIntegration['user']['tags']>;
     }>;
 };
 export type CreateUser<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['createUser']>, {
-    tags: common.ToTags<keyof TIntegration['user']['tags']>;
+    tags: commonTypes.ToTags<keyof TIntegration['user']['tags']>;
 }>) => Promise<UserResponse<TIntegration>>;
 export type GetUser<TIntegration extends common.BaseIntegration> = (x: Arg<client.Client['getUser']>) => Promise<UserResponse<TIntegration>>;
 export type ListUsers<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['listUsers']>, {
-    tags?: common.ToTags<keyof TIntegration['user']['tags']>;
+    tags?: commonTypes.ToTags<keyof TIntegration['user']['tags']>;
 }>) => Res<client.Client['listUsers']>;
 export type GetOrCreateUser<TIntegration extends common.BaseIntegration> = <TTags extends keyof TIntegration['user']['tags']>(x: utils.Merge<Arg<client.Client['getOrCreateUser']>, {
-    tags: common.ToTags<TTags>;
+    tags: commonTypes.ToTags<TTags>;
     discriminateByTags?: NoInfer<utils.Cast<TTags[], string[]>>;
 }>) => Promise<UserResponse<TIntegration>>;
 export type UpdateUser<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['updateUser']>, {
-    tags?: common.ToTags<keyof TIntegration['user']['tags']>;
+    tags?: commonTypes.ToTags<keyof TIntegration['user']['tags']>;
 }>) => Promise<UserResponse<TIntegration>>;
 export type DeleteUser<_TIntegration extends common.BaseIntegration> = client.Client['deleteUser'];
 type StateResponse<TIntegration extends common.BaseIntegration, TState extends keyof TIntegration['states']> = {

package/dist/integration/common/index.d.ts

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

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

@@ -1,8 +1,9 @@
 import { type Conversation, type Message, type User } from '@botpress/client';
+import type { commonTypes } from '../../common';
 import { Request, Response } from '../../serve';
 import { Cast, Merge, ValueOf } from '../../utils/type-utils';
 import { IntegrationSpecificClient } from '../client';
-import { BaseIntegration, ToTags } from '../common';
+import { BaseIntegration } from '../common';
 import { type IntegrationLogger } from './integration-logger';
 type IntegrationContextConfig<TIntegration extends BaseIntegration> = {
     configurationType: null;
@@ -54,13 +55,13 @@ export type ActionHandlers<TIntegration extends BaseIntegration> = {
     [ActionType in keyof TIntegration['actions']]: (props: ActionHandlerProps<TIntegration, Cast<ActionType, string>, TIntegration['actions'][ActionType]['input']>) => Promise<TIntegration['actions'][ActionType]['output']>;
 };
 export type CreateUserPayload<TIntegration extends BaseIntegration> = {
-    tags: ToTags<keyof TIntegration['user']['tags']>;
+    tags: commonTypes.ToTags<keyof TIntegration['user']['tags']>;
 };
 export type CreateUserHandlerProps<TIntegration extends BaseIntegration> = CommonHandlerProps<TIntegration> & CreateUserPayload<TIntegration>;
 export type CreateUserHandler<TIntegration extends BaseIntegration> = (props: CreateUserHandlerProps<TIntegration>) => Promise<Response | void>;
 export type CreateConversationPayload<TIntegration extends BaseIntegration, TChannel extends keyof TIntegration['channels'] = keyof TIntegration['channels']> = {
     channel: TChannel;
-    tags: ToTags<keyof TIntegration['channels'][TChannel]['conversation']['tags']>;
+    tags: commonTypes.ToTags<keyof TIntegration['channels'][TChannel]['conversation']['tags']>;
 };
 export type CreateConversationHandlerProps<TIntegration extends BaseIntegration> = CommonHandlerProps<TIntegration> & CreateConversationPayload<TIntegration>;
 export type CreateConversationHandler<TIntegration extends BaseIntegration> = (props: CreateConversationHandlerProps<TIntegration>) => Promise<Response | void>;
@@ -69,18 +70,18 @@ export type MessagePayload<TIntegration extends BaseIntegration, TChannel extend
     payload: TIntegration['channels'][TChannel]['messages'][TMessage];
     conversation: Merge<Conversation, {
         channel: TChannel;
-        tags: ToTags<keyof TIntegration['channels'][TChannel]['conversation']['tags']>;
+        tags: commonTypes.ToTags<keyof TIntegration['channels'][TChannel]['conversation']['tags']>;
     }>;
     message: Merge<Message, {
-        tags: ToTags<keyof TIntegration['channels'][TChannel]['message']['tags']>;
+        tags: commonTypes.ToTags<keyof TIntegration['channels'][TChannel]['message']['tags']>;
     }>;
     user: Merge<User, {
-        tags: ToTags<keyof TIntegration['user']['tags']>;
+        tags: commonTypes.ToTags<keyof TIntegration['user']['tags']>;
     }>;
 };
 export type MessageHandlerProps<TIntegration extends BaseIntegration, TChannel extends keyof TIntegration['channels'], TMessage extends keyof TIntegration['channels'][TChannel]['messages']> = CommonHandlerProps<TIntegration> & MessagePayload<TIntegration, TChannel, TMessage> & {
     ack: (props: {
-        tags: ToTags<keyof TIntegration['channels'][TChannel]['message']['tags']>;
+        tags: commonTypes.ToTags<keyof TIntegration['channels'][TChannel]['message']['tags']>;
     }) => Promise<void>;
 };
 export type ChannelHandlers<TIntegration extends BaseIntegration> = {

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

@@ -31,6 +31,15 @@ export type BasePlugin = {
     actions: Record<string, BaseAction>;
     tables: Record<string, BaseTable>;
     workflows: Record<string, BaseWorkflow>;
+    conversation: {
+        tags: Record<string, any>;
+    };
+    user: {
+        tags: Record<string, any>;
+    };
+    message: {
+        tags: Record<string, any>;
+    };
 };
 export type InputBasePlugin = utils.DeepPartial<BasePlugin>;
 export type DefaultPlugin<B extends utils.DeepPartial<BasePlugin>> = {
@@ -48,4 +57,7 @@ export type DefaultPlugin<B extends utils.DeepPartial<BasePlugin>> = {
     interfaces: undefined extends B['interfaces'] ? BasePlugin['interfaces'] : {
         [K in keyof B['interfaces']]: DefaultInterface<utils.Cast<B['interfaces'][K], InputBaseInterface>>;
     };
+    conversation: utils.Default<B['conversation'], BasePlugin['conversation']>;
+    user: utils.Default<B['user'], BasePlugin['user']>;
+    message: utils.Default<B['message'], BasePlugin['message']>;
 };

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

@@ -1,6 +1,6 @@
-import { BaseInterface } from '../../interface';
-import { Cast, Join, UnionToIntersection } from '../../utils/type-utils';
-import { BasePlugin } from './generic';
+import type { BaseInterface } from '../../interface';
+import type { Cast, Join, UnionToIntersection } from '../../utils/type-utils';
+import type { BasePlugin } from './generic';
 type EventKey<TIntegrationName extends string, TEventName extends string> = string extends TIntegrationName ? string : string extends TEventName ? string : Join<[TIntegrationName, ':', TEventName]>;
 export type EnumerateInterfaceEvents<TPlugin extends BasePlugin> = UnionToIntersection<{
     [TInterfaceName in keyof TPlugin['interfaces']]: {
@@ -14,6 +14,8 @@ export type PluginInterfaceExtension<TInterface extends BaseInterface = BaseInte
     id?: string;
     name: string;
     version: string;
+    integrationAlias: string;
+    integrationInterfaceAlias: string;
     entities: {
         [K in keyof TInterface['entities']]: {
             name: string;
@@ -35,13 +37,23 @@ export type PluginInterfaceExtension<TInterface extends BaseInterface = BaseInte
         };
     };
 };
+export type PluginIntegrationExtension = {
+    id?: string;
+    name: string;
+    version: string;
+    integrationAlias: string;
+};
 export type PluginInterfaceExtensions<TPlugin extends BasePlugin = BasePlugin> = {
-    [K in keyof TPlugin['interfaces']]: PluginInterfaceExtension<TPlugin['interfaces'][K]>;
+    [TPluginInterfaceAlias in keyof TPlugin['interfaces']]: PluginInterfaceExtension<TPlugin['interfaces'][TPluginInterfaceAlias]>;
+};
+export type PluginIntegrationExtensions<TPlugin extends BasePlugin = BasePlugin> = {
+    [TPluginIntegrationAlias in keyof TPlugin['integrations']]: PluginIntegrationExtension;
 };
 export type PluginConfiguration<TPlugin extends BasePlugin> = TPlugin['configuration'];
 export type PluginRuntimeProps<TPlugin extends BasePlugin = BasePlugin> = {
-    alias?: string;
+    alias: string;
     configuration: PluginConfiguration<TPlugin>;
     interfaces: PluginInterfaceExtensions<TPlugin>;
+    integrations: PluginIntegrationExtensions<TPlugin>;
 };
 export {};

package/dist/plugin/conversation-proxy/index.d.ts

@@ -0,0 +1,2 @@
+export { proxyConversation, proxyConversations } from './proxy';
+export { ActionableConversation, ConversationFinder } from './types';

package/dist/plugin/conversation-proxy/proxy.d.ts

@@ -0,0 +1,13 @@
+import type * as client from '@botpress/client';
+import type { BotSpecificClient } from '../../bot';
+import type { BasePlugin, PluginRuntimeProps } from '../common';
+import type { ActionableConversation, ConversationFinder } from './types';
+export declare const proxyConversations: <TPlugin extends BasePlugin>(props: {
+    client: BotSpecificClient<TPlugin> | client.Client;
+    plugin?: PluginRuntimeProps<TPlugin>;
+}) => ConversationFinder<TPlugin>;
+export declare const proxyConversation: <TPlugin extends BasePlugin>(props: {
+    client: BotSpecificClient<TPlugin> | client.Client;
+    plugin?: PluginRuntimeProps<TPlugin>;
+    conversation: client.Conversation;
+}) => ActionableConversation<TPlugin>;

package/dist/plugin/conversation-proxy/types.d.ts

@@ -0,0 +1,54 @@
+import type * as client from '@botpress/client';
+import type { commonTypes } from '../../common';
+import type { AsyncCollection } from '../../utils/api-paging-utils';
+import type * as typeUtils from '../../utils/type-utils';
+import type { BasePlugin } from '../common';
+import type * as messageProxy from '../message-proxy/types';
+import type * as userProxy from '../user-proxy/types';
+export type ConversationFinder<TPlugin extends BasePlugin> = _ConversationFinderForDepType<TPlugin, 'interfaces'> & _ConversationFinderForDepType<TPlugin, 'integrations'>;
+type _ConversationFinderForDepType<TPlugin extends BasePlugin, TDepType extends 'interfaces' | 'integrations'> = {
+    [TAlias in typeUtils.StringKeys<TPlugin[TDepType]> | '*']: {
+        [TChannelName in TAlias extends '*' ? '*' : typeUtils.StringKeys<TPlugin[TDepType][TAlias]['channels']> | '*']: _ConversationFinderForChannel<TPlugin, TChannelName, _MessageForChannel<TPlugin, TDepType, TAlias extends '*' ? string : TAlias, TChannelName extends '*' ? string : TChannelName>>;
+    };
+};
+type _ConversationFinderForChannel<TPlugin extends BasePlugin, TChannelName extends string, TMessage extends client.Message> = {
+    list: (props?: typeUtils.Merge<Omit<client.ClientInputs['listConversations'], 'integrationName' | 'channel' | 'nextToken'>, {
+        tags?: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['conversation']['tags']>>;
+    }>) => AsyncCollection<ActionableConversation<TPlugin, TChannelName extends '*' ? string : TChannelName, TMessage>>;
+    getById: (props: {
+        id: string;
+    }) => Promise<ActionableConversation<TPlugin, TChannelName extends '*' ? string : TChannelName, TMessage>>;
+};
+type _MessageForChannel<TPlugin extends BasePlugin, TDepType extends 'interfaces' | 'integrations', TAlias extends keyof TPlugin[TDepType], TChannelName extends keyof TPlugin[TDepType][TAlias]['channels']> = _FallbackWhenNever<Omit<client.Message, 'type' | 'payload' | 'tags'> & typeUtils.ValueOf<{
+    [TMessageName in typeUtils.StringKeys<TPlugin[TDepType][TAlias]['channels'][TChannelName]['messages']>]: {
+        type: TMessageName;
+        payload: TPlugin[TDepType][TAlias]['channels'][TChannelName]['messages'][TMessageName];
+        tags: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['message']['tags']>>;
+    };
+}>, typeUtils.Merge<client.Message, {
+    tags: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['message']['tags']>>;
+}>>;
+type _FallbackWhenNever<T, TFallback> = [T] extends [never] ? TFallback : T;
+export type ActionableConversation<TPlugin extends BasePlugin, TChannelName extends string = string, TMessage extends client.Message = client.Message> = typeUtils.Merge<client.Conversation, {
+    tags: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['conversation']['tags']>>;
+    channel: TChannelName;
+}> & {
+    delete: () => Promise<void>;
+    update: (props: typeUtils.Merge<Omit<client.ClientInputs['updateConversation'], 'id'>, {
+        tags?: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['conversation']['tags']>>;
+    }>) => Promise<ActionableConversation<TPlugin>>;
+    getMessage: (props: {
+        id: string;
+    }) => Promise<messageProxy.ActionableMessage<TPlugin, TMessage>>;
+    getOrCreateMessage: (props: Omit<client.ClientInputs['getOrCreateMessage'], 'conversationId' | 'tags' | 'type' | 'payload'> & typeUtils.DistributivePick<TMessage, 'type' | 'payload'> & {
+        tags: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['message']['tags']>>;
+    }) => Promise<messageProxy.ActionableMessage<TPlugin, TMessage>>;
+    createMessage: (props: Omit<client.ClientInputs['createMessage'], 'conversationId' | 'tags' | 'type' | 'payload'> & typeUtils.DistributivePick<TMessage, 'type' | 'payload'> & {
+        tags: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['message']['tags']>>;
+    }) => Promise<messageProxy.ActionableMessage<TPlugin, TMessage>>;
+    listMessages: (props?: typeUtils.Merge<Omit<client.ClientInputs['listMessages'], 'conversationId' | 'nextToken'>, {
+        tags?: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['message']['tags']>>;
+    }>) => AsyncCollection<messageProxy.ActionableMessage<TPlugin, TMessage>>;
+    listParticipants: () => AsyncCollection<userProxy.ActionableUser<TPlugin, string>>;
+};
+export {};

package/dist/plugin/conversation-proxy/types.test.d.ts

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

package/dist/plugin/definition.d.ts

@@ -2,7 +2,7 @@ import { StateDefinition as BotStateDefinition, EventDefinition as BotEventDefin
 import { IntegrationPackage, InterfacePackage } from '../package';
 import * as typeUtils from '../utils/type-utils';
 import { ZuiObjectSchema, ZuiObjectOrRefSchema, z } from '../zui';
-export { UserDefinition, ConversationDefinition, MessageDefinition, IntegrationConfigInstance, WorkflowDefinition, } from '../bot/definition';
+export { UserDefinition, ConversationDefinition, MessageDefinition, WorkflowDefinition } from '../bot/definition';
 type BaseConfig = ZuiObjectOrRefSchema;
 type BaseStates = Record<string, ZuiObjectOrRefSchema>;
 type BaseEvents = Record<string, ZuiObjectOrRefSchema>;

package/dist/plugin/event-proxy/proxy.d.ts

@@ -1,5 +1,5 @@
-import { Client } from '@botpress/client';
+import type * as client from '@botpress/client';
 import { BotSpecificClient } from '../../bot';
 import { BasePlugin, PluginRuntimeProps } from '../common';
 import { EventProxy } from './types';
-export declare const proxyEvents: <TPlugin extends BasePlugin>(client: BotSpecificClient<TPlugin> | Client, props: PluginRuntimeProps<TPlugin>) => EventProxy<TPlugin>;
+export declare const proxyEvents: <TPlugin extends BasePlugin>(client: BotSpecificClient<TPlugin> | client.Client, props: PluginRuntimeProps<TPlugin>) => EventProxy<TPlugin>;

package/dist/plugin/event-proxy/types.d.ts

@@ -1,13 +1,18 @@
-import { ClientInputs } from '@botpress/client';
-import * as utils from '../../utils/type-utils';
-import { BasePlugin } from '../common';
-export type EventSchedule = NonNullable<ClientInputs['createEvent']['schedule']>;
+import type * as client from '@botpress/client';
+import type { AsyncCollection } from '../../utils/api-paging-utils';
+import type * as utils from '../../utils/type-utils';
+import type { BasePlugin } from '../common';
+export type EventSchedule = NonNullable<client.ClientInputs['createEvent']['schedule']>;
 export type EventSender<TPayload> = {
-    emit: (event: TPayload) => Promise<void>;
-    schedule: (event: TPayload, schedule: EventSchedule) => Promise<void>;
+    emit: (event: TPayload) => Promise<client.Event>;
+    schedule: (event: TPayload, schedule: EventSchedule) => Promise<client.Event>;
     withConversationId: (conversationId: string) => EventSender<TPayload>;
     withUserId: (userId: string) => EventSender<TPayload>;
     withMessageId: (messageId: string) => EventSender<TPayload>;
+    list: (props?: Omit<client.ClientInputs['listEvents'], 'type' | 'nextToken' | 'conversationId' | 'messageId' | 'userId'>) => AsyncCollection<client.Event>;
+    getById: (props: {
+        id: string;
+    }) => Promise<client.Event>;
 };
 export type EventProxy<TPlugin extends BasePlugin> = utils.Normalize<{
     [TEventName in keyof TPlugin['events']]: EventSender<TPlugin['events'][TEventName]>;

package/dist/plugin/implementation.d.ts

@@ -1,7 +1,7 @@
 import type { MessageHandlersMap as BotMessageHandlersMap, EventHandlersMap as BotEventHandlersMap, StateExpiredHandlersMap as BotStateExpiredHandlersMap, HookHandlersMap as BotHookHandlersMap, WorkflowHandlersMap as BotWorkflowHandlersMap, ActionHandlersMap as BotActionHandlersMap, BotHandlers } from '../bot';
 import * as utils from '../utils';
 import { BasePlugin, PluginRuntimeProps } from './common';
-import { ActionHandlers, MessageHandlers, EventHandlers, StateExpiredHandlers, HookHandlers, WorkflowHandlers, MessageHandlersMap, EventHandlersMap, StateExpiredHandlersMap, HookHandlersMap, WorkflowHandlersMap } from './server/types';
+import { ActionHandlers, MessageHandlers, EventHandlers, StateExpiredHandlers, HookHandlers, WorkflowHandlers, HookHandlersMap, WorkflowHandlersMap } from './server/types';
 export type PluginImplementationProps<TPlugin extends BasePlugin = BasePlugin> = {
     actions: ActionHandlers<TPlugin>;
 };
@@ -26,9 +26,9 @@ export declare class PluginImplementation<TPlugin extends BasePlugin = BasePlugi
     get hookHandlers(): BotHookHandlersMap<TPlugin>;
     get workflowHandlers(): BotWorkflowHandlersMap<TPlugin>;
     readonly on: {
-        message: <T extends utils.types.StringKeys<MessageHandlersMap<TPlugin>>>(type: T, handler: MessageHandlers<TPlugin>[T]) => void;
-        event: <T extends utils.types.StringKeys<EventHandlersMap<TPlugin>>>(type: T, handler: EventHandlers<TPlugin>[T]) => void;
-        stateExpired: <T extends utils.types.StringKeys<StateExpiredHandlersMap<TPlugin>>>(type: T, handler: StateExpiredHandlers<TPlugin>[T]) => void;
+        message: <T extends utils.types.StringKeys<MessageHandlers<TPlugin>>>(type: T, handler: MessageHandlers<TPlugin>[T]) => void;
+        event: <T extends utils.types.StringKeys<EventHandlers<TPlugin>>>(type: T, handler: EventHandlers<TPlugin>[T]) => void;
+        stateExpired: <T extends utils.types.StringKeys<StateExpiredHandlers<TPlugin>>>(type: T, handler: StateExpiredHandlers<TPlugin>[T]) => void;
         beforeIncomingEvent: <T extends utils.types.StringKeys<HookHandlersMap<TPlugin>["before_incoming_event"]>>(type: T, handler: HookHandlers<TPlugin>["before_incoming_event"][T]) => void;
         beforeIncomingMessage: <T extends utils.types.StringKeys<HookHandlersMap<TPlugin>["before_incoming_message"]>>(type: T, handler: HookHandlers<TPlugin>["before_incoming_message"][T]) => void;
         beforeOutgoingMessage: <T extends utils.types.StringKeys<HookHandlersMap<TPlugin>["before_outgoing_message"]>>(type: T, handler: HookHandlers<TPlugin>["before_outgoing_message"][T]) => void;

package/dist/plugin/message-proxy/index.d.ts

@@ -0,0 +1,2 @@
+export { proxyMessage, proxyMessages } from './proxy';
+export { ActionableMessage, MessageFinder } from './types';

package/dist/plugin/message-proxy/proxy.d.ts

@@ -0,0 +1,13 @@
+import type * as client from '@botpress/client';
+import type { BotSpecificClient } from '../../bot';
+import type { BasePlugin, PluginRuntimeProps } from '../common';
+import type { ActionableMessage, AnyPluginMessage, MessageFinder } from './types';
+export declare const proxyMessages: <TPlugin extends BasePlugin>(props: {
+    client: BotSpecificClient<TPlugin> | client.Client;
+    plugin?: PluginRuntimeProps<TPlugin>;
+}) => MessageFinder<TPlugin>;
+export declare const proxyMessage: <TPlugin extends BasePlugin, TMessage extends client.Message | AnyPluginMessage<TPlugin> = AnyPluginMessage<TPlugin>>(props: {
+    client: BotSpecificClient<TPlugin> | client.Client;
+    plugin?: PluginRuntimeProps<TPlugin>;
+    message: TMessage;
+}) => ActionableMessage<TPlugin, TMessage>;

package/dist/plugin/message-proxy/types.d.ts

@@ -0,0 +1,22 @@
+import type * as client from '@botpress/client';
+import type { GetMessages } from '../../bot';
+import type { commonTypes } from '../../common';
+import type { AsyncCollection } from '../../utils/api-paging-utils';
+import type * as typeUtils from '../../utils/type-utils';
+import type { BasePlugin } from '../common';
+import type { IncomingMessages } from '../server';
+export type MessageFinder<TPlugin extends BasePlugin> = {
+    list: (props?: Omit<client.ClientInputs['listMessages'], 'nextToken'>) => AsyncCollection<ActionableMessage<TPlugin>>;
+    getById: (props: {
+        id: string;
+    }) => Promise<ActionableMessage<TPlugin>>;
+};
+export type AnyPluginMessage<TPlugin extends BasePlugin> = IncomingMessages<TPlugin>['*'] | IncomingMessages<TPlugin>[typeUtils.StringKeys<GetMessages<TPlugin>>];
+export type ActionableMessage<TPlugin extends BasePlugin, TMessage extends client.Message | AnyPluginMessage<TPlugin> = client.Message> = typeUtils.Merge<TMessage, {
+    tags: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['conversation']['tags']>>;
+}> & {
+    delete: () => Promise<void>;
+    update: (props: typeUtils.Merge<Omit<client.ClientInputs['updateMessage'], 'id'>, {
+        tags: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['message']['tags']>>;
+    }>) => Promise<ActionableMessage<TPlugin, TMessage>>;
+};