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

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

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,69 @@ 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}`;
-        }
+    llms() {
+        return this.mindset.llms();
     }
-    async allFunctionsDescriptors() {
+    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.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 +92,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';