@wabot-dev/framework 0.1.0-beta.6 → 0.1.0-beta.61

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

@@ -0,0 +1,38 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+
+let CommandMetadataStore = class CommandMetadataStore {
+    handlersMap = new Map();
+    handlersInverseMap = new Map();
+    commandsMap = new Map();
+    commandsInverseMap = new Map();
+    registerCommand(command, commandName) {
+        this.commandsMap.set(commandName, command);
+        this.commandsInverseMap.set(command, commandName);
+    }
+    registerHandler(command, handlerConstructor) {
+        let commandName = this.commandsInverseMap.get(command);
+        if (!commandName) {
+            throw new Error(`Should use @command decorator on command class ${command.name}`);
+        }
+        this.handlersMap.set(commandName, handlerConstructor);
+        this.handlersInverseMap.set(handlerConstructor, commandName);
+    }
+    getHandlerForCommandName(commandName) {
+        return this.handlersMap.get(commandName) ?? null;
+    }
+    getCommandNameForHandler(handlerConstructor) {
+        return this.handlersInverseMap.get(handlerConstructor) ?? null;
+    }
+    getCommandName(command) {
+        return this.commandsInverseMap.get(command) ?? null;
+    }
+    getCommandForCommandName(commandName) {
+        return this.commandsMap.get(commandName) ?? null;
+    }
+};
+CommandMetadataStore = __decorate([
+    singleton()
+], CommandMetadataStore);
+
+export { CommandMetadataStore };

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

@@ -0,0 +1,27 @@
+import { Entity } from '../../core/entity/Entity.js';
+import { CustomError } from '../../core/error/CustomError.js';
+
+class Job extends Entity {
+    get commandName() {
+        return this.data.commandName;
+    }
+    hasFinished() {
+        return this.data.successAt != null || this.data.failedAt != null;
+    }
+    setAsStarted() {
+        this.data.startedAt = new Date().getTime();
+    }
+    setAsSuccess() {
+        this.data.successAt = new Date().getTime();
+    }
+    setAsFailed(error) {
+        this.data.failedAt = new Date().getTime();
+        this.data.error = {
+            message: error.message,
+            stack: error.stack,
+            info: error instanceof CustomError ? error.info : undefined,
+        };
+    }
+}
+
+export { Job };

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

@@ -0,0 +1,31 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+
+let JobRepository = class JobRepository {
+    find(id) {
+        throw new Error('Method not implemented.');
+    }
+    findOrThrow(id) {
+        throw new Error('Method not implemented.');
+    }
+    findByIds(ids) {
+        throw new Error('Method not implemented.');
+    }
+    findAll(id) {
+        throw new Error('Method not implemented.');
+    }
+    create(item) {
+        throw new Error('Method not implemented.');
+    }
+    update(item) {
+        throw new Error('Method not implemented.');
+    }
+    delete(item) {
+        throw new Error('Method not implemented.');
+    }
+};
+JobRepository = __decorate([
+    singleton()
+], JobRepository);
+
+export { JobRepository };

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

@@ -0,0 +1,48 @@
+import { __decorate, __metadata } from 'tslib';
+import { CommandMetadataStore } from './CommandMetadataStore.js';
+import { JobRepository } from './JobRepository.js';
+import { singleton, container } from '../../core/injection/index.js';
+import { Logger } from '../../core/logger/Logger.js';
+
+let JobRunner = class JobRunner {
+    jobRepository;
+    handlerContainer;
+    logger = new Logger('wabot:job-runner');
+    constructor(jobRepository, handlerContainer) {
+        this.jobRepository = jobRepository;
+        this.handlerContainer = handlerContainer;
+    }
+    async run(job) {
+        try {
+            const { commandName, commandData } = job['data'];
+            const handlerConstructor = this.handlerContainer.getHandlerForCommandName(commandName);
+            if (!handlerConstructor) {
+                throw new Error(`Not found handler for command '${commandName}'`);
+            }
+            const handler = container.resolve(handlerConstructor);
+            const commandConstructor = this.handlerContainer.getCommandForCommandName(commandName);
+            if (!commandConstructor) {
+                throw new Error(`Not found class for command name '${commandName}'`);
+            }
+            job.setAsStarted();
+            await this.jobRepository.update(job);
+            const command = new commandConstructor(commandData);
+            await handler.handle(command);
+            job.setAsSuccess();
+        }
+        catch (e) {
+            this.logger.error(e);
+            job.setAsFailed(e instanceof Error ? e : new Error('Invalid Job error'));
+        }
+        finally {
+            await this.jobRepository.update(job);
+        }
+    }
+};
+JobRunner = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [JobRepository,
+        CommandMetadataStore])
+], JobRunner);
+
+export { JobRunner };

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

@@ -0,0 +1,36 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+import { Logger } from '../../core/logger/Logger.js';
+
+let JobsEventsHub = class JobsEventsHub {
+    logger = new Logger('wabot:jobs-events-hub');
+    jobsEventsListener = null;
+    notifyJobCreated(job) {
+        const timer = setTimeout(async () => {
+            if (!this.jobsEventsListener) {
+                return;
+            }
+            try {
+                await this.jobsEventsListener({
+                    jobId: job.id,
+                    commandName: job.commandName,
+                    type: 'created',
+                });
+            }
+            catch (err) {
+                this.logger.error(err);
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        }, 1000);
+    }
+    listenJobsEvents(listener) {
+        this.jobsEventsListener = listener;
+    }
+};
+JobsEventsHub = __decorate([
+    singleton()
+], JobsEventsHub);
+
+export { JobsEventsHub };

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,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,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}/IMindset.js

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