@cobrowser/chatgpt 0.6.4 → 0.6.5

package/dist/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const MESSAGE_SENDER: {
+    visitor: string;
+    chatbot: string;
+};
+export declare const MESSAGE_TYPES: {
+    text: string;
+    button: string;
+};
+export declare const DEFAULT_CONTEXT = "You are a helpful assistant. Continue the conversation based on the previous conversations \n  mentioned below. Keep your answers less than 200 characters. Any questions by the visitor out of the context\n  should be politely declined. \n\n";
+export declare const DESTINATION_LANGUAGE = "English";

package/dist/constants.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DESTINATION_LANGUAGE = exports.DEFAULT_CONTEXT = exports.MESSAGE_TYPES = exports.MESSAGE_SENDER = void 0;
+// Message sender in conversation history
+exports.MESSAGE_SENDER = {
+    visitor: 'visitor',
+    chatbot: 'chatbot'
+};
+// Message types in conversation history
+exports.MESSAGE_TYPES = {
+    text: 'text',
+    button: 'button'
+};
+// Default context for ChatGPT
+exports.DEFAULT_CONTEXT = `You are a helpful assistant. Continue the conversation based on the previous conversations 
+  mentioned below. Keep your answers less than 200 characters. Any questions by the visitor out of the context
+  should be politely declined. \n
+`;
+// Default destination language
+exports.DESTINATION_LANGUAGE = 'English';

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from './services/TranslationService/TranslationService';
 export * from './services/CopilotService/CopilotService';
+export * from './services/ChatService/ChatService';

package/dist/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./services/TranslationService/TranslationService"), exports);
 __exportStar(require("./services/CopilotService/CopilotService"), exports);
+__exportStar(require("./services/ChatService/ChatService"), exports);

package/dist/models/ChatGptMessage.d.ts

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

package/dist/models/ConversationHistory.d.ts

@@ -0,0 +1,13 @@
+interface ConversationHistory {
+    from: string;
+    to: string;
+    datetime: number;
+    body: MessageBody[];
+}
+interface MessageBody {
+    type: string;
+    text?: string;
+    id?: string;
+    label?: string;
+}
+export default ConversationHistory;

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

@@ -1,5 +1,4 @@
 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";
