@cobrowser/chatgpt 0.7.12 → 0.7.14

package/dist/index.d.ts

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

package/dist/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./services/TranslationService/TranslationService"), exports);
 __exportStar(require("./services/CopilotService/CopilotService"), exports);
 __exportStar(require("./services/ChatService/ChatService"), exports);
+__exportStar(require("./services/AssistantService/AssistantService"), exports);

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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,94 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __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;

package/package.json

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