@holocronlab/botruntime-sdk 6.13.3

package/dist/bot/definition.d.ts

@@ -0,0 +1,214 @@
+import { Table } from '@holocronlab/botruntime-client';
+import { SchemaTransformOptions } from '../common/types';
+import { IntegrationPackage, PluginPackage } from '../package';
+import { PluginInterfaceExtension, PluginIntegrationExtension } from '../plugin';
+import { SchemaDefinition } from '../schema';
+import { ValueOf, Merge, StringKeys } from '../utils/type-utils';
+import { z } from '../zui';
+type BaseConfig = z.ZuiObjectSchema;
+type BaseStates = Record<string, z.ZuiObjectOrRefSchema>;
+type BaseEvents = Record<string, z.ZuiObjectOrRefSchema>;
+type BaseActions = Record<string, z.ZuiObjectOrRefSchema>;
+type BaseTables = Record<string, z.ZuiObjectOrRefSchema>;
+type BaseWorkflows = Record<string, z.ZuiObjectSchema>;
+export type TagDefinition = {
+    title?: string;
+    description?: string;
+};
+export type StateType = 'conversation' | 'user' | 'bot' | 'workflow';
+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> & {
+    recurrence?: {
+        cron: string;
+        payload: z.input<TEvent>;
+    };
+    attributes?: Record<string, string>;
+};
+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 SecretDefinition = {
+    optional?: boolean;
+    description?: string;
+};
+export type ActionDefinition<TAction extends BaseActions[string] = BaseActions[string]> = {
+    title?: string;
+    description?: string;
+    input: SchemaDefinition<TAction>;
+    output: SchemaDefinition<z.ZuiObjectOrRefSchema>;
+    attributes?: Record<string, string>;
+};
+export type WorkflowDefinition<TWorkflow extends BaseWorkflows[string] = BaseWorkflows[string]> = {
+    title?: string;
+    description?: string;
+    input: SchemaDefinition<TWorkflow>;
+    output: SchemaDefinition<z.ZuiObjectSchema>;
+    tags?: Record<string, TagDefinition>;
+};
+export type TableDefinition<TTable extends BaseTables[string] = BaseTables[string]> = Merge<Omit<Table, 'id' | 'createdAt' | 'updatedAt' | 'name'>, {
+    schema: TTable;
+}>;
+export type ResolvedIntegrationConfigInstance<I extends IntegrationPackage = IntegrationPackage> = {
+    enabled?: boolean;
+    alias: string;
+    disabledChannels?: StringKeys<NonNullable<I['definition']['channels']>>[];
+} & ({
+    configurationType?: null;
+    configuration: z.input<NonNullable<I['definition']['configuration']>['schema']>;
+} | ValueOf<{
+    [K in StringKeys<NonNullable<I['definition']['configurations']>>]: {
+        configurationType: K;
+        configuration: z.input<NonNullable<I['definition']['configurations']>[K]['schema']>;
+    };
+}>);
+type IntegrationConfigInstance<I extends IntegrationPackage = IntegrationPackage> = Omit<ResolvedIntegrationConfigInstance<I>, 'alias'> & {
+    alias?: string;
+};
+type _ResolvedPluginConfigInstance<P extends PluginPackage = PluginPackage> = {
+    alias: string;
+    configuration: z.input<NonNullable<P['definition']['configuration']>['schema']>;
+    interfaces: {
+        [I in keyof NonNullable<P['definition']['interfaces']>]: PluginInterfaceExtension;
+    };
+    integrations: {
+        [I in keyof NonNullable<P['definition']['integrations']>]: PluginIntegrationExtension;
+    };
+};
+type PluginConfigInstance<P extends PluginPackage = PluginPackage> = Omit<_ResolvedPluginConfigInstance<P>, 'alias' | 'integrations' | 'interfaces'> & {
+    alias?: string;
+    /** Backing integrations for the plugin's dependencies */
+    dependencies: {
+        [K in StringKeys<NonNullable<P['definition']['interfaces']>>]: {
+            /**
+             * Alias of the integration to use to fullfil this dependency.
+             *
+             * This is the alias given when adding the integration to the bot
+             * via `addIntegration()`.
+             */
+            integrationAlias: string;
+            /**
+             * Alias of the interface within the integration.
+             *
+             * This is the alias defined by the integration package for the
+             * interface it implements.
+             */
+            integrationInterfaceAlias: string;
+        };
+    } & {
+        [K in StringKeys<NonNullable<P['definition']['integrations']>>]: {
+            /**
+             * Alias of the integration to use to fullfil this dependency.
+             *
+             * This is the alias given when adding the integration to the bot
+             * via `addIntegration()`.
+             */
+            integrationAlias: string;
+        };
+    };
+};
+export type IntegrationInstance = IntegrationPackage & ResolvedIntegrationConfigInstance;
+export type PluginInstance = PluginPackage & _ResolvedPluginConfigInstance;
+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;
+    };
+    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]>;
+    };
+    /** @deprecated Use the `recurrence` field on each event in `events` instead. */
+    recurringEvents?: Record<string, RecurringEventDefinition<TEvents>>;
+    actions?: {
+        [K in keyof TActions]: ActionDefinition<TActions[K]>;
+    };
+    tables?: {
+        [K in keyof TTables]: TableDefinition<TTables[K]>;
+    };
+    secrets?: Record<string, SecretDefinition>;
+    /**
+     * # EXPERIMENTAL
+     * This API is experimental and may change in the future.
+     */
+    workflows?: {
+        [K in keyof TWorkflows]: WorkflowDefinition<TWorkflows[K]>;
+    };
+    attributes?: Record<string, string>;
+    __advanced?: SchemaTransformOptions;
+};
+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'];
+    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'];
+    readonly tables: this['props']['tables'];
+    readonly secrets: this['props']['secrets'];
+    readonly workflows: this['props']['workflows'];
+    readonly attributes: this['props']['attributes'];
+    readonly __advanced: this['props']['__advanced'];
+    /** Bot definition with plugins merged into it */
+    readonly withPlugins: Pick<this['props'], 'user' | 'conversation' | 'message' | 'states' | 'events' | 'recurringEvents' | 'actions' | 'tables' | 'workflows'>;
+    constructor(props: BotDefinitionProps<TStates, TEvents, TActions, TTables, TWorkflows>);
+    get metadata(): {
+        readonly sdkVersion: string;
+    };
+    readonly clone?: (overrides?: Partial<BotDefinitionProps>) => BotDefinition;
+    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;
+    private _mergeTables;
+    private _mergeWorkflows;
+    private _prefixKeysWithPluginAlias;
+    /**
+     * Returns a copy of the bot definition where all interface entity references
+     * are resolved to the base entity schema as extended by the backing
+     * integration.
+     */
+    dereferencePluginEntities(): this;
+    private _buildZuiReferenceMap;
+    private _dereferenceZuiSchema;
+    private _dereferenceDefinitionSchemas;
+    private _dereferenceDefinitionSchema;
+    private _dereferenceActionDefinitionSchemas;
+}
+export {};

