@botpress/sdk 2.0.4 → 2.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,12 @@
+
+> @botpress/sdk@2.1.0 build /home/runner/work/botpress/botpress/packages/sdk
+> pnpm build:type && pnpm build:node
+
+
+> @botpress/sdk@2.1.0 build:type /home/runner/work/botpress/botpress/packages/sdk
+> tsc --emitDeclarationOnly --declaration
+
+
+> @botpress/sdk@2.1.0 build:node /home/runner/work/botpress/botpress/packages/sdk
+> ts-node -T build.ts
+

package/dist/base-logger.d.ts

@@ -0,0 +1,13 @@
+export declare abstract class BaseLogger<TOptions extends object> {
+    protected defaultOptions: TOptions;
+    protected constructor(defaultOptions: TOptions);
+    abstract with(options: TOptions): BaseLogger<TOptions>;
+    info(...args: Parameters<typeof console.info>): void;
+    debug(...args: Parameters<typeof console.debug>): void;
+    warn(...args: Parameters<typeof console.warn>): void;
+    error(...args: Parameters<typeof console.error>): void;
+    private _log;
+    private _serializeMessage;
+    protected getJsonMessage(msg: string): string;
+    private _getConsoleMethod;
+}

package/dist/bot/bot-logger.d.ts

@@ -0,0 +1,14 @@
+import { BaseLogger } from '../base-logger';
+type BotLogOptions = {
+    userID?: string;
+    conversationID?: string;
+    workflowID?: string;
+};
+export declare class BotLogger extends BaseLogger<BotLogOptions> {
+    constructor(options?: BotLogOptions);
+    with(options: BotLogOptions): BotLogger;
+    withUserID(userID: string): BotLogger;
+    withConversationID(conversationID: string): BotLogger;
+    withWorkflowID(workflowID: string): BotLogger;
+}
+export {};

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

@@ -0,0 +1,62 @@
+import * as client from '@botpress/client';
+import * as common from '../types';
+import * as types from './types';
+export * from './types';
+/**
+ * Just like the regular botpress client, but typed with the bot's properties.
+ */
+export declare class BotSpecificClient<TBot extends common.BaseBot> implements types.ClientOperations<TBot> {
+    private _client;
+    private _hooks;
+    constructor(_client: client.Client, _hooks?: types.ClientHooks);
+    getConversation: types.GetConversation<TBot>;
+    listConversations: types.ListConversations<TBot>;
+    updateConversation: types.UpdateConversation<TBot>;
+    deleteConversation: types.DeleteConversation<TBot>;
+    listParticipants: types.ListParticipants<TBot>;
+    addParticipant: types.AddParticipant<TBot>;
+    getParticipant: types.GetParticipant<TBot>;
+    removeParticipant: types.RemoveParticipant<TBot>;
+    getEvent: types.GetEvent<TBot>;
+    listEvents: types.ListEvents<TBot>;
+    createMessage: types.CreateMessage<TBot>;
+    getOrCreateMessage: types.GetOrCreateMessage<TBot>;
+    getMessage: types.GetMessage<TBot>;
+    updateMessage: types.UpdateMessage<TBot>;
+    listMessages: types.ListMessages<TBot>;
+    deleteMessage: types.DeleteMessage<TBot>;
+    getUser: types.GetUser<TBot>;
+    listUsers: types.ListUsers<TBot>;
+    updateUser: types.UpdateUser<TBot>;
+    deleteUser: types.DeleteUser<TBot>;
+    getState: types.GetState<TBot>;
+    setState: types.SetState<TBot>;
+    getOrSetState: types.GetOrSetState<TBot>;
+    patchState: types.PatchState<TBot>;
+    callAction: types.CallAction<TBot>;
+    uploadFile: types.UploadFile<TBot>;
+    upsertFile: types.UpsertFile<TBot>;
+    deleteFile: types.DeleteFile<TBot>;
+    listFiles: types.ListFiles<TBot>;
+    getFile: types.GetFile<TBot>;
+    updateFileMetadata: types.UpdateFileMetadata<TBot>;
+    searchFiles: types.SearchFiles<TBot>;
+    trackAnalytics: types.TrackAnalytics<TBot>;
+    /**
+     * @deprecated Use `callAction` to delegate the conversation creation to an integration.
+     */
+    createConversation: types.CreateConversation<TBot>;
+    /**
+     * @deprecated Use `callAction` to delegate the conversation creation to an integration.
+     */
+    getOrCreateConversation: types.GetOrCreateConversation<TBot>;
+    /**
+     * @deprecated Use `callAction` to delegate the user creation to an integration.
+     */
+    createUser: types.CreateUser<TBot>;
+    /**
+     * @deprecated Use `callAction` to delegate the user creation to an integration.
+     */
+    getOrCreateUser: types.GetOrCreateUser<TBot>;
+    private _run;
+}

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

