@cobrowser/chatgpt 0.7.31-beta.4 → 0.7.32-dev.0

package/dist/constants.d.ts

@@ -6,8 +6,8 @@ export declare const MESSAGE_TYPES: {
     text: string;
     button: string;
 };
-export declare const DEFAULT_PROMPT = "\n  You are a helpful assistant. Your role is to address visitor \n  queries related to the ongoing conversation and the last message received. Please ensure \n  that responses remain within the ongoing conversation. Politely decline any user queries \n  that is not present in the ongoing conversation. \n\n  You will always respond with a JSON. It will be in the format: \n\n  { answer: '', suggestions: [], connectWithAgent: true or false }\n\n  Fields in the JSON:\n\n  Answer: It will consist of the user's query answer based on the ongoing conversation. \n  Restrict this field to 100 characters.\n\n  Suggestions: Request 2 suggestions from user's perspective that he can ask. \n  It should be an array of strings. Restrict each suggestion to 50 characters.\n  \n  ConnectWithAgent: It is a boolean. It should be set to true if the user's query is \n  not found in the ongoing conversation. Politely tell the user to talk to a real agent. \n  Also when it is true, do not provide any suggestions.\n";
+export declare const DEFAULT_PROMPT = "You are a helpful assistant. Your role is to address visitor \nqueries related to the ongoing conversation and the last message received. Please ensure \nthat responses remain within the ongoing conversation. Politely decline any user queries \nthat is not present in the ongoing conversation. \n\nYou will always respond with a JSON. It will be in the format: \n\n{ answer: '', suggestions: [], connectWithAgent: true or false }\n\nFields in the JSON:\n\nAnswer: It will consist of the user's query answer based on the ongoing conversation. \nRestrict this field to 100 characters.\n\nSuggestions: Request 2 suggestions from user's perspective that he can ask. \nIt should be an array of strings. Restrict each suggestion to 50 characters.\n \nConnectWithAgent: It is a boolean. It should be set to true if the user's query is \nnot found in the ongoing conversation. Politely tell the user to talk to a real agent. \nAlso when it is true, do not provide any suggestions.\n";
 export declare const DESTINATION_LANGUAGE = "English";
 export declare const LANGUAGE_DETECTION_SYSTEM_ROLE = "\n  You are a language detection assistant. Your task is to analyze short text input and determine \n  its language using ISO language code. Respond only in JSON format with two key-value pairs: \n  - 'languageCode': the detected language's ISO code (or undefined if detection fails).\n  - 'isError': a boolean value (true if detection fails, false otherwise).\n";
 export declare const WORD_FREQUENCY_LANGUAGE_DETECTION_SYSTEM_ROLE = "\n  You are a language detection assistant. Your task is to analyze the most frequently occurring words in the given text \n  and determine the language based on those words. Respond only in JSON format with two key-value pairs: \n  - 'languageCode': the detected language's ISO code (or undefined if detection fails).\n  - 'isError': a boolean value (true if detection fails, false otherwise).\n";
-export declare const TRANSLATION_SYSTEM_ROLE = "\n  You are a translator that responds exclusively in JSON format. Your response must be a JSON object containing:\n  - 'translations': it is an array of objects. Each object in the array must contain:\n    - 'original': The original input message before translation.\n    - 'translation: The translated version of 'original', ensuring it is natural, culturally appropriate, and commonly used by native speakers.\n  - 'isError': a boolean value (true if translation fails, false otherwise).\n\n  **You MUST return the JSON format even if you fail to translate the text. In this case, translations field will be empty array and isError should be true.** \n\n  Ensure that 'translation' accurately represents the meaning of 'original' while considering cultural nuances, usual expressions, and natural phrasing in the target language.\n\n  Your response must follow this structure strictly.\n";
+export declare const TRANSLATION_SYSTEM_ROLE = "\n  You are a translator that responds exclusively in JSON format. Your response must be a JSON object containing:\n  - 'data': it is an array of objects. Each object in the array must contain:\n    - 'translated_message': The original input message before translation.\n    - 'translation: The translated version of 'translated_message', ensuring it is natural, culturally appropriate, and commonly used by native speakers.\n  - 'isError': a boolean value (true if translation fails, false otherwise).\n\n  Ensure that 'translation' accurately represents the meaning of 'translated_message' while considering cultural nuances, usual expressions, and natural phrasing in the target language.  \n  Your response must follow this structure strictly.\n";

package/dist/constants.js

@@ -12,27 +12,26 @@ exports.MESSAGE_TYPES = {
     button: 'button'
 };
 // Default prompt for ChatGPT
-exports.DEFAULT_PROMPT = `
-  You are a helpful assistant. Your role is to address visitor 
-  queries related to the ongoing conversation and the last message received. Please ensure 
-  that responses remain within the ongoing conversation. Politely decline any user queries 
-  that is not present in the ongoing conversation. 
+exports.DEFAULT_PROMPT = `You are a helpful assistant. Your role is to address visitor 
+queries related to the ongoing conversation and the last message received. Please ensure 
+that responses remain within the ongoing conversation. Politely decline any user queries 
+that is not present in the ongoing conversation. 
 