@@ -11,17 +10,12 @@ declare class BaseService {
      * @param model the main chatGPT model to use
      * @param maxNumberOfChoices How many chat completion choices to generate for each request.
      */
-    constructor(apiUrl?: string, model?: string, maxNumberOfChoices?: number);
+    constructor(apiUrl?: string, model?: string, maxNumberOfChoices?: number, apiKey?: string | undefined);
     /**
      * 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 only get the first choice
-     * @param response
-     */
-    getResponseUsageTokens(response: AxiosResponse): ChatGptUsageTokens | undefined;
     /**
      * function to handle requests errors
      * @param error

package/dist/services/BaseService/BaseService.js

@@ -12,7 +12,7 @@ class BaseService {
      * @param model the main chatGPT model to use
      * @param maxNumberOfChoices How many chat completion choices to generate for each request.
      */
-    constructor(apiUrl, model = 'gpt-3.5-turbo-1106', maxNumberOfChoices = 1) {
+    constructor(apiUrl, model = 'gpt-3.5-turbo', maxNumberOfChoices = 1, apiKey = process.env.OPEN_AI_API_KEY) {
         Object.defineProperty(this, "request", {
             enumerable: true,
             configurable: true,
@@ -41,7 +41,7 @@ class BaseService {
             baseURL: apiUrl || this.BASE_CHAT_COMPLETION_URL,
             headers: {
                 'Content-Type': 'application/json',
-                Authorization: `Bearer ${process.env.OPEN_AI_API_KEY} `,
+                Authorization: `Bearer ${apiKey} `,
             },
         });
         this.chatGptModel = model;
@@ -60,19 +60,6 @@ class BaseService {
         }
         return undefined;
     }
-    /**
-     * Filter the response from chatGpt API and only get the first choice
-     * @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

@@ -0,0 +1,8 @@
+import BaseService from '../BaseService/BaseService';
+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);
+    ask(context: string | undefined, conversationHistory: ConversationHistory[]): Promise<string | undefined>;
+}

package/dist/services/ChatService/ChatService.js

@@ -0,0 +1,94 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _ChatService_instances, _ChatService_formatConversationHistory;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatService = void 0;
+const ChatGptMessage_1 = require("../../models/ChatGptMessage");
+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);
+        _ChatService_instances.add(this);
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.model = model;
+    }
+    ask(context, conversationHistory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(conversationHistory === null || conversationHistory === void 0 ? void 0 : conversationHistory.length)) {
+                logger_1.default.error(':: ChatService.ask :: Conversation history must be provided');
+                return Promise.reject(new Error('Conversation history must be provided'));
+            }
+            const requestBody = {
+                model: this.model,
+                messages: __classPrivateFieldGet(this, _ChatService_instances, "m", _ChatService_formatConversationHistory).call(this, context, conversationHistory),
+            };
+            logger_1.default.info(`:: ChatService.ask :: ${JSON.stringify(requestBody)}`);
+            try {
+                const response = yield this.request.post('', requestBody);
+                return this.getResponseFirstChoice(response);
+            }
+            catch (e) {
+                this.handleErrors(e);
+                return Promise.reject(e);
+            }
+        });
+    }
+}
+exports.ChatService = ChatService;
+_ChatService_instances = new WeakSet(), _ChatService_formatConversationHistory = function _ChatService_formatConversationHistory(context, conversationHistory) {
+    const formatted = [
+        {
+            role: ChatGptMessage_1.ChatGptRole.SYSTEM,
+            content: context || constants_1.DEFAULT_CONTEXT,
+        }
+    ];
+    if (conversationHistory.length) {
+        for (const message of conversationHistory) {
+            const messageBody = message.body;
+            for (const body of messageBody) {
+                if (body.type === constants_1.MESSAGE_TYPES.text && message.from === constants_1.MESSAGE_SENDER.visitor) {
+                    formatted.push({
+                        role: ChatGptMessage_1.ChatGptRole.USER,
+                        content: body.text
+                    });
+                }
+                else if (body.type === constants_1.MESSAGE_TYPES.text && message.from === constants_1.MESSAGE_SENDER.chatbot) {
+                    formatted.push({
+                        role: ChatGptMessage_1.ChatGptRole.ASSISTANT,
+                        content: body.text
+                    });
+                }
+                else if (body.type === constants_1.MESSAGE_TYPES.button && message.from === constants_1.MESSAGE_SENDER.chatbot) {
+                    formatted.push({
+                        role: ChatGptMessage_1.ChatGptRole.ASSISTANT,
+                        content: body.label
+                    });
+                }
+            }
+        }
+    }
+    return formatted;
+};

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

@@ -1,9 +1,8 @@
 import BaseService from '../BaseService/BaseService';
 import ChatGptMessage from '../../models/ChatGptMessage';
-import CopilotSuggestion from '../../models/CopilotSuggestion';
 import Item from '../../models/Item';
 export declare class CopilotService extends BaseService {
-    constructor(apiUrl?: string, model?: string, maxNumberOfChoices?: number);
+    constructor(apiUrl?: string, model?: string, maxNumberOfChoices?: number, apiKey?: string);
     /**
      * 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
@@ -16,7 +15,7 @@ export declare class CopilotService extends BaseService {
      * this will make it easy to ask chatGpt for quick replies
      * @param conversation
      */
-    suggest(conversation: string): Promise<CopilotSuggestion | undefined>;
+    suggest(conversation: string): Promise<string | undefined>;
     /**
      * this will request chatGPT to recommend product or item based on the whole conversation
      * @param conversation the whole chat conversation

package/dist/services/CopilotService/CopilotService.js

@@ -17,8 +17,8 @@ const BaseService_1 = __importDefault(require("../BaseService/BaseService"));
 const logger_1 = __importDefault(require("../logger"));
 const ChatGptMessage_1 = require("../../models/ChatGptMessage");
 class CopilotService extends BaseService_1.default {
-    constructor(apiUrl, model, maxNumberOfChoices) {
-        super(apiUrl, model, maxNumberOfChoices);
+    constructor(apiUrl, model, maxNumberOfChoices, apiKey) {
+        super(apiUrl, model, maxNumberOfChoices, apiKey);
     }
     /**
      * a method to be used to suggest some quick replies for the agent based on the conversation
@@ -53,10 +53,7 @@ class CopilotService extends BaseService_1.default {
                     messages: [mainPromptMessage],
                 };
                 const response = yield this.request.post('', requestBody);
-                return {
-                    firstChoice: this.getResponseFirstChoice(response),
-                    usageTokens: this.getResponseUsageTokens(response),
-                };
+                return this.getResponseFirstChoice(response);
             }
             catch (e) {
                 this.handleErrors(e);

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

@@ -1,13 +1,11 @@
 import BaseService from '../BaseService/BaseService';
 export declare class TranslationService extends BaseService {
-    DESTINATION_LANGUAGE: string;
-    constructor(apiUrl?: string, model?: string, maxNumberOfChoices?: number);
+    constructor(apiUrl?: string, model?: string, maxNumberOfChoices?: number, apiKey?: string);
     /**
      * 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<any | undefined>;
-    findTextLanguage(text: string): Promise<any | undefined>;
+    translate(text: string, toLanguage?: string, fromLanguage?: string): Promise<string | undefined>;
 }

package/dist/services/TranslationService/TranslationService.js

@@ -16,15 +16,10 @@ exports.TranslationService = void 0;
 const ChatGptMessage_1 = require("../../models/ChatGptMessage");
 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) {
-        super(apiUrl, model, maxNumberOfChoices);
-        Object.defineProperty(this, "DESTINATION_LANGUAGE", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'English'
-        });
+    constructor(apiUrl, model, maxNumberOfChoices, apiKey) {
+        super(apiUrl, model, maxNumberOfChoices, apiKey);
     }
     /**
      * request the chatGpt Api to translate a specific test to a desired language
@@ -32,7 +27,7 @@ class TranslationService extends BaseService_1.default {
      * @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, toLanguage = this.DESTINATION_LANGUAGE, fromLanguage) {
+    translate(text, toLanguage = constants_1.DESTINATION_LANGUAGE, fromLanguage) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!text) {
                 logger_1.default.error('translation text should be provided');
@@ -44,59 +39,14 @@ class TranslationService extends BaseService_1.default {
             // 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: "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.",
-                    },
-                    {
-                        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);
-            }
-        });
-    }
-    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 = `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.`, 
-            // the body we need to send to the request
-            requestBody = {
-                model: this.chatGptModel,
-                messages: [
-                    {
-                        role: ChatGptMessage_1.ChatGptRole.SYSTEM,
-                        content: "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.",
-                    },
-                    {
+                messages: [{
                         role: ChatGptMessage_1.ChatGptRole.USER,
                         content: translateText,
-                    }
-                ],
+                    }],
             };
             try {
                 const response = yield this.request.post('', requestBody);
-                return {
-                    firstChoice: this.getResponseFirstChoice(response),
-                    usageTokens: this.getResponseUsageTokens(response),
-                };
+                return this.getResponseFirstChoice(response);
             }
             catch (e) {
                 this.handleErrors(e);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cobrowser/chatgpt",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "description": "chatgpt services to connect our projects with chatgpt api",
   "keywords": [
     "chatgpt",
@@ -22,8 +22,8 @@
   },
   "dependencies": {
     "@cobrowser/logger": "^1.0.0",
-    "axios": "^1.3.5",
-    "axios-mock-adapter": "^1.21.4"
+    "axios": "^1.6.1",
+    "axios-mock-adapter": "^1.22.0"
   },
   "directories": {
     "dist": "dist"
@@ -38,5 +38,5 @@
   "bugs": {
     "url": "https://bitbucket.org/cobrowser/cb_utils/issues"
   },
-  "gitHead": "0d2b7809e9ec1456985f4f7ecf30f43632fbf75b"
+  "gitHead": "9a912216d362a55aff403525d19c21ff9c31b513"
 }

package/dist/models/ChatGptUsageTokens.d.ts

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

package/dist/models/ChatGptUsageTokens.js

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

package/dist/models/CopilotSuggestion.d.ts

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