@cobrowser/chatgpt 0.7.3 → 0.7.5

package/dist/models/ChatGptMessage.d.ts

@@ -5,6 +5,9 @@ export declare enum ChatGptRole {
 }
 export interface ChatGptRequestBody {
     model: string;
+    response_format?: {
+        type: string;
+    };
     messages: ChatGptMessage[];
 }
 interface ChatGptMessage {

package/dist/models/ChatGptResponse.d.ts

@@ -0,0 +1,6 @@
+import ChatGptUsageTokens from './ChatGptUsageTokens';
+interface ChatGptResponse {
+    firstChoice?: string;
+    usageTokens?: ChatGptUsageTokens;
+}
+export default ChatGptResponse;

package/dist/models/ChatGptResponse.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/ChatGptUsageTokens.d.ts

@@ -0,0 +1,6 @@
+interface ChatGptUsageTokens {
+    prompt_tokens: Number;
+    completion_tokens: Number;
+    total_tokens: Number;
+}
+export default ChatGptUsageTokens;

package/dist/models/ChatGptUsageTokens.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/BaseService/BaseService.d.ts

@@ -1,21 +1,30 @@
 import { AxiosError, AxiosInstance, AxiosResponse } from 'axios';
+import ChatGptUsageTokens from '../../models/ChatGptUsageTokens';
 declare class BaseService {
     request: AxiosInstance;
     readonly BASE_CHAT_COMPLETION_URL = "https://api.openai.com/v1/chat/completions";
+    openaiApiKey: string | undefined;
     chatGptModel: string;
     maxNumberOfChatCompletionResult: number;
     /**
      *
-     * @param apiUrl Api url to be used to make API calls to openAI services
+     * @param apiKey
      * @param model the main chatGPT model to use
+     * @param apiUrl Api url to be used to make API calls to openAI services
      * @param maxNumberOfChoices How many chat completion choices to generate for each request.
+     *
      */
-    constructor(apiUrl?: string, model?: string, maxNumberOfChoices?: number, apiKey?: string | undefined);
+    constructor(apiKey?: string | undefined, model?: string, apiUrl?: string, maxNumberOfChoices?: number);
     /**
      * Filter the response from chatGpt API and only get the first choice
      * @param response
      */
     getResponseFirstChoice(response: AxiosResponse): string | undefined;
+    /**
+     * Filter the response from chatGpt API and get the usage tokens
+     * @param response
+     */
+    getResponseUsageTokens(response: AxiosResponse): ChatGptUsageTokens | undefined;
     /**
      * function to handle requests errors
      * @param error

package/dist/services/BaseService/BaseService.js

@@ -8,11 +8,13 @@ const logger_1 = __importDefault(require("../logger"));
 class BaseService {
     /**
      *
-     * @param apiUrl Api url to be used to make API calls to openAI services
+     * @param apiKey
      * @param model the main chatGPT model to use
+     * @param apiUrl Api url to be used to make API calls to openAI services
      * @param maxNumberOfChoices How many chat completion choices to generate for each request.
+     *
      */
-    constructor(apiUrl, model = 'gpt-3.5-turbo', maxNumberOfChoices = 1, apiKey = process.env.OPEN_AI_API_KEY) {
+    constructor(apiKey = process.env.OPEN_AI_API_KEY, model = 'gpt-3.5-turbo', apiUrl, maxNumberOfChoices = 1) {
         Object.defineProperty(this, "request", {
             enumerable: true,
             configurable: true,
@@ -25,6 +27,12 @@ class BaseService {
             writable: true,
             value: 'https://api.openai.com/v1/chat/completions'
         });
+        Object.defineProperty(this, "openaiApiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "chatGptModel", {
             enumerable: true,
             configurable: true,
@@ -44,6 +52,7 @@ class BaseService {
                 Authorization: `Bearer ${apiKey} `,
             },
         });
+        this.openaiApiKey = apiKey;
         this.chatGptModel = model;
         this.maxNumberOfChatCompletionResult = maxNumberOfChoices;
     }
@@ -60,6 +69,19 @@ class BaseService {
         }
         return undefined;
     }
+    /**
+     * Filter the response from chatGpt API and get the usage tokens
+     * @param response
+     */
+    getResponseUsageTokens(response) {
+        var _a;
+        if ((_a = response.data) === null || _a === void 0 ? void 0 : _a.usage) {
+            const usage = response.data.usage;
+            logger_1.default.info(`ChatGpt response usage tokens: ${JSON.stringify(usage)}`);
+            return usage;
+        }
+        return undefined;
+    }
     /**
      * function to handle requests errors
      * @param error

package/dist/services/ChatService/ChatService.d.ts

@@ -3,6 +3,6 @@ import ConversationHistory from 'src/models/ConversationHistory';
 export declare class ChatService extends BaseService {
     #private;
     model: string | undefined;
-    constructor(apiUrl?: string, model?: string, maxNumberOfChoices?: number, apiKey?: string);
+    constructor(apiKey?: string, model?: string, apiUrl?: string, maxNumberOfChoices?: number);
     ask(context: string | undefined, conversationHistory: ConversationHistory[]): Promise<string | undefined>;
 }

package/dist/services/ChatService/ChatService.js

@@ -24,8 +24,8 @@ const BaseService_1 = __importDefault(require("../BaseService/BaseService"));
 const logger_1 = __importDefault(require("../logger"));
 const constants_1 = require("../../constants");
 class ChatService extends BaseService_1.default {
-    constructor(apiUrl, model, maxNumberOfChoices, apiKey) {
-        super(apiUrl, model, maxNumberOfChoices, apiKey);
+    constructor(apiKey, model, apiUrl, maxNumberOfChoices) {
+        super(apiKey, model, apiUrl, maxNumberOfChoices);
         _ChatService_instances.add(this);
         Object.defineProperty(this, "model", {
             enumerable: true,

package/dist/services/CopilotService/CopilotService.d.ts

@@ -1,8 +1,10 @@
+import ChatGptResponse from '../../models/ChatGptResponse';
 import BaseService from '../BaseService/BaseService';
 import ChatGptMessage from '../../models/ChatGptMessage';
 import Item from '../../models/Item';
 export declare class CopilotService extends BaseService {
-    constructor(apiUrl?: string, model?: string, maxNumberOfChoices?: number, apiKey?: string);
+    assistantId: string | undefined;
+    constructor(apiKey?: string, model?: string, assistantId?: string, apiUrl?: string, maxNumberOfChoices?: number);
     /**
      * a method to be used to suggest some quick replies for the agent based on the conversation
      *  will be added as a single string in the format
@@ -15,11 +17,17 @@ export declare class CopilotService extends BaseService {
      * this will make it easy to ask chatGpt for quick replies
      * @param conversation
      */
-    suggest(conversation: string): Promise<string | undefined>;
+    suggest(conversation: string): Promise<ChatGptResponse | undefined>;
     /**
      * this will request chatGPT to recommend product or item based on the whole conversation
      * @param conversation the whole chat conversation
      * @param items the items to recommend from
      */
     recommend(conversation: ChatGptMessage[], items: Item[]): Promise<string | undefined>;
+    /**
+     * Get the reply of the assistant if the assistant_id is available
+     *
+     * @param message
+     */
+    getAssistantReply(message: string): Promise<string | undefined>;
 }

package/dist/services/CopilotService/CopilotService.js

@@ -16,9 +16,17 @@ exports.CopilotService = void 0;
 const BaseService_1 = __importDefault(require("../BaseService/BaseService"));
 const logger_1 = __importDefault(require("../logger"));
 const ChatGptMessage_1 = require("../../models/ChatGptMessage");
+const openai_1 = __importDefault(require("openai"));
 class CopilotService extends BaseService_1.default {
-    constructor(apiUrl, model, maxNumberOfChoices, apiKey) {
-        super(apiUrl, model, maxNumberOfChoices, apiKey);
+    constructor(apiKey, model, assistantId, apiUrl, maxNumberOfChoices) {
+        super(apiKey, model, apiUrl, maxNumberOfChoices);
+        Object.defineProperty(this, "assistantId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.assistantId = assistantId;
     }
     /**
      * a method to be used to suggest some quick replies for the agent based on the conversation
@@ -39,21 +47,37 @@ class CopilotService extends BaseService_1.default {
                 return Promise.reject(new Error('conversation must be provided'));
             }
             try {
+                if (this.assistantId) {
+                    // Here we get the last customer message as we dont need the whole conversation
+                    // as we are doing with the other approach
+                    const conversationArray = conversation.split('\n');
+                    const lastCustomerMessage = conversationArray.reverse().find(e => e.includes('customer:'));
+                    if (!lastCustomerMessage) {
+                        logger_1.default.error('last customer message not found');
+                        return Promise.reject(new Error('last customer message not found'));
+                    }
+                    const assistantReply = yield this.getAssistantReply(lastCustomerMessage);
+                    return {
+                        firstChoice: assistantReply
+                    };
+                }
                 // main prompt used to instruct chatGPT to suggest some quick replies
                 const mainPrompt = `Propose some quick replies for the agent to be used on the following conversation
-          display your response as unordered list:-\n${conversation}`;
+          display your response as unordered list:-\n${conversation}`, 
                 // main prompt will be the whole conversation as string
-                const mainPromptMessage = {
+                mainPromptMessage = {
                     role: ChatGptMessage_1.ChatGptRole.USER,
                     content: mainPrompt,
-                };
+                }, 
                 // the body we need to send to the request
-                const requestBody = {
+                requestBody = {
                     model: this.chatGptModel,
                     messages: [mainPromptMessage],
+                }, response = yield this.request.post('', requestBody);
+                return {
+                    firstChoice: this.getResponseFirstChoice(response),
+                    usageTokens: this.getResponseUsageTokens(response),
                 };
-                const response = yield this.request.post('', requestBody);
-                return this.getResponseFirstChoice(response);
             }
             catch (e) {
                 this.handleErrors(e);
@@ -74,18 +98,17 @@ class CopilotService extends BaseService_1.default {
             }
             try {
                 // main prompt used to instruct chatGPT to recommend products
-                const mainPrompt = `we have this list of Items: ${JSON.stringify(items)}, what to recommend for you`;
+                const mainPrompt = `we have this list of Items: ${JSON.stringify(items)}, what to recommend for you`, 
                 // main prompt will be the first message of the whole conversation
-                const firstMessage = {
+                firstMessage = {
                     role: ChatGptMessage_1.ChatGptRole.ASSISTANT,
                     content: mainPrompt,
-                };
+                }, 
                 // the body we need to send to the request
-                const requestBody = {
+                requestBody = {
                     model: this.chatGptModel,
                     messages: [firstMessage, ...conversation],
-                };
-                const response = yield this.request.post('', requestBody);
+                }, response = yield this.request.post('', requestBody);
                 return this.getResponseFirstChoice(response);
             }
             catch (e) {
@@ -94,5 +117,33 @@ class CopilotService extends BaseService_1.default {
             }
         });
     }
+    /**
+     * Get the reply of the assistant if the assistant_id is available
+     *
+     * @param message
+     */
+    getAssistantReply(message) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const openai = new openai_1.default({ apiKey: this.openaiApiKey });
+            let reply = undefined;
+            const thread = yield openai.beta.threads.create();
+            yield openai.beta.threads.messages.create(thread.id, { role: "user", content: message });
+            let run = yield openai.beta.threads.runs.create(thread.id, { assistant_id: (_a = this.assistantId) !== null && _a !== void 0 ? _a : '' });
+            while (['queued', 'in_progress', 'cancelling'].includes(run.status)) {
+                yield new Promise(resolve => setTimeout(resolve, 500));
+                run = yield openai.beta.threads.runs.retrieve(run.thread_id, run.id);
+            }
+            if (run.status === 'completed') {
+                const { data } = yield openai.beta.threads.messages.list(run.thread_id);
+                const messages = data.flatMap((message) => message === null || message === void 0 ? void 0 : message.content.map((content) => ((content.type === 'text' && message.role === 'assistant') ? content.text : '')));
+                const assistantMessage = messages.find(message => typeof message === 'object' && 'value' in message && typeof message.value === 'string');
+                if (assistantMessage) {
+                    reply = assistantMessage.value;
+                }
+            }
+            return reply;
+        });
+    }
 }
 exports.CopilotService = CopilotService;

