@wabot-dev/framework 0.1.0-beta.55 → 0.1.0-beta.56

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

@@ -2,122 +2,120 @@ 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 { GoogleGenAI } from '@google/genai';
+import OpenAI from 'openai';
 
 let GoogleChatAdapter = class GoogleChatAdapter {
     env;
-    genai;
+    openai;
     logger = new Logger('wabot:google-chat-adapter');
     constructor(env) {
         this.env = env;
         const apiKey = this.env.requireString('GOOGLE_API_KEY');
-        this.genai = new GoogleGenAI({ apiKey });
+        this.openai = new OpenAI({
+            apiKey,
+            baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+        });
     }
     async nextItem(req) {
-        const geminiInput = [];
-        geminiInput.push(...this.mapChatItems(req.prevItems, req.systemPrompt));
+        const messages = [];
+        // Add system prompt as system message
+        messages.push({ role: 'system', content: req.systemPrompt });
+        // Add previous chat items
+        messages.push(...this.mapChatItems(req.prevItems));
         const tools = req.tools.map((x) => this.mapTool(x));
         const request = {
             model: req.model,
-            contents: geminiInput,
+            messages,
             tools: tools.length > 0 ? tools : undefined,
+            tool_choice: 'auto',
         };
         this.logger.debug(`Call Gemini API with Request: ${JSON.stringify(request)}`);
-        const response = await this.genai.models.generateContent(request);
+        const response = await this.openai.chat.completions.create(request);
         return this.mapResponse(response);
     }
-    mapChatItems(chatItems, systemPrompt) {
-        const geminiInput = [];
-        if (systemPrompt) {
-            geminiInput.push({ role: 'user', parts: [{ text: 'system: ' + systemPrompt }] });
-            geminiInput.push({ role: 'model', parts: [{ text: 'I understand.' }] });
-        }
+    mapChatItems(chatItems) {
+        const messages = [];
         for (const chatItem of chatItems) {
             switch (chatItem.type) {
                 case 'humanMessage':
-                    geminiInput.push(this.mapHumanMessage(chatItem.humanMessage));
+                    messages.push(this.mapHumanMessage(chatItem.humanMessage));
                     break;
                 case 'botMessage':
-                    geminiInput.push(this.mapBotMessage(chatItem.botMessage));
+                    messages.push(this.mapBotMessage(chatItem.botMessage));
                     break;
                 case 'functionCall':
-                    geminiInput.push(...this.mapFunctionCall(chatItem.functionCall));
+                    messages.push(...this.mapFunctionCall(chatItem.functionCall));
                     break;
             }
         }
-        return geminiInput;
+        return messages;
     }
     mapHumanMessage(item) {
         if (!item.text) {
             throw new Error('User message content is empty');
         }
-        return { role: 'user', parts: [{ text: item.text }] };
+        return { role: 'user', content: item.text };
     }
     mapBotMessage(item) {
         if (!item.text) {
             throw new Error('Bot message content is empty');
         }
-        return { role: 'model', parts: [{ text: item.text }] };
+        return { role: 'assistant', content: item.text };
     }
     mapFunctionCall(item) {
         return [
             {
-                role: 'model',
-                parts: [
+                role: 'assistant',
+                tool_calls: [
                     {
-                        functionCall: {
+                        id: item.id,
+                        type: 'function',
+                        function: {
                             name: item.name,
-                            args: JSON.parse(item.arguments || '{}'),
+                            arguments: item.arguments || '{}',
                         },
                     },
                 ],
             },
             {
-                role: 'user',
-                parts: [
-                    {
-                        functionResponse: {
-                            name: item.name,
-                            response: {
-                                result: item.result || 'No result',
-                            },
-                        },
-                    },
-                ],
+                role: 'tool',
+                tool_call_id: item.id,
+                content: item.result ?? 'No result',
             },
         ];
     }
     mapTool(tool) {
         return {
-            functionDeclarations: [
-                {
-                    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),
-                    },
+            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 part = response.response.candidates[0].content.parts[0];
-        if (part.text) {
-            chatItem = { type: 'botMessage', botMessage: { text: part.text } };
+        const { tool_calls: responseFunctionCall, content: responseText } = response.choices?.[0]?.message ?? {};
+        if (responseText) {
+            chatItem = { type: 'botMessage', botMessage: { text: responseText } };
         }
-        else if (part.functionCall) {
+        else if (responseFunctionCall && responseFunctionCall[0]?.type === 'function') {
             chatItem = {
                 type: 'functionCall',
                 functionCall: {
-                    id: `gemini_${Date.now()}`,
-                    name: part.functionCall.name,
-                    arguments: JSON.stringify(part.functionCall.args || {}),
+                    id: responseFunctionCall[0].id,
+                    name: responseFunctionCall[0].function.name,
+                    arguments: responseFunctionCall[0].function.arguments,
                 },
             };
         }
@@ -125,10 +123,10 @@ let GoogleChatAdapter = class GoogleChatAdapter {
             throw new Error('Not supported Gemini Response');
         }
         let usage;
-        if (response.response.usageMetadata) {
+        if (response.usage) {
             usage = {
-                inputTokens: response.response.usageMetadata.promptTokenCount || 0,
-                outputTokens: response.response.usageMetadata.candidatesTokenCount || 0,
+                inputTokens: response.usage.prompt_tokens,
+                outputTokens: response.usage.completion_tokens,
             };
         }
         else {

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

@@ -5,6 +5,9 @@ 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();
     }

package/dist/src/index.d.ts

@@ -328,6 +328,7 @@ interface IJobData extends IEntityData {
     startedAt?: number;
     successAt?: number;
     failedAt?: number;
+    retryAt?: number;
     error?: {
         message: string;
         stack?: string;
@@ -336,6 +337,7 @@ interface IJobData extends IEntityData {
 }
 declare class Job extends Entity<IJobData> {
     get commandName(): string;
+    hasFinished(): boolean;
     setAsStarted(): void;
     setAsSuccess(): void;
     setAsFailed(error: Error): void;
@@ -1142,7 +1144,7 @@ declare class DeepSeekChatAdapter implements IChatAdapter {
 
 declare class GoogleChatAdapter implements IChatAdapter {
     private env;
-    private genai;
+    private openai;
     private logger;
     constructor(env: Env);
     nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wabot-dev/framework",
-  "version": "0.1.0-beta.55",
+  "version": "0.1.0-beta.56",
   "description": "Framework for IA Chat Bots",
   "type": "module",
   "main": "dist/src/index.js",