package/dist/bot/definition.test.d.ts

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

package/dist/bot/implementation.d.ts

@@ -0,0 +1,72 @@
+import type { Server } from 'node:http';
+import { BasePlugin, PluginImplementation } from '../plugin';
+import * as utils from '../utils';
+import { BaseBot } from './common';
+import { MessageHandlers, EventHandlers, StateExpiredHandlers, HookHandlers, WorkflowHandlers, MessageHandlersMap, EventHandlersMap, StateExpiredHandlersMap, HookHandlersMap, WorkflowHandlersMap, UnimplementedActionHandlers, InjectedBotHandlers, RegisterHandler } from './server';
+export type BotImplementationProps<TBot extends BaseBot = BaseBot, TPlugins extends Record<string, BasePlugin> = {}> = {
+    register?: RegisterHandler<TBot>;
+    actions: UnimplementedActionHandlers<TBot, TPlugins>;
+    plugins: {
+        [K in utils.types.StringKeys<TPlugins>]: PluginImplementation<TPlugins[K]>;
+    };
+};
+export declare class BotImplementation<TBot extends BaseBot = BaseBot, TPlugins extends Record<string, BasePlugin> = {}> implements InjectedBotHandlers<TBot> {
+    readonly props: BotImplementationProps<TBot, TPlugins>;
+    private _registerHandler;
+    private _actionHandlers;
+    private _messageHandlers;
+    private _eventHandlers;
+    private _stateExpiredHandlers;
+    private _hookHandlers;
+    private _workflowHandlers;
+    private _plugins;
+    private _registerOrder;
+    constructor(props: BotImplementationProps<TBot, TPlugins>);
+    get registerHandler(): RegisterHandler<TBot> | undefined;
+    get actionHandlers(): InjectedBotHandlers<TBot>['actionHandlers'];
+    get messageHandlers(): InjectedBotHandlers<TBot>['messageHandlers'];
+    get eventHandlers(): InjectedBotHandlers<TBot>['eventHandlers'];
+    get stateExpiredHandlers(): InjectedBotHandlers<TBot>['stateExpiredHandlers'];
+    get hookHandlers(): InjectedBotHandlers<TBot>['hookHandlers'];
+    get workflowHandlers(): InjectedBotHandlers<TBot>['workflowHandlers'];
+    readonly on: {
+        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;
+        /**
+         * # EXPERIMENTAL
+         * This API is experimental and may change in the future.
+         */
+        beforeIncomingCallAction: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["before_incoming_call_action"]>>(type: T, handler: HookHandlers<TBot>["before_incoming_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.
+         */
+        afterIncomingCallAction: <T extends utils.types.StringKeys<HookHandlersMap<TBot>["after_incoming_call_action"]>>(type: T, handler: HookHandlers<TBot>["after_incoming_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/implementation.test.d.ts

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

package/dist/bot/index.d.ts

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

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 '../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/responses.d.ts

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