doomiaichat 4.6.0 → 4.8.0

package/dist/openai.d.ts

@@ -1,4 +1,4 @@
-import { OpenAIApi, ChatCompletionRequestMessage } from "azure-openai";
+import { OpenAIApi } from "azure-openai";
 import GptBase from "./gptbase";
 import { OpenAIApiParameters, ChatReponse, SummaryReponse, FaqItem, ExaminationPaperResult, EmotionResult, SimilarityResult, QuestionItem, CommentResult, EmbeddingResult } from './declare';
 export default class OpenAIGpt extends GptBase {
@@ -82,7 +82,7 @@ export default class OpenAIGpt extends GptBase {
      * @param {*} messages
      * @returns
      */
-    protected pickUpFaqContent(messages: Array<any>): Array<FaqItem>;
+    protected pickUpFaqContent(messages: Array<any>): Promise<Array<FaqItem>>;
     /**
      * 从指定的文本内容中生成一张试卷
      * @param {*} content
@@ -97,7 +97,7 @@ export default class OpenAIGpt extends GptBase {
      * @param {*} result
      *
      */
-    protected pickUpQuestions(result: Array<any>, count: number, questiontype: string, score?: number): Array<QuestionItem>;
+    protected pickUpQuestions(result: Array<any>, count: number, questiontype: string, score?: number): Promise<Array<QuestionItem>>;
     /**
      * 验证JSON字符串是否是真正可转换为JSON的合法格式
      * 这里只能做一个最简单的处理，就是用两端的符号
@@ -108,5 +108,5 @@ export default class OpenAIGpt extends GptBase {
      * 将一段很长的文本，按1024长度来划分到多个中
      * @param {*} content
      */
-    protected splitLongText(content: string, len?: number): Array<ChatCompletionRequestMessage>;
+    protected splitLongText(content: string, len?: number): string[];
 }

package/dist/openai.js

@@ -18,11 +18,65 @@ const gptbase_1 = __importDefault(require("./gptbase"));
 const SECTION_LENGTH = 1024; ///每2400个字符分成一组
 const MESSAGE_LENGTH = 1; ///每次送8句话给openai 进行解析，送多了，会报错
 //请将答案放在最后,标记为答案：()
-const QUESTION_TEXT_MAPPING = {
-    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 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":[]}]的结构输出',
+    multiplechoice: '根据以下内容,请生成@ITEMCOUNT@道多选题,提供4个选项,每道题的选项中的元素用大写字母ABCD开头,每道题的答案至少有两个选项,输出结果必须是JSON数组并按照[{"question":"","choice":[],"answer":[]}]的结构输出',
+    trueorfalse: '根据以下内容,请生成@ITEMCOUNT@道判断题,每道题正确和错误两个选项，输出结果必须是JSON数组并按照[{"question":"","choice":["A.正确","B.错误"],"answer":[]}]的结构输出',
+    completion: '根据以下内容,请生成@ITEMCOUNT@道填空题和对应答案,输出结果必须是JSON数组并按照[{"question":"","answer":["填空答案1","填空答案2"]}]的结构输出'
+};
+/**
+ * 问题生成的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 {
@@ -92,6 +146,12 @@ class OpenAIGpt extends gptbase_1.default {
                     max_tokens: Number((callChatOption === null || callChatOption === void 0 ? void 0 : callChatOption.maxtoken) || this.maxtoken),
                     n: Number((callChatOption === null || callChatOption === void 0 ? void 0 : callChatOption.replyCounts) || 1) || 1
                 }, axiosOption);
+                // console.log('finish_reason==>', response.data.choices)
+                ////输出的内容不合规
+                if (response.data.choices[0].finish_reason === 'content_filter') {
+                    console.log('content_filter');
+                    return { successed: false, error: 'content filter' };
+                }
                 return { successed: true, message: response.data.choices, usage: response.data.usage };
             }
             catch (error) {
@@ -287,7 +347,16 @@ class OpenAIGpt extends gptbase_1.default {
      */
     getSummaryOfContent(content, axiosOption = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const arrContent = typeof (content) == 'string' ? this.splitLongText(content) : content;
+            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);
@@ -327,16 +396,23 @@ class OpenAIGpt extends gptbase_1.default {
             while (arrContent.length > 0 && gotted < count) {
                 questions4EverySentense = (count - gotted) / arrContent.length;
                 ////每次最多送MESSAGE_LENGTH句话给openai
-                let subarray = arrContent.slice(0, 1);
-                let itemCount = Math.min(Math.ceil(subarray.length * questions4EverySentense), count - gotted);
+                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数组结构输出。` },
+                    { role: 'user', content: arrContent.slice(0, 1)[0]
+                    }
+                ];
+                console.log('Faq Question Pick Prompt:', subarray);
                 //subarray.push({ role: 'user', content:'请根据上述内容,给出一道提问与答案以及答案关键词，按照先问题内容，再标准答案，再关键词的顺序输出,关键词之间用、分开'})
-                subarray.unshift({ role: 'system', content: `你是一位专业培训师,从以下内容中提取${itemCount}条提问及答案，并从答案内容提取出至少2个关键词，最终结果按照[{"question":"提问内容","answer":"答案内容","keywords":["关键词1","关键词2"]}]的JSON数组结构输出。` });
+                //subarray.unshift({ role: 'system', content: `你是一位专业培训师,从以下内容中提取${itemCount}条提问及答案，并从答案内容提取出至少2个关键词，最终结果按照[{"question":"提问内容","answer":"答案内容","keywords":["关键词1","关键词2"]}]的JSON数组结构输出。` })
+                // subarray.unshift({role: 'system', content: FAQ_ROLE_DEFINE});
                 //subarray.unshift({ role: 'system', content: `你是一位专业程序开发工程师,根据以下内容,按照[{"question":"问题内容","answer":"答案内容","keywords":["关键词1","关键词2"]}]JSON数组结构,给出${itemCount}条提问问题及答案以及答案关键词` })
                 // console.log('subarray', subarray)
                 let result = yield this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
                 if (result.successed && result.message) {
                     // console.log('result is ', result.message[0].message.content)
-                    let msgs = this.pickUpFaqContent(result.message);
+                    let msgs = yield this.pickUpFaqContent(result.message);
                     if (msgs.length) {
                         ///对外发送检出问答题的信号
                         this.emit('parseout', { type: 'qa', items: msgs });
@@ -345,7 +421,7 @@ class OpenAIGpt extends gptbase_1.default {
                     }
                 }
                 ////删除已经处理的文本
-                arrContent.splice(0, 4);
+                arrContent.splice(0, 1);
             }
             arrContent = []; /// 释放内存
             ///发出信号，解析完毕
@@ -360,32 +436,47 @@ class OpenAIGpt extends gptbase_1.default {
      */
     pickUpFaqContent(messages) {
         var _a, _b;
-        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, '');
-        let 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);
+        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, '');
+            let jsonObj = this.fixedJsonString(answerString);
+            if (!jsonObj.length) {
+                let fixedAsk = [
+                    { role: 'system', content: '角色扮演：假设你是一位高级JSON数据分析师' },
+                    { role: 'user', content: `请分析以下内容，严格按照[{"question":"提问内容","answer":"答案内容","keywords":["关键词1","关键词2"]}]的标准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);
                 }
-                item.keywords = realKeyword;
-                return item;
-            });
-            return jsonObj;
-        }
-        catch (err) {
-            console.log('JSON error', err);
-            return [];
-        }
+                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 [];
+            }
+        });
     }
     /**
      * 从指定的文本内容中生成一张试卷
@@ -426,7 +517,6 @@ class OpenAIGpt extends gptbase_1.default {
             }, noMoreQuestionRetrive = false, totalscore = 0;
             while (arrContent.length > 0 && !noMoreQuestionRetrive) {
                 ////每次最多送MESSAGE_LENGTH句话给openai
-                let subarray = arrContent.slice(0, MESSAGE_LENGTH);
                 /**
                  * 每种类型的题目进行遍历
                  */