@@ -0,0 +1,141 @@
+import * as client from '@botpress/client';
+import * as utils from '../../utils/type-utils';
+import * as common from '../types';
+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> = {
+    event: {
+        [K in keyof common.EnumerateEvents<TBot>]: utils.Merge<client.Event, {
+            type: K;
+            payload: common.EnumerateEvents<TBot>[K];
+        }>;
+    }[keyof common.EnumerateEvents<TBot>];
+};
+type MessageResponse<TBot extends common.BaseBot, TMessage extends keyof common.GetMessages<TBot> = keyof common.GetMessages<TBot>> = {
+    message: utils.ValueOf<{
+        [K in keyof common.GetMessages<TBot> as K extends TMessage ? K : never]: utils.Merge<client.Message, {
+            type: K;
+            payload: common.GetMessages<TBot>[K];
+        }>;
+    }>;
+};
+type StateResponse<TBot extends common.BaseBot, TState extends keyof TBot['states'] = keyof TBot['states']> = utils.Merge<Awaited<Res<client.Client['getState']>>, {
+    state: utils.Merge<Awaited<Res<client.Client['getState']>>['state'], {
+        payload: TBot['states'][TState];
+    }>;
+}>;
+export type CreateConversation<_TBot extends common.BaseBot> = client.Client['createConversation'];
+export type GetConversation<_TBot extends common.BaseBot> = client.Client['getConversation'];
+export type ListConversations<_TBot extends common.BaseBot> = client.Client['listConversations'];
+export type GetOrCreateConversation<_TBot extends common.BaseBot> = client.Client['getOrCreateConversation'];
+export type UpdateConversation<_TBot extends common.BaseBot> = client.Client['updateConversation'];
+export type DeleteConversation<_TBot extends common.BaseBot> = client.Client['deleteConversation'];
+export type ListParticipants<_TBot extends common.BaseBot> = client.Client['listParticipants'];
+export type AddParticipant<_TBot extends common.BaseBot> = client.Client['addParticipant'];
+export type GetParticipant<_TBot extends common.BaseBot> = client.Client['getParticipant'];
+export type RemoveParticipant<_TBot extends common.BaseBot> = client.Client['removeParticipant'];
+export type GetEvent<TBot extends common.BaseBot> = (x: Arg<client.Client['getEvent']>) => Promise<EventResponse<TBot>>;
+export type ListEvents<_TBot extends common.BaseBot> = client.Client['listEvents'];
+export type CreateMessage<TBot extends common.BaseBot> = <TMessage extends keyof common.GetMessages<TBot>>(x: utils.Merge<Arg<client.Client['createMessage']>, {
+    type: utils.Cast<TMessage, string>;
+    payload: utils.Cast<common.GetMessages<TBot>[TMessage], Record<string, any>>;
+}>) => Promise<MessageResponse<TBot, TMessage>>;
+export type GetOrCreateMessage<TBot extends common.BaseBot> = <TMessage extends keyof common.GetMessages<TBot>>(x: utils.Merge<Arg<client.Client['getOrCreateMessage']>, {
+    type: utils.Cast<TMessage, string>;
+    payload: utils.Cast<common.GetMessages<TBot>[TMessage], Record<string, any>>;
+}>) => Promise<MessageResponse<TBot, TMessage>>;
+export type GetMessage<TBot extends common.BaseBot> = (x: Arg<client.Client['getMessage']>) => Promise<MessageResponse<TBot>>;
+export type UpdateMessage<TBot extends common.BaseBot> = (x: Arg<client.Client['updateMessage']>) => Promise<MessageResponse<TBot>>;
+export type ListMessages<_TBot extends common.BaseBot> = client.Client['listMessages'];
+export type DeleteMessage<_TBot extends common.BaseBot> = client.Client['deleteMessage'];
+export type CreateUser<_TBot extends common.BaseBot> = client.Client['createUser'];
+export type GetUser<_TBot extends common.BaseBot> = client.Client['getUser'];
+export type ListUsers<_TBot extends common.BaseBot> = client.Client['listUsers'];
+export type GetOrCreateUser<_TBot extends common.BaseBot> = client.Client['getOrCreateUser'];
+export type UpdateUser<_TBot extends common.BaseBot> = client.Client['updateUser'];
+export type DeleteUser<_TBot extends common.BaseBot> = client.Client['deleteUser'];
+export type GetState<TBot extends common.BaseBot> = <TState extends keyof TBot['states']>(x: utils.Merge<Arg<client.Client['getState']>, {
+    name: utils.Cast<TState, string>;
+}>) => Promise<StateResponse<TBot, TState>>;
+export type SetState<TBot extends common.BaseBot> = <TState extends keyof TBot['states']>(x: utils.Merge<Arg<client.Client['setState']>, {
+    name: utils.Cast<TState, string>;
+    payload: TBot['states'][TState] | null;
+}>) => Promise<StateResponse<TBot, TState>>;
+export type GetOrSetState<TBot extends common.BaseBot> = <TState extends keyof TBot['states']>(x: utils.Merge<Arg<client.Client['getOrSetState']>, {
+    name: utils.Cast<TState, string>;
+    payload: TBot['states'][TState];
+}>) => Promise<StateResponse<TBot, TState>>;
+export type PatchState<TBot extends common.BaseBot> = <TState extends keyof TBot['states']>(x: utils.Merge<Arg<client.Client['patchState']>, {
+    name: utils.Cast<TState, string>;
+    payload: Partial<TBot['states'][TState]>;
+}>) => Promise<{
+    state: utils.Merge<Awaited<Res<client.Client['patchState']>>['state'], {
+        payload: TBot['states'][TState];
+    }>;
+}>;
+export type CallAction<TBot extends common.BaseBot> = <ActionType extends keyof common.EnumerateActions<TBot>>(x: utils.Merge<Arg<client.Client['callAction']>, {
+    type: utils.Cast<ActionType, string>;
+    input: utils.Cast<common.EnumerateActions<TBot>[ActionType], common.IntegrationInstanceActionDefinition>['input'];
+}>) => Promise<utils.Merge<Awaited<Res<client.Client['callAction']>>, {
+    output: utils.Cast<common.EnumerateActions<TBot>[ActionType], common.IntegrationInstanceActionDefinition>['output'];
+}>>;
+export type UploadFile<_TBot extends common.BaseBot> = client.Client['uploadFile'];
+export type UpsertFile<_TBot extends common.BaseBot> = client.Client['upsertFile'];
+export type DeleteFile<_TBot extends common.BaseBot> = client.Client['deleteFile'];
+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 TrackAnalytics<_TBot extends common.BaseBot> = client.Client['trackAnalytics'];
+export type ClientOperations<TBot extends common.BaseBot> = {
+    getConversation: GetConversation<TBot>;
+    listConversations: ListConversations<TBot>;
+    updateConversation: UpdateConversation<TBot>;
+    deleteConversation: DeleteConversation<TBot>;
+    listParticipants: ListParticipants<TBot>;
+    addParticipant: AddParticipant<TBot>;
+    getParticipant: GetParticipant<TBot>;
+    removeParticipant: RemoveParticipant<TBot>;
+    getEvent: GetEvent<TBot>;
+    listEvents: ListEvents<TBot>;
+    createMessage: CreateMessage<TBot>;
+    getOrCreateMessage: GetOrCreateMessage<TBot>;
+    getMessage: GetMessage<TBot>;
+    updateMessage: UpdateMessage<TBot>;
+    listMessages: ListMessages<TBot>;
+    deleteMessage: DeleteMessage<TBot>;
+    getUser: GetUser<TBot>;
+    listUsers: ListUsers<TBot>;
+    updateUser: UpdateUser<TBot>;
+    deleteUser: DeleteUser<TBot>;
+    getState: GetState<TBot>;
+    setState: SetState<TBot>;
+    getOrSetState: GetOrSetState<TBot>;
+    patchState: PatchState<TBot>;
+    callAction: CallAction<TBot>;
+    uploadFile: UploadFile<TBot>;
+    upsertFile: UpsertFile<TBot>;
+    deleteFile: DeleteFile<TBot>;
+    listFiles: ListFiles<TBot>;
+    getFile: GetFile<TBot>;
+    updateFileMetadata: UpdateFileMetadata<TBot>;
+    searchFiles: SearchFiles<TBot>;
+    trackAnalytics: TrackAnalytics<TBot>;
+};
+export type ClientInputs<TBot extends common.BaseBot> = {
+    [K in keyof ClientOperations<TBot>]: Arg<ClientOperations<TBot>[K]>;
+};
+export type ClientOutputs<TBot extends common.BaseBot> = {
+    [K in keyof ClientOperations<TBot>]: Awaited<Res<ClientOperations<TBot>[K]>>;
+};
+type ClientHooksBefore = {
+    [K in client.Operation]?: (x: client.ClientInputs[K]) => Promise<client.ClientInputs[K]>;
+};
+type ClientHooksAfter = {
+    [K in client.Operation]?: (x: client.ClientOutputs[K]) => Promise<client.ClientOutputs[K]>;
+};
+export type ClientHooks = {
+    before: ClientHooksBefore;
+    after: ClientHooksAfter;
+};
+export {};

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

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

