@wabot-dev/framework 0.2.0-beta.8 → 0.2.0

package/dist/src/addon/auth/api-key/@apiKeyHandshakeGuard.js

@@ -0,0 +1,16 @@
+import { handshakeMiddlewares } from '../../../feature/socket-controller/metadata/@handshakeMiddlewares.js';
+import '../../../feature/socket-controller/metadata/SocketControllerMetadataStore.js';
+import '../../../core/injection/index.js';
+import 'debug';
+import '../../../core/validation/metadata/ValidationMetadataStore.js';
+import 'socket.io';
+import '../../../feature/socket/SocketServerProvider.js';
+import { ApiKeyHandshakeGuardMiddleware } from './ApiKeyHandshakeGuardMiddleware.js';
+
+function apiKeyHandshakeGuard() {
+    return function (target) {
+        handshakeMiddlewares([ApiKeyHandshakeGuardMiddleware])(target);
+    };
+}
+
+export { apiKeyHandshakeGuard };

package/dist/src/addon/auth/api-key/{ApiKeyConnectionGuardMiddleware.js → ApiKeyHandshakeGuardMiddleware.js}

@@ -4,7 +4,7 @@ import { CustomError } from '../../../core/error/CustomError.js';
 import { injectable } from '../../../core/injection/index.js';
 import { ApiKeyRepository } from './ApiKeyRepository.js';
 
-let ApiKeyConnectionGuardMiddleware = class ApiKeyConnectionGuardMiddleware {
+let ApiKeyHandshakeGuardMiddleware = class ApiKeyHandshakeGuardMiddleware {
     apiKeyRepository;
     auth;
     constructor(apiKeyRepository, auth) {
@@ -45,10 +45,10 @@ let ApiKeyConnectionGuardMiddleware = class ApiKeyConnectionGuardMiddleware {
         }
     }
 };
-ApiKeyConnectionGuardMiddleware = __decorate([
+ApiKeyHandshakeGuardMiddleware = __decorate([
     injectable(),
     __metadata("design:paramtypes", [ApiKeyRepository,
         Auth])
-], ApiKeyConnectionGuardMiddleware);
+], ApiKeyHandshakeGuardMiddleware);
 
-export { ApiKeyConnectionGuardMiddleware };
+export { ApiKeyHandshakeGuardMiddleware };

package/dist/src/addon/auth/jwt/@jwtHandshakeGuard.js

@@ -0,0 +1,16 @@
+import { handshakeMiddlewares } from '../../../feature/socket-controller/metadata/@handshakeMiddlewares.js';
+import '../../../feature/socket-controller/metadata/SocketControllerMetadataStore.js';
+import '../../../core/injection/index.js';
+import 'debug';
+import '../../../core/validation/metadata/ValidationMetadataStore.js';
+import 'socket.io';
+import '../../../feature/socket/SocketServerProvider.js';
+import { JwtHandshakeGuardMiddleware } from './JwtHandshakeGuardMiddleware.js';
+
+function jwtHandshakeGuard() {
+    return function (target) {
+        handshakeMiddlewares([JwtHandshakeGuardMiddleware])(target);
+    };
+}
+
+export { jwtHandshakeGuard };

package/dist/src/addon/auth/jwt/{JwtConnectionGuardMiddleware.js → JwtHandshakeGuardMiddleware.js}

@@ -5,7 +5,7 @@ import { Auth } from '../../../core/auth/Auth.js';
 import { CustomError } from '../../../core/error/CustomError.js';
 import { JwtConfig } from './JwtConfig.js';
 
-let JwtConnectionGuardMiddleware = class JwtConnectionGuardMiddleware {
+let JwtHandshakeGuardMiddleware = class JwtHandshakeGuardMiddleware {
     config;
     auth;
     constructor(config, auth) {
@@ -48,10 +48,10 @@ let JwtConnectionGuardMiddleware = class JwtConnectionGuardMiddleware {
         }
     }
 };
-JwtConnectionGuardMiddleware = __decorate([
+JwtHandshakeGuardMiddleware = __decorate([
     injectable(),
     __metadata("design:paramtypes", [JwtConfig,
         Auth])
-], JwtConnectionGuardMiddleware);
+], JwtHandshakeGuardMiddleware);
 
-export { JwtConnectionGuardMiddleware };
+export { JwtHandshakeGuardMiddleware };

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

@@ -13,7 +13,7 @@ let AnthropicChatAdapter = class AnthropicChatAdapter {
         const apiKey = this.env.requireString('ANTHROPIC_API_KEY');
         this.anthropic = new Anthropic({ apiKey });
     }
-    async nextItem(req) {
+    async nextItems(req) {
         const tools = req.tools.map((x) => this.mapTool(x));
         const messages = this.mapChatItems(req.prevItems);
         const request = {
@@ -96,24 +96,6 @@ let AnthropicChatAdapter = class AnthropicChatAdapter {
         };
     }
     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 = {
@@ -124,7 +106,23 @@ let AnthropicChatAdapter = class AnthropicChatAdapter {
         else {
             throw new Error('Unable to found usage info');
         }
-        return { chatItem, usage };
+        const nextItems = [];
+        for (const content of response.content) {
+            if (content.type === 'text' && content.text) {
+                nextItems.push({ type: 'botMessage', botMessage: { text: content.text } });
+            }
+            else if (content.type === 'tool_use') {
+                nextItems.push({
+                    type: 'functionCall',
+                    functionCall: {
+                        id: content.id,
+                        name: content.name,
+                        arguments: JSON.stringify(content.input),
+                    },
+                });
+            }
+        }
+        return { usage, nextItems };
     }
 };
 AnthropicChatAdapter = __decorate([

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

@@ -18,7 +18,7 @@ class DeepSeekChatAdapter {
             baseURL,
         });
     }
-    async nextItem(req) {
+    async nextItems(req) {
         const deepSeekInput = [];
         deepSeekInput.push({ role: 'system', content: req.systemPrompt });
         deepSeekInput.push(...this.mapChatItems(req.prevItems));
@@ -130,7 +130,7 @@ class DeepSeekChatAdapter {
         else {
             throw new Error('Unable to found usage info');
         }
-        return { chatItem, usage };
+        return { nextItems: [chatItem], usage };
     }
 }
 

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

@@ -2,122 +2,133 @@ 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';
+import { Random } from '../../../core/random/Random.js';
+import { GoogleGenAI } from '@google/genai';
 
 let GoogleChatAdapter = class GoogleChatAdapter {
-    env;
-    openai;
-    logger = new Logger('wabot:google-chat-adapter');
+    ai;
+    logger = new Logger('wabot:google-chat-adapter-v2');
     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/',
-        });
+        this.ai = new GoogleGenAI({ apiKey: env.requireString('GOOGLE_API_KEY') });
     }
-    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 = {
+    async nextItems(req) {
+        const contents = [];
+        contents.push({ role: 'user', parts: [{ text: req.systemPrompt }] });
+        contents.push(...this.mapChatItems(req.prevItems));
+        const functionDeclarations = req.tools.map((x) => this.mapTool(x));
+        const response = await this.ai.models.generateContent({
             model: req.model,
-            messages,
-            tools,
-        };
-        const response = await this.openai.chat.completions.create(request);
+            contents,
+            config: { tools: [{ functionDeclarations }] },
+        });
         return this.mapResponse(response);
     }
     mapChatItems(chatItems) {
-        const messages = [];
+        const contents = [];
         for (const chatItem of chatItems) {
             switch (chatItem.type) {
                 case 'humanMessage':
-                    messages.push(this.mapHumanMessage(chatItem.humanMessage));
+                    contents.push(this.mapHumanMessage(chatItem.humanMessage));
                     break;
                 case 'botMessage':
-                    messages.push(this.mapBotMessage(chatItem.botMessage));
+                    contents.push(this.mapBotMessage(chatItem.botMessage));
                     break;
                 case 'functionCall':
-                    messages.push(...this.mapFunctionCall(chatItem.functionCall));
+                    contents.push(...this.mapFunctionCall(chatItem.functionCall));
                     break;
             }
         }
-        return messages;
+        return contents;
     }
     mapHumanMessage(item) {
         if (!item.text) {
             throw new Error('User message content is empty');
         }
-        return { role: 'user', content: item.text };
+        return { role: 'user', parts: [{ text: item.text }] };
     }
     mapBotMessage(item) {
         if (!item.text) {
             throw new Error('Bot message content is empty');
         }
-        return { role: 'assistant', content: item.text };
+        return { role: 'model', parts: [{ text: item.text }] };
     }
     mapFunctionCall(item) {
         return [
+            {
+                role: 'model',
+                parts: [
+                    {
+                        functionCall: {
+                            id: item.id,
+                            name: item.name,
+                            args: JSON.parse(item.arguments ?? '{}'),
+                        },
+                    },
+                ],
+            },
             {
                 role: 'function',
-                name: item.id,
-                content: item.result ?? 'No result',
+                parts: [
+                    {
+                        functionResponse: {
+                            id: item.id,
+                            name: item.name,
+                            response: { output: item.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,
-                }
+            name: tool.name,
+            description: tool.description,
+            parametersJsonSchema: {
+                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 } };
+        if (!response.candidates || !response.candidates.length) {
+            throw new Error('No candidates in response');
         }
-        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,
-                },
-            };
+        if (!response.usageMetadata ||
+            !response.usageMetadata.promptTokenCount ||
+            !response.usageMetadata.candidatesTokenCount) {
+            throw new Error('Not usage metadata');
         }
-        else {
-            throw new Error('Not supported Gemini Response');
+        const content = response.candidates.find((x) => x.content)?.content;
+        if (!content) {
+            throw new Error('Candidates has no content');
         }
-        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');
+        const nextItems = [];
+        for (const part of content.parts ?? []) {
+            if (part.text) {
+                nextItems.push({ type: 'botMessage', botMessage: { text: part.text } });
+            }
+            if (part.functionCall) {
+                const { id, name, args } = part.functionCall;
+                if (!name) {
+                    throw new Error('invalid function call');
+                }
+                nextItems.push({
+                    type: 'functionCall',
+                    functionCall: { id: id ?? Random.alphaNumericLowerCase(10), name, arguments: args && JSON.stringify(args) },
+                });
+            }
         }
-        return { chatItem, usage };
+        let usage = {
+            inputTokens: response.usageMetadata.promptTokenCount,
+            outputTokens: response.usageMetadata.candidatesTokenCount,
+        };
+        return { usage, nextItems };
     }
 };
 GoogleChatAdapter = __decorate([

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

@@ -6,7 +6,7 @@ import { singleton } from '../../../core/injection/index.js';
 let OpenaiChatAdapter = class OpenaiChatAdapter {
     openai = new OpenAI();
     logger = new Logger('wabot:openai-chat-adapter');
-    async nextItem(req) {
+    async nextItems(req) {
         const openIaInput = [];
         openIaInput.push({ role: 'system', content: req.systemPrompt });
         openIaInput.push(...this.mapChatItems(req.prevItems));
@@ -80,23 +80,6 @@ let OpenaiChatAdapter = class OpenaiChatAdapter {
         };
     }
     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 = {
@@ -107,7 +90,48 @@ let OpenaiChatAdapter = class OpenaiChatAdapter {
         else {
             throw new Error('Unable to found usage info');
         }
-        return { chatItem, usage };
+        const nextItems = [];
+        for (const output of response.output) {
+            if (output.type === 'message') {
+                for (const content of output.content) {
+                    if (content.type === 'output_text' && content.text) {
+                        nextItems.push({ type: 'botMessage', botMessage: { text: content.text } });
+                    }
+                }
+            }
+            else if (output.type === 'function_call') {
+                nextItems.push({
+                    type: 'functionCall',
+                    functionCall: { id: output.call_id, name: output.name, arguments: output.arguments },
+                });
+            }
+        }
+        return { usage, nextItems };
+        // let chatItem: IChatItem
+        // 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: ILanguageModelUsage
+        // 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([

package/dist/src/addon/chat-bot/wabot/WabotChatAdapter.js

@@ -15,7 +15,7 @@ let WabotChatAdapter = class WabotChatAdapter {
             this.baseUrl = this.baseUrl.substring(0, this.baseUrl.length - 1);
         }
     }
-    async nextItem(req) {
+    async nextItems(req) {
         const response = await fetch(this.baseUrl + '/chat-bot/next-item', {
             method: 'post',
             headers: {

package/dist/src/addon/chat-controller/cmd/CmdChannel.js

@@ -1,21 +1,25 @@
-import { __decorate } from 'tslib';
+import { __decorate, __metadata } from 'tslib';
 import { injectable } from '../../../core/injection/index.js';
 import * as readline from 'readline';
 import * as fs from 'fs';
 import * as path from 'path';
 import { Random } from '../../../core/random/Random.js';
+import { Auth } from '../../../core/auth/Auth.js';
 
 var CmdChannel_1;
 const chatIdPath = '.cmd-channel/id.json';
 const authInfoPath = '.cmd-channel/auth-info.json';
 let CmdChannel = CmdChannel_1 = class CmdChannel {
-    authInfo = undefined;
+    auth;
     chatId = undefined;
     rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
     });
     callBack = null;
+    constructor(auth) {
+        this.auth = auth;
+    }
     listen(callback) {
         this.callBack = callback;
     }
@@ -44,8 +48,11 @@ let CmdChannel = CmdChannel_1 = class CmdChannel {
             };
             if (!this.callBack)
                 return;
-            if (this.authInfo === undefined) {
-                this.authInfo = readJsonFromFile(authInfoPath);
+            if (!this.auth.isAssigned()) {
+                const authInfo = readJsonFromFile(authInfoPath);
+                if (authInfo) {
+                    this.auth.assign(authInfo);
+                }
             }
             this.callBack({
                 chatConnection,
@@ -55,18 +62,18 @@ let CmdChannel = CmdChannel_1 = class CmdChannel {
                 reply: (message) => {
                     console.log(`\n[${message.senderName}]: ${message.text}\n`);
                     this.rl.prompt();
+                    if (this.auth.isAssigned()) {
+                        writeJsonToFile(authInfoPath, this.auth.require());
+                    }
                 },
-                authInfo: this.authInfo || undefined,
-                setAuthInfo: (authInfo) => {
-                    this.authInfo = authInfo || null;
-                    writeJsonToFile(authInfoPath, this.authInfo);
-                },
+                injectInstances: [[Auth, this.auth]],
             });
         });
     }
 };
 CmdChannel = CmdChannel_1 = __decorate([
-    injectable()
+    injectable(),
+    __metadata("design:paramtypes", [Auth])
 ], CmdChannel);
 function writeJsonToFile(filename, data) {
     const filePath = path.resolve(process.cwd(), filename);

package/dist/src/addon/chat-controller/socket/@socket.js

@@ -18,7 +18,7 @@ function socket(config) {
             channelConstructor: SocketChannel,
             functionName: propertyKey.toString(),
             controllerConstructor: target.constructor,
-            channelConfig: new SocketChannelConfig(config.channel),
+            channelConfig: new SocketChannelConfig(config.namespace, config.handshakeMidlewares),
         });
     };
 }