@wabot-dev/framework 0.1.0-beta.25 → 0.1.0-beta.27

package/dist/src/ai/deepseek/DeepSeekChatBotAdapter.js

@@ -92,7 +92,7 @@ let DeepSeekChatBotAdapter = class DeepSeekChatBotAdapter extends ChatBotAdapter
                 deepSeekInput.push({
                     role: 'tool',
                     tool_call_id: itemData.content.id,
-                    content: itemData.content.result,
+                    content: itemData.content.result ?? 'No result',
                 });
             }
         }

package/dist/src/ai/openia/OpenaiChatAdapter.js

@@ -0,0 +1,101 @@
+import { Logger } from '../../logger/Logger.js';
+import { OpenAI } from 'openai';
+
+class OpenaiChatAdapter {
+    openai = new OpenAI();
+    logger = new Logger('wabot:openai-chat-adapter');
+    async nextItem(req) {
+        const openIaInput = [];
+        openIaInput.push({ role: 'system', content: req.systemPrompt });
+        openIaInput.push(...this.mapChatItems(req.prevItems));
+        const tools = req.tools.map((x) => this.mapTool(x));
+        const response = await this.openai.responses.create({
+            model: req.model,
+            input: openIaInput,
+            tools,
+        });
+        return this.mapResponse(response);
+    }
+    mapChatItems(chatItems) {
+        const openIaInput = [];
+        for (const { type, content } of chatItems) {
+            switch (type) {
+                case 'CONNECTION_MESSAGE':
+                    openIaInput.push(this.mapConectionMessage(content));
+                    break;
+                case 'BOT_MESSAGE':
+                    openIaInput.push(this.mapBotMessage(content));
+                    break;
+                case 'FUNCTION_CALL':
+                    openIaInput.push(...this.mapFunctionCall(content));
+                    break;
+            }
+        }
+        return openIaInput;
+    }
+    mapConectionMessage(item) {
+        if (!item.text) {
+            throw new Error('System message content is empty');
+        }
+        return { role: 'user', content: item.text };
+    }
+    mapBotMessage(item) {
+        if (!item.text) {
+            throw new Error('System message content is empty');
+        }
+        return { role: 'assistant', content: item.text };
+    }
+    mapFunctionCall(item) {
+        return [
+            {
+                type: 'function_call',
+                call_id: item.id,
+                name: item.name,
+                arguments: JSON.stringify(item.arguments),
+            },
+            {
+                type: 'function_call_output',
+                call_id: item.id,
+                output: item.result ?? 'Not result',
+            },
+        ];
+    }
+    mapTool(tool) {
+        return {
+            type: 'function',
+            name: tool.name,
+            description: tool.description,
+            parameters: {
+                type: 'object',
+                properties: tool.parameters.reduce((prev, param) => ({
+                    ...prev,
+                    [param.name]: { type: param.type, description: param.description },
+                }), {}),
+                required: tool.parameters.map((param) => param.name),
+            },
+            strict: true,
+        };
+    }
+    mapResponse(response) {
+        let newItem;
+        if (response.output_text) {
+            newItem = { type: 'BOT_MESSAGE', content: { text: response.output_text } };
+        }
+        else if (response.output && response.output[0]?.type == 'function_call') {
+            newItem = {
+                type: 'FUNCTION_CALL',
+                content: {
+                    id: response.output[0].call_id,
+                    name: response.output[0].name,
+                    arguments: response.output[0].arguments,
+                },
+            };
+        }
+        else {
+            throw new Error('Not supported OpenIA Response');
+        }
+        return newItem;
+    }
+}
+
+export { OpenaiChatAdapter };

package/dist/src/ai/openia/OpenaiChatBotAdapter.js

@@ -73,7 +73,7 @@ let OpenaiChatBotAdapter = class OpenaiChatBotAdapter extends ChatBotAdapter {
                 openIaInput.push({
                     type: 'function_call_output',
                     call_id: itemData.content.id,
-                    output: itemData.content.result,
+                    output: itemData.content.result ?? 'Not result',
                 });
             }
         }

package/dist/src/index.d.ts