package/dist/bot/definition.d.ts

@@ -0,0 +1,111 @@
+import { IntegrationPackage, PluginPackage } from '../package';
+import { SchemaDefinition } from '../schema';
+import { ValueOf } from '../utils/type-utils';
+import z, { ZuiObjectSchema } from '../zui';
+type BaseConfig = ZuiObjectSchema;
+type BaseStates = Record<string, ZuiObjectSchema>;
+type BaseEvents = Record<string, ZuiObjectSchema>;
+type BaseActions = Record<string, ZuiObjectSchema>;
+export type TagDefinition = {
+    title?: string;
+    description?: string;
+};
+export type StateType = 'conversation' | 'user' | 'bot';
+export type StateDefinition<TState extends BaseStates[string] = BaseStates[string]> = SchemaDefinition<TState> & {
+    type: StateType;
+    expiry?: number;
+};
+export type RecurringEventDefinition<TEvents extends BaseEvents = BaseEvents> = {
+    [K in keyof TEvents]: {
+        type: K;
+        payload: z.infer<TEvents[K]>;
+        schedule: {
+            cron: string;
+        };
+    };
+}[keyof TEvents];
+export type EventDefinition<TEvent extends BaseEvents[string] = BaseEvents[string]> = SchemaDefinition<TEvent>;
+export type ConfigurationDefinition<TConfig extends BaseConfig = BaseConfig> = SchemaDefinition<TConfig>;
+export type UserDefinition = {
+    tags?: Record<string, TagDefinition>;
+};
+export type ConversationDefinition = {
+    tags?: Record<string, TagDefinition>;
+};
+export type MessageDefinition = {
+    tags?: Record<string, TagDefinition>;
+};
+export type ActionDefinition<TAction extends BaseActions[string] = BaseActions[string]> = {
+    title?: string;
+    description?: string;
+    input: SchemaDefinition<TAction>;
+    output: SchemaDefinition<ZuiObjectSchema>;
+};
+export type IntegrationConfigInstance<I extends IntegrationPackage = IntegrationPackage> = {
+    enabled: boolean;
+} & ({
+    configurationType?: null;
+    configuration: z.infer<NonNullable<I['definition']['configuration']>['schema']>;
+} | ValueOf<{
+    [K in keyof NonNullable<I['definition']['configurations']>]: {
+        configurationType: K;
+        configuration: z.infer<NonNullable<I['definition']['configurations']>[K]['schema']>;
+    };
+}>);
+export type PluginConfigInstance<P extends PluginPackage = PluginPackage> = {
+    configuration: z.infer<NonNullable<P['definition']['configuration']>['schema']>;
+    interfaces: {
+        [I in keyof NonNullable<P['definition']['interfaces']>]: {
+            name: string;
+            version: string;
+        };
+    };
+};
+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> = {
+    integrations?: {
+        [K: string]: IntegrationInstance;
+    };
+    plugins?: {
+        [K: string]: PluginInstance;
+    };
+    user?: UserDefinition;
+    conversation?: ConversationDefinition;
+    message?: MessageDefinition;
+    states?: {
+        [K in keyof TStates]: StateDefinition<TStates[K]>;
+    };
+    configuration?: ConfigurationDefinition;
+    events?: {
+        [K in keyof TEvents]: EventDefinition<TEvents[K]>;
+    };
+    recurringEvents?: Record<string, RecurringEventDefinition<TEvents>>;
+    actions?: {
+        [K in keyof TActions]: ActionDefinition<TActions[K]>;
+    };
+};
+export declare class BotDefinition<TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions> {
+    readonly props: BotDefinitionProps<TStates, TEvents, TActions>;
+    readonly integrations: this['props']['integrations'];
+    readonly plugins: this['props']['plugins'];
+    readonly user: this['props']['user'];
+    readonly conversation: this['props']['conversation'];
+    readonly message: this['props']['message'];
+    readonly states: this['props']['states'];
+    readonly configuration: this['props']['configuration'];
+    readonly events: this['props']['events'];
+    readonly recurringEvents: this['props']['recurringEvents'];
+    readonly actions: this['props']['actions'];
+    constructor(props: BotDefinitionProps<TStates, TEvents, TActions>);
+    addIntegration<I extends IntegrationPackage>(integrationPkg: I, config: IntegrationConfigInstance<I>): this;
+    addPlugin<P extends PluginPackage>(pluginPkg: P, config: PluginConfigInstance<P>): this;
+    private _mergeUser;
+    private _mergeConversation;
+    private _mergeMessage;
+    private _mergeStates;
+    private _mergeEvents;
+    private _mergeRecurringEvents;
+    private _mergeActions;
+}
+export {};

