@wabot-dev/framework 0.1.0-beta.4 → 0.1.0-beta.40

package/dist/src/feature/async/runCommandHandlers.js

@@ -0,0 +1,29 @@
+import { JobsEventsHub } from './JobsEventsHub.js';
+import { JobRunner } from './JobRunner.js';
+import { CommandMetadataStore } from './CommandMetadataStore.js';
+import { JobRepository } from './JobRepository.js';
+import { container } from '../../core/injection/index.js';
+
+function runAsyncCommandHandlers(handlers) {
+    const eventsHub = container.resolve(JobsEventsHub);
+    const jobRunner = container.resolve(JobRunner);
+    const jobRepository = container.resolve(JobRepository);
+    const commandsHandlersContainer = container.resolve(CommandMetadataStore);
+    const handledCommands = handlers
+        .map((x) => commandsHandlersContainer.getCommandNameForHandler(x))
+        .filter((x) => x)
+        .map((x) => x);
+    eventsHub.listenJobsEvents(async (event) => {
+        try {
+            const job = await jobRepository.findOrThrow(event.jobId);
+            if (handledCommands.includes(job.commandName)) {
+                jobRunner.run(job);
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+    });
+}
+
+export { runAsyncCommandHandlers };

package/dist/src/{core/chat → feature/chat-bot}/Chat.js

@@ -1,6 +1,6 @@
-import { Persistent } from '../Persistent.js';
+import { Entity } from '../../core/entity/Entity.js';
 
-class Chat extends Persistent {
+class Chat extends Entity {
     constructor(data) {
         super(data);
     }

package/dist/src/feature/chat-bot/ChatAdapter.js

@@ -0,0 +1,7 @@
+class ChatAdapter {
+    nextItem(req) {
+        throw new Error('Method not implemented.');
+    }
+}
+
+export { ChatAdapter };

package/dist/src/feature/chat-bot/ChatBot.js

@@ -0,0 +1,50 @@
+import { ChatItem } from './ChatItem.js';
+
+class ChatBot {
+    memory;
+    adapter;
+    mindset;
+    constructor(memory, adapter, mindset) {
+        this.memory = memory;
+        this.adapter = adapter;
+        this.mindset = mindset;
+    }
+    async sendMessage(message, callback) {
+        const newChatItem = new ChatItem({
+            type: 'humanMessage',
+            humanMessage: message,
+        });
+        await this.memory.create(newChatItem);
+        this.processLoop(callback);
+    }
+    async processLoop(callback) {
+        const prevItems = await this.memory.findLastItems(10);
+        if (prevItems.length === 0) {
+            return;
+        }
+        const lastChatItem = prevItems[prevItems.length - 1];
+        if (lastChatItem.type === 'botMessage') {
+            return;
+        }
+        const systemPrompt = await this.mindset.systemPrompt();
+        const tools = this.mindset.tools();
+        const { chatItem: newItemData } = await this.adapter.nextItem({
+            model: 'gpt',
+            systemPrompt,
+            tools,
+            prevItems: prevItems.map((x) => x.getData()),
+        });
+        if (newItemData.type === 'functionCall') {
+            newItemData.functionCall.result = await this.mindset.callFunction(newItemData.functionCall.name, newItemData.functionCall.arguments ?? '{}');
+        }
+        const newChatItem = new ChatItem(newItemData);
+        await this.memory.create(newChatItem);
+        if (newChatItem.type === 'botMessage') {
+            callback(newChatItem.botMessage);
+            return;
+        }
+        this.processLoop(callback);
+    }
+}
+
+export { ChatBot };

package/dist/src/feature/chat-bot/ChatItem.js

@@ -0,0 +1,24 @@
+import { Entity } from '../../core/entity/Entity.js';
+
+class ChatItem extends Entity {
+    get type() {
+        return this.data.type;
+    }
+    get botMessage() {
+        return this.data.botMessage;
+    }
+    get functionCall() {
+        return this.data.functionCall;
+    }
+    setFunctionResult(result) {
+        if (this.data.type !== 'functionCall') {
+            throw new Error('The chat item is not functionCall type');
+        }
+        this.data.functionCall.result = result;
+    }
+    getData() {
+        return this.data;
+    }
+}
+
+export { ChatItem };

package/dist/src/feature/chat-bot/ChatMemory.js

@@ -0,0 +1,10 @@
+class ChatMemory {
+    findLastItems(count) {
+        throw new Error("Method not implemented.");
+    }
+    create(item) {
+        throw new Error("Method not implemented.");
+    }
+}
+
+export { ChatMemory };

package/dist/src/{core/chat/repository/IChatRepository.js → feature/chat-bot/ChatRepository.js}

@@ -1,7 +1,4 @@
-import { __decorate } from 'tslib';
-import { singleton } from '../../../injection/index.js';
-
-let ChatRepository = class ChatRepository {
+class ChatRepository {
     create(chat) {
         throw new Error('Method not implemented.');
     }
@@ -11,9 +8,6 @@ let ChatRepository = class ChatRepository {
     findMemory(chatId) {
         throw new Error('Method not implemented.');
     }
-};
-ChatRepository = __decorate([
-    singleton()
-], ChatRepository);
+}
 
 export { ChatRepository };

package/dist/src/feature/chat-bot/IChatItem.js

@@ -0,0 +1,3 @@
+const chatItemTypeOptions = ['botMessage', 'humanMessage', 'functionCall'];
+
+export { chatItemTypeOptions };

package/dist/src/{chatbot → feature/chat-bot}/metadata/@chatBot.js

@@ -1,4 +1,4 @@
-import { container, inject } from '../../injection/index.js';
+import { container, inject } from '../../../core/injection/index.js';
 import { v4 } from 'uuid';
 import { ChatBotMetadataStore } from './ChatBotMetadataStore.js';
 

package/dist/src/{chatbot → feature/chat-bot}/metadata/ChatBotMetadataStore.js

@@ -1,5 +1,5 @@
 import { __decorate } from 'tslib';
-import { singleton } from '../../injection/index.js';
+import { singleton } from '../../../core/injection/index.js';
 
 let ChatBotMetadataStore = class ChatBotMetadataStore {
     chatBots = [];

package/dist/src/{controller/channel → feature/chat-controller}/ChatResolver.js

@@ -1,8 +1,9 @@
 import { __decorate, __metadata } from 'tslib';
-import { ChatRepository } from '../../core/chat/repository/IChatRepository.js';
-import { Chat } from '../../core/chat/Chat.js';
-import '../../core/user/IUserRepository.js';
-import { injectable } from '../../injection/index.js';
+import { Chat } from '../chat-bot/Chat.js';
+import { ChatRepository } from '../chat-bot/ChatRepository.js';
+import { injectable } from '../../core/injection/index.js';
+import 'uuid';
+import '../chat-bot/metadata/ChatBotMetadataStore.js';
 
 let ChatResolver = class ChatResolver {
     chatRepository;

package/dist/src/{controller → feature/chat-controller}/metadata/ControllerMetadataStore.js

@@ -1,5 +1,5 @@
 import { __decorate } from 'tslib';
-import { singleton } from '../../injection/index.js';
+import { singleton } from '../../../core/injection/index.js';
 
 let ControllerMetadataStore = class ControllerMetadataStore {
     channels = new Map();

package/dist/src/{controller → feature/chat-controller}/metadata/controller/@chatController.js

@@ -1,4 +1,4 @@
-import { container, injectable } from '../../../injection/index.js';
+import { container, injectable } from '../../../../core/injection/index.js';
 import { ControllerMetadataStore } from '../ControllerMetadataStore.js';
 
 function chatController(config) {

package/dist/src/feature/chat-controller/runChatControllers.js

@@ -0,0 +1,69 @@
+import { container } from '../../core/injection/index.js';
+import { Chat } from '../chat-bot/Chat.js';
+import { ChatBot } from '../chat-bot/ChatBot.js';
+import { ChatMemory } from '../chat-bot/ChatMemory.js';
+import { ChatRepository } from '../chat-bot/ChatRepository.js';
+import 'uuid';
+import { ChatBotMetadataStore } from '../chat-bot/metadata/ChatBotMetadataStore.js';
+import 'reflect-metadata';
+import '../mindset/metadata/MindsetMetadataStore.js';
+import { Mindset } from '../mindset/IMindset.js';
+import '../mindset/MindsetOperator.js';
+import { ChatResolver } from './ChatResolver.js';
+import { ControllerMetadataStore } from './metadata/ControllerMetadataStore.js';
+import { Container } from '../../core/injection/Container.js';
+
+async function prepareChatContainer(container, messageContext, mindsetCtor) {
+    const chatContainer = container.createChildContainer();
+    chatContainer.register(Container, { useValue: chatContainer });
+    chatContainer.registerInstance(Chat, messageContext.chat);
+    const chatRepository = container.resolve(ChatRepository);
+    const chatMemory = await chatRepository.findMemory(messageContext.chat.id);
+    if (!chatMemory) {
+        throw new Error('Not found Chat Memory for Chat with Id=' + messageContext.chat.id);
+    }
+    chatContainer.registerInstance(ChatMemory, chatMemory);
+    const chatBotMetadataStore = container.resolve(ChatBotMetadataStore);
+    const chatBots = chatBotMetadataStore.getChatBotsMetadata();
+    for (const chatBotMetadata of chatBots) {
+        chatContainer.beforeResolution(chatBotMetadata.constructor, (a, b) => {
+            const subContainer = chatContainer.createChildContainer();
+            subContainer.register(Mindset, { useClass: chatBotMetadata.mindsetConstructor });
+            const chatBot = subContainer.resolve(ChatBot);
+            chatContainer.register(chatBotMetadata.injectionToken, { useValue: chatBot });
+        });
+    }
+    return chatContainer;
+}
+function runChatControllers(controllers) {
+    const metadataStore = container.resolve(ControllerMetadataStore);
+    const chatResolver = container.resolve(ChatResolver);
+    for (const controllerCtor of controllers) {
+        const chatControllerMetadata = metadataStore.getChatControllerMetadata(controllerCtor);
+        if (!chatControllerMetadata) {
+            continue;
+        }
+        for (const channelMetadata of chatControllerMetadata.channels) {
+            const channelContainer = container.createChildContainer();
+            if (channelMetadata.channelConfig) {
+                channelContainer.register(channelMetadata.channelConfig.constructor, {
+                    useValue: channelMetadata.channelConfig,
+                });
+            }
+            const channel = channelContainer.resolve(channelMetadata.channelConstructor);
+            channel.listen(async (channelMessage) => {
+                const chat = await chatResolver.resolve(channelMessage.chatConnection);
+                const chatContainer = await prepareChatContainer(channelContainer, {
+                    chat,
+                    message: channelMessage.message,
+                    reply: channelMessage.reply,
+                });
+                const chatController = chatContainer.resolve(channelMetadata.controllerConstructor);
+                chatController[channelMetadata.functionName](channelMessage);
+            });
+            channel.connect();
+        }
+    }
+}
+
+export { runChatControllers };

package/dist/src/{channels → feature}/express/ExpressProvider.js

@@ -1,9 +1,8 @@
 import { __decorate, __metadata } from 'tslib';
 import { HttpServerProvider } from '../http/HttpServerProvider.js';
 import express from 'express';
-import { singleton } from 'tsyringe';
-import bodyParser from 'body-parser';
-import { Logger } from '../../logger/Logger.js';
+import { Logger } from '../../core/logger/Logger.js';
+import { singleton } from '../../core/injection/index.js';
 
 let ExpressProvider = class ExpressProvider {
     httpServerProvider;
@@ -23,7 +22,6 @@ let ExpressProvider = class ExpressProvider {
     }
     createExpress() {
         const expressApp = express();
-        expressApp.use(bodyParser.json());
         expressApp.use((req, res, next) => {
             const start = process.hrtime();
             res.on('finish', () => {

package/dist/src/{channels → feature}/http/HttpServerProvider.js

@@ -1,7 +1,7 @@
 import { __decorate } from 'tslib';
-import { Logger } from '../../logger/Logger.js';
+import { singleton } from '../../core/injection/index.js';
+import { Logger } from '../../core/logger/Logger.js';
 import { Server } from 'http';
-import { singleton } from 'tsyringe';
 
 let HttpServerProvider = class HttpServerProvider {
     server = null;

package/dist/src/{mindset → feature/mindset}/MindsetOperator.js

@@ -1,8 +1,8 @@
 import { __decorate, __metadata } from 'tslib';
-import { injectable } from '../injection/index.js';
+import { injectable } from '../../core/injection/index.js';
 import { Mindset } from './IMindset.js';
 import { MindsetMetadataStore } from './metadata/MindsetMetadataStore.js';
-import { Container } from '../injection/Container.js';
+import { Container } from '../../core/injection/Container.js';
 
 let MindsetOperator = class MindsetOperator {
     mindset;
@@ -22,64 +22,66 @@ let MindsetOperator = class MindsetOperator {
     limits() {
         return this.mindset.limits();
     }
-    async callFunction(name, params) {
-        const fnMetadata = this.metadata.modules
-            .map((module) => module.functions)
-            .flat()
-            .find((fn) => fn.name === name);
-        if (!fnMetadata) {
-            throw new Error(`Function ${name} not found`);
-        }
-        const paramsObj = JSON.parse(params);
-        const module = this.container.resolve(fnMetadata.moduleConstructor);
-        try {
-            const response = await module[name](paramsObj);
-            if (!response) {
-                return 'success';
-            }
-            return response.toString();
-        }
-        catch (error) {
-            return `Error: ${error}`;
-        }
+    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;
     }
-    async allFunctionsDescriptors() {
+    tools() {
         return this.metadata.modules
-            .map((module) => module.functions.map((fn) => this.functionDescriptor(fn)))
+            .map((module) => module.functions.map((fn) => this.tool(fn, module)))
             .flat();
     }
-    functionDescriptor(fn) {
+    tool(fn, module) {
         const description = fn.config.description.replaceAll('#', ' ');
         return {
-            type: 'function',
+            language: module.config.language ?? 'english',
             name: fn.name,
             description,
-            parameters: {
-                type: 'object',
-                properties: fn.params.reduce((prev, param) => ({
-                    ...prev,
-                    [param.name]: this.toolParam(param),
-                }), {}),
-                required: fn.params.filter((param) => !param.config.optional).map((param) => param.name)
-            },
+            parameters: fn.params.map((param) => this.toolParameter(param)),
         };
     }
-    toolParam(param) {
-        const addons = {
-            description: `
+    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) {
-                addons.description = `${addons.description}
+                description = `${description}
           ### format: ISO 8681 - YYYY-MM-DDTHH:mm:ssZ
-          ${addons.description}
         `;
                 return 'string';
             }
@@ -87,9 +89,31 @@ let MindsetOperator = class MindsetOperator {
         })();
         return {
             type,
-            ...addons,
+            name: param.name,
+            description,
         };
     }
+    async callFunction(name, params) {
+        const fnMetadata = this.metadata.modules
+            .map((module) => module.functions)
+            .flat()
+            .find((fn) => fn.name === name);
+        if (!fnMetadata) {
+            throw new Error(`Function ${name} not found`);
+        }
+        const paramsObj = JSON.parse(params);
+        const module = this.container.resolve(fnMetadata.moduleConstructor);
+        try {
+            const response = await module[name](paramsObj);
+            if (!response) {
+                return 'success';
+            }
+            return response.toString();
+        }
+        catch (error) {
+            return `Error: ${error}`;
+        }
+    }
 };
 MindsetOperator = __decorate([
     injectable(),

package/dist/src/{mindset → feature/mindset}/metadata/MindsetMetadataStore.js

@@ -1,5 +1,5 @@
 import { __decorate } from 'tslib';
-import { singleton } from '../../injection/index.js';
+import { singleton } from '../../../core/injection/index.js';
 import { MINDSET_FUNCTION_DECORATION_FUNCTION } from './functions/decoratorNames.js';
 import { MINDSET_DECORATION_MINDSET } from './mindsets/decoratorNames.js';
 import { MINDSET_MODULE_DECORATION_MODULE } from './modules/decoratorNames.js';

package/dist/src/{mindset → feature/mindset}/metadata/functions/@mindsetFunction.js

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { container } from '../../../injection/index.js';
+import { container } from '../../../../core/injection/index.js';
 import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
 import { MINDSET_FUNCTION_DECORATION_FUNCTION } from './decoratorNames.js';
 

package/dist/src/{mindset → feature/mindset}/metadata/mindsets/@mindset.js

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { container, injectable } from '../../../injection/index.js';
+import { container, injectable } from '../../../../core/injection/index.js';
 import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
 import { MINDSET_DECORATION_MINDSET } from './decoratorNames.js';
 

package/dist/src/{mindset → feature/mindset}/metadata/modules/@mindsetModule.js

@@ -1,5 +1,4 @@
-import 'reflect-metadata';
-import { container, injectable } from '../../../injection/index.js';
+import { container, injectable } from '../../../../core/injection/index.js';
 import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
 import { MINDSET_MODULE_DECORATION_MODULE } from './decoratorNames.js';
 

package/dist/src/{mindset → feature/mindset}/metadata/params/@param.js

@@ -1,6 +1,6 @@
 import 'reflect-metadata';
 import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
-import { container } from '../../../injection/index.js';
+import { container } from '../../../../core/injection/index.js';
 import { PARAM_DECORATION_PARAM } from './decoratorNames.js';
 
 function param(config) {

package/dist/src/feature/money/Money.js

@@ -0,0 +1,61 @@
+import { Storable } from '../../core/storable/Storable.js';
+import { Big } from 'big.js';
+
+Big.strict = true;
+class Money extends Storable {
+    getData() {
+        return { ...this.data };
+    }
+    get amount() {
+        return Big(this.data.amount);
+    }
+    get currency() {
+        return this.data.currency;
+    }
+    plus(money) {
+        this.validateEqualCurrencies(this.data.currency, money.data.currency);
+        return new Money({
+            amount: this.amount.plus(money.amount).toFixed(6),
+            currency: this.currency,
+        });
+    }
+    minus(money) {
+        this.validateEqualCurrencies(this.data.currency, money.data.currency);
+        return new Money({
+            amount: this.amount.minus(money.amount).toFixed(6),
+            currency: this.currency,
+        });
+    }
+    times(value) {
+        return new Money({
+            amount: this.amount.times(new Big(String(value))).toFixed(6),
+            currency: this.currency,
+        });
+    }
+    div(value) {
+        return new Money({
+            amount: this.amount.div(new Big(String(value))).toFixed(6),
+            currency: this.currency,
+        });
+    }
+    negative() {
+        return new Money({
+            amount: new Big('0').minus(this.amount).toFixed(6),
+            currency: this.currency,
+        });
+    }
+    isGretterThan(money) {
+        this.validateEqualCurrencies(this.data.currency, money.data.currency);
+        return this.amount.gt(money.amount);
+    }
+    validateEqualCurrencies(left, right) {
+        if (left !== right) {
+            throw new Error(`Is not posible operate with diferent currencies: '${left}' and '${right}'`);
+        }
+    }
+    static zero(currency) {
+        return new Money({ currency, amount: '0' });
+    }
+}
+
+export { Money };

package/dist/src/feature/rest-controller/injection-tokens.js

@@ -0,0 +1,4 @@
+const EXPRESS_REQ = 'EXPRESS_REQ';
+const EXPRESS_RES = 'EXPRESS_RES';
+
+export { EXPRESS_REQ, EXPRESS_RES };

package/dist/src/feature/rest-controller/metadata/@get.js

@@ -0,0 +1,19 @@
+import { container } from '../../../core/injection/index.js';
+import { RestControllerMetadataStore } from './RestControllerMetadataStore.js';
+
+function get(config) {
+    return function (target, propertyKey) {
+        const functionName = propertyKey.toString();
+        const paramsTypes = Reflect.getMetadata('design:paramtypes', target, functionName);
+        const store = container.resolve(RestControllerMetadataStore);
+        store.saveEndPointMetadata({
+            controllerConstructor: target.constructor,
+            method: 'get',
+            config: typeof config === 'string' ? { path: config } : config,
+            functionName,
+            paramsTypes,
+        });
+    };
+}
+
+export { get };

package/dist/src/feature/rest-controller/metadata/@middleware.js

@@ -0,0 +1,16 @@
+import { container } from '../../../core/injection/index.js';
+import { RestControllerMetadataStore } from './RestControllerMetadataStore.js';
+
+function middleware(middlewareConstructor) {
+    return function (target, propertyKey) {
+        const functionName = propertyKey.toString();
+        const store = container.resolve(RestControllerMetadataStore);
+        store.saveMiddlewareMetadata({
+            controllerConstructor: target.constructor,
+            functionName,
+            middlewareConstructor: middlewareConstructor,
+        });
+    };
+}
+
+export { middleware };

package/dist/src/feature/rest-controller/metadata/@post.js

@@ -0,0 +1,19 @@
+import { container } from '../../../core/injection/index.js';
+import { RestControllerMetadataStore } from './RestControllerMetadataStore.js';
+
+function post(config) {
+    return function (target, propertyKey) {
+        const functionName = propertyKey.toString();
+        const paramsTypes = Reflect.getMetadata('design:paramtypes', target, functionName);
+        const store = container.resolve(RestControllerMetadataStore);
+        store.saveEndPointMetadata({
+            controllerConstructor: target.constructor,
+            method: 'post',
+            config: typeof config === 'string' ? { path: config } : config,
+            functionName,
+            paramsTypes,
+        });
+    };
+}
+
+export { post };

package/dist/src/feature/rest-controller/metadata/@restController.js

@@ -0,0 +1,15 @@
+import { container, injectable } from '../../../core/injection/index.js';
+import { RestControllerMetadataStore } from './RestControllerMetadataStore.js';
+
+function restController(config) {
+    return function (target) {
+        const metaDataStore = container.resolve(RestControllerMetadataStore);
+        metaDataStore.saveControllerMetadata({
+            controllerConstructor: target,
+            path: typeof config === 'string' ? config : config.path,
+        });
+        injectable()(target);
+    };
+}
+
+export { restController };