@@ -436,14 +526,20 @@ class OpenAIGpt extends gptbase_1.default {
                     ///还需要抓取题目
                     if (remainCount[key] > 0) {
                         noMoreQuestionRetrive = false;
-                        let itemCount = Math.min(remainCount[key], Math.ceil(subarray.length * sectionCount[key]));
-                        subarray.unshift({ role: 'system', content: QUESTION_TEXT_MAPPING[key].replace('@ITEMCOUNT@', itemCount) });
+                        //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);
                         console.log('subarray returned', result.successed);
                         if (result.successed && result.message) {
                             //console.log('paper result', key, result.message.length)
-                            let pickedQuestions = this.pickUpQuestions(result.message, itemCount, key, ITEM_SCORE[key]);
+                            let pickedQuestions = yield this.pickUpQuestions(result.message, itemCount, key, ITEM_SCORE[key]);
                             if (pickedQuestions.length) {
                                 ///对外发送检出题目的信号
                                 this.emit('parseout', { type: 'question', name: key, items: pickedQuestions });
@@ -452,7 +548,7 @@ class OpenAIGpt extends gptbase_1.default {
                                 totalscore = totalscore + pickedQuestions.length * ITEM_SCORE[key];
                             }
                         }
-                        subarray.splice(0, 1); ///把第一个角色定位的问法删除
+                        //subarray.splice(0, 1);  ///把第一个角色定位的问法删除
                         // subarray.splice(subarray.length - 1, 1);  ///把第一个角色定位的问法删除
                     }
                 }
@@ -472,76 +568,92 @@ class OpenAIGpt extends gptbase_1.default {
      */
     pickUpQuestions(result, count, questiontype, score = 1) {
         var _a, _b;
-        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, '');
-        let 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))
-                            };
-                        });
+        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, '');
+            let jsonObj = this.fixedJsonString(answerString);
+            ////修复的结果无法用程序修复，请求GPT来分析修复一下这个结果
+            if (!jsonObj.length) {
+                let fixedAsk = [
+                    { role: 'system', content: '角色扮演：假设你是一位高级JSON数据分析师' },
+                    { role: 'user', content: `请分析以下内容，严格按照${QUESTION_PROMPT_FIXED[questiontype]}的标准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;
+                        }
                     }
-                    ///如果是非判断题，题目的选项数量小于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 = (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;
                     }
-                }
-                switch (questiontype) {
-                    case 'singlechoice':
-                        questionitem.answer = (questionitem.answer + '').replace(/,|[^ABCDEFG]/g, '').split('').slice(0, 1);
-                        break;
-                    case 'multiplechoice':
-                        questionitem.answer = (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;
-                }
-                return questionitem;
-            });
-        }
-        catch (err) {
-            console.log('error happened:', err);
-        }
-        return returnItems.filter(i => { return i != null; }).slice(0, count);
+                    ///单选题验证
+                    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;
+                    }
+                    return questionitem;
+                });
+            }
+            catch (err) {
+                console.log('error happened:', err);
+            }
+            return returnItems.filter(i => { return i != null; }).slice(0, count);
+        });
     }
     /**
      * 验证JSON字符串是否是真正可转换为JSON的合法格式
@@ -607,9 +719,9 @@ class OpenAIGpt extends gptbase_1.default {
                     break;
                 }
             }
-            const subtext = content.substr(start, realLength);
+            const subtext = content.substr(start, realLength).replace(/\t|\n|\v|\r|\f/g, '');
             if (subtext)
-                message.push({ role: 'user', content: subtext });
+                message.push(subtext); //message.push({ role: 'user', content: subtext })
             start += realLength || len;
         }
         return message;

package/dist/stabilityplusai.js

@@ -31,7 +31,7 @@ class StabilityPlusAI extends stabilityai_1.default {
             try {
                 let param = Object.assign(Object.assign({}, axiosOption), { method: "post", url: `${paramOption.endpoint || this.apiSetting.endpoint}/sdapi/v1/txt2img`, data: {
                         "enable_hr": false,
-                        "denoising_strength": paramOption.denoising_strength || this.apiOption.denoising_strength || 0,
+                        "denoising_strength": paramOption.denoising_strength || this.apiOption.denoising_strength || 0.5,
                         "firstphase_width": 0,
                         "firstphase_height": 0,
                         "hr_scale": paramOption.hr_scale || this.apiOption.hr_scale || 2,
@@ -46,10 +46,10 @@ class StabilityPlusAI extends stabilityai_1.default {
                         "subseed_strength": 0,
                         "seed_resize_from_h": -1,
                         "seed_resize_from_w": -1,
-                        "sampler_name": paramOption.sampler || this.apiOption.sampler || "Euler",
+                        "sampler_name": paramOption.sampler || this.apiOption.sampler || "Euler a",
                         "batch_size": 1,
                         "n_iter": paramOption.samples || this.apiOption.samples || 1,
-                        "steps": paramOption.steps || this.apiOption.steps || 50,
+                        "steps": paramOption.steps || this.apiOption.steps || 20,
                         "cfg_scale": paramOption.cfg_scale || this.apiOption.cfg_scale || 7,
                         "width": paramOption.width || this.apiOption.width || 512,
                         "height": paramOption.height || this.apiOption.height || 512,
@@ -69,11 +69,11 @@ class StabilityPlusAI extends stabilityai_1.default {
                         // "save_images": false,
                         // "alwayson_scripts": {}
                     } });
-                console.log('param', param);
                 const response = yield (0, declare_1.request)(param);
                 if (response.successed) {
                     return { successed: true, type: 'image', data: response.data.images, };
                 }
+                console.log('response result ', response.data);
                 return Object.assign({ successed: false }, response.data);
             }
             catch (error) {

package/package.json

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

package/src/openai.ts

@@ -5,13 +5,68 @@ import { OpenAIApiParameters, ChatReponse, OutlineSummaryItem, SummaryReponse, F
 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 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":[]}]的结构输出',
+    multiplechoice: '根据以下内容,请生成@ITEMCOUNT@道多选题,提供4个选项,每道题的选项中的元素用大写字母ABCD开头,每道题的答案至少有两个选项,输出结果必须是JSON数组并按照[{"question":"","choice":[],"answer":[]}]的结构输出',
+    trueorfalse: '根据以下内容,请生成@ITEMCOUNT@道判断题,每道题正确和错误两个选项，输出结果必须是JSON数组并按照[{"question":"","choice":["A.正确","B.错误"],"answer":[]}]的结构输出',
+    completion: '根据以下内容,请生成@ITEMCOUNT@道填空题和对应答案,输出结果必须是JSON数组并按照[{"question":"","answer":["填空答案1","填空答案2"]}]的结构输出'
 }
 
+/**
+ * 问题生成的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']
 
 export default class OpenAIGpt extends GptBase {
@@ -84,6 +139,12 @@ export default class OpenAIGpt extends GptBase {
                 max_tokens: Number(callChatOption?.maxtoken || this.maxtoken),
                 n: Number(callChatOption?.replyCounts || 1) || 1
             }, axiosOption);
+            // console.log('finish_reason==>', response.data.choices)
+            ////输出的内容不合规
+            if (response.data.choices[0].finish_reason ==='content_filter') {
+                console.log('content_filter')
+                return {successed:false,error:'content filter'}
+            }
             return { successed: true, message: response.data.choices, usage: response.data.usage };
         } catch (error) {
             console.log('result is error ', error)
@@ -260,7 +321,15 @@ export default class OpenAIGpt extends GptBase {
      * @param axiosOption 
      */
     override async getSummaryOfContent(content: string | Array<any>, axiosOption: any = {}): Promise<SummaryReponse> {
-        const arrContent = typeof (content) == 'string' ? this.splitLongText(content) : content;
+        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);
@@ -296,16 +365,23 @@ export default class OpenAIGpt extends GptBase {
         while (arrContent.length > 0 && gotted < count) {
             questions4EverySentense = (count - gotted) / arrContent.length
             ////每次最多送MESSAGE_LENGTH句话给openai
-            let subarray = arrContent.slice(0, 1);
-            let itemCount = Math.min(Math.ceil(subarray.length * questions4EverySentense), count - gotted);
+            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数组结构输出。`},
+                { role: 'user', content: arrContent.slice(0, 1)[0] 
+            }
+            ]
+            console.log('Faq Question Pick Prompt:', subarray) 
             //subarray.push({ role: 'user', content:'请根据上述内容,给出一道提问与答案以及答案关键词，按照先问题内容，再标准答案，再关键词的顺序输出,关键词之间用、分开'})
-            subarray.unshift({ role: 'system', content: `你是一位专业培训师,从以下内容中提取${itemCount}条提问及答案，并从答案内容提取出至少2个关键词，最终结果按照[{"question":"提问内容","answer":"答案内容","keywords":["关键词1","关键词2"]}]的JSON数组结构输出。` })
+            //subarray.unshift({ role: 'system', content: `你是一位专业培训师,从以下内容中提取${itemCount}条提问及答案，并从答案内容提取出至少2个关键词，最终结果按照[{"question":"提问内容","answer":"答案内容","keywords":["关键词1","关键词2"]}]的JSON数组结构输出。` })
+            // subarray.unshift({role: 'system', content: FAQ_ROLE_DEFINE});
             //subarray.unshift({ role: 'system', content: `你是一位专业程序开发工程师,根据以下内容,按照[{"question":"问题内容","answer":"答案内容","keywords":["关键词1","关键词2"]}]JSON数组结构,给出${itemCount}条提问问题及答案以及答案关键词` })
             // console.log('subarray', subarray)
             let result = await this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
             if (result.successed && result.message) {
                 // console.log('result is ', result.message[0].message.content)
-                let msgs = this.pickUpFaqContent(result.message);
+                let msgs = await this.pickUpFaqContent(result.message);
                 if (msgs.length) {
                     ///对外发送检出问答题的信号
                     this.emit('parseout', { type: 'qa', items: msgs })
@@ -316,7 +392,7 @@ export default class OpenAIGpt extends GptBase {
             }
 
             ////删除已经处理的文本
-            arrContent.splice(0, 4);
+            arrContent.splice(0, 1);
         }
         arrContent = [];  /// 释放内存
         ///发出信号，解析完毕
@@ -329,11 +405,26 @@ export default class OpenAIGpt extends GptBase {
      * @param {*} messages 
      * @returns 
      */
-    protected pickUpFaqContent(messages: Array<any>): Array<FaqItem> {
+    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, '');
         let jsonObj = this.fixedJsonString(answerString);
-        if (!jsonObj.length) return []
+        if (!jsonObj.length){
+            let fixedAsk = [
+                { role: 'system', content: '角色扮演：假设你是一位高级JSON数据分析师' },
+                { role: 'user', content: `请分析以下内容，严格按照[{"question":"提问内容","answer":"答案内容","keywords":["关键词1","关键词2"]}]的标准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);
@@ -393,7 +484,6 @@ export default class OpenAIGpt extends GptBase {
 
         while (arrContent.length > 0 && !noMoreQuestionRetrive) {
             ////每次最多送MESSAGE_LENGTH句话给openai
-            let subarray = arrContent.slice(0, MESSAGE_LENGTH);
             /**
              * 每种类型的题目进行遍历
              */
@@ -404,14 +494,20 @@ export default class OpenAIGpt extends GptBase {
                 if (remainCount[key] > 0) {
                     noMoreQuestionRetrive = false;
 
-                    let itemCount = Math.min(remainCount[key], Math.ceil(subarray.length * sectionCount[key]));
-                    subarray.unshift({ role: 'system', content: QUESTION_TEXT_MAPPING[key].replace('@ITEMCOUNT@', itemCount) })
+                    //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);
                     console.log('subarray returned', result.successed)
                     if (result.successed && result.message) {
                         //console.log('paper result', key, result.message.length)
-                        let pickedQuestions = this.pickUpQuestions(result.message, itemCount, key, ITEM_SCORE[key]);
+                        let pickedQuestions = await this.pickUpQuestions(result.message, itemCount, key, ITEM_SCORE[key]);
                         if (pickedQuestions.length) {
                             ///对外发送检出题目的信号
                             this.emit('parseout', { type: 'question', name: key, items: pickedQuestions })
@@ -420,7 +516,7 @@ export default class OpenAIGpt extends GptBase {
                             totalscore = totalscore + pickedQuestions.length * ITEM_SCORE[key];
                         }
                     }
-                    subarray.splice(0, 1);  ///把第一个角色定位的问法删除
+                    //subarray.splice(0, 1);  ///把第一个角色定位的问法删除
                     // subarray.splice(subarray.length - 1, 1);  ///把第一个角色定位的问法删除
                 }
             }
@@ -438,11 +534,25 @@ export default class OpenAIGpt extends GptBase {
      * @param {*} result
      * 
      */
-    protected pickUpQuestions(result: Array<any>, count: number, questiontype: string, score: number = 1): Array<QuestionItem> {
+    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, '');
         let jsonObj = this.fixedJsonString(answerString);
-        if (!jsonObj.length) return []
+        ////修复的结果无法用程序修复，请求GPT来分析修复一下这个结果
+        if (!jsonObj.length){
+            let fixedAsk = [
+                {role:'system',content:'角色扮演：假设你是一位高级JSON数据分析师'},
+                { role: 'user', content: `请分析以下内容，严格按照${QUESTION_PROMPT_FIXED[questiontype]}的标准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);
@@ -557,8 +667,8 @@ export default class OpenAIGpt extends GptBase {
      * 将一段很长的文本，按1024长度来划分到多个中
      * @param {*} content 
      */
-    protected splitLongText(content: string, len = SECTION_LENGTH): Array<ChatCompletionRequestMessage> {
-        let start = 0, message: Array<ChatCompletionRequestMessage> = [], length = content.length;
+    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;
@@ -569,8 +679,8 @@ export default class OpenAIGpt extends GptBase {
                     break;
                 }
             }
-            const subtext = content.substr(start, realLength);
-            if (subtext) message.push({ role: 'user', content: subtext })
+            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;

package/src/stabilityplusai.ts

@@ -20,7 +20,7 @@ export default class StabilityPlusAI extends StabilityAI {
                 url: `${paramOption.endpoint || this.apiSetting.endpoint}/sdapi/v1/txt2img`,
                 data: {
                     "enable_hr": false,
-                    "denoising_strength": paramOption.denoising_strength || this.apiOption.denoising_strength ||  0,
+                    "denoising_strength": paramOption.denoising_strength || this.apiOption.denoising_strength ||  0.5,
                     "firstphase_width": 0,
                     "firstphase_height": 0,
                     "hr_scale": paramOption.hr_scale || this.apiOption.hr_scale || 2,
@@ -35,10 +35,10 @@ export default class StabilityPlusAI extends StabilityAI {
                     "subseed_strength": 0,
                     "seed_resize_from_h": -1,
                     "seed_resize_from_w": -1,
-                    "sampler_name": paramOption.sampler || this.apiOption.sampler || "Euler", //"Euler",
+                    "sampler_name": paramOption.sampler || this.apiOption.sampler || "Euler a", //"Euler",
                     "batch_size": 1,
                     "n_iter": paramOption.samples || this.apiOption.samples || 1,        //生成的数量
-                    "steps": paramOption.steps || this.apiOption.steps ||  50,
+                    "steps": paramOption.steps || this.apiOption.steps ||  20,
                     "cfg_scale": paramOption.cfg_scale || this.apiOption.cfg_scale || 7,
                     "width": paramOption.width || this.apiOption.width || 512, 
                     "height": paramOption.height || this.apiOption.height || 512,
@@ -60,11 +60,11 @@ export default class StabilityPlusAI extends StabilityAI {
                 },
 
             };
-            console.log('param', param)
             const response: any = await request(param)
             if (response.successed) {
                 return { successed: true, type: 'image', data: response.data.images, };
             }
+            console.log('response result ', response.data)
             return { successed: false, ...response.data };
         } catch (error) {
             console.log('result is error ', error)