-  You will always respond with a JSON. It will be in the format: 
+You will always respond with a JSON. It will be in the format: 
 
-  { answer: '', suggestions: [], connectWithAgent: true or false }
+{ answer: '', suggestions: [], connectWithAgent: true or false }
 
-  Fields in the JSON:
+Fields in the JSON:
 
-  Answer: It will consist of the user's query answer based on the ongoing conversation. 
-  Restrict this field to 100 characters.
+Answer: It will consist of the user's query answer based on the ongoing conversation. 
+Restrict this field to 100 characters.
 
-  Suggestions: Request 2 suggestions from user's perspective that he can ask. 
-  It should be an array of strings. Restrict each suggestion to 50 characters.
-  
-  ConnectWithAgent: It is a boolean. It should be set to true if the user's query is 
-  not found in the ongoing conversation. Politely tell the user to talk to a real agent. 
-  Also when it is true, do not provide any suggestions.
+Suggestions: Request 2 suggestions from user's perspective that he can ask. 
+It should be an array of strings. Restrict each suggestion to 50 characters.
+ 
+ConnectWithAgent: It is a boolean. It should be set to true if the user's query is 
+not found in the ongoing conversation. Politely tell the user to talk to a real agent. 
+Also when it is true, do not provide any suggestions.
 `;
 // Default destination language
 exports.DESTINATION_LANGUAGE = 'English';
@@ -53,14 +52,11 @@ exports.WORD_FREQUENCY_LANGUAGE_DETECTION_SYSTEM_ROLE = `
 // Message translation system role
 exports.TRANSLATION_SYSTEM_ROLE = `
   You are a translator that responds exclusively in JSON format. Your response must be a JSON object containing:
-  - 'translations': it is an array of objects. Each object in the array must contain:
-    - 'original': The original input message before translation.
-    - 'translation: The translated version of 'original', ensuring it is natural, culturally appropriate, and commonly used by native speakers.
+  - 'data': it is an array of objects. Each object in the array must contain:
+    - 'translated_message': The original input message before translation.
+    - 'translation: The translated version of 'translated_message', ensuring it is natural, culturally appropriate, and commonly used by native speakers.
   - 'isError': a boolean value (true if translation fails, false otherwise).
 
-  **You MUST return the JSON format even if you fail to translate the text. In this case, translations field will be empty array and isError should be true.** 
-
-  Ensure that 'translation' accurately represents the meaning of 'original' while considering cultural nuances, usual expressions, and natural phrasing in the target language.
-
+  Ensure that 'translation' accurately represents the meaning of 'translated_message' while considering cultural nuances, usual expressions, and natural phrasing in the target language.  
   Your response must follow this structure strictly.
 `;

package/dist/index.d.ts

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

package/dist/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./services/TranslationService/TranslationService"), export
 __exportStar(require("./services/CopilotService/CopilotService"), exports);
 __exportStar(require("./services/ChatService/ChatService"), exports);
 __exportStar(require("./services/AssistantService/AssistantService"), exports);
+__exportStar(require("./services/ResponseService/ResponseService"), exports);

package/dist/services/AssistantService/AssistantService.d.ts

@@ -1,6 +1,6 @@
-import { AssistantResponseFormatOption } from 'openai/resources/beta/threads/threads';
-import ChatGPTResponse from '../../models/ChatGPTResponse';
+import ChatGptResponse from '../../models/ChatGptResponse';
 import BaseService from '../BaseService/BaseService';
+import { AssistantResponseFormatOption } from 'openai/resources/beta/threads/threads';
 export declare class AssistantService extends BaseService {
     assistantId: string | undefined;
     threadId: string | undefined;
@@ -22,5 +22,5 @@ export declare class AssistantService extends BaseService {
         tools?: any[];
         functionOutputs?: string;
         definedSchema?: AssistantResponseFormatOption;
-    }): Promise<ChatGPTResponse | undefined>;
+    }): Promise<ChatGptResponse | undefined>;
 }

package/dist/services/AssistantService/AssistantService.js

