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

package/dist/src/addon/auth/jwt/JwtRefreshTokenRepository.js

@@ -0,0 +1,25 @@
+class JwtRefreshTokenRepository {
+    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.');
+    }
+}
+
+export { JwtRefreshTokenRepository };

package/dist/src/addon/auth/jwt/JwtSigner.js

@@ -0,0 +1,36 @@
+import { __decorate, __metadata } from 'tslib';
+import jwt from 'jsonwebtoken';
+import { JwtConfig } from './JwtConfig.js';
+import { JwtTokenDto } from './JwtTokenDto.js';
+import { injectable } from '../../../core/injection/index.js';
+import { Mapper } from '../../../core/mapper/Mapper.js';
+import { JwtRefreshToken } from './JwtRefreshToken.js';
+
+let JwtSigner = class JwtSigner {
+    config;
+    mapper;
+    constructor(config, mapper) {
+        this.config = config;
+        this.mapper = mapper;
+    }
+    async signAccessToken(info) {
+        const _authInfo = info instanceof JwtRefreshToken
+            ? {
+                ...info.authInfo,
+                refreshTokenId: info.id,
+            }
+            : info;
+        const token = jwt.sign(_authInfo, this.config.secretOrPrivateKey, {
+            expiresIn: this.config.accessExpirationSeconds,
+        });
+        const expiration = new Date().getTime() + this.config.accessExpirationSeconds * 1000;
+        return this.mapper.map({ token, expiration }, JwtTokenDto);
+    }
+};
+JwtSigner = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [JwtConfig,
+        Mapper])
+], JwtSigner);
+
+export { JwtSigner };

package/dist/src/addon/auth/jwt/JwtTokenDto.js

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

package/dist/src/addon/auth/jwt/PgJwtRefreshTokenRepository.js

@@ -0,0 +1,21 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../../../core/injection/index.js';
+import { Pool } from 'pg';
+import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
+import { JwtRefreshToken } from './JwtRefreshToken.js';
+
+let PgJwtRefreshTokenRepository = class PgJwtRefreshTokenRepository extends PgCrudRepository {
+    constructor(pool) {
+        super(pool, {
+            schema: 'wabot',
+            table: 'jwt_refresh_token',
+            constructor: JwtRefreshToken,
+        });
+    }
+};
+PgJwtRefreshTokenRepository = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Pool])
+], PgJwtRefreshTokenRepository);
+
+export { PgJwtRefreshTokenRepository };

package/dist/src/addon/chat-bot/anthropic/AnthropicChatAdapter.js

