@cobrowser/chatgpt 0.7.31 → 0.7.32-dev.0

package/dist/services/CopilotService/CopilotService.js

@@ -8,25 +8,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 _CopilotService_instances, _CopilotService_processSuggestions;
 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);
-        _CopilotService_instances.add(this);
         Object.defineProperty(this, "assistantId", {
             enumerable: true,
             configurable: true,
@@ -39,6 +32,12 @@ 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;
     }
@@ -57,14 +56,43 @@ class CopilotService extends BaseService_1.default {
     suggest(conversation) {
         return __awaiter(this, void 0, void 0, function* () {
             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.getAssistantSuggestions(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);
                 }
-                return yield this.getChatCompletionSuggestions(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);
@@ -73,30 +101,35 @@ class CopilotService extends BaseService_1.default {
         });
     }
     /**
-     * Get suggestions from Chat Completion API.
-     *
-     * @param message
+     * 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
      */
-    getChatCompletionSuggestions(conversation) {
+    recommend(conversation, items) {
         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: __classPrivateFieldGet(this, _CopilotService_instances, "m", _CopilotService_processSuggestions).call(this, this.getResponseFirstChoice(response)),
-                usageTokens: this.getResponseUsageTokens(response),
-            };
+            if (!(items === null || items === void 0 ? void 0 : items.length) || !(conversation === null || conversation === void 0 ? void 0 : conversation.length)) {
+                logger_1.default.error('conversation or items not found');
+                return Promise.reject(new Error('conversation and items must be provided'));
+            }
+            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`, 
+                // main prompt will be the first message of the whole conversation
+                firstMessage = {
+                    role: ChatGptMessage_1.ChatGptRole.ASSISTANT,
+                    content: mainPrompt,
+                }, 
+                // the body we need to send to the request
+                requestBody = {
+                    model: this.chatGptModel,
+                    messages: [firstMessage, ...conversation],
+                }, response = yield this.request.post('', requestBody);
+                return this.getResponseFirstChoice(response);
+            }
+            catch (e) {
+                this.handleErrors(e);
+                return Promise.reject(e);
+            }
         });
     }
     /**
@@ -104,42 +137,38 @@ class CopilotService extends BaseService_1.default {
      *
      * @param message
      */
-    getAssistantSuggestions(conversation) {
+    getAssistantReply(message) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            // 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');
+                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) {
-                    const answers = assistantMessages.map(message => message.value);
+                    let answers = assistantMessages.map(message => message.value);
                     return {
-                        data: __classPrivateFieldGet(this, _CopilotService_instances, "m", _CopilotService_processSuggestions).call(this, answers),
+                        firstChoice: JSON.stringify(answers),
                         threadId: run.thread_id,
                         usageTokens: run.usage,
                     };
@@ -148,10 +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;
-_CopilotService_instances = new WeakSet(), _CopilotService_processSuggestions = function _CopilotService_processSuggestions(suggestions) {
-    suggestions = suggestions ? suggestions : [];
-    suggestions = suggestions.filter(suggestion => !!suggestion.trim());
-    return suggestions;
-};

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

@@ -13,8 +13,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TranslationService = void 0;
-const constants_1 = require("../../utils/constants");
-const ChatGPTMessage_1 = require("../../models/ChatGPTMessage");
+const constants_1 = require("../../constants");
+const ChatGptMessage_1 = require("../../models/ChatGptMessage");
 const logger_1 = __importDefault(require("../logger"));
 const BaseService_1 = __importDefault(require("../BaseService/BaseService"));
 class TranslationService extends BaseService_1.default {
@@ -42,20 +42,19 @@ class TranslationService extends BaseService_1.default {
                 response_format: { type: 'json_object' },
                 messages: [
                     {
-                        role: ChatGPTMessage_1.ChatGPTRole.SYSTEM,
+                        role: ChatGptMessage_1.ChatGptRole.SYSTEM,
                         content: constants_1.TRANSLATION_SYSTEM_ROLE,
                     },
                     {
-                        role: ChatGPTMessage_1.ChatGPTRole.USER,
+                        role: ChatGptMessage_1.ChatGptRole.USER,
                         content: translateText,
                     },
                 ],
             };
             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),
                 };
             }
@@ -81,20 +80,19 @@ class TranslationService extends BaseService_1.default {
                 response_format: { type: 'json_object' },
                 messages: [
                     {
-                        role: ChatGPTMessage_1.ChatGPTRole.SYSTEM,
+                        role: ChatGptMessage_1.ChatGptRole.SYSTEM,
                         content: constants_1.LANGUAGE_DETECTION_SYSTEM_ROLE,
                     },
                     {
-                        role: ChatGPTMessage_1.ChatGPTRole.USER,
+                        role: ChatGptMessage_1.ChatGptRole.USER,
                         content: translateText,
                     }
                 ],
             };
             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),
                 };
             }
@@ -120,20 +118,19 @@ class TranslationService extends BaseService_1.default {
                 response_format: { type: 'json_object' },
                 messages: [
                     {
-                        role: ChatGPTMessage_1.ChatGPTRole.SYSTEM,
+                        role: ChatGptMessage_1.ChatGptRole.SYSTEM,
                         content: constants_1.WORD_FREQUENCY_LANGUAGE_DETECTION_SYSTEM_ROLE,
                     },
                     {
-                        role: ChatGPTMessage_1.ChatGPTRole.USER,
+                        role: ChatGptMessage_1.ChatGptRole.USER,
                         content: translateText,
                     }
                 ],
             };
             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),
                 };
             }