@@ -68,7 +68,10 @@ class AssistantService extends BaseService_1.default {
             const openai = new openai_1.default({ apiKey: this.openaiApiKey });
             let run;
             if (runOptions.functionOutputs && this.runId) {
-                run = yield openai.beta.threads.runs.submitToolOutputsAndPoll(this.threadId, this.runId, { tool_outputs: JSON.parse(runOptions.functionOutputs) });
+                run = yield openai.beta.threads.runs.submitToolOutputsAndPoll(this.runId, {
+                    thread_id: this.threadId,
+                    tool_outputs: JSON.parse(runOptions.functionOutputs)
+                });
             }
             else {
                 const lastThreadMessasges = yield openai.beta.threads.messages.list(this.threadId, { order: "desc", limit: 2 });
@@ -92,7 +95,7 @@ class AssistantService extends BaseService_1.default {
             }
             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);
+                run = yield openai.beta.threads.runs.retrieve(run.id, { thread_id: run.thread_id });
             }
             if (run.status === 'completed') {
                 const { data } = yield openai.beta.threads.messages.list(run.thread_id, { order: 'desc', limit: 1 });
@@ -101,7 +104,7 @@ class AssistantService extends BaseService_1.default {
                 if (assistantMessages.length) {
                     let answer = assistantMessages.map(message => message.value).join('\n');
                     return {
-                        data: answer.replace(/【.*?】/g, ''),
+                        firstChoice: answer.replace(/【.*?】/g, ''),
                         threadId: run.thread_id,
                         usageTokens: run.usage,
                     };

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

@@ -1,30 +1,20 @@
 import { AxiosError, AxiosInstance, AxiosResponse } from 'axios';
-import ChatGPTUsageTokens from '../../models/ChatGPTUsageTokens';
-interface Response<Data = any> {
-    result: Data;
-}
+import ChatGptUsageTokens from '../../models/ChatGptUsageTokens';
 declare class BaseService {
-    readonly BASE_CHAT_COMPLETION_URL = "https://api.openai.com/v1/chat/completions";
     request: AxiosInstance;
+    readonly BASE_CHAT_COMPLETION_URL = "https://api.openai.com/v1/chat/completions";
     openaiApiKey: string | undefined;
     chatGptModel: string;
     maxNumberOfChatCompletionResult: number;
     /**
+     *
      * @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(apiKey?: string | undefined, model?: string, apiUrl?: string, maxNumberOfChoices?: number);
-    /**
-     * Automatically wraps all async methods to sanitize their return values
-     * This ensures ALL service methods are automatically sanitized without any developer intervention
-     */
-    private processAsyncMethods;
-    /**
-     * Recursively sanitizes any value
-     */
-    private clean;
     /**
      * Filter the response from chatGpt API and only get the first choice
      * @param response
@@ -34,12 +24,11 @@ declare class BaseService {
      * Filter the response from chatGpt API and get the usage tokens
      * @param response
      */
-    getResponseUsageTokens(response: AxiosResponse): ChatGPTUsageTokens | undefined;
+    getResponseUsageTokens(response: AxiosResponse): ChatGptUsageTokens | undefined;
     /**
      * function to handle requests errors
      * @param error
      */
     handleErrors(error: AxiosError): void;
-    protected response<Data>(data: Data): Response<Data>;
 }
 export default BaseService;

package/dist/services/BaseService/BaseService.js

@@ -1,39 +1,31 @@
 "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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const axios_1 = __importDefault(require("axios"));
-const xss_validation_1 = require("@cobrowser/xss-validation");
 const logger_1 = __importDefault(require("../logger"));
 class BaseService {
     /**
+     *
      * @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(apiKey = process.env.OPEN_AI_API_KEY, model = 'gpt-4o', apiUrl, maxNumberOfChoices = 1) {
-        Object.defineProperty(this, "BASE_CHAT_COMPLETION_URL", {
+        Object.defineProperty(this, "request", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 'https://api.openai.com/v1/chat/completions'
+            value: void 0
         });
-        Object.defineProperty(this, "request", {
+        Object.defineProperty(this, "BASE_CHAT_COMPLETION_URL", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: 'https://api.openai.com/v1/chat/completions'
         });
         Object.defineProperty(this, "openaiApiKey", {
             enumerable: true,
@@ -63,70 +55,6 @@ class BaseService {
         this.openaiApiKey = apiKey;
         this.chatGptModel = model;
         this.maxNumberOfChatCompletionResult = maxNumberOfChoices;
-        // Automatically wrap all async methods that return ChatGpt responses
-        this.processAsyncMethods();
-    }
-    /**
-     * Automatically wraps all async methods to sanitize their return values
-     * This ensures ALL service methods are automatically sanitized without any developer intervention
-     */
-    processAsyncMethods() {
-        const proto = Object.getPrototypeOf(this), methodNames = Object.getOwnPropertyNames(proto);
-        console.log('BASE SERVICE processAsyncMethods methodNames: ', methodNames);
-        for (const methodName of methodNames) {
-            const method = proto[methodName];
-            console.log('BASE SERVICE processAsyncMethods method: ', method);
-            // Skip constructor, non-functions, and utility methods
-            // But include service methods like getReply, getAssistant, etc.
-            if (methodName === 'constructor' ||
-                methodName === 'suggest' ||
-                typeof method !== 'function' ||
-                (methodName.startsWith('get') &&
-                    !methodName.startsWith('getReply') &&
-                    !methodName.startsWith('getAssist') &&
-                    !methodName.startsWith('getChatGPT')) ||
-                methodName.startsWith('handle') ||
-                methodName.includes('Sanitize') ||
-                methodName.includes('sanitize')) {
-                continue;
-            }
-            const originalMethod = method.bind(this);
-            console.log('ORIGINAL METHOD: ', originalMethod);
-            // Replace the method with a sanitizing wrapper
-            this[methodName] = (...args) => __awaiter(this, void 0, void 0, function* () {
-                console.log('WRAPPER args: ', args);
-                try {
-                    const result = this.response(yield originalMethod(...args)), sanitizedResult = this.clean(result);
-                    console.log('BASE SERVICE processAsyncMethods sanitizedResult: ', sanitizedResult);
-                    return sanitizedResult;
-                }
-                catch (error) {
-                    throw error;
-                }
-            });
-        }
-    }
-    /**
-     * Recursively sanitizes any value
-     */
-    clean(value) {
-        console.log('BASE SERVICE clean value: ', value);
-        if (!value) {
-            return;
-        }
-        // Data could be plain string or JSON string. 
-        if (typeof value === 'string') {
-            try {
-                value = JSON.parse(value);
-            }
-            catch (error) { }
-        }
-        const sanitized = xss_validation_1.XSSProtector.sanitize(value), encoded = xss_validation_1.XSSProtector.encode(sanitized);
-        console.log('BASE SERVICE clean sanitized aaaaa: ', sanitized);
-        console.log('BASE SERVICE clean encoded: ', encoded);
-        console.log('BASE SERVICE clean encoded data: ', encoded.result.data);
-        logger_1.default.info({ value, sanitized, encoded }, ':: Sanitized Response ::');
-        return encoded;
     }
     /**
      * Filter the response from chatGpt API and only get the first choice
@@ -137,7 +65,7 @@ class BaseService {
         if ((_a = response.data.choices) === null || _a === void 0 ? void 0 : _a.length) {
             const firstChatGptResponseMessage = response.data.choices[0].message;
             logger_1.default.info(`First ChatGpt Message: ${firstChatGptResponseMessage.content}`);
-            return JSON.parse(firstChatGptResponseMessage.content);
+            return firstChatGptResponseMessage.content;
         }
         return undefined;
     }
@@ -171,10 +99,5 @@ class BaseService {
         }
         logger_1.default.error(`error message ${error.message}`);
     }
-    response(data) {
-        return {
-            result: data,
-        };
-    }
 }
 exports.default = BaseService;

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

@@ -1,11 +1,11 @@
+import ChatGptResponse from '../../models/ChatGptResponse';
+import BaseService from '../BaseService/BaseService';
 import ChatGptMessage from '../../models/ChatGptMessage';
 import Item from '../../models/Item';
-import BaseService from '../BaseService/BaseService';
-import ChatGPTResponse from '../../models/ChatGPTResponse';
-import ChatGPTUsageTokens from 'src/models/ChatGPTUsageTokens';
 export declare class CopilotService extends BaseService {
     assistantId: string | undefined;
     threadId: string | undefined;
+    conversationId: string | undefined;
     constructor(apiKey?: string, model?: string, assistantId?: string, threadId?: string, apiUrl?: string, maxNumberOfChoices?: number);
     /**
      * a method to be used to suggest some quick replies for the agent based on the conversation
@@ -19,24 +19,21 @@ export declare class CopilotService extends BaseService {
      * this will make it easy to ask chatGpt for quick replies
      * @param conversation
      */
-    suggest(conversation: string): Promise<ChatGPTResponse | 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<{
-        data: string | undefined;
-        usageTokens: ChatGPTUsageTokens | undefined;
-    }>;
-    getChatGPTQuickReplies(conversation: string): Promise<{
-        data: string | undefined;
-        usageTokens: ChatGPTUsageTokens | undefined;
-    }>;
+    recommend(conversation: ChatGptMessage[], items: Item[]): Promise<string | undefined>;
     /**
      * Get the reply of the assistant if the assistant_id is available
      *
      * @param message
      */
-    getAssistantReply(conversation: string): Promise<ChatGPTResponse | undefined>;
+    getAssistantReply(message: string): Promise<ChatGptResponse | undefined>;
+    private isAssistantIdFormat;
+    private isPromptIdFormat;
+    private ensureConversation;
+    getPromptReply(message: string): Promise<ChatGptResponse | undefined>;
 }

package/dist/services/CopilotService/CopilotService.js

@@ -13,10 +13,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CopilotService = void 0;
-const ChatGptMessage_1 = require("../../models/ChatGptMessage");
+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"));
-const BaseService_1 = __importDefault(require("../BaseService/BaseService"));
 class CopilotService extends BaseService_1.default {
     constructor(apiKey, model, assistantId, threadId, apiUrl, maxNumberOfChoices) {
         super(apiKey, model, apiUrl, maxNumberOfChoices);
@@ -32,9 +32,14 @@ class CopilotService extends BaseService_1.default {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "conversationId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.assistantId = assistantId;
         this.threadId = threadId;
-        console.log('API URL: ', apiUrl);
     }
     /**
      * a method to be used to suggest some quick replies for the agent based on the conversation
@@ -50,17 +55,44 @@ class CopilotService extends BaseService_1.default {
      */
     suggest(conversation) {
         return __awaiter(this, void 0, void 0, function* () {
-            console.log('SUGGEST conversation: ', conversation);
             if (!(conversation === null || conversation === void 0 ? void 0 : conversation.length)) {
-                logger_1.default.error('Conversation must be provided');
-                return Promise.reject(new Error('Conversation must be provided'));
+                logger_1.default.error('conversation must be provided');
+                return Promise.reject(new Error('conversation must be provided'));
             }
             try {
                 if (this.assistantId) {
-                    return yield this.getAssistantReply(conversation);
+                    // 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'));
+                    }
+                    // Route based on id shape: asst_* => Assistant API, prompt_* => Responses API
+                    if (this.isAssistantIdFormat(this.assistantId)) {
+                        return yield this.getAssistantReply(lastCustomerMessage);
+                    }
+                    return yield this.getPromptReply(lastCustomerMessage);
                 }
-                console.log('NOT ASSISTANT 111111111111');
-                return yield this.getChatGPTQuickReplies(conversation);
+                // 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
+          Your response must only contains a valid JSON array of strings like this:
+          ["Reply 1", "Reply 2", "Reply 3"]. the conversation is:-\n${conversation}`, 
+                // main prompt will be the whole conversation as string
+                mainPromptMessage = {
+                    role: ChatGptMessage_1.ChatGptRole.USER,
+                    content: mainPrompt,
+                }, 
+                // the body we need to send to the request
+                requestBody = {
+                    model: this.chatGptModel,
+                    messages: [mainPromptMessage],
+                }, response = yield this.request.post('', requestBody);
+                return {
+                    firstChoice: this.getResponseFirstChoice(response),
+                    usageTokens: this.getResponseUsageTokens(response),
+                };
             }
             catch (e) {
                 this.handleErrors(e);
@@ -92,10 +124,7 @@ class CopilotService extends BaseService_1.default {
                     model: this.chatGptModel,
                     messages: [firstMessage, ...conversation],
                 }, response = yield this.request.post('', requestBody);
-                return {
-                    data: this.getResponseFirstChoice(response),
-                    usageTokens: this.getResponseUsageTokens(response),
-                };
+                return this.getResponseFirstChoice(response);
             }
             catch (e) {
                 this.handleErrors(e);
@@ -103,72 +132,43 @@ class CopilotService extends BaseService_1.default {
             }
         });
     }
-    getChatGPTQuickReplies(conversation) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // 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
-    Your response must only contains a valid JSON array of strings like this:
-    ["Reply 1", "Reply 2", "Reply 3"]. the conversation is:-\n${conversation}`, 
-            // main prompt will be the whole conversation as string
-            mainPromptMessage = {
-                role: ChatGptMessage_1.ChatGptRole.USER,
-                content: mainPrompt,
-            }, 
-            // the body we need to send to the request
-            requestBody = {
-                model: this.chatGptModel,
-                messages: [mainPromptMessage],
-            }, response = yield this.request.post('', requestBody);
-            return {
-                data: this.getResponseFirstChoice(response),
-                usageTokens: this.getResponseUsageTokens(response),
-            };
-        });
-    }
     /**
      * Get the reply of the assistant if the assistant_id is available
      *
      * @param message
      */
-    getAssistantReply(conversation) {
+    getAssistantReply(message) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            console.log('getAssistantReply conversation: ', conversation);
-            // 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'), 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 openai = new openai_1.default({ apiKey: this.openaiApiKey });
             let run;
             if (!this.threadId) {
                 const thread = yield openai.beta.threads.create();
                 this.threadId = thread.id;
             }
-            const lastThreadMessasges = yield openai.beta.threads.messages.list(this.threadId, { order: "desc", limit: 2 }), isRepeatedMessage = lastThreadMessasges.data.find(msg => msg.content[0].type === 'text' && msg.content[0].text.value === lastCustomerMessage);
+            const lastThreadMessasges = yield openai.beta.threads.messages.list(this.threadId, { order: "desc", limit: 2 });
+            const isRepeatedMessage = lastThreadMessasges.data.find(msg => msg.content[0].type === 'text' && msg.content[0].text.value === message);
             // making sure that we're not saving repeated messages
             if (isRepeatedMessage) {
                 const runs = yield openai.beta.threads.runs.list(this.threadId, { order: "desc", limit: 1 });
                 run = runs.data[0];
             }
             else {
-                yield openai.beta.threads.messages.create(this.threadId, { role: "user", content: lastCustomerMessage });
+                yield openai.beta.threads.messages.create(this.threadId, { role: "user", content: message });
                 run = yield openai.beta.threads.runs.create(this.threadId, { 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);
+                run = yield openai.beta.threads.runs.retrieve(run.id, { thread_id: run.thread_id });
             }
             if (run.status === 'completed') {
-                const { data } = yield openai.beta.threads.messages.list(run.thread_id, { order: 'desc', limit: 1 }), messages = data.flatMap((message) => message === null || message === void 0 ? void 0 : message.content.map((content) => ((content.type === 'text' && message.role === 'assistant') ? content.text : ''))), assistantMessages = messages.filter(message => typeof message === 'object' && 'value' in message && typeof message.value === 'string');
-                console.log('GET ASSISTANT REPLY assistantMessages: ', assistantMessages);
+                const { data } = yield openai.beta.threads.messages.list(run.thread_id, { order: 'desc', limit: 1 });
+                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 assistantMessages = messages.filter(message => typeof message === 'object' && 'value' in message && typeof message.value === 'string');
                 if (assistantMessages.length) {
                     let answers = assistantMessages.map(message => message.value);
-                    console.log('GET ASSISTANT REPLY answers: ', answers);
                     return {
-                        data: answers,
+                        firstChoice: JSON.stringify(answers),
                         threadId: run.thread_id,
                         usageTokens: run.usage,
                     };
@@ -177,5 +177,72 @@ class CopilotService extends BaseService_1.default {
             return undefined;
         });
     }
+    isAssistantIdFormat(id) {
+        return !!id && /^asst_[A-Za-z0-9]+$/.test(id);
+    }
+    isPromptIdFormat(id) {
+        return !!id && /^pmpt_[A-Za-z0-9]+$/.test(id);
+    }
+    ensureConversation(openai) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.conversationId) {
+                return this.conversationId;
+            }
+            const conv = yield openai.conversations.create();
+            this.conversationId = conv.id;
+            return conv.id;
+        });
+    }
+    getPromptReply(message) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        return __awaiter(this, void 0, void 0, function* () {
+            const openai = new openai_1.default({ apiKey: this.openaiApiKey });
+            const conversationId = yield this.ensureConversation(openai);
+            const request = {
+                //model: this.chatGptModel || 'gpt-4o-mini',
+                input: message,
+                store: true,
+                conversation: conversationId,
+                include: ['file_search_call.results'],
+            };
+            if (this.assistantId && this.isPromptIdFormat(this.assistantId)) {
+                request.prompt = { id: this.assistantId };
+            }
+            const response = yield openai.responses.create(request);
+            response.output.forEach((item, index) => {
+            });
+            if ((_a = response.conversation) === null || _a === void 0 ? void 0 : _a.id) {
+                this.conversationId = response.conversation.id;
+            }
+            // Sometimes if the prompt needs a file search, the output will be an array of messages
+            // which includes multiple messages (some of them are not useful for the user, but the last one is)
+            const output = response.output || [];
+            const assistantMessages = output.filter((item) => item.type === 'message' && item.role === 'assistant');
+            if (assistantMessages.length) {
+                const text = assistantMessages.flatMap((m) => { var _a, _b; return ((_b = (_a = m.content) === null || _a === void 0 ? void 0 : _a.filter((c) => c.type === 'output_text')) === null || _b === void 0 ? void 0 : _b.map((c) => c.text)) || []; });
+                return {
+                    firstChoice: text.pop(),
+                    threadId: this.conversationId,
+                    usageTokens: {
+                        prompt_tokens: Number((_c = ((_b = response.usage) === null || _b === void 0 ? void 0 : _b.prompt_tokens)) !== null && _c !== void 0 ? _c : 0),
+                        completion_tokens: Number((_e = ((_d = response.usage) === null || _d === void 0 ? void 0 : _d.completion_tokens)) !== null && _e !== void 0 ? _e : 0),
+                        total_tokens: Number((_g = ((_f = response.usage) === null || _f === void 0 ? void 0 : _f.total_tokens)) !== null && _g !== void 0 ? _g : 0),
+                    },
+                };
+            }
+            if (response.output_text) {
+                return {
+                    firstChoice: response.output_text,
+                    threadId: this.conversationId,
+                    usageTokens: {
+                        prompt_tokens: Number((_j = ((_h = response.usage) === null || _h === void 0 ? void 0 : _h.prompt_tokens)) !== null && _j !== void 0 ? _j : 0),
+                        completion_tokens: Number((_l = ((_k = response.usage) === null || _k === void 0 ? void 0 : _k.completion_tokens)) !== null && _l !== void 0 ? _l : 0),
+                        total_tokens: Number((_o = ((_m = response.usage) === null || _m === void 0 ? void 0 : _m.total_tokens)) !== null && _o !== void 0 ? _o : 0),
+                    },
+                };
+            }
+            return undefined;
+        });
+    }
 }
 exports.CopilotService = CopilotService;

package/dist/services/ResponseService/ResponseService.d.ts

@@ -0,0 +1,37 @@
+import ChatGptResponse from '../../models/ChatGptResponse';
+import OpenAI from "openai";
+import BaseService from '../BaseService/BaseService';
+interface ResponseServiceOptions {
+    instructions?: string;
+    tools?: any[];
+    functionOutputs?: string;
+    definedSchema?: any;
+    conversationId?: string;
+}
+export declare class ResponseService extends BaseService {
+    promptId: string | undefined;
+    conversationId: string | undefined;
+    lastResponseId: string | undefined;
+    constructor(apiKey?: string, promptId?: string, conversationId?: string);
+    /**
+     * Create a new conversation/response chain
+     */
+    createConversation(): Promise<string>;
+    /**
+     * Get the reply using the Response API
+     *
+     * @param message
+     * @param runOptions
+     */
+    getReply(message: string, runOptions?: ResponseServiceOptions): Promise<ChatGptResponse | undefined>;
+    handleFunctionOutputs(openai: OpenAI, functionOutputs: string, runOptions?: ResponseServiceOptions): Promise<ChatGptResponse>;
+    processResponseOutput(response: any): ChatGptResponse;
+    reset(): void;
+    getConversationId(): string | undefined;
+    getLastResponseId(): string | undefined;
+    getPromptId(): string | undefined;
+    setPromptId(promptId: string): void;
+    setConversationId(conversationId: string): void;
+    setLastResponseId(lastResponseId: string): void;
+}
+export {};

package/dist/services/ResponseService/ResponseService.js

@@ -0,0 +1,213 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseService = void 0;
+const logger_1 = __importDefault(require("../logger"));
+const openai_1 = __importDefault(require("openai"));
+const BaseService_1 = __importDefault(require("../BaseService/BaseService"));
+class ResponseService extends BaseService_1.default {
+    constructor(apiKey, promptId, conversationId) {
+        super(apiKey);
+        Object.defineProperty(this, "promptId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "conversationId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lastResponseId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.promptId = promptId;
+        this.conversationId = conversationId;
+    }
+    /**
+     * Create a new conversation/response chain
+     */
+    createConversation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Create a real conversation using the Conversations API
+            const openai = new openai_1.default({ apiKey: this.openaiApiKey });
+            const conversation = yield openai.conversations.create();
+            this.conversationId = conversation.id;
+            return this.conversationId;
+        });
+    }
+    /**
+     * Get the reply using the Response API
+     *
+     * @param message
+     * @param runOptions
+     */
+    getReply(message, runOptions = {}) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.promptId) {
+                logger_1.default.error('Prompt ID is required for Response API');
+                return Promise.reject(new Error('Prompt ID is required for Response API'));
+            }
+            logger_1.default.info(`New response with message: ${message} & options: ${JSON.stringify(runOptions)}`);
+            const openai = new openai_1.default({ apiKey: this.openaiApiKey });
+            try {
+                if (runOptions.functionOutputs) {
+                    return yield this.handleFunctionOutputs(openai, runOptions.functionOutputs, runOptions);
+                }
+                if (!runOptions.conversationId && !this.conversationId) {
+                    const createdId = yield this.createConversation();
+                    this.conversationId = createdId;
+                }
+                const responseRequest = {
+                    input: message,
+                    store: true,
+                    include: ['file_search_call.results'],
+                };
+                if (this.promptId) {
+                    responseRequest.prompt = {
+                        id: this.promptId
+                    };
+                }
+                if (runOptions.instructions) {
+                    responseRequest.instructions = runOptions.instructions;
+                }
+                const conversationIdToUse = runOptions.conversationId || this.conversationId;
+                if (conversationIdToUse) {
+                    responseRequest.conversation = conversationIdToUse;
+                }
+                if ((_a = runOptions.tools) === null || _a === void 0 ? void 0 : _a.length) {
+                    responseRequest.tools = runOptions.tools;
+                }
+                if (runOptions.definedSchema) {
+                    responseRequest.text = {
+                        format: runOptions.definedSchema
+                    };
+                }
+                const response = yield openai.responses.create(responseRequest);
+                this.lastResponseId = response.id;
+                if ((_b = response.conversation) === null || _b === void 0 ? void 0 : _b.id) {
+                    this.conversationId = response.conversation.id;
+                }
+                else if (runOptions.conversationId) {
+                    this.conversationId = runOptions.conversationId;
+                }
+                return this.processResponseOutput(response);
+            }
+            catch (error) {
+                logger_1.default.error('Error in ResponseService.getReply:', error);
+                return Promise.reject(error);
+            }
+        });
+    }
+    handleFunctionOutputs(openai, functionOutputs, runOptions = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const toolOutputs = JSON.parse(functionOutputs);
+                const formattedInputs = toolOutputs.map((output) => ({
+                    type: 'function_call_output',
+                    call_id: output.call_id,
+                    output: output.output
+                }));
+                const responseRequest = {
+                    input: formattedInputs,
+                    store: true,
+                };
+                const conversationIdToUse = runOptions.conversationId || this.conversationId;
+                if (!conversationIdToUse) {
+                    const createdId = yield this.createConversation();
+                    this.conversationId = createdId;
+                }
+                responseRequest.conversation = runOptions.conversationId || this.conversationId;
+                if (this.promptId) {
+                    responseRequest.prompt = {
+                        id: this.promptId
+                    };
+                }
+                const response = yield openai.responses.create(responseRequest);
+                this.lastResponseId = response.id;
+                return this.processResponseOutput(response);
+            }
+            catch (error) {
+                logger_1.default.error('Error handling function outputs:', error);
+                throw error;
+            }
+        });
+    }
+    processResponseOutput(response) {
+        const output = response.output || [];
+        const assistantMessages = output.filter((item) => item.type === 'message' && item.role === 'assistant');
+        const functionCalls = output.filter((item) => item.type === 'function_call');
+        if (functionCalls.length > 0) {
+            return {
+                requiredActions: JSON.stringify(functionCalls),
+                threadId: this.conversationId,
+                usageTokens: response.usage,
+            };
+        }
+        if (assistantMessages.length > 0) {
+            const textContent = assistantMessages
+                .flatMap((msg) => msg.content || [])
+                .filter((content) => content.type === 'output_text' || content.type === 'text')
+                .map((content) => content.text || content.value)
+                .filter((text) => text);
+            if (textContent) {
+                return {
+                    firstChoice: textContent.pop().replace(/【.*?】/g, ''),
+                    threadId: this.conversationId,
+                    usageTokens: response.usage,
+                };
+            }
+        }
+        if (response.output_text) {
+            return {
+                firstChoice: response.output_text.replace(/【.*?】/g, ''),
+                threadId: this.conversationId,
+                usageTokens: response.usage,
+            };
+        }
+        return {
+            threadId: this.conversationId,
+            usageTokens: response.usage,
+        };
+    }
+    reset() {
+        this.lastResponseId = undefined;
+        this.conversationId = undefined;
+    }
+    getConversationId() {
+        return this.conversationId;
+    }
+    getLastResponseId() {
+        return this.lastResponseId;
+    }
+    getPromptId() {
+        return this.promptId;
+    }
+    setPromptId(promptId) {
+        this.promptId = promptId;
+    }
+    setConversationId(conversationId) {
+        this.conversationId = conversationId;
+    }
+    setLastResponseId(lastResponseId) {
+        this.lastResponseId = lastResponseId;
+    }
+}
+exports.ResponseService = ResponseService;

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

