@cobrowser/chatgpt 0.7.10 → 0.7.12

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

@@ -13,4 +13,5 @@ export declare class TranslationService extends BaseService {
     translate(text: string, toLanguage?: string, fromLanguage?: string): Promise<ChatGptResponse | undefined>;
     findTextLanguage(text: string): Promise<ChatGptResponse | undefined>;
     getFindTextLanguagePromptMessage(text: string): string;
+    findTextLanguageBasedOnFrequency(text: string): Promise<ChatGptResponse | undefined>;
 }

package/dist/services/TranslationService/TranslationService.js

@@ -53,7 +53,8 @@ class TranslationService extends BaseService_1.default {
             }
             const desiredLanguage = toLanguage, 
             // instruction on what to do with the text
-            translateText = `Translate the following ${fromLanguage} text to ${desiredLanguage}: ${text}`, 
+            translateText = `Translate the following ${fromLanguage} text to ${desiredLanguage} 
+      if it's not already in ${desiredLanguage}: ${text}`, 
             // the body we need to send to the request
             requestBody = {
                 model: this.chatGptModel,
@@ -122,5 +123,43 @@ class TranslationService extends BaseService_1.default {
         return `In which language is this text in '${text}'? The response should be {'languageCode': 'language_code_here', 'isError': 'true or false based on whether you did find the language code or not'}. 
     Other responses or explanations are not allowed.`;
     }
+    findTextLanguageBasedOnFrequency(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'));
+            }
+            text = '```' + text + '```';
+            // instruction on what to do with the text
+            const translateText = `Tell me the language ISO code of the  enclosed between triple backticks ${text}
+    based on most words used. Give me the result in just one word, the ISO code of the language with most words.`, 
+            // the body we need to send to the request
+            requestBody = {
+                model: this.chatGptModel,
+                response_format: { type: 'json_object' },
+                messages: [
+                    {
+                        role: ChatGptMessage_1.ChatGptRole.SYSTEM,
+                        content: this.FIND_TEXT_LANGUAGE_SYSTEM_ROLE,
+                    },
+                    {
+                        role: ChatGptMessage_1.ChatGptRole.USER,
+                        content: translateText,
+                    }
+                ],
+            };
+            try {
+                const response = yield this.request.post('', requestBody);
+                return {
+                    firstChoice: this.getResponseFirstChoice(response),
+                    usageTokens: this.getResponseUsageTokens(response),
+                };
+            }
+            catch (e) {
+                this.handleErrors(e);
+                return Promise.reject(e);
+            }
+        });
+    }
 }
 exports.TranslationService = TranslationService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cobrowser/chatgpt",
-  "version": "0.7.10",
+  "version": "0.7.12",
   "description": "chatgpt services to connect our projects with chatgpt api",
   "keywords": [
     "chatgpt",
@@ -39,5 +39,5 @@
   "bugs": {
     "url": "https://bitbucket.org/cobrowser/cb_utils/issues"
   },
-  "gitHead": "bfd41572602b05246d75c9a817b120e08f41f8a6"
+  "gitHead": "346f32b794180f7d008560c9cddff248de092355"
 }

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

@@ -1,19 +0,0 @@
-import ChatGptResponse from '../../models/ChatGptResponse';
-import BaseService from '../BaseService/BaseService';
-export declare class AssistantService extends BaseService {
-    assistantId: string | undefined;
-    threadId: string | undefined;
-    constructor(apiKey?: string, assistantId?: string, threadId?: string);
-    /**
-     * Create new thread
-     *
-     * @param message
-     */
-    createThread(): Promise<string>;
-    /**
-     * Get the reply of the assistant if the assistant_id is available
-     *
-     * @param message
-     */
-    getReply(message: string): Promise<ChatGptResponse | undefined>;
-}

package/dist/services/AssistantService/AssistantService.js

@@ -1,94 +0,0 @@
-"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.AssistantService = void 0;
-const logger_1 = __importDefault(require("../logger"));
-const openai_1 = __importDefault(require("openai"));
-const BaseService_1 = __importDefault(require("../BaseService/BaseService"));
-class AssistantService extends BaseService_1.default {
-    constructor(apiKey, assistantId, threadId) {
-        super(apiKey);
-        Object.defineProperty(this, "assistantId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "threadId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.assistantId = assistantId;
-        this.threadId = threadId;
-    }
-    /**
-     * Create new thread
-     *
-     * @param message
-     */
-    createThread() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const openai = new openai_1.default({ apiKey: this.openaiApiKey }), thread = yield openai.beta.threads.create();
-            this.threadId = thread.id;
-            return this.threadId;
-        });
-    }
-    /**
-     * Get the reply of the assistant if the assistant_id is available
-     *
-     * @param message
-     */
-    getReply(message) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.assistantId || !this.threadId) {
-                logger_1.default.error('Assistant and Thread are required');
-                return Promise.reject(new Error('Assistant and Thread are required'));
-            }
-            const openai = new openai_1.default({ apiKey: this.openaiApiKey });
-            let run;
-            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);
-            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: 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);
-            }
-            if (run.status === 'completed') {
-                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 answer = assistantMessages.map(message => message.value).join('\n');
-                    return {
-                        firstChoice: answer.replace(/【.*?】/g, ''),
-                        threadId: run.thread_id,
-                        usageTokens: run.usage,
-                    };
-                }
-            }
-            return undefined;
-        });
-    }
-}
-exports.AssistantService = AssistantService;