doomiaichat 4.9.0 → 5.1.0

package/src/openai.ts

@@ -1,81 +1,17 @@
 import { Configuration, OpenAIApi, ChatCompletionRequestMessage } from "azure-openai"
-// 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 = 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: any = {
-    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: any ={
-    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: any = {
-    singlechoice: '[{"question":"","choice":[],"answer":[]}]',
-    multiplechoice: '[{"question":"","choice":[],"answer":[]}]',
-    trueorfalse: '[{"question":"","choice":["A.正确","B.错误"],"answer":[]}]',
-    completion: '[{"question":"","answer":["填空答案1","填空答案2"]}]'
-}
-const QUESTION_TYPE: string[] = ['singlechoice', 'multiplechoice', 'trueorfalse', 'completion']
+import { OpenAIApiParameters, ChatReponse, EmbeddingResult } from './declare'
 
 export default class OpenAIGpt extends GptBase {
     protected readonly apiKey: string;
     protected aiApi: OpenAIApi | undefined;
     protected readonly chatModel: string;
     protected readonly maxtoken: number;
+    protected readonly top_p: number;
+    protected readonly presence_penalty:number;
+    protected readonly frequency_penalty: number;
     protected readonly temperature: number;
-    protected readonly embeddingmodel:string;       
+    protected readonly embeddingmodel: string;
     /**
      * 
      * @param apiKey 调用OpenAI 的key
@@ -87,7 +23,10 @@ export default class OpenAIGpt extends GptBase {
         this.apiKey = apiKey;
         this.chatModel = apiOption.model || 'gpt-3.5-turbo';
         this.maxtoken = apiOption.maxtoken || 2048;
+        this.top_p = apiOption.top_p || 0.95;
         this.temperature = apiOption.temperature || 0.9;
+        this.presence_penalty = apiOption.presence_penalty || 0;
+        this.frequency_penalty = apiOption.frequency_penalty || 0;
         this.embeddingmodel = apiOption.embedding || 'text-embedding-ada-002';
     }
     /**
@@ -101,13 +40,13 @@ export default class OpenAIGpt extends GptBase {
      * 获得文字的向量
      * @param text 
      */
-    override async getTextEmbedding(text: string, axiosOption: any): Promise<EmbeddingResult>{
+    override async getTextEmbedding(text: string, axiosOption: any): Promise<EmbeddingResult> {
         if (!text) return { successed: false, error: { errcode: 2, errmsg: 'content required' } };
         if (!this.aiApi) {
             this.aiApi = this.createOpenAI(this.apiKey);
         }
         try {
-            const response:any = await this.aiApi.createEmbedding({
+            const response: any = await this.aiApi.createEmbedding({
                 model: this.embeddingmodel,
                 input: text,
             }, axiosOption);
@@ -132,18 +71,21 @@ export default class OpenAIGpt extends GptBase {
             [{ role: 'user', content: chatText }] : chatText;
         // console.log('message', message)
         try {
-            const response:any = await this.aiApi.createChatCompletion({
+            const response: any = await this.aiApi.createChatCompletion({
                 model: callChatOption?.model || this.chatModel,
                 messages: message,
                 temperature: Number(callChatOption?.temperature || this.temperature),
                 max_tokens: Number(callChatOption?.maxtoken || this.maxtoken),
+                top_p: Number(callChatOption?.top_p || this.top_p), 
+                presence_penalty: Number(callChatOption?.presence_penalty || this.presence_penalty), 
+                frequency_penalty: Number(callChatOption?.frequency_penalty || this.frequency_penalty), 
                 n: Number(callChatOption?.replyCounts || 1) || 1
             }, axiosOption);
             // console.log('finish_reason==>', response.data.choices)
             ////输出的内容不合规
-            if (response.data.choices[0].finish_reason ==='content_filter') {
+            if (response.data.choices[0].finish_reason === 'content_filter') {
                 console.log('content_filter')
-                return { successed: false, error:'content_filter'}
+                return { successed: false, error: 'content_filter' }
             }
             return { successed: true, message: response.data.choices, usage: response.data.usage };
         } catch (error) {
@@ -158,55 +100,65 @@ export default class OpenAIGpt extends GptBase {
      * @param _paramOption 
      * @param axiosOption 
      */
-    override async chatRequestInStream(chatText: string | Array<any>, callChatOption: OpenAIApiParameters, attach?: any, axiosOption?: any):Promise<any>{
-        if (!chatText) this.emit('chaterror', { successed: false, error:'no text in chat'});
+    override async chatRequestInStream(chatText: string | Array<any>, callChatOption: OpenAIApiParameters, attach?: any, axiosOption?: any): Promise<any> {
+        if (!chatText) this.emit('chaterror', { successed: false, error: 'no text in chat' });
         if (!this.aiApi) {
             this.aiApi = this.createOpenAI(this.apiKey);
         }
+        // const DATA_END_TAG = `"usage":null}`
         let message: Array<ChatCompletionRequestMessage> = 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:any = null,usage:any = null;
+            let finishreason: any = null, usage: any = null,errtxt = '';
             ///便于知道返回的requestid
             // console.log('model', callChatOption?.model || this.chatModel,)
             const response: any = await this.aiApi.createChatCompletion({
                 model: callChatOption?.model || this.chatModel,
                 messages: message,
-                stream:true,
+                stream: true,
+                top_p: Number(callChatOption?.top_p || this.top_p),
+                presence_penalty: Number(callChatOption?.presence_penalty || this.presence_penalty),
+                frequency_penalty: Number(callChatOption?.frequency_penalty || this.frequency_penalty), 
                 temperature: Number(callChatOption?.temperature || this.temperature),
                 max_tokens: Number(callChatOption?.maxtoken || this.maxtoken)
             }, axiosOption);
-            let replytext:string[] = [];
-           
-            response.data.on('data', (data:any) => {
-                const lines = data.toString().split('\n').filter((line:string) => line.trim() !== '');
+            let replytext: string[] = [];
+
+            response.data.on('data', (data: any) => {
+                const lines = data.toString().split('\n').filter((line: string) => line.trim() !== '');
                 ///已经返回了结束原因
                 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);
+                        if (attach) output = Object.assign({}, output, attach);
                         this.emit('chatdone', output)
                         return; // Stream finished
                     }
                     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;
                         replytext.push(streamtext);
                         let output = { successed: true, requestid, text: replytext.join(''), finish_reason: finishreason, index: parsed.choices[0].index, usage };
-                        if (attach) output = Object.assign({},output, attach);
-                        this.emit(finishreason ? 'chatdone':'chattext', output )
+                        if (attach) output = Object.assign({}, output, attach);
+                        this.emit(finishreason ? 'chatdone' : 'chattext', output)
                         if (finishreason) 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 });
                     }
                 }
             });
@@ -217,489 +169,521 @@ export default class OpenAIGpt extends GptBase {
         }
     }
 
-    /**
-     * 点评问题回答的评价
-     * @param question 
-     * @param answer 
-     * @param axiosOption 
-     */
-    override async commentQuestionAnswer(question: string, answer: string, axiosOption: any = { timeout: 30000 }): Promise<CommentResult>{
-        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 = await 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 { 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 
-     */
-    override async getScentenceEmotional(s1: string, axiosOption: any = { timeout: 30000 }): Promise<EmotionResult> {
-        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 = await 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 question 
+    //  * @param answer 
+    //  * @param axiosOption 
+    //  */
+    // override async commentQuestionAnswer(question: string, answer: string, axiosOption: any = { timeout: 30000 }): Promise<CommentResult> {
+    //     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 = await 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 { 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 
+    //  */
+    // override async getScentenceEmotional(s1: string, axiosOption: any = { timeout: 30000 }): Promise<EmotionResult> {
+    //     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 = await 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 
-     */
-    override async getScentenseSimilarity(s1: string, s2: string, axiosOption: any = { timeout: 30000 }): Promise<SimilarityResult> {
-        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 = await 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 {*} s1 
+    //  * @param {*} s2 
+    //  */
+    // override async getScentenseSimilarity(s1: string, s2: string, axiosOption: any = { timeout: 30000 }): Promise<SimilarityResult> {
+    //     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 = await 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 
-     */
-    override async getSimilarityContent(content: string, count: number = 1, axiosOption: any = {}): Promise<ChatReponse> {
-        let chnReg: boolean = /([\u4e00-\u9fa5]|[\ufe30-\uffa0])/.test(content)  ///检查源话是否含有中文内容
-        let engReg: boolean = /[a-zA-Z]/.test(content)  ///检查源话是否含有英文内容
-        ///如果源话是全中文，那么结果中不应该出来英文的相似说法，如果源话是全英文，则结果不能出现全中文的说法
-        let prefix = (!chnReg && engReg) ? '请用完整的英文表达,' : ((chnReg && !engReg) ? '请用完整的中文表达,' : '')
-        const text = `${prefix}生成与下面句子意思相同的内容"${content}"`
-        let result = await 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 
-     */
-    override async getSummaryOfContent(content: string | Array<any>, axiosOption: any = {}): Promise<SummaryReponse> {
-        let arrContent:any[] =[]; 
-        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: Array<OutlineSummaryItem> = [];
-        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 = await 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 
-     *///并在答案末尾处必须给出答案内容中的关键词
-    override async generateQuestionsFromContent(content: string, count: number = 1, everyContentLength: number = SECTION_LENGTH, axiosOption: any = {}): Promise<ChatReponse> {
-        let arrContent = this.splitLongText(content, everyContentLength || SECTION_LENGTH);
-        ///如果最后一段的文字内容过短，则把最后一段内容追加到前一段中，并删除最后一段
-        let totalLen = arrContent.length;
-        if (totalLen>=2 && (arrContent[totalLen-1]?.length||0)<100){
-            arrContent[totalLen - 2] +=  arrContent[totalLen - 1];
-            arrContent.splice(totalLen-1,1);                
-        }
-        ///没20句话分为一组，适应大文件内容多次请求组合结果
-        ///每一句话需要产生的题目
-        let questions4EverySentense: number = count / arrContent.length; //Math.ceil(arrContent.length / 20);
-        let faqs: FaqItem[] = [], gotted: number = 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 = await this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
-            ///如果请求发生了网络错误(不是内容合规问题），则再重试一次，如果任然有错则放弃
-            if (!result.successed && result.error!='content_filter'){
-                console.log('network error,retry onemore time')
-                result = await this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
-            }
-            if (result.successed && result.message) {
-                let msgs = await 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) };
-    }
+    // /**
+    //   * 获得一种内容的相似说法
+    //  * 比如：
+    //  * 你今年多大？
+    //  * 相似问法：您是哪一年出生的
+    //  * 您今年贵庚？
+    //  * @param {*} content 
+    //  * @param {需要出来的数量} count 
+    //  */
+    // override async getSimilarityContent(content: string, count: number = 1, axiosOption: any = {}): Promise<ChatReponse> {
+    //     let chnReg: boolean = /([\u4e00-\u9fa5]|[\ufe30-\uffa0])/.test(content)  ///检查源话是否含有中文内容
+    //     let engReg: boolean = /[a-zA-Z]/.test(content)  ///检查源话是否含有英文内容
+    //     ///如果源话是全中文，那么结果中不应该出来英文的相似说法，如果源话是全英文，则结果不能出现全中文的说法
+    //     let prefix = (!chnReg && engReg) ? '请用完整的英文表达,' : ((chnReg && !engReg) ? '请用完整的中文表达,' : '')
+    //     const text = `${prefix}生成与下面句子意思相同的内容"${content}"`
+    //     let result = await 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 
+    //  */
+    // override async getSummaryOfContent(content: string | Array<any>, axiosOption: any = {}): Promise<SummaryReponse> {
+    //     let arrContent: any[] = [];
+    //     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: Array<OutlineSummaryItem> = [];
+    //     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 = await 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 
+    //  *///并在答案末尾处必须给出答案内容中的关键词
+    // override async generateQuestionsFromContent(content: string, count: number = 1, everyContentLength: number = SECTION_LENGTH, axiosOption: any = {}): Promise<ChatReponse> {
+    //     let arrContent = this.splitLongText(content, everyContentLength || SECTION_LENGTH);
+    //     ///如果最后一段的文字内容过短，则把最后一段内容追加到前一段中，并删除最后一段
+    //     let totalLen = arrContent.length;
+    //     if (totalLen >= 2 && (arrContent[totalLen - 1]?.length || 0) < 100) {
+    //         arrContent[totalLen - 2] += arrContent[totalLen - 1];
+    //         arrContent.splice(totalLen - 1, 1);
+    //     }
+    //     ///没20句话分为一组，适应大文件内容多次请求组合结果
+    //     ///每一句话需要产生的题目
+    //     let questions4EverySentense: number = count / arrContent.length; //Math.ceil(arrContent.length / 20);
+    //     let faqs: FaqItem[] = [], gotted: number = 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 = await this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
+    //         ///如果请求发生了网络错误(不是内容合规问题），则再重试一次，如果任然有错则放弃
+    //         if (!result.successed && result.error != 'content_filter') {
+    //             console.log('network error,retry onemore time')
+    //             result = await this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
+    //         }
+    //         if (result.successed && result.message) {
+    //             let msgs = await 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 
-     */
-    protected async pickUpFaqContent(messages: Array<any>): Promise<Array<FaqItem>> {
-        if (!messages[0]?.message?.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: any = await 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: FaqItem) => {
-                let realKeyword: string[] = [];
-                let keywords: string[] = (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 [];
-        }
-    }
+    // /**
+    //  * 解析Faq返回的问题
+    //  * @param {*} messages 
+    //  * @returns 
+    //  */
+    // protected async pickUpFaqContent(messages: Array<any>): Promise<Array<FaqItem>> {
+    //     if (!messages[0]?.message?.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: any = await 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 []
+    //     }
 
-    /**
-     * 从指定的文本内容中生成一张试卷
-     * @param {*} content 
-     * @param {试卷的参数} paperOption 
-     * totalscore: 试卷总分，默认100
-     * section: {type:[0,1,2,3]为单选、多选、判断、填空题型  count:生成多少道  score:本段分数} 
-     * @param {*} axiosOption 
-     * @returns 
-     *///并在答案末尾处必须给出答案内容中的关键词
-    override async generateExaminationPaperFromContent(content: string, paperOption: any = {}, everyContentLength: number = SECTION_LENGTH, axiosOption: any = {}): Promise<ExaminationPaperResult> {
-        let arrContent = this.splitLongText(content, everyContentLength || SECTION_LENGTH);
-        ///如果最后一段的文字内容过短，则把最后一段内容追加到前一段中，并删除最后一段
-        let totalLen = arrContent.length;
-        if (totalLen >= 2 && (arrContent[totalLen - 1]?.length || 0) < 100) {
-            arrContent[totalLen - 2] += arrContent[totalLen - 1];
-            arrContent.splice(totalLen - 1, 1);
-        }
-        let sectionCount: any = {
-            singlechoice: (paperOption.singlechoice?.count || 0) / arrContent.length,
-            multiplechoice: (paperOption.multiplechoice?.count || 0) / arrContent.length,
-            trueorfalse: (paperOption.trueorfalse?.count || 0) / arrContent.length,
-            completion: (paperOption.completion?.count || 0) / arrContent.length
-        };
-        ///剩余待生成的题目数量
-        let remainCount: any = {
-            singlechoice: paperOption.singlechoice?.count || 0,
-            multiplechoice: paperOption.multiplechoice?.count || 0,
-            trueorfalse: paperOption.trueorfalse?.count || 0,
-            completion: paperOption.completion?.count || 0
-        };
-        ///每种类型的题目的分数
-        let ITEM_SCORE: any = {
-            singlechoice: paperOption.singlechoice?.score || 0,
-            multiplechoice: paperOption.multiplechoice?.score || 0,
-            trueorfalse: paperOption.trueorfalse?.score || 0,
-            completion: paperOption.completion?.score || 0
-        };
-        ///最后生成出来的结果
-        let paperReturned: any = {
-            singlechoice: [], multiplechoice: [], trueorfalse: [], completion: []
 
-        }, noMoreQuestionRetrive: boolean = false, totalscore: number = 0;
+    //     try {
+    //         //let jsonObj = JSON.parse(answerString);
+    //         //let jsonObj = eval(answerString);
+    //         jsonObj.map((item: FaqItem) => {
+    //             let realKeyword: string[] = [];
+    //             let keywords: string[] = (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 [];
+    //     }
+    // }
 
-        while (arrContent.length > 0 && !noMoreQuestionRetrive) {
-            ////每次最多送MESSAGE_LENGTH句话给openai
-            /**
-             * 每种类型的题目进行遍历
-             */
-            noMoreQuestionRetrive = true;
-            for (const key of QUESTION_TYPE) {
-                ///还需要抓取题目
-                if (remainCount[key] > 0) {
-                    noMoreQuestionRetrive = false;
+    // /**
+    //  * 从指定的文本内容中生成一张试卷
+    //  * @param {*} content 
+    //  * @param {试卷的参数} paperOption 
+    //  * totalscore: 试卷总分，默认100
+    //  * section: {type:[0,1,2,3]为单选、多选、判断、填空题型  count:生成多少道  score:本段分数} 
+    //  * @param {*} axiosOption 
+    //  * @returns 
+    //  *///并在答案末尾处必须给出答案内容中的关键词
+    // override async generateExaminationPaperFromContent(content: string, paperOption: any = {}, everyContentLength: number = SECTION_LENGTH, axiosOption: any = {}): Promise<ExaminationPaperResult> {
+    //     let arrContent = this.splitLongText(content, everyContentLength || SECTION_LENGTH);
+    //     ///如果最后一段的文字内容过短，则把最后一段内容追加到前一段中，并删除最后一段
+    //     let totalLen = arrContent.length;
+    //     if (totalLen >= 2 && (arrContent[totalLen - 1]?.length || 0) < 100) {
+    //         arrContent[totalLen - 2] += arrContent[totalLen - 1];
+    //         arrContent.splice(totalLen - 1, 1);
+    //     }
+    //     let sectionCount: any = {
+    //         singlechoice: (paperOption.singlechoice?.count || 0) / arrContent.length,
+    //         multiplechoice: (paperOption.multiplechoice?.count || 0) / arrContent.length,
+    //         trueorfalse: (paperOption.trueorfalse?.count || 0) / arrContent.length,
+    //         completion: (paperOption.completion?.count || 0) / arrContent.length
+    //     };
+    //     ///剩余待生成的题目数量
+    //     let remainCount: any = {
+    //         singlechoice: paperOption.singlechoice?.count || 0,
+    //         multiplechoice: paperOption.multiplechoice?.count || 0,
+    //         trueorfalse: paperOption.trueorfalse?.count || 0,
+    //         completion: paperOption.completion?.count || 0
+    //     };
+    //     ///每种类型的题目的分数
+    //     let ITEM_SCORE: any = {
+    //         singlechoice: paperOption.singlechoice?.score || 0,
+    //         multiplechoice: paperOption.multiplechoice?.score || 0,
+    //         trueorfalse: paperOption.trueorfalse?.score || 0,
+    //         completion: paperOption.completion?.score || 0
+    //     };
+    //     ///最后生成出来的结果
+    //     let paperReturned: any = {
+    //         singlechoice: [], multiplechoice: [], trueorfalse: [], completion: []
 
-                    //let itemCount = Math.min(remainCount[key], Math.ceil(subarray.length * sectionCount[key]));
-                    let itemCount = Math.min(remainCount[key], Math.ceil(sectionCount[key]));
-                    let subarray:any[] = [
-                            { 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 = await this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
-                    ///如果请求发生了网络错误(不是内容合规问题），则再重试一次，如果任然有错则放弃
-                    if (!result.successed && result.error != 'content_filter') {
-                        console.log('network error,retry onemore time')
-                        result = await 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 = await 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
-     * 
-     */
-    protected async pickUpQuestions(result: Array<any>, count: number, questiontype: string, score: number = 1): Promise<Array<QuestionItem>> {
-        if (!result[0]?.message?.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:any  =await 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: QuestionItem[] = [];
-        try {
-            // let jsonObj = JSON.parse(answerString);
-            returnItems = jsonObj.map((questionitem: any) => {
-                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: string, index: number) => {
-                            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;
-                    }
+    //     }, noMoreQuestionRetrive: boolean = false, totalscore: number = 0;
 
-                }
-                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: any) => { return x.iscorrect == 1 });
-                        questionitem.answer = [rightItem?.id || 'Z'] ;   //[(questionitem.answer + '').indexOf('正确') >= 0 ? 'A' : 'B']
-                        break;
-                }
-                ///单选题验证
-                if (questiontype == 'singlechoice') {
-                    let rightAnswer = questionitem.choice ? questionitem.choice.filter((item: { iscorrect: number; }) => { 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: { iscorrect: number; }) => { 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;
+    //     while (arrContent.length > 0 && !noMoreQuestionRetrive) {
+    //         ////每次最多送MESSAGE_LENGTH句话给openai
+    //         /**
+    //          * 每种类型的题目进行遍历
+    //          */
+    //         noMoreQuestionRetrive = true;
+    //         for (const key of QUESTION_TYPE) {
+    //             ///还需要抓取题目
+    //             if (remainCount[key] > 0) {
+    //                 noMoreQuestionRetrive = false;
 
-                return questionitem;
-            })
-        } catch (err) {
-            console.log('error happened:', err);
-        }
-        return returnItems.filter(i => { return i != null; }).slice(0, count);
-    }
-    /**
-     * 验证JSON字符串是否是真正可转换为JSON的合法格式
-     * 这里只能做一个最简单的处理，就是用两端的符号
-     * @param jsonstr 
-     */
-    protected fixedJsonString(jsonstr: string): any[] {
-        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){
+    //                 //let itemCount = Math.min(remainCount[key], Math.ceil(subarray.length * sectionCount[key]));
+    //                 let itemCount = Math.min(remainCount[key], Math.ceil(sectionCount[key]));
+    //                 let subarray: any[] = [
+    //                     { role: 'system', content: QUESTION_ROLE_DEFINE[key] },
+    //                     { role: 'user', content: QUESTION_PROMPT[key].replace('@ITEMCOUNT@', itemCount).replace('@CONTENT@', arrContent.slice(0, 1)[0]) },
+    //                     // { role: 'user', content:`出题材料：${arrContent.slice(0, 1)[0]}`}
+    //                 ]
+    //                 // subarray.unshift()
+    //                 console.log('subarray', subarray)
+    //                 let result = await this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
+    //                 ///如果请求发生了网络错误(不是内容合规问题），则再重试一次，如果任然有错则放弃
+    //                 if (!result.successed && result.error != 'content_filter') {
+    //                     console.log('network error,retry onemore time')
+    //                     result = await this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
+    //                 }
+    //                 console.log('subarray returned', result.successed)
+    //                 if (result.successed && result.message) {
+    //                     ///以下再次验证好像没有什么效果，暂时取消
+    //                     // subarray.push(
+    //                     //     {role: 'assistant', content: result.message[0].message.content},
+    //                     //     {role: 'user', content:`请将上述结果，结合出题材料再次进行验证，结果必须满足问题对应的正确答案必须在出题材料中完整且一字不差连续出现，如出现不满足的情况，请再次修正直到问题对应的正确答案必须在出题材料中完整且一字不差连续出现为止，最终按照结果要求输出后输出`
+    //                     // })
+    //                     // console.log('subarray reask', subarray)
+    //                     // result = await this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
+    //                     // if (result.successed && result.message){
+    //                     //console.log('paper result', key, result.message.length)
+    //                     let pickedQuestions = await 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];
 
-            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:any[] = [];
-        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;
-    }
+    //                         console.log('start sleep', new Date().getTime())
+    //                         await this.sleep(30);
+    //                         console.log('do check', new Date().getTime())
+    //                         let allItemInfo = pickedQuestions.map((q: QuestionItem, idx: number) => { return `\r\n(${idx + 1}).` + q.question + '\n选项\n' + q.choice?.map(c => { return `(${c.id}) ${c.content}`; }).join('\n'); }).join('\n');
+    //                         console.log('allItemInfo', allItemInfo)
+    //                         let prmopt = [{
+    //                             role: 'user',
+    //                             content: `请根据内容，完成以下题目作答,最终结果标准JSON数组并按照[{"seq":serialnumber,"answer":[正确答案]}]的结构输出。
+    //                         \n内容："${arrContent.slice(0, 1)[0]}"
+    //                             \r\n${QUESTION_TYPE_TITLE[key]}\r\n${allItemInfo}`
+    //                         }];
+    //                         let checkResult = await this.chatRequest(prmopt, { replyCounts: 1 }, axiosOption);
+    //                         if (checkResult.successed && checkResult.message) {
+    //                             console.log("出题试卷答案:", pickedQuestions.map((oq, on) => {
+    //                                 return `(${on + 1}).` + oq.question + '  答案 : ' + oq.answer + ''
+    //                             }).join('\n'))
+    //                             console.log("复查后的答案:", checkResult.message[0].message.content.trim())
+    //                         }
+    //                         await this.sleep(30);
+    //                     }
+    //                 }
+    //                 //subarray.splice(0, 1);  ///把第一个角色定位的问法删除
+    //                 // subarray.splice(subarray.length - 1, 1);  ///把第一个角色定位的问法删除
+    //             }
+    //         }
 
-    /**
-     * 将一段很长的文本，按1024长度来划分到多个中
-     * @param {*} content 
-     */
-    protected splitLongText(content: string, len = SECTION_LENGTH): string[]{ //Array<ChatCompletionRequestMessage> {
-        let start = 0, message: string[] = [], length = content.length;
-        while (start < length) {
+    //         ////删除已经处理的文本
+    //         arrContent.splice(0, MESSAGE_LENGTH);
+    //     }
+    //     console.log('parseover')
+    //     ///发出信号，解析完毕
+    //     this.emit('parseover', { type: 'question', items: paperReturned })
+    //     return { successed: true, score: totalscore, paper: paperReturned }
+    // }
+    // /**
+    //  * 从答复中得到题目
+    //  * @param {*} result
+    //  * 
+    //  */
+    // protected async pickUpQuestions(result: Array<any>, count: number, questiontype: string, score: number = 1): Promise<Array<QuestionItem>> {
+    //     if (!result[0]?.message?.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) {
+    //         console.log('Json格式有误，再次进行GPT修复', answerString);
+    //         let fixedAsk = [
+    //             { role: 'system', content: '角色扮演：假设你是一位高级JSON数据分析师' },
+    //             { role: 'user', content: `请分析以下内容，严格按照${QUESTION_PROMPT_FIXED[questiontype]}的标准JSON数组结构输出。如果内容不足以提取问题和答案，请直接输出JSON空数组，无需提供参考。` },
+    //             { role: 'user', content: answerString },
+    //         ]
+    //         let fixedJsonResult: any = await 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);
+    //         }
+    //         console.log('Json GPT修复 结果', fixedJsonResult.successed, answerString)
+    //         if (!jsonObj.length) return []
+    //     }
+    //     let returnItems: QuestionItem[] = [];
+    //     try {
+    //         // let jsonObj = JSON.parse(answerString);
+    //         returnItems = jsonObj.map((questionitem: any) => {
+    //             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: string, index: number) => {
+    //                         let seqNo = 'ABCDEFG'[index]; //String.fromCharCode(65 + index);
+    //                         let correctReg = new RegExp(`${seqNo}.|${seqNo}`, 'ig')
+    //                         return {
+    //                             id: seqNo,
+    //                             content: (item + '').replace(correctReg, '').trim(),
+    //                             iscorrect: (questionitem.fullanswer || '').indexOf(seqNo) >= 0 ? 1 : 0
+    //                         }
+    //                     })
+    //                 }
+    //                 ///如果是非判断题，题目的选项数量小于2 ，则无效
+    //                 ///如果是判断题，题目的选项必须=2
+    //                 if (!questionitem.choice || (questiontype != 'trueorfalse' && questionitem.choice.length < 3) || (questiontype == 'trueorfalse' && questionitem.choice.length != 2)) {
+    //                     return null;
+    //                 }
 
-            let realLength: number = 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;
-    }
+    //             }
+    //             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(''))).sort();
+    //                     break;
+    //                 case 'trueorfalse':
+    //                     let rightItem = questionitem.choice.find((x: any) => { return x.iscorrect == 1 });
+    //                     questionitem.answer = [rightItem?.id || 'Z'];   //[(questionitem.answer + '').indexOf('正确') >= 0 ? 'A' : 'B']
+    //                     break;
+    //             }
+    //             ///单选题验证
+    //             if (questiontype == 'singlechoice') {
+    //                 let rightAnswer = questionitem.choice ? questionitem.choice.filter((item: { iscorrect: number; }) => { 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: { iscorrect: number; }) => { 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 
+    //  */
+    // protected fixedJsonString(jsonstr: string): any[] {
+    //     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: any[] = [];
+    //     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 
+    //  */
+    // protected splitLongText(content: string, len = SECTION_LENGTH): string[] { //Array<ChatCompletionRequestMessage> {
+    //     let start = 0, message: string[] = [], length = content.length;
+    //     while (start < length) {
+
+    //         let realLength: number = 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(/\s+/g, "").replace(/\t|\n|\v|\r|\f/g, ' ')
+    //         if (subtext) message.push(subtext); //message.push({ role: 'user', content: subtext })
+    //         start += realLength || len;
+    //     }
+    //     return message;
+    // }
+
+    // sleep(second: number) {
+    //     return new Promise(resolve => {
+    //         setTimeout(() => { resolve(true) }, second * 1000)
+    //     })
+    // }
 
 }