package/dist/services/TranslationService/TranslationService.d.ts

@@ -1,11 +1,16 @@
+import ChatGptResponse from '../../models/ChatGptResponse';
 import BaseService from '../BaseService/BaseService';
 export declare class TranslationService extends BaseService {
-    constructor(apiUrl?: string, model?: string, maxNumberOfChoices?: number, apiKey?: string);
+    SYSTEM_ROLE_MESSAGE: string;
+    FIND_TEXT_LANGUAGE_SYSTEM_ROLE: string;
+    constructor(apiKey?: string, model?: string, apiUrl?: string, maxNumberOfChoices?: number);
     /**
      * request the chatGpt Api to translate a specific test to a desired language
      * @param text the text to translate
      * @param toLanguage the desired language to translate to ( English is the default )
      * @param fromLanguage if we want to specify the language of the text, we can use this ( optional)
      */
-    translate(text: string, toLanguage?: string, fromLanguage?: string): Promise<string | undefined>;
+    translate(text: string, toLanguage?: string, fromLanguage?: string): Promise<ChatGptResponse | undefined>;
+    findTextLanguage(text: string): Promise<ChatGptResponse | undefined>;
+    getFindTextLanguagePromptMessage(text: string): string;
 }

package/dist/services/TranslationService/TranslationService.js

