@wabot-dev/framework 0.1.0-beta.9 → 0.2.0-beta.1

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,73 @@
+import { __decorate, __metadata } from 'tslib';
+import 'reflect-metadata';
+import { injectable } from '../../core/injection/index.js';
+import '../mindset/metadata/MindsetMetadataStore.js';
+import { MindsetOperator } from '../mindset/MindsetOperator.js';
+import { ChatAdapter } from './ChatAdapter.js';
+import { ChatItem } from './ChatItem.js';
+import { ChatMemory } from './ChatMemory.js';
+
+let ChatBot = 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 identity = await this.mindset.identity();
+        const llms = await this.mindset.llms();
+        if (llms.length === 0) {
+            throw new Error(`Invalid ${this.mindset.constructor.name} - llms not found`);
+        }
+        const llm = llms[0];
+        const { chatItem: newItemData } = await this.adapter.nextItem({
+            model: llm.model,
+            provider: llm.provider,
+            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 ?? '{}');
+        }
+        else if (newItemData.type === 'botMessage') {
+            newItemData.botMessage.senderName = identity.name;
+        }
+        const newChatItem = new ChatItem(newItemData);
+        await this.memory.create(newChatItem);
+        if (newChatItem.type === 'botMessage') {
+            callback(newChatItem.botMessage);
+            return;
+        }
+        this.processLoop(callback);
+    }
+};
+ChatBot = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [ChatMemory,
+        ChatAdapter,
+        MindsetOperator])
+], ChatBot);
+
+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,10 @@
 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 '../chat-bot/ChatBot.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,83 @@
+import { Auth } from '../../core/auth/Auth.js';
+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);
+    if (messageContext.authInfo) {
+        const auth = chatContainer.resolve(Auth);
+        auth.assign(messageContext.authInfo);
+    }
+    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,
+                    ...channelMessage,
+                });
+                const chatController = chatContainer.resolve(channelMetadata.controllerConstructor);
+                const receivedMessage = {
+                    message: channelMessage.message,
+                    reply: (message) => {
+                        channelMessage.reply(message);
+                        if (channelMessage.setAuthInfo) {
+                            const auth = chatContainer.resolve(Auth);
+                            channelMessage.setAuthInfo(auth['authInfo'] || undefined);
+                        }
+                    },
+                };
+                chatController[channelMetadata.functionName](receivedMessage);
+            });
+            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}/IMindset.js

@@ -8,6 +8,12 @@ class Mindset {
     limits() {
         throw new Error('Method not implemented.');
     }
+    workflow() {
+        throw new Error('Method not implemented.');
+    }
+    llms() {
+        throw new Error('Method not implemented.');
+    }
 }
 
 export { Mindset };

package/dist/src/feature/mindset/MindsetOperator.js

@@ -0,0 +1,180 @@
+import { __decorate, __metadata } from 'tslib';
+import { injectable } from '../../core/injection/index.js';
+import { Mindset } from './IMindset.js';
+import { MindsetMetadataStore } from './metadata/MindsetMetadataStore.js';
+import { Container } from '../../core/injection/Container.js';
+
+let MindsetOperator = class MindsetOperator {
+    mindset;
+    container;
+    metadata;
+    constructor(mindset, container, metadataStore) {
+        this.mindset = mindset;
+        this.container = container;
+        this.metadata = metadataStore.getMindsetMetadata(this.mindset.constructor);
+    }
+    identity() {
+        return this.mindset.identity();
+    }
+    skills() {
+        return this.mindset.skills();
+    }
+    limits() {
+        return this.mindset.limits();
+    }
+    workflow() {
+        return this.mindset.workflow();
+    }
+    llms() {
+        return this.mindset.llms();
+    }
+    async systemPrompt() {
+        let [identity, skills, limits, workflow] = await Promise.all([
+            this.identity(),
+            this.skills(),
+            this.limits(),
+            this.workflow(),
+        ]);
+        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('#', ' ');
+        workflow = workflow.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}
+
+          ## Workflow (in your main language)
+          ${workflow}
+  
+          ## 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,
+        };
+    }
+    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 await this.functionResponseToString(response);
+        }
+        catch (error) {
+            return await this.functionErrorToString(error);
+        }
+    }
+    async functionResponseToString(response) {
+        if (response instanceof Response) {
+            const contentType = response.headers.get('Content-Type') || '';
+            let body;
+            try {
+                body = contentType.includes('application/json')
+                    ? await response.json()
+                    : await response.text();
+            }
+            catch (error) {
+                body = { message: response.ok ? 'OK' : 'Unable to parse error body' };
+            }
+            return JSON.stringify({
+                httpCode: response.status,
+                body: typeof body === 'object' ? body : { message: body },
+            });
+        }
+        const type = typeof response;
+        if (type === 'string') {
+            return response;
+        }
+        else if (type === 'boolean' || type === 'number') {
+            return `${response}`;
+        }
+        else {
+            return JSON.stringify(response);
+        }
+    }
+    async functionErrorToString(error) {
+        if (error instanceof Response) {
+            return await this.functionResponseToString(error);
+        }
+        if (error?.response && typeof error.response === 'object' && error.response.status) {
+            const { status, data } = error.response;
+            return JSON.stringify({
+                httpCode: status,
+                body: typeof data === 'object' ? data : { message: data?.toString?.() || 'Unknown error' },
+            });
+        }
+        if (error?.message) {
+            return error.message;
+        }
+        return 'Unknown error occurred';
+    }
+};
+MindsetOperator = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Mindset,
+        Container,
+        MindsetMetadataStore])
+], MindsetOperator);
+
+export { MindsetOperator };

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/money/MoneyDto.js

@@ -0,0 +1,22 @@
+import { __decorate, __metadata } from 'tslib';
+import '../../core/injection/index.js';
+import '../../core/validation/metadata/ValidationMetadataStore.js';
+import { isNotEmpty } from '../../core/validation/validators/is-not-empty/@isNotEmpty.js';
+import { isString } from '../../core/validation/validators/is-string/@isString.js';
+
+class MoneyDto {
+    amount = '';
+    currency = '';
+}
+__decorate([
+    isString(),
+    isNotEmpty(),
+    __metadata("design:type", String)
+], MoneyDto.prototype, "amount", void 0);
+__decorate([
+    isString(),
+    isNotEmpty(),
+    __metadata("design:type", String)
+], MoneyDto.prototype, "currency", void 0);
+
+export { MoneyDto };