@wabot-dev/framework 0.1.0-beta.29 → 0.1.0-beta.30

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 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

@@ -3,7 +3,7 @@ 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';
 
 let ExpressProvider = class ExpressProvider {
     httpServerProvider;

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

@@ -1,5 +1,5 @@
 import { __decorate } from 'tslib';
-import { Logger } from '../../logger/Logger.js';
+import { Logger } from '../../core/logger/Logger.js';
 import { Server } from 'http';
 import { singleton } from 'tsyringe';
 

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;
@@ -93,9 +93,6 @@ let MindsetOperator = class MindsetOperator {
             description,
         };
     }
-    /**
-     * @deprecated use id
-     */
     async callFunction(name, params) {
         const fnMetadata = this.metadata.modules
             .map((module) => module.functions)
@@ -117,62 +114,6 @@ 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 {
-            type: 'function',
-            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),
-            },
-        };
-    }
-    /**
-     * @deprecated use id
-     */
-    toolParam(param) {
-        const addons = {
-            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}
-          ### format: ISO 8681 - YYYY-MM-DDTHH:mm:ssZ
-          ${addons.description}
-        `;
-                return 'string';
-            }
-            throw new Error(`Unsupported type`);
-        })();
-        return {
-            type,
-            ...addons,
-        };
-    }
 };
 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/{auth → feature/rest-controller/auth}/Auth.js

@@ -1,6 +1,6 @@
 import { __decorate } from 'tslib';
-import { CustomError } from '../error/CustomError.js';
-import { scoped, Lifecycle } from '../injection/index.js';
+import { CustomError } from '../../../core/error/CustomError.js';
+import { scoped, Lifecycle } from '../../../core/injection/index.js';
 
 let Auth = class Auth {
     authInfo = null;

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

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

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

@@ -1,4 +1,4 @@
-import { container } from '../../injection/index.js';
+import { container } from '../../../core/injection/index.js';
 import { RestControllerMetadataStore } from './RestControllerMetadataStore.js';
 
 function middleware(middlewareConstructor) {

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

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

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

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

package/dist/src/{rest-controller → feature/rest-controller}/metadata/RestControllerMetadataStore.js

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

package/dist/src/{rest-controller → feature/rest-controller}/runRestControllers.js

@@ -1,29 +1,11 @@
-import '../controller/channel/ChatResolver.js';
-import '../controller/channel/UserResolver.js';
-import { container } from '../injection/index.js';
-import '../controller/metadata/ControllerMetadataStore.js';
-import '../channels/cmd/CmdChannel.js';
-import { ExpressProvider } from '../channels/express/ExpressProvider.js';
-import '../channels/http/HttpServerProvider.js';
-import '../channels/socket/SocketChannel.js';
-import '../channels/socket/SocketChannelConfig.js';
-import '../channels/socket/SocketServerProvider.js';
-import '../channels/telegram/TelegramChannel.js';
-import '../channels/whatsapp/WhatsAppChannel.js';
-import '../channels/whatsapp/EnvWhatsAppRepository.js';
-import '../channels/whatsapp/PgWhatsAppRepository.js';
-import '../core/chat/repository/IChatRepository.js';
-import '../core/user/IUserRepository.js';
-import '../channels/whatsapp/WhatsAppReceiverByDevConnection.js';
-import '../channels/whatsapp/WhatsAppReceiverByWebHook.js';
-import '../channels/whatsapp/WhatsAppSenderByCloudApi.js';
-import '../channels/whatsapp/WhatsAppSenderByDevConnection.js';
-import { Logger } from '../logger/Logger.js';
-import '../validation/metadata/ValidationMetadataStore.js';
-import { validate } from '../validation/validate.js';
 import path from 'path';
+import { container } from '../../core/injection/index.js';
 import { RestControllerMetadataStore } from './metadata/RestControllerMetadataStore.js';
-import { CustomError } from '../error/CustomError.js';
+import { Logger } from '../../core/logger/Logger.js';
+import { ExpressProvider } from '../express/ExpressProvider.js';
+import '../../core/validation/metadata/ValidationMetadataStore.js';
+import { validate } from '../../core/validation/validate.js';
+import { CustomError } from '../../core/error/CustomError.js';
 
 function buildRequest(req) {
     return Object.assign({}, req.body, req.query, req.params);

package/dist/src/{channels → feature}/socket/SocketServerProvider.js

@@ -1,5 +1,5 @@
 import { __decorate, __metadata } from 'tslib';
-import { Logger } from '../../logger/Logger.js';
+import { Logger } from '../../core/logger/Logger.js';
 import { HttpServerProvider } from '../http/HttpServerProvider.js';
 import { Server } from 'socket.io';
 import { singleton } from 'tsyringe';