@@ -0,0 +1,135 @@
+import { __decorate, __metadata } from 'tslib';
+import { Env } from '../../../core/env/Env.js';
+import { singleton } from '../../../core/injection/index.js';
+import { Logger } from '../../../core/logger/Logger.js';
+import { Anthropic } from '@anthropic-ai/sdk';
+
+let AnthropicChatAdapter = class AnthropicChatAdapter {
+    env;
+    anthropic;
+    logger = new Logger('wabot:anthropic-chat-adapter');
+    constructor(env) {
+        this.env = env;
+        const apiKey = this.env.requireString('ANTHROPIC_API_KEY');
+        this.anthropic = new Anthropic({ apiKey });
+    }
+    async nextItem(req) {
+        const tools = req.tools.map((x) => this.mapTool(x));
+        const messages = this.mapChatItems(req.prevItems);
+        const request = {
+            model: req.model,
+            max_tokens: 4096,
+            system: req.systemPrompt,
+            messages,
+            tools: tools.length > 0 ? tools : undefined,
+        };
+        this.logger.debug(`Call Claude API with Request: ${JSON.stringify(request)}`);
+        const response = await this.anthropic.messages.create(request);
+        return this.mapResponse(response);
+    }
+    mapChatItems(chatItems) {
+        const messages = [];
+        for (const chatItem of chatItems) {
+            switch (chatItem.type) {
+                case 'humanMessage':
+                    messages.push(this.mapHumanMessage(chatItem.humanMessage));
+                    break;
+                case 'botMessage':
+                    messages.push(this.mapBotMessage(chatItem.botMessage));
+                    break;
+                case 'functionCall':
+                    messages.push(...this.mapFunctionCall(chatItem.functionCall));
+                    break;
+            }
+        }
+        return messages;
+    }
+    mapHumanMessage(item) {
+        if (!item.text) {
+            throw new Error('User message content is empty');
+        }
+        return { role: 'user', content: item.text };
+    }
+    mapBotMessage(item) {
+        if (!item.text) {
+            throw new Error('Assistant message content is empty');
+        }
+        return { role: 'assistant', content: item.text };
+    }
+    mapFunctionCall(item) {
+        return [
+            {
+                role: 'assistant',
+                content: [
+                    {
+                        type: 'tool_use',
+                        id: item.id,
+                        name: item.name,
+                        input: JSON.parse(item.arguments || '{}'),
+                    },
+                ],
+            },
+            {
+                role: 'user',
+                content: [
+                    {
+                        type: 'tool_result',
+                        tool_use_id: item.id,
+                        content: item.result || 'No result',
+                    },
+                ],
+            },
+        ];
+    }
+    mapTool(tool) {
+        return {
+            name: tool.name,
+            description: tool.description,
+            input_schema: {
+                type: 'object',
+                properties: tool.parameters.reduce((prev, param) => ({
+                    ...prev,
+                    [param.name]: { type: param.type, description: param.description },
+                }), {}),
+                required: tool.parameters.map((param) => param.name),
+            },
+        };
+    }
+    mapResponse(response) {
+        let chatItem;
+        const content = response.content[0];
+        if (content.type === 'text') {
+            chatItem = { type: 'botMessage', botMessage: { text: content.text } };
+        }
+        else if (content.type === 'tool_use') {
+            chatItem = {
+                type: 'functionCall',
+                functionCall: {
+                    id: content.id,
+                    name: content.name,
+                    arguments: JSON.stringify(content.input),
+                },
+            };
+        }
+        else {
+            throw new Error('Not supported Claude Response');
+        }
+        let usage;
+        if (response.usage) {
+            usage = {
+                inputTokens: response.usage.input_tokens,
+                outputTokens: response.usage.output_tokens,
+            };
+        }
+        else {
+            throw new Error('Unable to found usage info');
+        }
+        return { chatItem, usage };
+    }
+};
+AnthropicChatAdapter = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Env])
+], AnthropicChatAdapter);
+
+export { AnthropicChatAdapter };

package/dist/src/addon/chat-bot/deepseek/DeepSeekChatAdapter.js

