doomiaichat 4.9.0 → 5.0.0

package/dist/openai.js

@@ -13,72 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 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 = 1024; ///每2400个字符分成一组
-const MESSAGE_LENGTH = 1; ///每次送8句话给openai 进行解析，送多了，会报错
-//请将答案放在最后,标记为答案：()
-// const QUESTION_TEXT_MAPPING: any = {
-//     singlechoice: '你是一名专业的出题老师,根据以下内容,生成@ITEMCOUNT@道单选题,每道题目4个选项,每道题的选项中的元素用大写字母ABCD开头,每道题一个正确答案,输出结果必须是JSON数组并按照[{"question":"","choice":[],"answer":[]}]的结构输出',
-//     multiplechoice: '你是一名专业的出题老师,根据以下内容,请生成@ITEMCOUNT@道多选题,提供4个选项,每道题的选项中的元素用大写字母ABCD开头,每道题的答案至少有两个选项,输出结果必须是JSON数组并按照[{"question":"","choice":[],"answer":[]}]的结构输出',  //请将答案放在最后,标记为答案：()
-//     trueorfalse: '你是一名专业的出题老师,根据以下内容,请生成@ITEMCOUNT@道判断题,每道题正确和错误两个选项，输出结果必须是JSON数组并按照[{"question":"","choice":["A.正确","B.错误"],"answer":[]}]的结构输出', //标记为答案：(正确或错误)
-//     completion: '你是一名专业的出题老师,根据以下内容,请生成@ITEMCOUNT@道填空题和对应答案,输出结果必须是JSON数组并按照[{"question":"","answer":["填空答案1","填空答案2"]}]的结构输出' //请将答案放在最后,标记为答案：()
-// }
-const FAQ_ROLE_DEFINE = `
-角色扮演：你是一位精通各行业的培训专家，你擅长从资料里提取重点要点，并形成用于培训员工的问题及对应的答案和答案的关键词。请记住:
-1、问题需要偏口语化，问题需要与所给的资料相关，绝不能问超出所给资料的范围；每个问题需要有主语，所提问题需要准确、完整、清晰，绝不能有歧义；意思相近的问题不要重复给出；
-2、对应的答案必须要在资料中能找到，绝对不能给出在资料里没有的答案，答案的关键词必须完整在所给的答案中出现，绝不能给出不在答案里的关键词；
-3、生成问题的时候，请出具有代表性的问题，对于一些无关紧要的问题可以忽略。特别注意资料中关于数字、参数、特点等关键信息的提取，在给出的问题中尽可能覆盖；
-4、生成的结果严格按照[{"question":"提问内容","answer":"答案内容","keywords":["关键词1","关键词2"]}]的标准JSON数组结构输出。
-`;
-const QUESTION_ROLE_DEFINE = {
-    singlechoice: `
-角色扮演：你是一位精通各行业的培训专家，你擅长从资料里提取重点要点，并形成用于培训员工的单选题，每道题包括一个问题和四个选项，其中只有一个选项是正确的。请记住:
-1、问题需要与所给的资料相关，绝不能问超出所给资料的范围；每个问题需要有主语，所提问题需要准确、完整、清晰，绝不能有歧义；意思相近的问题不要重复给出；
-2、四个选项用大写字母ABCD开头，其中只有一个是正确的选项，而且这个正确的选项必须要在资料中能找到，绝对不能给出在资料里没有的正确选项；
-3、生成问题的时候，请出具有代表性的问题，对于一些无关紧要的问题可以忽略。特别注意资料中关于数字、参数、特点等关键信息的提取，在给出的问题中尽可能覆盖；
-4、生成的结果严格按照标准JSON数组并按照[{"question":"","choice":[],"answer":[]}]的结构输出`,
-    multiplechoice: `
-角色扮演：你是一位精通各行业的培训专家，你擅长从资料里提取重点要点，并形成用于培训员工的多选题，每道题包括一个问题和四个选项，其中至少有两个选项是正确的。请记住:
-1、问题需要与所给的资料相关，绝不能问超出所给资料的范围；每个问题需要有主语，所提问题需要准确、完整、清晰，绝不能有歧义；意思相近的问题不要重复给出；
-2、四个选项用大写字母ABCD开头，其中至少有两个是正确的选项，而且正确的选项必须要在资料中能找到，绝对不能给出在资料里没有的正确选项；
-3、生成问题的时候，请出具有代表性的问题，对于一些无关紧要的问题可以忽略。特别注意资料中关于数字、参数、特点等关键信息的提取，在给出的问题中尽可能覆盖；
-4、生成的结果严格按照标准JSON数组并按照[{"question":"","choice":[],"answer":[]}]的结构输出
-    `,
-    trueorfalse: `
-角色扮演：你是一位精通各行业的培训专家，你擅长从资料里提取重点要点，并形成用于培训员工的判断题，每道题包括一个问题和一个正确和一个错误的两个选项。请记住:
-1、问题需要与所给的资料相关，绝不能问超出所给资料的范围；每个问题需要有主语，所提问题需要准确、完整、清晰，绝不能有歧义；意思相近的问题不要重复给出；
-2、两个选项必须为“正确”和“错误”这两个，正确答案必须是其中一个；
-3、生成问题的时候，请出具有代表性的问题，对于一些无关紧要的问题可以忽略。特别注意资料中关于数字、参数、特点等关键信息的提取，在给出的问题中尽可能覆盖；
-5、生成的结果严格按照标准JSON数组并按照[{"question":"","choice":["A.正确","B.错误"],"answer":[]}]的结构输出'
-    `,
-    completion: `
-角色扮演：你是一位精通各行业的培训专家，你擅长从资料里提取重点要点，并形成用于培训员工的填空题及对应的答案。请记住:
-1、问题需要与所给的资料相关，绝不能问超出所给资料的范围；每个问题需要有主语，所提问题需要准确、完整、清晰，绝不能有歧义；意思相近的问题不要重复给出；
-2、对应的答案必须要在资料中能找到，绝对不能给出在资料里没有的答案，答案尽量选择数字、词组等，字数不超过10个字，避免出现过长的答案；
-3、生成问题的时候，请出具有代表性的问题，对于一些无关紧要的问题可以忽略。特别注意资料中关于数字、参数、特点等关键信息的提取，在给出的问题中尽可能覆盖；
-4、生成的结果严格按照标准JSON数组并按照[{"question":"","answer":["填空答案1","填空答案2"]}]的结构输出'
-`
-};
-/**
- * 问题生成的Prompt
- */
-const QUESTION_PROMPT = {
-    singlechoice: '根据以下内容,生成@ITEMCOUNT@道单选题,每道题目4个选项,每道题的选项中的元素用大写字母ABCD开头,每道题一个正确答案,输出结果必须是JSON数组并按照[{"question":"","choice":[],"answer":[]}]的结构输出。如果内容不足以提取问题和答案，请直接输出JSON空数组。',
-    multiplechoice: '根据以下内容,请生成@ITEMCOUNT@道多选题,提供4个选项,每道题的选项中的元素用大写字母ABCD开头,每道题的答案至少有两个选项,输出结果必须是JSON数组并按照[{"question":"","choice":[],"answer":[]}]的结构输出。如果内容不足以提取问题和答案，请直接输出JSON空数组。',
-    trueorfalse: '根据以下内容,请生成@ITEMCOUNT@道判断题,每道题正确和错误两个选项，输出结果必须是JSON数组并按照[{"question":"","choice":["A.正确","B.错误"],"answer":[]}]的结构输出。如果内容不足以提取问题和答案，请直接输出JSON空数组。',
-    completion: '根据以下内容,请生成@ITEMCOUNT@道填空题和对应答案,输出结果必须是JSON数组并按照[{"question":"","answer":["填空答案1","填空答案2"]}]的结构输出。如果内容不足以提取问题和答案，请直接输出JSON空数组。'
-};
-/**
- * 问题生成的Prompt
- */
-const QUESTION_PROMPT_FIXED = {
-    singlechoice: '[{"question":"","choice":[],"answer":[]}]',
-    multiplechoice: '[{"question":"","choice":[],"answer":[]}]',
-    trueorfalse: '[{"question":"","choice":["A.正确","B.错误"],"answer":[]}]',
-    completion: '[{"question":"","answer":["填空答案1","填空答案2"]}]'
-};
-const QUESTION_TYPE = ['singlechoice', 'multiplechoice', 'trueorfalse', 'completion'];
 class OpenAIGpt extends gptbase_1.default {
     /**
      *
@@ -173,12 +108,13 @@ class OpenAIGpt extends gptbase_1.default {
             if (!this.aiApi) {
                 this.aiApi = this.createOpenAI(this.apiKey);
             }
+            // const DATA_END_TAG = `"usage":null}`
             let message = typeof (chatText) == 'string' ?
                 [{ role: 'user', content: chatText }] : chatText;
             axiosOption = Object.assign({}, axiosOption || { timeout: 60000 }, { responseType: 'stream' });
             let requestid = Math.ceil(Math.random() * (new Date().getTime() * Math.random()) / 1000);
             try {
-                let finishreason = null, usage = null;
+                let finishreason = null, usage = null, errtxt = '';
                 ///便于知道返回的requestid
                 // console.log('model', callChatOption?.model || this.chatModel,)
                 const response = yield this.aiApi.createChatCompletion({
@@ -194,9 +130,15 @@ class OpenAIGpt extends gptbase_1.default {
                     ///已经返回了结束原因
                     if (finishreason)
                         return;
-                    for (const line of lines) {
-                        const message = line.replace(/^data: /, '');
-                        if (message === '[DONE]') {
+                    // console.log('before add', lines.join('').split('data:'));
+                    let alltext = (errtxt + lines.join('')).split('data:');
+                    // console.log('alltext',alltext)
+                    errtxt = '';
+                    for (const line of alltext) {
+                        let txt = line.trim();
+                        if (!txt)
+                            continue;
+                        if (txt === '[DONE]') {
                             let output = { successed: true, requestid, text: replytext.join(''), finish_reason: 'stop', usage };
                             if (attach)
                                 output = Object.assign({}, output, attach);
@@ -206,7 +148,8 @@ class OpenAIGpt extends gptbase_1.default {
                         try {
                             ///{ delta: { content: '$\\' }, index: 0, finish_reason: null }
                             ///发送出去
-                            const parsed = JSON.parse(message);
+                            const parsed = JSON.parse(txt);
+                            ///已经返回一个正确的了，可以重置这个变量了
                             finishreason = parsed.choices[0].finish_reason;
                             usage = parsed.usage;
                             let streamtext = parsed.choices[0].delta.content;
@@ -219,7 +162,8 @@ class OpenAIGpt extends gptbase_1.default {
                                 return;
                         }
                         catch (error) {
-                            this.emit('chaterror', { successed: false, requestid, error: 'JSON parse stream message', message });
+                            errtxt += txt; ///这一段json没有结束，作为下一次的流过来时使用
+                            this.emit('chaterror', { successed: false, requestid, error: 'JSON parse stream message', errtxt });
                         }
                     }
                 });
@@ -231,522 +175,5 @@ class OpenAIGpt extends gptbase_1.default {
             }
         });
     }
-    /**
-     * 点评问题回答的评价
-     * @param question
-     * @param answer
-     * @param axiosOption
-     */
-    commentQuestionAnswer(question, answer, axiosOption = { timeout: 30000 }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!question || !answer)
-                return { successed: false, error: { errcode: 2, errmsg: '缺失参数' } };
-            let message = [
-                { role: 'system', content: '你是一名专业的知识点评师。' },
-                { role: 'user', content: `问题题干:“${question}”` },
-                { role: 'user', content: `回答内容:“${answer}”` },
-                { role: 'user', content: `请根据以上的回答内容进行点评，给出一段不超过200字的评语，并给出0-100的评分。` },
-                { role: 'user', content: `结果完整按照{"comment":"点评内容","score":"评分"}的JSON结构输出` }
-            ];
-            const result = yield this.chatRequest(message, {}, axiosOption);
-            if (result.successed && result.message) {
-                let value = result.message[0].message.content.trim();
-                let replyJson = this.fixedJsonString(value);
-                ///能够提取到内容
-                if (replyJson.length)
-                    return Object.assign({ successed: true }, replyJson[0]);
-                ///回答的内容非JSON格式，自己来提取算了
-                console.log('自己组装');
-                let matched = value.match(/\d+分/g), score = 0;
-                if (matched && matched.length) {
-                    score = Number(matched[0].replace('分', ''));
-                }
-                return { successed: true, comment: value, score };
-            }
-            return { successed: false };
-        });
-    }
-    /**
-     * 判断一句话的表达情绪
-     * @param {*} s1
-     * @param {*} axiosOption
-     */
-    getScentenceEmotional(s1, axiosOption = { timeout: 30000 }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!s1)
-                return { successed: false, error: { errcode: 2, errmsg: '缺失参数' } };
-            const emotion = ['愤怒', '威胁', '讽刺', '愧疚', '兴奋', '友好', '消极', '生气', '正常'];
-            const messages = [
-                { role: 'system', content: `你是一名专业的语言大师` },
-                { role: 'user', content: s1 },
-                { role: 'user', content: `请分析上述内容的语言情绪,请从"${emotion.join(',')}"这些情绪中对应一个输出` },
-            ];
-            const result = yield this.chatRequest(messages, {}, axiosOption);
-            if (result.successed && result.message) {
-                let value = result.message[0].message.content.trim();
-                for (const word of emotion) {
-                    if (value.indexOf(word) >= 0)
-                        return { successed: true, emotion: word };
-                }
-            }
-            return { successed: true, emotion: '未知' };
-        });
-    }
-    /**
-     * 获取两句话的相似度取值
-     * @param {*} s1
-     * @param {*} s2
-     */
-    getScentenseSimilarity(s1, s2, axiosOption = { timeout: 30000 }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!s1 || !s2)
-                return { successed: false, error: { errcode: 2, errmsg: '缺失参数' } };
-            const messages = [
-                { role: 'system', content: '你是一名专业的语言分析大师' },
-                { role: 'user', content: s1 },
-                { role: 'user', content: s2 },
-                { role: 'user', content: '请从语义上对比以上两句话的相似度,请仅输出0至100之间的整数对比结果即可' },
-            ];
-            const result = yield this.chatRequest(messages, { maxtoken: 32 }, axiosOption);
-            if (result.successed && result.message) {
-                let value = result.message[0].message.content.replace(/[^\d]/g, "");
-                if (value > 100)
-                    value = Math.floor(value / 10);
-                return { successed: true, value: Number(value) };
-            }
-            return { successed: false, error: result.error, value: 0 };
-        });
-    }
-    /**
-      * 获得一种内容的相似说法
-     * 比如：
-     * 你今年多大？
-     * 相似问法：您是哪一年出生的
-     * 您今年贵庚？
-     * @param {*} content
-     * @param {需要出来的数量} count
-     */
-    getSimilarityContent(content, count = 1, axiosOption = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let chnReg = /([\u4e00-\u9fa5]|[\ufe30-\uffa0])/.test(content); ///检查源话是否含有中文内容
-            let engReg = /[a-zA-Z]/.test(content); ///检查源话是否含有英文内容
-            ///如果源话是全中文，那么结果中不应该出来英文的相似说法，如果源话是全英文，则结果不能出现全中文的说法
-            let prefix = (!chnReg && engReg) ? '请用完整的英文表达,' : ((chnReg && !engReg) ? '请用完整的中文表达,' : '');
-            const text = `${prefix}生成与下面句子意思相同的内容"${content}"`;
-            let result = yield this.chatRequest(text, { replyCounts: count }, axiosOption);
-            if (!result.successed || !result.message)
-                return result;
-            let replys = result.message.map(item => { return item.message.content.trim(); });
-            return { successed: true, message: replys };
-        });
-    }
-    /**
-     * 提取内容的中心思想摘要
-     * @param content
-     * @param axiosOption
-     */
-    getSummaryOfContent(content, axiosOption = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let arrContent = [];
-            if (typeof (content) == 'string') {
-                let splittext = this.splitLongText(content);
-                for (const string of splittext) {
-                    arrContent.push({ role: 'user', content: string });
-                }
-            }
-            else {
-                arrContent = content;
-            }
-            let summary = [];
-            while (arrContent.length > 0) {
-                let subarray = arrContent.slice(0, MESSAGE_LENGTH);
-                subarray.push({ role: 'user', content: '根据上述内容精简，提炼内容提纲及摘要内容，每项摘要内容尽量精简数据化不超过100字，结果严格按照[{outline:"提纲标题","summary":["摘要内容1","摘要内容2","摘要内容3"]}]的JSON结构输出' });
-                let result = yield this.chatRequest(subarray, {}, axiosOption);
-                if (result.successed && result.message) {
-                    try {
-                        // console.log('result.message[0].content', result.message[0].message.content)
-                        let jsonObjItems = JSON.parse(result.message[0].message.content);
-                        if (Array.isArray(jsonObjItems))
-                            summary = summary.concat(jsonObjItems);
-                    }
-                    catch (error) {
-                        console.log('result.message[0].content', error);
-                    }
-                }
-                ////删除已经处理的文本
-                arrContent.splice(0, MESSAGE_LENGTH);
-            }
-            return { successed: true, article: summary };
-        });
-    }
-    /**
-     * 从指定的文本内容中生成相关的问答
-     * @param {*} content
-     * @param {*} count
-     * @param {*} axiosOption
-     * @returns
-     */ //并在答案末尾处必须给出答案内容中的关键词
-    generateQuestionsFromContent(content, count = 1, everyContentLength = SECTION_LENGTH, axiosOption = {}) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            let arrContent = this.splitLongText(content, everyContentLength || SECTION_LENGTH);
-            ///如果最后一段的文字内容过短，则把最后一段内容追加到前一段中，并删除最后一段
-            let totalLen = arrContent.length;
-            if (totalLen >= 2 && (((_a = arrContent[totalLen - 1]) === null || _a === void 0 ? void 0 : _a.length) || 0) < 100) {
-                arrContent[totalLen - 2] += arrContent[totalLen - 1];
-                arrContent.splice(totalLen - 1, 1);
-            }
-            ///没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 itemCount = Math.min(Math.ceil(questions4EverySentense), count - gotted);
-                let subarray = [
-                    { role: 'system', content: FAQ_ROLE_DEFINE },
-                    { role: 'user', content: `从以下内容中提取${itemCount}条提问及答案，并从答案内容提取出至少2个关键词，最终结果按照[{"question":"提问内容","answer":"答案内容","keywords":["关键词1","关键词2"]}]的JSON数组结构输出。如果内容不足以提取问题和答案，请直接输出JSON空数组 []。` },
-                    { role: 'user', content: arrContent.slice(0, 1)[0] }
-                ];
-                console.log('Faq Question Pick Prompt:', subarray);
-                let result = yield this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
-                ///如果请求发生了网络错误(不是内容合规问题），则再重试一次，如果任然有错则放弃
-                if (!result.successed && result.error != 'content_filter') {
-                    console.log('network error,retry onemore time');
-                    result = yield this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
-                }
-                if (result.successed && result.message) {
-                    let msgs = yield this.pickUpFaqContent(result.message);
-                    if (msgs.length) {
-                        ///对外发送检出问答题的信号
-                        this.emit('parseout', { type: 'qa', items: msgs });
-                        gotted += msgs.length; //result.message.length;
-                        faqs = faqs.concat(msgs);
-                    }
-                }
-                ////删除已经处理的文本
-                arrContent.splice(0, 1);
-            }
-            arrContent = []; /// 释放内存
-            ///发出信号，解析完毕
-            this.emit('parseover', { type: 'qa', items: faqs });
-            return { successed: true, message: faqs.slice(0, count) };
-        });
-    }
-    /**
-     * 解析Faq返回的问题
-     * @param {*} messages
-     * @returns
-     */
-    pickUpFaqContent(messages) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!((_b = (_a = messages[0]) === null || _a === void 0 ? void 0 : _a.message) === null || _b === void 0 ? void 0 : _b.content))
-                return [];
-            let answerString = messages[0].message.content.trim().replace(/\t|\n|\v|\r|\f/g, '');
-            if (answerString === '[]')
-                return [];
-            let jsonObj = this.fixedJsonString(answerString);
-            if (!jsonObj.length) {
-                let fixedAsk = [
-                    { role: 'system', content: '角色扮演：假设你是一位高级JSON数据分析师' },
-                    { role: 'user', content: `请分析以下内容，严格按照[{"question":"提问内容","answer":"答案内容","keywords":["关键词1","关键词2"]}]的标准JSON数组结构输出。如果内容不足以提取问题和答案，请直接输出JSON空数组，无需提供参考。` },
-                    { role: 'user', content: answerString },
-                ];
-                console.log('pickUpFaqContent fixedAsk', fixedAsk);
-                let fixedJsonResult = yield this.chatRequest(fixedAsk, { replyCounts: 1 }, {});
-                if (fixedJsonResult.successed) {
-                    answerString = fixedJsonResult.message[0].message.content.trim().replace(/\t|\n|\v|\r|\f/g, '');
-                    jsonObj = this.fixedJsonString(answerString);
-                }
-                if (!jsonObj.length)
-                    return [];
-            }
-            try {
-                //let jsonObj = JSON.parse(answerString);
-                //let jsonObj = eval(answerString);
-                jsonObj.map((item) => {
-                    let realKeyword = [];
-                    let keywords = (item.keywords + '').split(',');
-                    let answer = item.answer || '';
-                    for (const k of keywords) {
-                        if (k && answer.indexOf(k) >= 0)
-                            realKeyword.push(k);
-                    }
-                    item.keywords = realKeyword;
-                    return item;
-                });
-                return jsonObj;
-            }
-            catch (err) {
-                console.log('JSON error', err);
-                return [];
-            }
-        });
-    }
-    /**
-     * 从指定的文本内容中生成一张试卷
-     * @param {*} content
-     * @param {试卷的参数} paperOption
-     * totalscore: 试卷总分，默认100
-     * section: {type:[0,1,2,3]为单选、多选、判断、填空题型  count:生成多少道  score:本段分数}
-     * @param {*} axiosOption
-     * @returns
-     */ //并在答案末尾处必须给出答案内容中的关键词
-    generateExaminationPaperFromContent(content, paperOption = {}, everyContentLength = SECTION_LENGTH, axiosOption = {}) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
-        return __awaiter(this, void 0, void 0, function* () {
-            let arrContent = this.splitLongText(content, everyContentLength || SECTION_LENGTH);
-            ///如果最后一段的文字内容过短，则把最后一段内容追加到前一段中，并删除最后一段
-            let totalLen = arrContent.length;
-            if (totalLen >= 2 && (((_a = arrContent[totalLen - 1]) === null || _a === void 0 ? void 0 : _a.length) || 0) < 100) {
-                arrContent[totalLen - 2] += arrContent[totalLen - 1];
-                arrContent.splice(totalLen - 1, 1);
-            }
-            let sectionCount = {
-                singlechoice: (((_b = paperOption.singlechoice) === null || _b === void 0 ? void 0 : _b.count) || 0) / arrContent.length,
-                multiplechoice: (((_c = paperOption.multiplechoice) === null || _c === void 0 ? void 0 : _c.count) || 0) / arrContent.length,
-                trueorfalse: (((_d = paperOption.trueorfalse) === null || _d === void 0 ? void 0 : _d.count) || 0) / arrContent.length,
-                completion: (((_e = paperOption.completion) === null || _e === void 0 ? void 0 : _e.count) || 0) / arrContent.length
-            };
-            ///剩余待生成的题目数量
-            let remainCount = {
-                singlechoice: ((_f = paperOption.singlechoice) === null || _f === void 0 ? void 0 : _f.count) || 0,
-                multiplechoice: ((_g = paperOption.multiplechoice) === null || _g === void 0 ? void 0 : _g.count) || 0,
-                trueorfalse: ((_h = paperOption.trueorfalse) === null || _h === void 0 ? void 0 : _h.count) || 0,
-                completion: ((_j = paperOption.completion) === null || _j === void 0 ? void 0 : _j.count) || 0
-            };
-            ///每种类型的题目的分数
-            let ITEM_SCORE = {
-                singlechoice: ((_k = paperOption.singlechoice) === null || _k === void 0 ? void 0 : _k.score) || 0,
-                multiplechoice: ((_l = paperOption.multiplechoice) === null || _l === void 0 ? void 0 : _l.score) || 0,
-                trueorfalse: ((_m = paperOption.trueorfalse) === null || _m === void 0 ? void 0 : _m.score) || 0,
-                completion: ((_o = paperOption.completion) === null || _o === void 0 ? void 0 : _o.score) || 0
-            };
-            ///最后生成出来的结果
-            let paperReturned = {
-                singlechoice: [], multiplechoice: [], trueorfalse: [], completion: []
-            }, noMoreQuestionRetrive = false, totalscore = 0;
-            while (arrContent.length > 0 && !noMoreQuestionRetrive) {
-                ////每次最多送MESSAGE_LENGTH句话给openai
-                /**
-                 * 每种类型的题目进行遍历
-                 */
-                noMoreQuestionRetrive = true;
-                for (const key of QUESTION_TYPE) {
-                    ///还需要抓取题目
-                    if (remainCount[key] > 0) {
-                        noMoreQuestionRetrive = false;
-                        //let itemCount = Math.min(remainCount[key], Math.ceil(subarray.length * sectionCount[key]));
-                        let itemCount = Math.min(remainCount[key], Math.ceil(sectionCount[key]));
-                        let subarray = [
-                            { role: 'system', content: QUESTION_ROLE_DEFINE[key] },
-                            { role: 'user', content: QUESTION_PROMPT[key].replace('@ITEMCOUNT@', itemCount) },
-                            { role: 'user', content: arrContent.slice(0, 1)[0] }
-                        ];
-                        // subarray.unshift()
-                        console.log('subarray', subarray);
-                        let result = yield this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
-                        ///如果请求发生了网络错误(不是内容合规问题），则再重试一次，如果任然有错则放弃
-                        if (!result.successed && result.error != 'content_filter') {
-                            console.log('network error,retry onemore time');
-                            result = yield this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
-                        }
-                        console.log('subarray returned', result.successed);
-                        if (result.successed && result.message) {
-                            //console.log('paper result', key, result.message.length)
-                            let pickedQuestions = yield this.pickUpQuestions(result.message, itemCount, key, ITEM_SCORE[key]);
-                            if (pickedQuestions.length) {
-                                ///对外发送检出题目的信号
-                                this.emit('parseout', { type: 'question', name: key, items: pickedQuestions });
-                                paperReturned[key] = paperReturned[key].concat(pickedQuestions);
-                                remainCount[key] = remainCount[key] - pickedQuestions.length;
-                                totalscore = totalscore + pickedQuestions.length * ITEM_SCORE[key];
-                            }
-                        }
-                        //subarray.splice(0, 1);  ///把第一个角色定位的问法删除
-                        // subarray.splice(subarray.length - 1, 1);  ///把第一个角色定位的问法删除
-                    }
-                }
-                ////删除已经处理的文本
-                arrContent.splice(0, MESSAGE_LENGTH);
-            }
-            console.log('parseover');
-            ///发出信号，解析完毕
-            this.emit('parseover', { type: 'question', items: paperReturned });
-            return { successed: true, score: totalscore, paper: paperReturned };
-        });
-    }
-    /**
-     * 从答复中得到题目
-     * @param {*} result
-     *
-     */
-    pickUpQuestions(result, count, questiontype, score = 1) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!((_b = (_a = result[0]) === null || _a === void 0 ? void 0 : _a.message) === null || _b === void 0 ? void 0 : _b.content))
-                return [];
-            let answerString = result[0].message.content.trim().replace(/\t|\n|\v|\r|\f/g, '');
-            if (answerString === '[]')
-                return [];
-            let jsonObj = this.fixedJsonString(answerString);
-            ////修复的结果无法用程序修复，请求GPT来分析修复一下这个结果
-            if (!jsonObj.length) {
-                let fixedAsk = [
-                    { role: 'system', content: '角色扮演：假设你是一位高级JSON数据分析师' },
-                    { role: 'user', content: `请分析以下内容，严格按照${QUESTION_PROMPT_FIXED[questiontype]}的标准JSON数组结构输出。如果内容不足以提取问题和答案，请直接输出JSON空数组，无需提供参考。` },
-                    { role: 'user', content: answerString },
-                ];
-                console.log('fixedAsk', fixedAsk);
-                let fixedJsonResult = yield this.chatRequest(fixedAsk, { replyCounts: 1 }, {});
-                if (fixedJsonResult.successed) {
-                    answerString = fixedJsonResult.message[0].message.content.trim().replace(/\t|\n|\v|\r|\f/g, '');
-                    jsonObj = this.fixedJsonString(answerString);
-                }
-                if (!jsonObj.length)
-                    return [];
-            }
-            let returnItems = [];
-            try {
-                // let jsonObj = JSON.parse(answerString);
-                returnItems = jsonObj.map((questionitem) => {
-                    console.log('answer item from jsonObj', questionitem);
-                    if (questionitem.choice && Array.isArray(questionitem.choice) && questiontype != 'completion') {
-                        questionitem.fullanswer = (questionitem.answer + '').replace(/,|[^ABCDE]/g, '');
-                        questionitem.score = score;
-                        if (questionitem.choice) {
-                            questionitem.choice = questionitem.choice.map((item, index) => {
-                                let seqNo = 'ABCDEFG'[index]; //String.fromCharCode(65 + index);
-                                let correctReg = new RegExp(`${seqNo}.|${seqNo}`, 'ig');
-                                // console.log('itemitemitem', item)
-                                //let answer = jsonObj.fullanswer
-                                return {
-                                    id: seqNo,
-                                    content: (item + '').replace(correctReg, '').trim(),
-                                    iscorrect: (questionitem.fullanswer || '').indexOf(seqNo) >= 0 ? 1 : 0
-                                    //|| jsonObj.fullanswer.indexOf(m))
-                                };
-                            });
-                        }
-                        ///如果是非判断题，题目的选项数量小于2 ，则无效
-                        ///如果是判断题，题目的选项必须=2
-                        if (!questionitem.choice || (questiontype != 'trueorfalse' && questionitem.choice.length < 3) || (questiontype == 'trueorfalse' && questionitem.choice.length != 2)) {
-                            return null;
-                        }
-                    }
-                    switch (questiontype) {
-                        case 'singlechoice':
-                            questionitem.answer = (questionitem.answer + '').replace(/,|[^ABCDEFG]/g, '').split('').slice(0, 1);
-                            break;
-                        case 'multiplechoice':
-                            questionitem.answer = Array.from(new Set((questionitem.answer + '').replace(/,|[^ABCDEFG]/g, '').split('')));
-                            break;
-                        case 'trueorfalse':
-                            let rightItem = questionitem.choice.find((x) => { return x.iscorrect == 1; });
-                            questionitem.answer = [(rightItem === null || rightItem === void 0 ? void 0 : rightItem.id) || 'Z']; //[(questionitem.answer + '').indexOf('正确') >= 0 ? 'A' : 'B']
-                            break;
-                    }
-                    ///单选题验证
-                    if (questiontype == 'singlechoice') {
-                        let rightAnswer = questionitem.choice ? questionitem.choice.filter((item) => { return item.iscorrect === 1; }) : [];
-                        ///单选题的正确选项大于了1个
-                        if (rightAnswer.length != 1 || !questionitem.answer || questionitem.answer.length !== 1)
-                            return null;
-                        ///正确选项和答案不一致
-                        if (rightAnswer[0].id.toUpperCase() != (questionitem.answer[0] || '').toUpperCase())
-                            return null;
-                    }
-                    ///多选题验证
-                    if (questiontype == 'multiplechoice') {
-                        let rightAnswer = questionitem.choice ? questionitem.choice.filter((item) => { return item.iscorrect === 1; }) : [];
-                        ///单选题的正确选项大于了1个
-                        if (rightAnswer.length === 0 || !questionitem.answer || questionitem.answer.length === 0)
-                            return null;
-                    }
-                    ///判断题验证:防止没有答案的
-                    if (questiontype == 'trueorfalse' && !questionitem.answer.length)
-                        return null;
-                    return questionitem;
-                });
-            }
-            catch (err) {
-                console.log('error happened:', err);
-            }
-            return returnItems.filter(i => { return i != null; }).slice(0, count);
-        });
-    }
-    /**
-     * 验证JSON字符串是否是真正可转换为JSON的合法格式
-     * 这里只能做一个最简单的处理，就是用两端的符号
-     * @param jsonstr
-     */
-    fixedJsonString(jsonstr) {
-        console.log('original json string:', jsonstr);
-        ///检查返回的是不是一个数组对象（我们需要的是数组对象)
-        let firstBracketSymbol = jsonstr.indexOf("["); ////必须过滤出来数组
-        let lastBracketSymbol = jsonstr.lastIndexOf("]");
-        ///第一个花括号出现的位置，如果花括号出现的位置早于 [ ,则默认返回的对象不是一个数组，仅仅是一个对象，
-        ///则需要我们用中括号包住
-        let firstBraceSymbol = jsonstr.indexOf("{");
-        let lastBraceSymbol = jsonstr.lastIndexOf("}");
-        ///返回的不是一个数组结构的,只是一个{}，我们帮他完成数组拼接
-        if (firstBraceSymbol >= 0 &&
-            firstBraceSymbol < (firstBracketSymbol >= 0 ? firstBracketSymbol : 1000) &&
-            lastBraceSymbol > firstBraceSymbol &&
-            lastBraceSymbol >= 0 && lastBraceSymbol > lastBracketSymbol) {
-            jsonstr = '[' + jsonstr.substr(firstBraceSymbol, lastBraceSymbol - firstBraceSymbol + 1);
-            +']';
-            firstBracketSymbol = 0;
-            lastBracketSymbol = jsonstr.length - 1;
-        }
-        else if (firstBracketSymbol < 0 || lastBracketSymbol < 0 || lastBracketSymbol <= firstBracketSymbol) {
-            return [];
-        }
-        jsonstr = jsonstr.substr(firstBracketSymbol, lastBracketSymbol - firstBracketSymbol + 1);
-        ///尽量处理一些能够一眼识别出来的JSON错误
-        jsonstr = jsonstr.replace(/}{/g, '},{');
-        let mutilitems = jsonstr.split('][');
-        ///确实存在多个数组拼接在一起，中间没有逗号隔开的了
-        let retObject = [];
-        for (let str of mutilitems) {
-            if (!str.startsWith('['))
-                str = '[' + str;
-            if (!str.endsWith(']'))
-                str = str + ']';
-            // console.log('json str', str)
-            try {
-                let jsonObj = eval(str);
-                retObject = retObject.concat(jsonObj);
-            }
-            catch (err) {
-                console.log('json error', str);
-            }
-        }
-        return retObject;
-    }
-    /**
-     * 将一段很长的文本，按1024长度来划分到多个中
-     * @param {*} content
-     */
-    splitLongText(content, len = SECTION_LENGTH) {
-        let start = 0, message = [], length = content.length;
-        while (start < length) {
-            let realLength = len;
-            ////以句号或引号进行分段，不要随意截取
-            for (let i = start + len; i >= start; i--) {
-                if (/[。”"?？]/.test(content[i] + '')) {
-                    realLength = i - start + 1;
-                    break;
-                }
-            }
-            const subtext = content.substr(start, realLength).replace(/\t|\n|\v|\r|\f/g, '');
-            if (subtext)
-                message.push(subtext); //message.push({ role: 'user', content: subtext })
-            start += realLength || len;
-        }
-        return message;
-    }
 }
 exports.default = OpenAIGpt;