@@ -117,7 +117,7 @@ interface IChatMessage extends IStorableData {
     text?: string;
     documents?: IChatDocument[];
     images?: IChatImage[];
-    senderName: string;
+    senderName?: string;
 }
 interface IConnectionChatMessage extends IChatMessage {
     chatConnection: IChatConnection;
@@ -129,7 +129,7 @@ interface IChatFunctionCall {
     id: string;
     name: string;
     arguments?: string;
-    result: string;
+    result?: string;
 }
 
 type ISystemMessageItem = {
@@ -144,7 +144,8 @@ type ISystemFunctionCallItem = {
     type: 'FUNCTION_CALL';
     content: IChatFunctionCall;
 };
-type IChatItemData = IEntityData & (ISystemMessageItem | IReceivedMessageItem | ISystemFunctionCallItem);
+type IChatItemRawData = ISystemMessageItem | IReceivedMessageItem | ISystemFunctionCallItem;
+type IChatItemData = IEntityData & IChatItemRawData;
 type IChatItemType = IChatItemData['type'];
 declare class ChatItem extends Entity<IChatItemData> {
     getType(): "BOT_MESSAGE" | "CONNECTION_MESSAGE" | "FUNCTION_CALL";
@@ -332,7 +333,17 @@ declare class MindsetOperator implements IMindset {
     identity(): Promise<IMindsetIdentity>;
     skills(): Promise<string>;
     limits(): Promise<string>;
+    systemPrompt(): Promise<string>;
+    tools(): IChatTool[];
+    tool(fn: IMindsetFunctionMetadata, module: IMindsetModuleMetadata): IChatTool;
+    private toolParameter;
+    /**
+     * @deprecated use id
+     */
     callFunction(name: string, params: string): Promise<string>;
+    /**
+     * @deprecated use id
+     */
     allFunctionsDescriptors(): Promise<{
         readonly type: "function";
         readonly name: string;
@@ -343,7 +354,13 @@ declare class MindsetOperator implements IMindset {
             readonly required: string[];
         };
     }[]>;
+    /**
+     * @deprecated use id
+     */
     private functionDescriptor;
+    /**
+     * @deprecated use id
+     */
     private toolParam;
 }
 
@@ -385,6 +402,27 @@ declare class ChatBot implements IChatBot {
     protected processLoop(callback: (message: IChatMessage) => void): Promise<void>;
 }
 
+interface IChatToolParameter {
+    type: string;
+    name: string;
+    description: string;
+}
+interface IChatTool {
+    language: string;
+    name: string;
+    description: string;
+    parameters: IChatToolParameter[];
+}
+interface IChatAdapterNextItemReq {
+    model: string;
+    systemPrompt: string;
+    tools: IChatTool[];
+    prevItems: IChatItemRawData[];
+}
+interface IChatAdapter {
+    nextItem(req: IChatAdapterNextItemReq): Promise<IChatItemRawData>;
+}
+
 declare class DeepSeekChatBotAdapter extends ChatBotAdapter {
     private deepSeek;
     private model;
@@ -403,6 +441,18 @@ declare class OpenaiChatBotAdapter extends ChatBotAdapter {
     private mapChatItems;
 }
 
+declare class OpenaiChatAdapter implements IChatAdapter {
+    private openai;
+    private logger;
+    nextItem(req: IChatAdapterNextItemReq): Promise<IChatItemRawData>;
+    private mapChatItems;
+    private mapConectionMessage;
+    private mapBotMessage;
+    private mapFunctionCall;
+    private mapTool;
+    private mapResponse;
+}
+
 declare class ClaudeChatBotAdapter extends ChatBotAdapter {
     private anthropic;
     private model;
@@ -465,6 +515,7 @@ declare class Job extends Entity<IJobData> {
 interface ICrudRepository<T> {
     find(id: string): Promise<T | null>;
     findOrThrow(id: string): Promise<T>;
+    findByIds(ids: string[]): Promise<T[]>;
     findAll(id: string): Promise<T[]>;
     create(item: T): Promise<void>;
     update(item: T): Promise<void>;
@@ -515,6 +566,7 @@ declare class PgCrudRepository<P extends Entity<IEntityData>> extends PgReposito
     protected readonly config: IPgRepositoryConfig<P>;
     constructor(pool: Pool, config: IPgRepositoryConfig<P>);
     find(id: string): Promise<P | null>;
+    findByIds(ids: string[]): Promise<P[]>;
     findOrThrow(id: string): Promise<P>;
     findAll(): Promise<P[]>;
     create(item: P): Promise<void>;
@@ -1289,6 +1341,9 @@ interface IModelValidationError extends IValidationError {
         [key: string]: string[];
     };
 }
+interface IArrayValidationError extends IValidationError {
+    items: (IValidationError[] | null)[];
+}
 type IValidationResult<V> = {
     value: V;
     error?: undefined;
@@ -1303,7 +1358,14 @@ type IModelValidationResult<V> = {
     value?: undefined;
     error: IModelValidationError;
 };
-type IValidator = (value: any, options: any) => IValidationResult<any>;
+type IArrayValidationResult<V> = {
+    value: V[];
+    error?: undefined;
+} | {
+    value?: undefined;
+    error: IArrayValidationError;
+};
+type IValidator<V = any, O = any> = (value: V, options: O) => IValidationResult<V>;
 interface IPropertyValidatorInfo {
     propertyName: string;
     validator: IValidator;
@@ -1333,6 +1395,18 @@ declare class ValidationMetadataStore {
     private getConstructorPropertiesValidatorsInfo;
 }
 
+interface IValidateArrayOptions {
+}
+interface IValidateArrayOptionsWithItemsValidators extends IValidateArrayOptions {
+    itemsValidator?: {
+        validator: IValidator;
+        options: any;
+    }[];
+}
+declare function validateArray(value: any, options?: IValidateArrayOptionsWithItemsValidators): IArrayValidationResult<any>;
+
+declare function isArray(options?: IValidateArrayOptions): (target: object, propertyKey: string | symbol) => void;
+
 declare function validateIsBoolean(value: any): IValidationResult<boolean>;
 
 declare function validateIsDate(value: any): IValidationResult<Date>;
@@ -1359,4 +1433,6 @@ declare function validateModel<V>(value: any, info: IModelValidatorsInfo<V>): IM
 
 declare function validate<V>(value: any, modelConstructor: IConstructor<V>): IModelValidationResult<V>;
 
-export { Async, Auth, AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, ClaudeChatBotAdapter, CmdChannel, Command, CommandMetadataStore, Container, ControllerMetadataStore, CustomError, DeepSeekChatBotAdapter, EmailService, Entity, Env, EnvWhatsAppRepository, ExpressProvider, HtmlModule, HttpServerProvider, type IChannelMetadata, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatFunctionCall, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConnectionChatMessage, type IConstructor, type ICrudRepository, type ICustomErrorData, type IEmailService, type IEndPointMetadata, type IEntityData, type IEnvType, type IGetConfig, type IGetWhatsAppTemplateRequest, type IHtmlModuleOptions, type IJobData, type IJobEvent, type IJobEventListener, type IJwtRefreshTokenData, type IListenWhatsAppMessageRequest, type IMessageContext, type IMessageMetadata, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IOtpService, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPostConfig, type IPrimitive, type IPropertyValidatorInfo, type IReceivedMessage, type IReceivedMessageItem, type IRestControllerConfig, type IRestControllerMetadata, type ISendEmailRequest, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type IServerConfig, type IServerProvider, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type IStorableData, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppContact, type IWhatsAppData, type IWhatsAppMessage, type IWhatsAppMessageListener, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsAppTemplate, type IWhatsAppTemplateComponent, type IWhatsAppTemplateMessage, type IWhatsAppTemplateParameter, type IWhatsAppTemplateResponse, type IWhatsAppWebhookPayload, type IWhatsappChannelConfig, type IchatControllerConfig, type IrunChannelProps, Job, JobRepository, JobRunner, JobsEventsHub, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, Mapper, MessageContext, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatBotAdapter, OtpService, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Persistent, PgChatMemory, PgChatRepository, PgCrudRepository, PgRepositoryBase, PgUserRepository, PgWhatsAppRepository, RamChatMemory, RamChatRepository, RamUserRepository, Random, RegisterUserModule, RegisterUserWithEmailRequest, RestControllerMetadataStore, SendOneTimePasswordRequest, SocketChannel, SocketChannelConfig, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, ValidationMetadataStore, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByDevConnection, WhatsAppReceiverByWebHook, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByDevConnection, WhatsappChannelConfig, chatBot, chatController, cmd, command, commandHandler, container, get, inject, injectable, isBoolean, isDate, isModel, isNotEmpty, isNumber, isOptional, isPresent, isString, jwtGuard, max, middleware, min, mindset, mindsetFunction, mindsetModule, param, post, prepareChatContainer, restController, runAsyncCommandHandlers, runChannel, runRestControllers, runServer, scoped, singleton, socket, telegram, validate, validateIsBoolean, validateIsDate, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, whatsapp };
+declare function modelInfo<V>(modelConstructor: IConstructor<V>): IModelValidatorsInfo<V>;
+
+export { Async, Auth, AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, ClaudeChatBotAdapter, CmdChannel, Command, CommandMetadataStore, Container, ControllerMetadataStore, CustomError, DeepSeekChatBotAdapter, EmailService, Entity, Env, EnvWhatsAppRepository, ExpressProvider, HtmlModule, HttpServerProvider, type IArrayValidationError, type IArrayValidationResult, type IChannelMetadata, type IChatAdapter, type IChatAdapterNextItemReq, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatFunctionCall, type IChatItemData, type IChatItemRawData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatTool, type IChatToolParameter, type IChatType, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConnectionChatMessage, type IConstructor, type ICrudRepository, type ICustomErrorData, type IEmailService, type IEndPointMetadata, type IEntityData, type IEnvType, type IGetConfig, type IGetWhatsAppTemplateRequest, type IHtmlModuleOptions, type IJobData, type IJobEvent, type IJobEventListener, type IJwtRefreshTokenData, type IListenWhatsAppMessageRequest, type IMessageContext, type IMessageMetadata, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IOtpService, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPostConfig, type IPrimitive, type IPropertyValidatorInfo, type IReceivedMessage, type IReceivedMessageItem, type IRestControllerConfig, type IRestControllerMetadata, type ISendEmailRequest, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type IServerConfig, type IServerProvider, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type IStorableData, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppContact, type IWhatsAppData, type IWhatsAppMessage, type IWhatsAppMessageListener, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsAppTemplate, type IWhatsAppTemplateComponent, type IWhatsAppTemplateMessage, type IWhatsAppTemplateParameter, type IWhatsAppTemplateResponse, type IWhatsAppWebhookPayload, type IWhatsappChannelConfig, type IchatControllerConfig, type IrunChannelProps, Job, JobRepository, JobRunner, JobsEventsHub, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, Mapper, MessageContext, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatAdapter, OpenaiChatBotAdapter, OtpService, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Persistent, PgChatMemory, PgChatRepository, PgCrudRepository, PgRepositoryBase, PgUserRepository, PgWhatsAppRepository, RamChatMemory, RamChatRepository, RamUserRepository, Random, RegisterUserModule, RegisterUserWithEmailRequest, RestControllerMetadataStore, SendOneTimePasswordRequest, SocketChannel, SocketChannelConfig, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, ValidationMetadataStore, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByDevConnection, WhatsAppReceiverByWebHook, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByDevConnection, WhatsappChannelConfig, chatBot, chatController, cmd, command, commandHandler, container, get, inject, injectable, isArray, isBoolean, isDate, isModel, isNotEmpty, isNumber, isOptional, isPresent, isString, jwtGuard, max, middleware, min, mindset, mindsetFunction, mindsetModule, modelInfo, param, post, prepareChatContainer, restController, runAsyncCommandHandlers, runChannel, runRestControllers, runServer, scoped, singleton, socket, telegram, validate, validateArray, validateIsBoolean, validateIsDate, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, whatsapp };

package/dist/src/index.js

@@ -1,5 +1,6 @@
 export { DeepSeekChatBotAdapter } from './ai/deepseek/DeepSeekChatBotAdapter.js';
 export { OpenaiChatBotAdapter } from './ai/openia/OpenaiChatBotAdapter.js';
+export { OpenaiChatAdapter } from './ai/openia/OpenaiChatAdapter.js';
 export { ClaudeChatBotAdapter } from './ai/claude/ClaudeChatBotAdapter.js';
 export { command } from './async/@command.js';
 export { commandHandler } from './async/@commandHandler.js';
@@ -115,6 +116,7 @@ export { isString } from './validation/metadata/@isString.js';
 export { max } from './validation/metadata/@max.js';
 export { min } from './validation/metadata/@min.js';
 export { ValidationMetadataStore } from './validation/metadata/ValidationMetadataStore.js';
+export { isArray } from './validation/metadata/@isArray.js';
 export { validateIsBoolean } from './validation/validators/validateIsBoolean.js';
 export { validateIsDate } from './validation/validators/validateIsDate.js';
 export { validateIsNotEmpty } from './validation/validators/validateIsNotEmpty.js';
@@ -124,5 +126,7 @@ export { validateMax } from './validation/validators/validateMax.js';
 export { validateMin } from './validation/validators/validateMin.js';
 export { validateIsPresent } from './validation/validators/validateIsPresent.js';
 export { validateModel } from './validation/validators/validateModel.js';
+export { validateArray } from './validation/validators/validateArray.js';
 export { validate } from './validation/validate.js';
+export { modelInfo } from './validation/modelInfo.js';
 export { Container } from './injection/Container.js';

package/dist/src/mindset/MindsetOperator.js

@@ -22,6 +22,80 @@ let MindsetOperator = class MindsetOperator {
     limits() {
         return this.mindset.limits();
     }
+    async systemPrompt() {
+        let [identity, skills, limits] = await Promise.all([
+            this.identity(),
+            this.skills(),
+            this.limits(),
+        ]);
+        const language = identity.language.replaceAll('#', ' ');
+        const name = identity.name.replaceAll('#', ' ');
+        const age = identity.age ? identity.age.toString().replaceAll('#', ' ') : null;
+        const personality = identity.personality ? identity.personality.replaceAll('#', ' ') : null;
+        skills = skills.replaceAll('#', ' ');
+        limits = limits.replaceAll('#', ' ');
+        const systemPrompt = `
+         # System Instructions
+         you should act as a assistant.
+         your main language is ${language}.
+         your name is ${name}.
+         ${age ? 'you are ' + age + ' years old.' : ''}
+         
+          ${personality ? '## Personality (in your main language) \n' + personality : ''}
+  
+          ## Skills (in your main language)
+          ${skills}
+  
+          ## System limitations (in your main language)
+          ${limits}
+  
+          ## Chat memory
+          Next you will receive a chat history,
+          you should use this information to answer the user.
+      `;
+        return systemPrompt;
+    }
+    tools() {
+        return this.metadata.modules
+            .map((module) => module.functions.map((fn) => this.tool(fn, module)))
+            .flat();
+    }
+    tool(fn, module) {
+        const description = fn.config.description.replaceAll('#', ' ');
+        return {
+            language: module.config.language ?? 'english',
+            name: fn.name,
+            description,
+            parameters: fn.params.map((param) => this.toolParameter(param)),
+        };
+    }
+    toolParameter(param) {
+        let description = `
+      ### description (in your main language)
+      ${param.config.description.replaceAll('#', ' ')}
+      `;
+        const type = (() => {
+            if (param.type === Number)
+                return 'number';
+            if (param.type === String)
+                return 'string';
+            if (param.type === Date) {
+                description = `${description}
+          ### format: ISO 8681 - YYYY-MM-DDTHH:mm:ssZ
+        `;
+                return 'string';
+            }
+            throw new Error(`Unsupported type`);
+        })();
+        return {
+            type,
+            name: param.name,
+            description,
+        };
+    }
+    /**
+     * @deprecated use id
+     */
     async callFunction(name, params) {
         const fnMetadata = this.metadata.modules
             .map((module) => module.functions)
@@ -43,11 +117,17 @@ let MindsetOperator = class MindsetOperator {
             return `Error: ${error}`;
         }
     }
+    /**
+     * @deprecated use id
+     */
     async allFunctionsDescriptors() {
         return this.metadata.modules
             .map((module) => module.functions.map((fn) => this.functionDescriptor(fn)))
             .flat();
     }
+    /**
+     * @deprecated use id
+     */
     functionDescriptor(fn) {
         const description = fn.config.description.replaceAll('#', ' ');
         return {
@@ -64,6 +144,9 @@ let MindsetOperator = class MindsetOperator {
             },
         };
     }
+    /**
+     * @deprecated use id
+     */
     toolParam(param) {
         const addons = {
             description: `

package/dist/src/repository/pg/PgCrudRepository.js

@@ -18,6 +18,16 @@ class PgCrudRepository extends PgRepositoryBase {
         const items = await this.query(sql, [id]);
         return items.at(0) ?? null;
     }
+    async findByIds(ids) {
+        const sql = `
+      SELECT ${this.columns}
+      FROM ${this.table}
+      WHERE id IN (${ids.map((_, i) => '$' + (i + 1)).join(',')})
+      LIMIT 1
+    `;
+        const items = await this.query(sql, ids);
+        return items;
+    }
     async findOrThrow(id) {
         const item = await this.find(id);
         if (!item) {

package/dist/src/validation/metadata/@isArray.js

@@ -0,0 +1,18 @@
+import { container } from '../../injection/index.js';
+import { validateArray } from '../validators/validateArray.js';
+import { ValidationMetadataStore } from './ValidationMetadataStore.js';
+
+function isArray(options) {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateArray,
+            validatorOptions: options,
+        });
+    };
+}
+
+export { isArray };

package/dist/src/validation/metadata/ValidationMetadataStore.js

@@ -1,6 +1,7 @@
 import { __decorate } from 'tslib';
 import { singleton } from '../../injection/index.js';
 import { _IS_OPTIONAL_DUMMY_VALIDATOR_ } from '../validators/validateIsOptional.js';
+import { validateArray } from '../validators/validateArray.js';
 
 function getClassHierarchy(cls) {
     const classes = [];
@@ -24,6 +25,33 @@ let ValidationMetadataStore = class ValidationMetadataStore {
             modelValidators.set(validatorMetadata.propertyName, propertyValidators);
         }
         propertyValidators.unshift(validatorMetadata);
+        const arrayValidatorMetadata = propertyValidators.find((x) => x.validator === validateArray);
+        if (!arrayValidatorMetadata) {
+            return;
+        }
+        if (!arrayValidatorMetadata.validatorOptions) {
+            arrayValidatorMetadata.validatorOptions = {};
+        }
+        const arrayValidatorOptions = arrayValidatorMetadata.validatorOptions;
+        if (!arrayValidatorOptions.itemsValidator) {
+            arrayValidatorOptions.itemsValidator = [];
+        }
+        const removeValidatorsMetadata = [];
+        for (const validatorMetadata of propertyValidators) {
+            if (validatorMetadata.validator === validateArray ||
+                validatorMetadata.validator === _IS_OPTIONAL_DUMMY_VALIDATOR_) {
+                continue;
+            }
+            arrayValidatorOptions.itemsValidator.push({
+                options: validatorMetadata.validatorOptions,
+                validator: validatorMetadata.validator,
+            });
+            removeValidatorsMetadata.push(validatorMetadata);
+        }
+        for (const toRemove of removeValidatorsMetadata) {
+            const indexToRemove = propertyValidators.indexOf(toRemove);
+            propertyValidators.splice(indexToRemove, 1);
+        }
     }
     getModelValidatorsInfo(modelConstructor) {
         const constructors = getClassHierarchy(modelConstructor);

package/dist/src/validation/modelInfo.js

@@ -0,0 +1,9 @@
+import { container } from '../injection/index.js';
+import { ValidationMetadataStore } from './metadata/ValidationMetadataStore.js';
+
+function modelInfo(modelConstructor) {
+    const metadataStore = container.resolve(ValidationMetadataStore);
+    return metadataStore.getModelValidatorsInfo(modelConstructor);
+}
+
+export { modelInfo };

package/dist/src/validation/validators/validateArray.js

@@ -0,0 +1,41 @@
+function validateArray(value, options) {
+    if (!Array.isArray(value)) {
+        return {
+            error: { description: 'Should be an array', items: [] },
+        };
+    }
+    const { itemsValidator } = options ?? {};
+    const valueOut = [];
+    const errorItems = [];
+    for (const item of value) {
+        let itemOut = item;
+        const itemErrors = [];
+        for (const itemValidator of itemsValidator ?? []) {
+            const { error, value } = itemValidator.validator(itemOut, itemValidator.options);
+            if (error) {
+                itemErrors.push(error);
+            }
+            else {
+                itemOut = value;
+            }
+        }
+        if (itemErrors.length == 0) {
+            valueOut.push(itemOut);
+            errorItems.push(null);
+        }
+        else {
+            valueOut.push(null);
+            errorItems.push(itemErrors);
+        }
+    }
+    if (errorItems.some((x) => x != null)) {
+        return {
+            error: { description: 'Error on some items', items: errorItems },
+        };
+    }
+    return {
+        value: valueOut,
+    };
+}
+
+export { validateArray };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wabot-dev/framework",
-  "version": "0.1.0-beta.25",
+  "version": "0.1.0-beta.27",
   "description": "Framework for IA Chat Bots",
   "type": "module",
   "main": "dist/src/index.js",