@@ -0,0 +1,137 @@
+import { Logger } from '../../../core/logger/Logger.js';
+import { OpenAI } from 'openai';
+
+class DeepSeekChatAdapter {
+    deepSeek;
+    logger = new Logger('wabot:deepseek-chat-adapter');
+    constructor() {
+        const apiKey = process.env.DEEPSEEK_API_KEY;
+        const baseURL = process.env.DEEPSEEK_BASE_URL;
+        if (!apiKey) {
+            throw new Error('DEEPSEEK_API_KEY env variable is required');
+        }
+        if (!baseURL) {
+            throw new Error('DEEPSEEK_BASE_URL env variable is required');
+        }
+        this.deepSeek = new OpenAI({
+            apiKey,
+            baseURL,
+        });
+    }
+    async nextItem(req) {
+        const deepSeekInput = [];
+        deepSeekInput.push({ role: 'system', content: req.systemPrompt });
+        deepSeekInput.push(...this.mapChatItems(req.prevItems));
+        const tools = req.tools.map((x) => this.mapTool(x));
+        const response = await this.deepSeek.chat.completions.create({
+            model: req.model,
+            messages: deepSeekInput,
+            tools,
+            tool_choice: 'auto',
+        });
+        return this.mapResponse(response);
+    }
+    mapChatItems(chatItems) {
+        const deepSeekInput = [];
+        for (const chatItem of chatItems) {
+            switch (chatItem.type) {
+                case 'humanMessage':
+                    deepSeekInput.push(this.mapHumanMessage(chatItem.humanMessage));
+                    break;
+                case 'botMessage':
+                    deepSeekInput.push(this.mapBotMessage(chatItem.botMessage));
+                    break;
+                case 'functionCall':
+                    deepSeekInput.push(...this.mapFunctionCall(chatItem.functionCall));
+                    break;
+            }
+        }
+        return deepSeekInput;
+    }
+    mapHumanMessage(item) {
+        if (!item.text) {
+            throw new Error('User message content is empty');
+        }
+        return { role: 'user', content: item.text };
+    }
+    mapBotMessage(item) {
+        if (!item.text) {
+            throw new Error('Assistant message content is empty');
+        }
+        return { role: 'assistant', content: item.text };
+    }
+    mapFunctionCall(item) {
+        return [
+            {
+                role: 'assistant',
+                tool_calls: [
+                    {
+                        id: item.id,
+                        type: 'function',
+                        function: {
+                            name: item.name,
+                            arguments: item.arguments || '{}',
+                        },
+                    },
+                ],
+            },
+            {
+                role: 'tool',
+                tool_call_id: item.id,
+                content: item.result ?? 'No result',
+            },
+        ];
+    }
+    mapTool(tool) {
+        return {
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: {
+                    type: 'object',
+                    properties: tool.parameters.reduce((prev, param) => ({
+                        ...prev,
+                        [param.name]: { type: param.type, description: param.description },
+                    }), {}),
+                    required: tool.parameters.map((param) => param.name),
+                    additionalProperties: false,
+                },
+                strict: true,
+            },
+        };
+    }
+    mapResponse(response) {
+        let chatItem;
+        const { tool_calls: responseFunctionCall, content: responseText } = response.choices?.[0]?.message ?? {};
+        if (responseText) {
+            chatItem = { type: 'botMessage', botMessage: { text: responseText } };
+        }
+        else if (responseFunctionCall && responseFunctionCall[0]?.type === 'function') {
+            chatItem = {
+                type: 'functionCall',
+                functionCall: {
+                    id: responseFunctionCall[0].id,
+                    name: responseFunctionCall[0].function.name,
+                    arguments: responseFunctionCall[0].function.arguments,
+                },
+            };
+        }
+        else {
+            throw new Error('Not supported DeepSeek Response');
+        }
+        let usage;
+        if (response.usage) {
+            usage = {
+                inputTokens: response.usage.prompt_tokens,
+                outputTokens: response.usage.completion_tokens,
+            };
+        }
+        else {
+            throw new Error('Unable to found usage info');
+        }
+        return { chatItem, usage };
+    }
+}
+
+export { DeepSeekChatAdapter };

package/dist/src/addon/chat-bot/google/GoogleChatAdapter.js

