@wabot-dev/framework 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Wabot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/src/_virtual/_commonjsHelpers.js

@@ -0,0 +1,5 @@
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+export { getDefaultExportFromCjs };

package/dist/src/_virtual/main.js

@@ -0,0 +1,7 @@
+import { getDefaultExportFromCjs } from './_commonjsHelpers.js';
+import { __require as requireMain } from '../node_modules/dotenv/lib/main.js';
+
+var mainExports = requireMain();
+var dotenv = /*@__PURE__*/getDefaultExportFromCjs(mainExports);
+
+export { dotenv as default };

package/dist/src/_virtual/main2.js

@@ -0,0 +1,3 @@
+var main = {exports: {}};
+
+export { main as __module };

package/dist/src/ai/index.d.ts

@@ -0,0 +1 @@
+export * from './openia';

package/dist/src/ai/openia/OpenaiChatBotAdapter.d.ts

@@ -0,0 +1,9 @@
+import { ChatBotAdapter, IChatItem } from '@/chatbot';
+import { MindsetOperator } from '@/mindset';
+export declare class OpenaiChatBotAdapter extends ChatBotAdapter {
+    private openai;
+    private model;
+    constructor(mindset: MindsetOperator);
+    generateNextChatItem(chatItems: IChatItem[]): Promise<IChatItem>;
+    private mapChatItems;
+}

package/dist/src/ai/openia/OpenaiChatBotAdapter.js

@@ -0,0 +1,85 @@
+import { __decorate, __metadata } from 'tslib';
+import { injectable } from '../../injection/index.js';
+import { OpenAI } from 'openai';
+import '../../chatbot/chat/repository/ram/RamChatRepository.js';
+import '../../chatbot/chat/repository/IChatRepository.js';
+import 'uuid';
+import '../../chatbot/metadata/ChatBotMetadataStore.js';
+import '../../chatbot/ChatBot.js';
+import { ChatBotAdapter } from '../../chatbot/ChatBotAdapter.js';
+import 'reflect-metadata';
+import '../../mindset/metadata/MindsetMetadataStore.js';
+import { MindsetOperator } from '../../mindset/MindsetOperator.js';
+
+let OpenaiChatBotAdapter = class OpenaiChatBotAdapter extends ChatBotAdapter {
+    openai = new OpenAI();
+    model;
+    constructor(mindset) {
+        super(mindset);
+        const model = process.env.OPENAI_CHAT_MODEL;
+        if (!model) {
+            throw new Error(`OPENAI_CHAT_MODEL env variable is required`);
+        }
+        this.model = model;
+    }
+    async generateNextChatItem(chatItems) {
+        const systemPrompt = await this.systemPrompt();
+        const tools = (await this.mindset.allFunctionsDescriptors()).map((fn) => {
+            const parameters = { ...fn.parameters, additionalProperties: false, type: 'object' };
+            return { ...fn, type: 'function', parameters, strict: true };
+        });
+        const response = await this.openai.responses.create({
+            model: this.model,
+            input: [{ role: 'system', content: systemPrompt }, ...this.mapChatItems(chatItems)],
+            tools,
+        });
+        let newChatItem;
+        if (response.output_text) {
+            newChatItem = await this.buildBotMessageItem(response.output_text);
+        }
+        else if (response.output && response.output[0]?.type == 'function_call') {
+            newChatItem = await this.buildFunctionCallItem(response.output[0].call_id, response.output[0].name, response.output[0].arguments);
+        }
+        else {
+            throw new Error('Not supported OpenIA Response');
+        }
+        return newChatItem;
+    }
+    mapChatItems(chatItems) {
+        const openIaInput = [];
+        for (const item of chatItems) {
+            if (item.type === 'USER_MESSAGE') {
+                if (!item.content.text) {
+                    throw new Error('System message content is empty');
+                }
+                openIaInput.push({ role: 'user', content: item.content.text });
+            }
+            else if (item.type === 'BOT_MESSAGE') {
+                if (!item.content.text) {
+                    throw new Error('System message content is empty');
+                }
+                openIaInput.push({ role: 'assistant', content: item.content.text });
+            }
+            if (item.type === 'FUNCTION_CALL') {
+                openIaInput.push({
+                    type: 'function_call',
+                    call_id: item.content.foreignId,
+                    name: item.content.name,
+                    arguments: JSON.stringify(item.content.arguments),
+                });
+                openIaInput.push({
+                    type: 'function_call_output',
+                    call_id: item.content.foreignId,
+                    output: item.content.result,
+                });
+            }
+        }
+        return openIaInput;
+    }
+};
+OpenaiChatBotAdapter = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [MindsetOperator])
+], OpenaiChatBotAdapter);
+
+export { OpenaiChatBotAdapter };