package/dist/bot/implementation.d.ts

@@ -0,0 +1,39 @@
+import type { Server } from 'node:http';
+import { BasePlugin, PluginImplementation } from '../plugin';
+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: {
+        [K in keyof TPlugins]: PluginImplementation<TPlugins[K]>;
+    };
+};
+export declare class BotImplementation<TBot extends BaseBot = BaseBot, TPlugins extends Record<string, BasePlugin> = {}> implements BotHandlers<TBot> {
+    readonly props: BotImplementationProps<TBot, TPlugins>;
+    readonly actionHandlers: ActionHandlers<TBot>;
+    readonly messageHandlers: MessageHandlersMap<TBot>;
+    readonly eventHandlers: EventHandlersMap<TBot>;
+    readonly stateExpiredHandlers: StateExpiredHandlersMap<TBot>;
+    readonly hookHandlers: HookHandlersMap<TBot>;
+    /**
+     * alias for actionHandlers
+     */
+    get actions(): ActionHandlers<TBot>;
+    constructor(props: BotImplementationProps<TBot, TPlugins>);
+    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;
+    };
+    private readonly _use;
+    readonly handler: (req: import("../serve").Request) => Promise<import("../serve").Response | void>;
+    readonly start: (port?: number) => Promise<Server>;
+}

package/dist/bot/index.d.ts

@@ -0,0 +1,6 @@
+export * from './definition';
+export * from './implementation';
+export * from './client';
+export * from './server';
+export * from './types/generic';
+export * from './bot-logger';

package/dist/bot/merge-bots.d.ts

@@ -0,0 +1,2 @@
+import { BotHandlers } from './server';
+export declare const mergeBots: (dest: BotHandlers<any>, src: BotHandlers<any>) => void;

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

@@ -0,0 +1,2 @@
+import { BotContext } from './types';
+export declare const extractContext: (headers: Record<string, string | undefined>) => BotContext;

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

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