@@ -0,0 +1,128 @@
+import { __decorate, __metadata } from 'tslib';
+import { Env } from '../../../core/env/Env.js';
+import { singleton } from '../../../core/injection/index.js';
+import { Logger } from '../../../core/logger/Logger.js';
+import OpenAI from 'openai';
+
+let GoogleChatAdapter = class GoogleChatAdapter {
+    env;
+    openai;
+    logger = new Logger('wabot:google-chat-adapter');
+    constructor(env) {
+        this.env = env;
+        const apiKey = this.env.requireString('GOOGLE_API_KEY');
+        this.openai = new OpenAI({
+            apiKey,
+            baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+        });
+    }
+    async nextItem(req) {
+        const messages = [];
+        messages.push({ role: 'system', content: req.systemPrompt });
+        messages.push(...this.mapChatItems(req.prevItems));
+        const tools = req.tools.map((x) => this.mapTool(x));
+        const request = {
+            model: req.model,
+            messages,
+            tools,
+        };
+        const response = await this.openai.chat.completions.create(request);
+        return this.mapResponse(response);
+    }
+    mapChatItems(chatItems) {
+        const messages = [];
+        for (const chatItem of chatItems) {
+            switch (chatItem.type) {
+                case 'humanMessage':
+                    messages.push(this.mapHumanMessage(chatItem.humanMessage));
+                    break;
+                case 'botMessage':
+                    messages.push(this.mapBotMessage(chatItem.botMessage));
+                    break;
+                case 'functionCall':
+                    messages.push(...this.mapFunctionCall(chatItem.functionCall));
+                    break;
+            }
+        }
+        return messages;
+    }
+    mapHumanMessage(item) {
+        if (!item.text) {
+            throw new Error('User message content is empty');
+        }
+        return { role: 'user', content: item.text };
+    }
+    mapBotMessage(item) {
+        if (!item.text) {
+            throw new Error('Bot message content is empty');
+        }
+        return { role: 'assistant', content: item.text };
+    }
+    mapFunctionCall(item) {
+        return [
+            {
+                role: 'function',
+                name: item.id,
+                content: item.result ?? 'No result',
+            },
+        ];
+    }
+    mapTool(tool) {
+        return {
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: {
+                    type: 'object',
+                    properties: tool.parameters.reduce((prev, param) => ({
+                        ...prev,
+                        [param.name]: {
+                            type: param.type,
+                            description: param.description,
+                        },
+                    }), {}),
+                    required: tool.parameters.map((param) => param.name),
+                    additionalProperties: false,
+                }
+            },
+        };
+    }
+    mapResponse(response) {
+        let chatItem;
+        const { tool_calls: responseFunctionCall, content: responseText } = response.choices?.[0]?.message ?? {};
+        if (responseText) {
+            chatItem = { type: 'botMessage', botMessage: { text: responseText } };
+        }
+        else if (responseFunctionCall && responseFunctionCall[0]?.type === 'function') {
+            chatItem = {
+                type: 'functionCall',
+                functionCall: {
+                    id: responseFunctionCall[0].id,
+                    name: responseFunctionCall[0].function.name,
+                    arguments: responseFunctionCall[0].function.arguments,
+                },
+            };
+        }
+        else {
+            throw new Error('Not supported Gemini Response');
+        }
+        let usage;
+        if (response.usage) {
+            usage = {
+                inputTokens: response.usage.prompt_tokens,
+                outputTokens: response.usage.completion_tokens,
+            };
+        }
+        else {
+            throw new Error('Unable to found usage info');
+        }
+        return { chatItem, usage };
+    }
+};
+GoogleChatAdapter = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Env])
+], GoogleChatAdapter);
+
+export { GoogleChatAdapter };

package/dist/src/addon/chat-bot/openia/OpenaiChatAdapter.js

@@ -0,0 +1,117 @@
+import { __decorate } from 'tslib';
+import { Logger } from '../../../core/logger/Logger.js';
+import { OpenAI } from 'openai';
+import { singleton } from '../../../core/injection/index.js';
+
+let OpenaiChatAdapter = class OpenaiChatAdapter {
+    openai = new OpenAI();
+    logger = new Logger('wabot:openai-chat-adapter');
+    async nextItem(req) {
+        const openIaInput = [];
+        openIaInput.push({ role: 'system', content: req.systemPrompt });
+        openIaInput.push(...this.mapChatItems(req.prevItems));
+        const tools = req.tools.map((x) => this.mapTool(x));
+        const response = await this.openai.responses.create({
+            model: req.model,
+            input: openIaInput,
+            tools,
+        });
+        return this.mapResponse(response);
+    }
+    mapChatItems(chatItems) {
+        const openIaInput = [];
+        for (const chatItem of chatItems) {
+            switch (chatItem.type) {
+                case 'humanMessage':
+                    openIaInput.push(this.mapConectionMessage(chatItem.humanMessage));
+                    break;
+                case 'botMessage':
+                    openIaInput.push(this.mapBotMessage(chatItem.botMessage));
+                    break;
+                case 'functionCall':
+                    openIaInput.push(...this.mapFunctionCall(chatItem.functionCall));
+                    break;
+            }
+        }
+        return openIaInput;
+    }
+    mapConectionMessage(item) {
+        if (!item.text) {
+            throw new Error('System message content is empty');
+        }
+        return { role: 'user', content: item.text };
+    }
+    mapBotMessage(item) {
+        if (!item.text) {
+            throw new Error('System message content is empty');
+        }
+        return { role: 'assistant', content: item.text };
+    }
+    mapFunctionCall(item) {
+        return [
+            {
+                type: 'function_call',
+                call_id: item.id,
+                name: item.name,
+                arguments: JSON.stringify(item.arguments),
+            },
+            {
+                type: 'function_call_output',
+                call_id: item.id,
+                output: item.result ?? 'Not result',
+            },
+        ];
+    }
+    mapTool(tool) {
+        return {
+            type: 'function',
+            name: tool.name,
+            description: tool.description,
+            parameters: {
+                type: 'object',
+                properties: tool.parameters.reduce((prev, param) => ({
+                    ...prev,
+                    [param.name]: { type: param.type, description: param.description },
+                }), {}),
+                required: tool.parameters.map((param) => param.name),
+                additionalProperties: false,
+            },
+            strict: true,
+        };
+    }
+    mapResponse(response) {
+        let chatItem;
+        if (response.output_text) {
+            chatItem = { type: 'botMessage', botMessage: { text: response.output_text } };
+        }
+        else if (response.output && response.output[0]?.type == 'function_call') {
+            chatItem = {
+                type: 'functionCall',
+                functionCall: {
+                    id: response.output[0].call_id,
+                    name: response.output[0].name,
+                    arguments: response.output[0].arguments,
+                },
+            };
+        }
+        else {
+            throw new Error('Not supported OpenIA Response');
+        }
+        let usage;
+        if (response.usage) {
+            usage = {
+                inputTokens: response.usage.input_tokens,
+                outputTokens: response.usage.output_tokens,
+            };
+        }
+        else {
+            throw new Error('Unable to found usage info');
+        }
+        return { chatItem, usage };
+    }
+};
+OpenaiChatAdapter = __decorate([
+    singleton()
+], OpenaiChatAdapter);
+
+export { OpenaiChatAdapter };