package/dist/src/ai/openia/index.d.ts

@@ -0,0 +1 @@
+export * from './OpenaiChatBotAdapter';

package/dist/src/channels/cmd/CmdChannel.d.ts

@@ -0,0 +1,9 @@
+import { ChatResolver, IChatChannel, IMessageContext } from '@/controller';
+export declare class CmdChannel implements IChatChannel {
+    private chatResolver;
+    private rl;
+    private callBack;
+    constructor(chatResolver: ChatResolver);
+    listen(callback: (message: IMessageContext) => void): void;
+    connect(): void;
+}

package/dist/src/channels/cmd/CmdChannel.js

@@ -0,0 +1,58 @@
+import { __decorate, __metadata } from 'tslib';
+import { ChatResolver } from '../../controller/channel/ChatResolver.js';
+import { injectable } from '../../injection/index.js';
+import '../../controller/metadata/ControllerMetadataStore.js';
+import * as readline from 'readline';
+
+var CmdChannel_1;
+let CmdChannel = CmdChannel_1 = class CmdChannel {
+    chatResolver;
+    rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    callBack = null;
+    constructor(chatResolver) {
+        this.chatResolver = chatResolver;
+    }
+    listen(callback) {
+        this.callBack = callback;
+    }
+    connect() {
+        this.rl.on('line', async (input) => {
+            const trimmedInput = input.trim();
+            if (trimmedInput.toLowerCase() === 'exit') {
+                this.rl.close();
+                return;
+            }
+            const origin = {
+                chatId: 'cmd',
+                chatType: 'PRIVATE',
+                channelType: CmdChannel_1,
+            };
+            const chat = await this.chatResolver.resolve(origin);
+            if (!this.callBack)
+                return;
+            this.callBack({
+                chatId: chat.getId(),
+                origin,
+                message: {
+                    text: trimmedInput,
+                    sender: {
+                        shortName: 'Cmd',
+                    },
+                },
+                reply: (message) => {
+                    console.log(`\n[${message.sender.shortName}]: ${message.text}\n`);
+                    this.rl.prompt();
+                },
+            });
+        });
+    }
+};
+CmdChannel = CmdChannel_1 = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [ChatResolver])
+], CmdChannel);
+
+export { CmdChannel };

package/dist/src/channels/cmd/index.d.ts

@@ -0,0 +1 @@
+export * from './CmdChannel';

package/dist/src/channels/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cmd';
+export * from './telegram';

package/dist/src/channels/telegram/@telegram.d.ts

@@ -0,0 +1,2 @@
+import { ITelegramChannelConfig } from './TelegramChannelConfig';
+export declare function telegram(config: ITelegramChannelConfig): (target: object, propertyKey: string | symbol) => void;

package/dist/src/channels/telegram/@telegram.js

@@ -0,0 +1,19 @@
+import { container } from '../../injection/index.js';
+import '../../controller/channel/ChatResolver.js';
+import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
+import { TelegramChannel } from './TelegramChannel.js';
+import { TelegramChannelConfig } from './TelegramChannelConfig.js';
+
+function telegram(config) {
+    return function (target, propertyKey) {
+        const store = container.resolve(ControllerMetadataStore);
+        store.saveChannelMetadata({
+            channelConstructor: TelegramChannel,
+            functionName: propertyKey.toString(),
+            controllerConstructor: target.constructor,
+            channelConfig: new TelegramChannelConfig(config.botToken),
+        });
+    };
+}
+
+export { telegram };

package/dist/src/channels/telegram/TelegramChannel.d.ts

@@ -0,0 +1,12 @@
+import { IChatChannel } from '../../controller/channel/IChatChannel';
+import { ChatResolver } from '../../controller/channel/ChatResolver';
+import { IMessageContext } from '../../controller/channel/IMessageContext';
+import { TelegramChannelConfig } from './TelegramChannelConfig';
+export declare class TelegramChannel implements IChatChannel {
+    private config;
+    private chatResolver;
+    private bot;
+    constructor(config: TelegramChannelConfig, chatResolver: ChatResolver);
+    listen(callback: (message: IMessageContext) => void): void;
+    connect(): void;
+}

package/dist/src/channels/telegram/TelegramChannel.js

@@ -0,0 +1,54 @@
+import { __decorate, __metadata } from 'tslib';
+import { Bot } from 'grammy';
+import { ChatResolver } from '../../controller/channel/ChatResolver.js';
+import { TelegramChannelConfig } from './TelegramChannelConfig.js';
+import { injectable } from '../../injection/index.js';
+
+var TelegramChannel_1;
+let TelegramChannel = TelegramChannel_1 = class TelegramChannel {
+    config;
+    chatResolver;
+    bot;
+    constructor(config, chatResolver) {
+        this.config = config;
+        this.chatResolver = chatResolver;
+        this.bot = new Bot(this.config.botToken);
+    }
+    listen(callback) {
+        this.bot.on('message', async (ctx) => {
+            if (!ctx.message) {
+                return;
+            }
+            const origin = {
+                chatId: ctx.message.chat.id.toString(),
+                chatType: ctx.message.chat.type === 'private' ? 'PRIVATE' : 'GROUP',
+                channelType: TelegramChannel_1,
+            };
+            const chat = await this.chatResolver.resolve(origin);
+            callback({
+                chatId: chat.getId(),
+                origin,
+                message: {
+                    text: ctx.message.text,
+                    sender: {
+                        shortName: ctx.from.first_name,
+                        senderId: ctx.from.id != null ? ctx.from.id.toString() : undefined,
+                    },
+                },
+                reply: (replyMessage) => {
+                    replyMessage.text && ctx.reply(replyMessage.text);
+                },
+            });
+        });
+    }
+    connect() {
+        this.bot.start();
+    }
+};
+TelegramChannel = TelegramChannel_1 = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [TelegramChannelConfig,
+        ChatResolver])
+], TelegramChannel);
+
+export { TelegramChannel };

package/dist/src/channels/telegram/TelegramChannelConfig.d.ts

@@ -0,0 +1,7 @@
+export interface ITelegramChannelConfig {
+    botToken: string;
+}
+export declare class TelegramChannelConfig implements ITelegramChannelConfig {
+    botToken: string;
+    constructor(botToken: string);
+}

package/dist/src/channels/telegram/TelegramChannelConfig.js

@@ -0,0 +1,8 @@
+class TelegramChannelConfig {
+    botToken;
+    constructor(botToken) {
+        this.botToken = botToken;
+    }
+}
+
+export { TelegramChannelConfig };

package/dist/src/channels/telegram/index.d.ts

@@ -0,0 +1,3 @@
+export * from './@telegram';
+export * from './TelegramChannelConfig';
+export * from './TelegramChannel';

package/dist/src/chatbot/ChatBot.d.ts

@@ -0,0 +1,11 @@
+import { IChatMessage } from '@/message';
+import { ChatBotAdapter } from './ChatBotAdapter';
+import { IChatBot } from './IChatBot';
+import { ChatMemory } from './chat';
+export declare class ChatBot implements IChatBot {
+    private memory;
+    private adapter;
+    constructor(memory: ChatMemory, adapter: ChatBotAdapter);
+    sendMessage(message: IChatMessage, callback: (message: IChatMessage) => void): Promise<void>;
+    protected processLoop(callback: (message: IChatMessage) => void): Promise<void>;
+}

package/dist/src/chatbot/ChatBot.js

@@ -0,0 +1,51 @@
+import { __decorate, __metadata } from 'tslib';
+import { v4 } from 'uuid';
+import { ChatBotAdapter } from './ChatBotAdapter.js';
+import './chat/repository/ram/RamChatRepository.js';
+import { ChatMemory } from './chat/repository/IChatMemory.js';
+import './chat/repository/IChatRepository.js';
+import { injectable } from '../injection/index.js';
+
+let ChatBot = class ChatBot {
+    memory;
+    adapter;
+    constructor(memory, adapter) {
+        this.memory = memory;
+        this.adapter = adapter;
+        this.memory = memory;
+    }
+    async sendMessage(message, callback) {
+        const newChatItem = {
+            id: v4(),
+            createdAt: new Date(),
+            type: 'USER_MESSAGE',
+            content: message,
+        };
+        await this.memory.saveItem(newChatItem);
+        this.processLoop(callback);
+    }
+    async processLoop(callback) {
+        const prevChatItems = await this.memory.findLastItems(10);
+        if (prevChatItems.length === 0) {
+            return;
+        }
+        const lastChatItem = prevChatItems[prevChatItems.length - 1];
+        if (lastChatItem.type === 'BOT_MESSAGE') {
+            return;
+        }
+        const newChatItem = await this.adapter.generateNextChatItem(prevChatItems);
+        await this.memory.saveItem(newChatItem);
+        if (newChatItem.type === 'BOT_MESSAGE') {
+            callback(newChatItem.content);
+            return;
+        }
+        this.processLoop(callback);
+    }
+};
+ChatBot = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [ChatMemory,
+        ChatBotAdapter])
+], ChatBot);
+
+export { ChatBot };

package/dist/src/chatbot/ChatBotAdapter.d.ts

@@ -0,0 +1,26 @@
+import { MindsetOperator } from '@/mindset/MindsetOperator';
+import { IChatItem } from './chat/IChatItem';
+export interface IChatBotAdapter {
+    generateNextChatItem(chatItems: IChatItem[]): Promise<IChatItem>;
+}
+export declare class ChatBotAdapter implements IChatBotAdapter {
+    protected mindset: MindsetOperator;
+    constructor(mindset: MindsetOperator);
+    generateNextChatItem(chatItems: IChatItem[]): Promise<IChatItem>;
+    protected systemPrompt(): Promise<string>;
+    protected buildBotMessageItem(text: string): Promise<{
+        id: string;
+        createdAt: Date;
+    } & import("./chat").ISystemMessageItem>;
+    protected buildFunctionCallItem(foreignId: string, functionName: string, functionArguments: string): Promise<{
+        readonly id: string;
+        readonly createdAt: Date;
+        readonly type: "FUNCTION_CALL";
+        readonly content: {
+            readonly foreignId: string;
+            readonly name: string;
+            readonly arguments: string;
+            readonly result: string;
+        };
+    }>;
+}

package/dist/src/chatbot/ChatBotAdapter.js

@@ -0,0 +1,74 @@
+import { v4 } from 'uuid';
+
+class ChatBotAdapter {
+    mindset;
+    constructor(mindset) {
+        this.mindset = mindset;
+    }
+    generateNextChatItem(chatItems) {
+        throw new Error('Not implemented');
+    }
+    async systemPrompt() {
+        let [identity, skills, limits] = await Promise.all([
+            this.mindset.identity(),
+            this.mindset.skills(),
+            this.mindset.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 buildBotMessageItem(text) {
+        const shortName = (await this.mindset.identity()).name;
+        const newBotMessage = {
+            id: v4(),
+            createdAt: new Date(),
+            type: 'BOT_MESSAGE',
+            content: {
+                sender: { shortName },
+                text,
+            },
+        };
+        return newBotMessage;
+    }
+    async buildFunctionCallItem(foreignId, functionName, functionArguments) {
+        const functionResult = await this.mindset.callFunction(functionName, functionArguments);
+        const newFunctionCall = {
+            id: v4(),
+            createdAt: new Date(),
+            type: 'FUNCTION_CALL',
+            content: {
+                foreignId,
+                name: functionName,
+                arguments: functionArguments,
+                result: functionResult,
+            },
+        };
+        return newFunctionCall;
+    }
+}
+
+export { ChatBotAdapter };

package/dist/src/chatbot/IChatBot.d.ts

@@ -0,0 +1,4 @@
+import { IChatMessage } from '@/message';
+export interface IChatBot {
+    sendMessage(message: IChatMessage, callback: (message: IChatMessage) => void): void | Promise<void>;
+}

package/dist/src/chatbot/chat/Chat.d.ts

@@ -0,0 +1,23 @@
+export type IChatType = 'PRIVATE' | 'GROUP';
+export interface IChatConnection {
+    channelType: string;
+    chatId: string;
+}
+export interface IChatData {
+    id?: string;
+    createdAt?: Date;
+    type: IChatType;
+    connections: IChatConnection[];
+}
+export declare class Chat {
+    private data;
+    constructor(data: IChatData);
+    isPrivate(): boolean;
+    isGroup(): boolean;
+    hasConnection(connection: IChatConnection): boolean;
+    private validatePrivateChat;
+    private validateGroupChat;
+    getId(): string;
+    wasCreated(): boolean;
+    validate(): void;
+}

package/dist/src/chatbot/chat/Chat.js

@@ -0,0 +1,55 @@
+class Chat {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    isPrivate() {
+        return this.data.type === 'PRIVATE';
+    }
+    isGroup() {
+        return this.data.type === 'GROUP';
+    }
+    hasConnection(connection) {
+        for (const con of this.data.connections) {
+            if (con.channelType === connection.channelType && con.chatId === connection.chatId) {
+                return true;
+            }
+        }
+        return false;
+    }
+    validatePrivateChat() {
+        if (this.data.connections.length < 1) {
+            throw new Error('PRIVATE chat should have one or more connections');
+        }
+    }
+    validateGroupChat() {
+        if (this.data.connections.length != 1) {
+            throw new Error('GROUP chat should have exactly one connection');
+        }
+    }
+    getId() {
+        if (!this.data.id) {
+            throw new Error('Chat ID is required');
+        }
+        return this.data.id;
+    }
+    wasCreated() {
+        return !!this.data.createdAt || !!this.data.id;
+    }
+    validate() {
+        if (!this.data.id) {
+            throw new Error('Chat ID is required');
+        }
+        if (!this.data.createdAt) {
+            throw new Error('Chat createdAt is required');
+        }
+        if (this.data.type === 'PRIVATE') {
+            this.validatePrivateChat();
+        }
+        else if (this.data.type === 'GROUP') {
+            this.validateGroupChat();
+        }
+    }
+}
+
+export { Chat };

package/dist/src/chatbot/chat/IChatFunctionCall.d.ts

@@ -0,0 +1,6 @@
+export interface IChatFunctionCall {
+    foreignId: string;
+    name: string;
+    arguments?: string;
+    result: string;
+}

package/dist/src/chatbot/chat/IChatItem.d.ts

@@ -0,0 +1,19 @@
+import { IChatMessage } from '../../message/IChatMessage';
+import { IChatFunctionCall } from './IChatFunctionCall';
+export type ISystemMessageItem = {
+    type: 'BOT_MESSAGE';
+    content: IChatMessage;
+};
+export type IUserMessageItem = {
+    type: 'USER_MESSAGE';
+    content: IChatMessage;
+};
+export type ISystemFunctionCallItem = {
+    type: 'FUNCTION_CALL';
+    content: IChatFunctionCall;
+};
+export type IChatItem = {
+    id: string;
+    createdAt: Date;
+} & (ISystemMessageItem | IUserMessageItem | ISystemFunctionCallItem);
+export type IChatItemType = IChatItem['type'];

package/dist/src/chatbot/chat/index.d.ts

@@ -0,0 +1,4 @@
+export * from './repository';
+export * from './Chat';
+export * from './IChatFunctionCall';
+export * from './IChatItem';

package/dist/src/chatbot/chat/repository/IChatMemory.d.ts

@@ -0,0 +1,9 @@
+import { IChatItem } from '../IChatItem';
+export interface IChatMemory {
+    findLastItems(count: number): Promise<IChatItem[]>;
+    saveItem(item: IChatItem): Promise<void>;
+}
+export declare class ChatMemory implements IChatMemory {
+    findLastItems(count: number): Promise<IChatItem[]>;
+    saveItem(item: IChatItem): Promise<void>;
+}

package/dist/src/chatbot/chat/repository/IChatMemory.js

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

package/dist/src/chatbot/chat/repository/IChatRepository.d.ts

@@ -0,0 +1,12 @@
+import { Chat, IChatConnection } from '../Chat';
+import { IChatMemory } from './IChatMemory';
+export interface IChatRepository {
+    create(chat: Chat): Promise<void>;
+    findByConnection(query: IChatConnection): Promise<Chat | null>;
+    findMemory(chatId: string): Promise<IChatMemory | null>;
+}
+export declare class ChatRepository implements IChatRepository {
+    create(chat: Chat): Promise<void>;
+    findByConnection(query: IChatConnection): Promise<Chat | null>;
+    findMemory(chatId: string): Promise<IChatMemory | null>;
+}