@wabot-dev/framework 0.1.0-beta.42 → 0.1.0-beta.43

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

@@ -14,109 +14,127 @@ let GoogleChatAdapter = class GoogleChatAdapter {
         this.genai = new GoogleGenAI({ apiKey });
     }
     async nextItem(req) {
-        const contents = this.buildContents(req.prevItems, req.systemPrompt);
-        const tools = req.tools.length > 0 ? req.tools.map(this.mapTool) : undefined;
-        const request = { model: req.model, contents, tools };
+        const geminiInput = [];
+        geminiInput.push(...this.mapChatItems(req.prevItems, req.systemPrompt));
+        const tools = req.tools.map((x) => this.mapTool(x));
+        const request = {
+            model: req.model,
+            contents: geminiInput,
+            tools: tools.length > 0 ? tools : undefined,
+        };
         this.logger.debug(`Call Gemini API with Request: ${JSON.stringify(request)}`);
         const response = await this.genai.models.generateContent(request);
         return this.mapResponse(response);
     }
-    buildContents(chatItems, systemPrompt) {
-        const contents = [];
+    mapChatItems(chatItems, systemPrompt) {
+        const geminiInput = [];
         if (systemPrompt) {
-            contents.push({ role: 'user', parts: [{ text: systemPrompt }] }, { role: 'model', parts: [{ text: 'I understand. I will follow these instructions.' }] });
+            geminiInput.push({ role: 'user', parts: [{ text: 'system: ' + systemPrompt }] });
+            geminiInput.push({ role: 'model', parts: [{ text: 'I understand.' }] });
         }
-        chatItems.forEach((chatItem) => {
+        for (const chatItem of chatItems) {
             switch (chatItem.type) {
                 case 'humanMessage':
-                    this.validateMessageContent(chatItem.humanMessage.text, 'User');
-                    contents.push({ role: 'user', parts: [{ text: chatItem.humanMessage.text }] });
+                    geminiInput.push(this.mapHumanMessage(chatItem.humanMessage));
                     break;
                 case 'botMessage':
-                    this.validateMessageContent(chatItem.botMessage.text, 'Assistant');
-                    contents.push({ role: 'model', parts: [{ text: chatItem.botMessage.text }] });
+                    geminiInput.push(this.mapBotMessage(chatItem.botMessage));
                     break;
                 case 'functionCall':
-                    contents.push(...this.mapFunctionCall(chatItem.functionCall));
+                    geminiInput.push(...this.mapFunctionCall(chatItem.functionCall));
                     break;
             }
-        });
-        return contents;
+        }
+        return geminiInput;
+    }
+    mapHumanMessage(item) {
+        if (!item.text) {
+            throw new Error('User message content is empty');
+        }
+        return { role: 'user', parts: [{ text: item.text }] };
     }
-    validateMessageContent(text, messageType) {
-        if (!text) {
-            throw new Error(`${messageType} message content is empty`);
+    mapBotMessage(item) {
+        if (!item.text) {
+            throw new Error('Bot message content is empty');
         }
+        return { role: 'model', parts: [{ text: item.text }] };
     }
     mapFunctionCall(item) {
-        const args = JSON.parse(item.arguments || '{}');
         return [
             {
                 role: 'model',
-                parts: [{ functionCall: { name: item.name, args } }],
+                parts: [
+                    {
+                        functionCall: {
+                            name: item.name,
+                            args: JSON.parse(item.arguments || '{}'),
+                        },
+                    },
+                ],
             },
             {
                 role: 'user',
                 parts: [
                     {
-                        functionResponse: { name: item.name, response: { result: item.result || 'No result' } },
+                        functionResponse: {
+                            name: item.name,
+                            response: {
+                                result: item.result || 'No result',
+                            },
+                        },
                     },
                 ],
             },
         ];
     }
-    mapTool = (tool) => ({
-        functionDeclarations: [
-            {
-                name: tool.name,
-                description: tool.description,
-                parameters: {
-                    type: 'object',
-                    properties: tool.parameters.reduce((acc, param) => ({
-                        ...acc,
-                        [param.name]: { type: param.type, description: param.description },
-                    }), {}),
-                    required: tool.parameters.map((param) => param.name),
+    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),
+                    },
                 },
-            },
-        ],
-    });
+            ],
+        };
+    }
     mapResponse(response) {
-        this.validateResponse(response);
+        let chatItem;
         const part = response.response.candidates[0].content.parts[0];
-        const chatItem = part.text
-            ? { type: 'botMessage', botMessage: { text: part.text } }
-            : part.functionCall
-                ? {
-                    type: 'functionCall',
-                    functionCall: {
-                        id: `gemini_${Date.now()}`,
-                        name: part.functionCall.name,
-                        arguments: JSON.stringify(part.functionCall.args || {}),
-                    },
-                }
-                : (() => {
-                    throw new Error('Not supported Gemini Response');
-                })();
-        const usage = {
-            inputTokens: response.response.usageMetadata?.promptTokenCount || 0,
-            outputTokens: response.response.usageMetadata?.candidatesTokenCount || 0,
-        };
-        if (!response.response.usageMetadata) {
-            throw new Error('Unable to found usage info');
+        if (part.text) {
+            chatItem = { type: 'botMessage', botMessage: { text: part.text } };
         }
-        return { chatItem, usage };
-    }
-    validateResponse(response) {
-        if (!response.response) {
-            throw new Error('Invalid Gemini response structure');
+        else if (part.functionCall) {
+            chatItem = {
+                type: 'functionCall',
+                functionCall: {
+                    id: `gemini_${Date.now()}`,
+                    name: part.functionCall.name,
+                    arguments: JSON.stringify(part.functionCall.args || {}),
+                },
+            };
         }
-        if (!response.response.candidates?.[0]) {
-            throw new Error('No candidates in Gemini response');
+        else {
+            throw new Error('Not supported Gemini Response');
         }
-        if (!response.response.candidates[0].content?.parts?.[0]) {
-            throw new Error('No parts in Gemini response');
+        let usage;
+        if (response.response.usageMetadata) {
+            usage = {
+                inputTokens: response.response.usageMetadata.promptTokenCount || 0,
+                outputTokens: response.response.usageMetadata.candidatesTokenCount || 0,
+            };
         }
+        else {
+            throw new Error('Unable to found usage info');
+        }
+        return { chatItem, usage };
     }
 };
 GoogleChatAdapter = __decorate([

package/dist/src/index.d.ts

@@ -807,7 +807,7 @@ declare class PgRepositoryBase<P extends Entity<IEntityData>> {
     constructor(pool: Pool, config: IPgRepositoryConfig<any>);
     protected values(item: P): (string | number | boolean | Date | null)[];
     protected exec(sql: string, values: any[]): Promise<void>;
-    protected query(sql: string, values: any[]): Promise<any[]>;
+    protected query(sql: string, values: any[]): Promise<P[]>;
     protected connect(): Promise<Pool>;
     protected ensureTable(): Promise<void>;
     protected ensureColumns(): Promise<void>;
@@ -862,12 +862,12 @@ declare class GoogleChatAdapter implements IChatAdapter {
     private logger;
     constructor(env: Env);
     nextItem(req: IChatAdapterNextItemReq): Promise<IChatAdapterNextItemRes>;
-    private buildContents;
-    private validateMessageContent;
+    private mapChatItems;
+    private mapHumanMessage;
+    private mapBotMessage;
     private mapFunctionCall;
     private mapTool;
     private mapResponse;
-    private validateResponse;
 }
 
 declare class OpenaiChatAdapter implements IChatAdapter {

package/package.json

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