doomiaichat 3.0.0 → 3.0.1

package/dist/openai.d.ts

@@ -76,14 +76,7 @@ export default class OpenAIGpt extends GptBase {
      * @param {*} count
      * @param {*} axiosOption
      * @returns
-     */ generateQuestionsFromContent(content: string, count?: number, axiosOption?: any): Promise<ChatReponse>;
-    /**
-     * 从指定的文本内容中生成相关的问答
-     * @param {*} content
-     * @param {*} count
-     * @param {*} axiosOption
-     * @returns
-     */ generateQuestionsFromContent_Orgin(content: string, count?: number, promotion?: string | null, sliceslength?: number, axiosOption?: any): Promise<ChatReponse>;
+     */ generateQuestionsFromContent(content: string, count?: number, everyContentLength?: number, axiosOption?: any): Promise<ChatReponse>;
     /**
      * 解析Faq返回的问题
      * @param {*} messages
@@ -98,7 +91,7 @@ export default class OpenAIGpt extends GptBase {
      * section: {type:[0,1,2,3]为单选、多选、判断、填空题型  count:生成多少道  score:本段分数}
      * @param {*} axiosOption
      * @returns
-     */ generateExaminationPaperFromContent(content: string, paperOption?: any, axiosOption?: any): Promise<ExaminationPaperResult>;
+     */ generateExaminationPaperFromContent(content: string, paperOption?: any, everyContentLength?: number, axiosOption?: any): Promise<ExaminationPaperResult>;
     /**
      * 从答复中得到题目
      * @param {*} result

package/dist/openai.js

@@ -15,7 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const azure_openai_1 = require("azure-openai");
 // import { EventEmitter } from "events";
 const gptbase_1 = __importDefault(require("./gptbase"));
-const SECTION_LENGTH = 1600; ///每2400个字符分成一组
+const SECTION_LENGTH = 1024; ///每2400个字符分成一组
 const MESSAGE_LENGTH = 1; ///每次送8句话给openai 进行解析，送多了，会报错
 //请将答案放在最后,标记为答案：()
 const QUESTION_TEXT_MAPPING = {
@@ -119,7 +119,6 @@ class OpenAIGpt extends gptbase_1.default {
             try {
                 let finishreason = null, usage = null;
                 const response = yield this.aiApi.createChatCompletion({
-                    // engine: callChatOption?.engine||this.engine,
                     model: (callChatOption === null || callChatOption === void 0 ? void 0 : callChatOption.model) || this.chatModel,
                     messages: message,
                     stream: true,
@@ -130,7 +129,6 @@ class OpenAIGpt extends gptbase_1.default {
                     const lines = data.toString().split('\n').filter((line) => line.trim() !== '');
                     for (const line of lines) {
                         const message = line.replace(/^data: /, '');
-                        // console.log('message', message)
                         if (message === '[DONE]') {
                             this.emit('chatdone', { successed: true, finish_reason: finishreason, usage });
                             return; // Stream finished
@@ -144,16 +142,13 @@ class OpenAIGpt extends gptbase_1.default {
                             this.emit('chattext', { successed: true, text: parsed.choices[0].delta.content, finish_reason: parsed.choices[0].finish_reason, index: parsed.choices[0].index, usage });
                         }
                         catch (error) {
-                            this.emit('chaterror', { successed: false, error: 'no text in chat', message });
-                            //console.error('Could not JSON parse stream message', message, error);
+                            this.emit('chaterror', { successed: false, error: 'JSON parse stream message', message });
                         }
                     }
                 });
             }
             catch (error) {
                 this.emit('error', { successed: false, error: 'call axios faied ' + error });
-                //console.log('result is error ', error)
-                // return { successed: false, error };
             }
         });
     }
@@ -303,9 +298,9 @@ class OpenAIGpt extends gptbase_1.default {
      * @param {*} axiosOption
      * @returns
      */ //并在答案末尾处必须给出答案内容中的关键词
-    generateQuestionsFromContent(content, count = 1, axiosOption = {}) {
+    generateQuestionsFromContent(content, count = 1, everyContentLength = SECTION_LENGTH, axiosOption = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            let arrContent = this.splitLongText(content, 300);
+            let arrContent = this.splitLongText(content, everyContentLength || SECTION_LENGTH);
             ///没20句话分为一组，适应大文件内容多次请求组合结果
             ///每一句话需要产生的题目
             let questions4EverySentense = count / arrContent.length; //Math.ceil(arrContent.length / 20);
@@ -313,7 +308,7 @@ class OpenAIGpt extends gptbase_1.default {
             while (arrContent.length > 0 && gotted < count) {
                 questions4EverySentense = (count - gotted) / arrContent.length;
                 ////每次最多送MESSAGE_LENGTH句话给openai
-                let subarray = arrContent.slice(0, 4);
+                let subarray = arrContent.slice(0, 1);
                 let itemCount = Math.min(Math.ceil(subarray.length * questions4EverySentense), count - gotted);
                 //subarray.push({ role: 'user', content:'请根据上述内容,给出一道提问与答案以及答案关键词，按照先问题内容，再标准答案，再关键词的顺序输出,关键词之间用、分开'})
                 subarray.unshift({ role: 'system', content: `你是一位专业培训师,从以下内容中提取${itemCount}条提问及答案，并从答案内容提取出至少2个关键词，最终结果按照[{"question":"提问内容","answer":"答案内容","keywords":["关键词1","关键词2"]}]的JSON数组结构输出。` });
@@ -339,38 +334,6 @@ class OpenAIGpt extends gptbase_1.default {
             return { successed: true, message: faqs.slice(0, count) };
         });
     }
-    /**
-     * 从指定的文本内容中生成相关的问答
-     * @param {*} content
-     * @param {*} count
-     * @param {*} axiosOption
-     * @returns
-     */ //并在答案末尾处必须给出答案内容中的关键词
-    generateQuestionsFromContent_Orgin(content, count = 1, promotion = null, sliceslength = SECTION_LENGTH, axiosOption = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let arrContent = this.splitLongText(content, sliceslength || 300);
-            ///没20句话分为一组，适应大文件内容多次请求组合结果
-            ///每一句话需要产生的题目
-            let questions4EverySentense = count / arrContent.length; //Math.ceil(arrContent.length / 20);
-            let faqs = [], gotted = 0;
-            while (arrContent.length > 0 && gotted < count) {
-                questions4EverySentense = (count - gotted) / arrContent.length;
-                ////每次最多送MESSAGE_LENGTH句话给openai
-                let subarray = arrContent.slice(0, 4);
-                let itemCount = Math.min(Math.ceil(subarray.length * questions4EverySentense), count - gotted);
-                subarray.unshift({ role: 'system', content: promotion || `你是一位专业培训师,从以下内容中提取${itemCount}条提问及答案，并从答案内容提取出至少2个关键词，最终结果按照[{"question":"提问内容","answer":"答案内容","keywords":["关键词1","关键词2"]}]的JSON数组结构输出。` });
-                let result = yield this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
-                if (result.successed && result.message) {
-                    let answer = result.message.map(i => { return i.message.content.trim().replace(/\t|\n|\v|\r|\f/g, ''); });
-                    faqs = faqs.concat(answer);
-                }
-                ////删除已经处理的文本
-                arrContent.splice(0, 4);
-            }
-            arrContent = []; /// 释放内存
-            return { successed: true, message: faqs };
-        });
-    }
     /**
      * 解析Faq返回的问题
      * @param {*} messages
@@ -417,10 +380,10 @@ class OpenAIGpt extends gptbase_1.default {
      * @param {*} axiosOption
      * @returns
      */ //并在答案末尾处必须给出答案内容中的关键词
-    generateExaminationPaperFromContent(content, paperOption = {}, axiosOption = {}) {
+    generateExaminationPaperFromContent(content, paperOption = {}, everyContentLength = SECTION_LENGTH, axiosOption = {}) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         return __awaiter(this, void 0, void 0, function* () {
-            let arrContent = this.splitLongText(content, 1024);
+            let arrContent = this.splitLongText(content, everyContentLength || SECTION_LENGTH);
             let sectionCount = {
                 singlechoice: (((_a = paperOption.singlechoice) === null || _a === void 0 ? void 0 : _a.count) || 0) / arrContent.length,
                 multiplechoice: (((_b = paperOption.multiplechoice) === null || _b === void 0 ? void 0 : _b.count) || 0) / arrContent.length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doomiaichat",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Doomisoft OpenAI",
   "main": "dist/index.js",
   "scripts": {

package/src/openai.ts

@@ -2,7 +2,7 @@ import { Configuration, OpenAIApi, ChatCompletionRequestMessage } from "azure-op
 // import { EventEmitter } from "events";
 import GptBase from "./gptbase"
 import { OpenAIApiParameters, ChatReponse, OutlineSummaryItem, SummaryReponse, FaqItem, ExaminationPaperResult, EmotionResult, SimilarityResult, QuestionItem, CommentResult, EmbeddingResult } from './declare'
-const SECTION_LENGTH = 1600;     ///每2400个字符分成一组
+const SECTION_LENGTH = 1024;     ///每2400个字符分成一组
 const MESSAGE_LENGTH = 1;      ///每次送8句话给openai 进行解析，送多了，会报错
 //请将答案放在最后,标记为答案：()
 const QUESTION_TEXT_MAPPING: any = {
@@ -270,8 +270,8 @@ export default class OpenAIGpt extends GptBase {
      * @param {*} axiosOption 
      * @returns 
      *///并在答案末尾处必须给出答案内容中的关键词
-    async generateQuestionsFromContent(content: string, count: number = 1, axiosOption: any = {}): Promise<ChatReponse> {
-        let arrContent = this.splitLongText(content, 300);
+    async generateQuestionsFromContent(content: string, count: number = 1, everyContentLength: number = SECTION_LENGTH, axiosOption: any = {}): Promise<ChatReponse> {
+        let arrContent = this.splitLongText(content, everyContentLength || SECTION_LENGTH);
         ///没20句话分为一组，适应大文件内容多次请求组合结果
         ///每一句话需要产生的题目
         let questions4EverySentense: number = count / arrContent.length; //Math.ceil(arrContent.length / 20);
@@ -279,7 +279,7 @@ export default class OpenAIGpt extends GptBase {
         while (arrContent.length > 0 && gotted < count) {
             questions4EverySentense = (count - gotted) / arrContent.length
             ////每次最多送MESSAGE_LENGTH句话给openai
-            let subarray = arrContent.slice(0, 4);
+            let subarray = arrContent.slice(0, 1);
             let itemCount = Math.min(Math.ceil(subarray.length * questions4EverySentense), count - gotted);
             //subarray.push({ role: 'user', content:'请根据上述内容,给出一道提问与答案以及答案关键词，按照先问题内容，再标准答案，再关键词的顺序输出,关键词之间用、分开'})
             subarray.unshift({ role: 'system', content: `你是一位专业培训师,从以下内容中提取${itemCount}条提问及答案，并从答案内容提取出至少2个关键词，最终结果按照[{"question":"提问内容","answer":"答案内容","keywords":["关键词1","关键词2"]}]的JSON数组结构输出。` })
@@ -307,36 +307,6 @@ export default class OpenAIGpt extends GptBase {
         return { successed: true, message: faqs.slice(0, count) };
     }
 
-    /**
-     * 从指定的文本内容中生成相关的问答
-     * @param {*} content 
-     * @param {*} count 
-     * @param {*} axiosOption 
-     * @returns 
-     *///并在答案末尾处必须给出答案内容中的关键词
-    async generateQuestionsFromContent_Orgin(content: string, count: number = 1, promotion: string | null = null, sliceslength: number = SECTION_LENGTH, axiosOption: any = {}): Promise<ChatReponse> {
-        let arrContent = this.splitLongText(content, sliceslength || 300);
-        ///没20句话分为一组，适应大文件内容多次请求组合结果
-        ///每一句话需要产生的题目
-        let questions4EverySentense: number = count / arrContent.length; //Math.ceil(arrContent.length / 20);
-        let faqs: any[] = [], gotted: number = 0;
-        while (arrContent.length > 0 && gotted < count) {
-            questions4EverySentense = (count - gotted) / arrContent.length
-            ////每次最多送MESSAGE_LENGTH句话给openai
-            let subarray = arrContent.slice(0, 4);
-            let itemCount = Math.min(Math.ceil(subarray.length * questions4EverySentense), count - gotted);
-            subarray.unshift({ role: 'system', content: promotion || `你是一位专业培训师,从以下内容中提取${itemCount}条提问及答案，并从答案内容提取出至少2个关键词，最终结果按照[{"question":"提问内容","answer":"答案内容","keywords":["关键词1","关键词2"]}]的JSON数组结构输出。` })
-            let result = await this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
-            if (result.successed && result.message) {
-                let answer = result.message.map(i => { return i.message.content.trim().replace(/\t|\n|\v|\r|\f/g, '') })
-                faqs = faqs.concat(answer);
-            }
-            ////删除已经处理的文本
-            arrContent.splice(0, 4);
-        }
-        arrContent = [];  /// 释放内存
-        return { successed: true, message: faqs };
-    }
     /**
      * 解析Faq返回的问题
      * @param {*} messages 
@@ -382,8 +352,8 @@ export default class OpenAIGpt extends GptBase {
      * @param {*} axiosOption 
      * @returns 
      *///并在答案末尾处必须给出答案内容中的关键词
-    async generateExaminationPaperFromContent(content: string, paperOption: any = {}, axiosOption: any = {}): Promise<ExaminationPaperResult> {
-        let arrContent = this.splitLongText(content, 1024);
+    async generateExaminationPaperFromContent(content: string, paperOption: any = {}, everyContentLength: number = SECTION_LENGTH, axiosOption: any = {}): Promise<ExaminationPaperResult> {
+        let arrContent = this.splitLongText(content, everyContentLength || SECTION_LENGTH);
         let sectionCount: any = {
             singlechoice: (paperOption.singlechoice?.count || 0) / arrContent.length,
             multiplechoice: (paperOption.multiplechoice?.count || 0) / arrContent.length,