@@ -18,8 +18,26 @@ const BaseService_1 = __importDefault(require("../BaseService/BaseService"));
 const logger_1 = __importDefault(require("../logger"));
 const constants_1 = require("../../constants");
 class TranslationService extends BaseService_1.default {
-    constructor(apiUrl, model, maxNumberOfChoices, apiKey) {
-        super(apiUrl, model, maxNumberOfChoices, apiKey);
+    constructor(apiKey, model, apiUrl, maxNumberOfChoices) {
+        super(apiKey, model, apiUrl, maxNumberOfChoices);
+        Object.defineProperty(this, "SYSTEM_ROLE_MESSAGE", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'You are a translator that provides a response in JSON format only. '
+                + 'The response should be a JSON object with a boolean called \'error\' and \'data,\''
+                + ' which is an array of objects. Each object in the array will contain a \'translation\' property, '
+                + 'holding the translation of the message, and a \'translated_message\' property, '
+                + 'which will contain the original message before being translated.'
+                + ' Additionally, the \'translation\' property will hold the translation of the \'translated_message\' property.'
+        });
+        Object.defineProperty(this, "FIND_TEXT_LANGUAGE_SYSTEM_ROLE", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'You are a translator that provides a response in JSON format only—a JSON that contains'
+                + ' \'languageCode\' and \'isError\' if you cannot detect the language.'
+        });
     }
     /**
      * request the chatGpt Api to translate a specific test to a desired language
@@ -39,14 +57,24 @@ class TranslationService extends BaseService_1.default {
             // the body we need to send to the request
             requestBody = {
                 model: this.chatGptModel,
-                messages: [{
+                response_format: { type: 'json_object' },
+                messages: [
+                    {
+                        role: ChatGptMessage_1.ChatGptRole.SYSTEM,
+                        content: this.SYSTEM_ROLE_MESSAGE,
+                    },
+                    {
                         role: ChatGptMessage_1.ChatGptRole.USER,
                         content: translateText,
-                    }],
+                    },
+                ],
             };
             try {
                 const response = yield this.request.post('', requestBody);
-                return this.getResponseFirstChoice(response);
+                return {
+                    firstChoice: this.getResponseFirstChoice(response),
+                    usageTokens: this.getResponseUsageTokens(response),
+                };
             }
             catch (e) {
                 this.handleErrors(e);
@@ -54,5 +82,45 @@ class TranslationService extends BaseService_1.default {
             }
         });
     }
+    findTextLanguage(text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!text) {
+                logger_1.default.error('translation text should be provided');
+                return Promise.reject(new Error('text must be provided'));
+            }
+            // instruction on what to do with the text
+            const translateText = this.getFindTextLanguagePromptMessage(text), 
+            // the body we need to send to the request
+            requestBody = {
+                model: this.chatGptModel,
+                response_format: { type: 'json_object' },
+                messages: [
+                    {
+                        role: ChatGptMessage_1.ChatGptRole.SYSTEM,
+                        content: this.FIND_TEXT_LANGUAGE_SYSTEM_ROLE,
+                    },
+                    {
+                        role: ChatGptMessage_1.ChatGptRole.USER,
+                        content: translateText,
+                    }
+                ],
+            };
+            try {
+                const response = yield this.request.post('', requestBody);
+                return {
+                    firstChoice: this.getResponseFirstChoice(response),
+                    usageTokens: this.getResponseUsageTokens(response),
+                };
+            }
+            catch (e) {
+                this.handleErrors(e);
+                return Promise.reject(e);
+            }
+        });
+    }
+    getFindTextLanguagePromptMessage(text) {
+        return `In which language is this text in '${text}'? The response should be {'languageCode': 'language_code_here', 'isError': 'true or false based on whether you did find the language code or not'}. 
+    Other responses or explanations are not allowed.`;
+    }
 }
 exports.TranslationService = TranslationService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cobrowser/chatgpt",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "description": "chatgpt services to connect our projects with chatgpt api",
   "keywords": [
     "chatgpt",
@@ -23,7 +23,8 @@
   "dependencies": {
     "@cobrowser/logger": "^1.0.0",
     "axios": "^1.6.1",
-    "axios-mock-adapter": "^1.22.0"
+    "axios-mock-adapter": "^1.22.0",
+    "openai": "^4.32.0"
   },
   "directories": {
     "dist": "dist"
@@ -38,5 +39,5 @@
   "bugs": {
     "url": "https://bitbucket.org/cobrowser/cb_utils/issues"
   },
-  "gitHead": "a47a44686f48c6618b3570470c46c9a8cb0e8d68"
+  "gitHead": "5a4bff51323eed4e0c17a865e7783d8dfc0323e1"
 }