@@ -1,5 +1,5 @@
 import BaseService from '../BaseService/BaseService';
-import ChatGPTResponse from '../../models/ChatGPTResponse';
+import ChatGptResponse from '../../models/ChatGptResponse';
 export declare class TranslationService extends BaseService {
     constructor(apiKey?: string, model?: string, apiUrl?: string, maxNumberOfChoices?: number);
     /**
@@ -9,17 +9,17 @@ export declare class TranslationService extends BaseService {
      * @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<ChatGPTResponse | undefined>;
+    translate(text: string, toLanguage?: string, fromLanguage?: string): Promise<ChatGptResponse | undefined>;
     /**
      * Detects the ISO language code of a text
      *
      * @param text text to detect
      */
-    findTextLanguage(text: string): Promise<ChatGPTResponse | undefined>;
+    findTextLanguage(text: string): Promise<ChatGptResponse | undefined>;
     /**
      * Detects the ISO language code of a text based on frequency of words
      *
      * @param text text to detect
      */
-    findTextLanguageBasedOnFrequency(text: string): Promise<ChatGPTResponse | undefined>;
+    findTextLanguageBasedOnFrequency(text: string): Promise<ChatGptResponse | undefined>;
 }

package/dist/services/TranslationService/TranslationService.js

@@ -52,13 +52,11 @@ class TranslationService extends BaseService_1.default {
                 ],
             };
             try {
-                logger_1.default.info({ requestBody }, ':: TranslationServicee.translate :: Translating ::');
                 const response = yield this.request.post('', requestBody);
                 return {
-                    data: this.getResponseFirstChoice(response),
+                    firstChoice: this.getResponseFirstChoice(response),
                     usageTokens: this.getResponseUsageTokens(response),
                 };
-                // return response.data;
             }
             catch (e) {
                 this.handleErrors(e);
@@ -92,10 +90,9 @@ class TranslationService extends BaseService_1.default {
                 ],
             };
             try {
-                logger_1.default.info({ requestBody }, ':: TranslationServicee.findTextLanguage :: Finding text language ::');
                 const response = yield this.request.post('', requestBody);
                 return {
-                    data: this.getResponseFirstChoice(response),
+                    firstChoice: this.getResponseFirstChoice(response),
                     usageTokens: this.getResponseUsageTokens(response),
                 };
             }