package/dist/src/{pre-made/repository/chat → addon/chat-bot}/pg/PgChatMemory.js

@@ -1,7 +1,9 @@
-import '../../../../core/chat/repository/IChatRepository.js';
-import { ChatItem } from '../../../../core/chat/ChatItem.js';
-import '../../../../core/user/IUserRepository.js';
-import { PgCrudRepository } from '../../../../repository/pg/PgCrudRepository.js';
+import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
+import '../../../feature/chat-bot/ChatBot.js';
+import { ChatItem } from '../../../feature/chat-bot/ChatItem.js';
+import '../../../core/injection/index.js';
+import 'uuid';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 
 class PgChatMemory extends PgCrudRepository {
     chatId;

package/dist/src/{pre-made/repository/chat → addon/chat-bot}/pg/PgChatRepository.js

@@ -1,11 +1,12 @@
 import { __decorate, __metadata } from 'tslib';
-import '../../../../core/chat/repository/IChatRepository.js';
-import { Chat } from '../../../../core/chat/Chat.js';
-import '../../../../core/user/IUserRepository.js';
-import { singleton } from '../../../../injection/index.js';
 import { Pool } from 'pg';
 import { PgChatMemory } from './PgChatMemory.js';
-import { PgCrudRepository } from '../../../../repository/pg/PgCrudRepository.js';
+import { singleton } from '../../../core/injection/index.js';
+import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
+import { Chat } from '../../../feature/chat-bot/Chat.js';
+import '../../../feature/chat-bot/ChatBot.js';
+import 'uuid';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 
 let PgChatRepository = class PgChatRepository extends PgCrudRepository {
     constructor(pool) {

package/dist/src/{pre-made/repository/chat → addon/chat-bot}/ram/RamChatRepository.js

@@ -1,7 +1,7 @@
 import { __decorate } from 'tslib';
 import { v4 } from 'uuid';
 import { RamChatMemory } from './RamChatMemory.js';
-import { singleton } from '../../../../injection/index.js';
+import { singleton } from '../../../core/injection/index.js';
 
 let RamChatRepository = class RamChatRepository {
     items = [];
@@ -16,7 +16,7 @@ let RamChatRepository = class RamChatRepository {
         this.items.push(chat);
         const memory = {
             memory: new RamChatMemory(),
-            chatId: chat.getId(),
+            chatId: chat.id,
         };
         this.memories.push(memory);
     }