@@ -131,10 +128,9 @@ class TranslationService extends BaseService_1.default {
                 ],
             };
             try {
-                logger_1.default.info({ requestBody }, ':: TranslationServicee.findTextLanguageBasedOnFrequency :: Finding text language ::');
                 const response = yield this.request.post('', requestBody);
                 return {
-                    data: this.getResponseFirstChoice(response),
+                    firstChoice: this.getResponseFirstChoice(response),
                     usageTokens: this.getResponseUsageTokens(response),
                 };
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cobrowser/chatgpt",
-  "version": "0.7.31-beta.4",
+  "version": "0.7.32-dev.0",
   "description": "chatgpt services to connect our projects with chatgpt api",
   "keywords": [
     "chatgpt",
@@ -21,11 +21,10 @@
     "precommit": "npm run lint && npm run test && npm run upgrade && npm run security"
   },
   "dependencies": {
-    "@cobrowser/logger": "^2.0.2",
-    "@cobrowser/xss-validation": "^2.0.1",
+    "@cobrowser/logger": "^2.0.6",
     "axios": "^1.6.1",
     "axios-mock-adapter": "^1.22.0",
-    "openai": "^4.86.2"
+    "openai": "^6.3.0"
   },
   "directories": {
     "dist": "dist"
@@ -40,5 +39,5 @@
   "bugs": {
     "url": "https://bitbucket.org/cobrowser/cb_utils/issues"
   },
-  "gitHead": "a9c0febce4f98443c3845381f58816a71423d82c"
+  "gitHead": "246db1800e2c2238ae01d99a69c971fe6ecd4795"
 }

package/dist/models/ChatGPTResponse.d.ts

@@ -1,8 +0,0 @@
-import ChatGPTUsageTokens from './ChatGPTUsageTokens';
-interface ChatGPTResponse {
-    data?: any;
-    usageTokens?: ChatGPTUsageTokens;
-    threadId?: string;
-    requiredActions?: string;
-}
-export default ChatGPTResponse;

package/dist/models/ChatGPTResponse.js

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

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,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });