doomiaichat 4.5.0 → 4.7.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 {
@@ -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,56 @@ 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"]}]的结构输出'
 };
 const QUESTION_TYPE = ['singlechoice', 'multiplechoice', 'trueorfalse', 'completion'];
 class OpenAIGpt extends gptbase_1.default {
@@ -287,7 +332,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,10 +381,16 @@ 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]
+                    }
+                ];
                 //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);
@@ -345,7 +405,7 @@ class OpenAIGpt extends gptbase_1.default {
                     }
                 }
                 ////删除已经处理的文本
-                arrContent.splice(0, 4);
+                arrContent.splice(0, 1);
             }
             arrContent = []; /// 释放内存
             ///发出信号，解析完毕
@@ -426,18 +486,26 @@ 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);
                 /**
                  * 每种类型的题目进行遍历
                  */
+                console.log('arrContent.length', arrContent.length);
                 noMoreQuestionRetrive = true;
                 for (const key of QUESTION_TYPE) {
                     ///还需要抓取题目
                     if (remainCount[key] > 0) {
                         noMoreQuestionRetrive = false;
-                        let itemCount = Math.min(remainCount[key], Math.ceil(subarray.length * sectionCount[key]));
-                        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]);
@@ -449,13 +517,14 @@ 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);  ///把第一个角色定位的问法删除
                     }
                 }
                 ////删除已经处理的文本
                 arrContent.splice(0, MESSAGE_LENGTH);
             }
+            console.log('parseover');
             ///发出信号，解析完毕
             this.emit('parseover', { type: 'question', items: paperReturned });
             return { successed: true, score: totalscore, paper: paperReturned };
@@ -603,9 +672,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/stabilityai.d.ts

@@ -28,6 +28,8 @@ export interface StabilityOption {
     'negative'?: string;
     'engine'?: string;
     'endpoint'?: string;
+    'denoising_strength'?: number;
+    'hr_scale'?: number;
 }
 export interface StabilityResult extends ApiResult {
     'data'?: any;

package/dist/stabilityplusai.js

@@ -31,10 +31,10 @@ 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": 0,
+                        "denoising_strength": paramOption.denoising_strength || this.apiOption.denoising_strength || 0.5,
                         "firstphase_width": 0,
                         "firstphase_height": 0,
-                        "hr_scale": 2,
+                        "hr_scale": paramOption.hr_scale || this.apiOption.hr_scale || 2,
                         "hr_upscaler": "string",
                         "hr_second_pass_steps": 0,
                         "hr_resize_x": 0,
@@ -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,
@@ -73,6 +73,7 @@ class StabilityPlusAI extends stabilityai_1.default {
                 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.5.0",
+  "version": "4.7.0",
   "description": "Doomisoft OpenAI",
   "main": "dist/index.js",
   "scripts": {

package/src/openai.ts

@@ -5,13 +5,58 @@ 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"]}]的结构输出'
+}
 const QUESTION_TYPE: string[] = ['singlechoice', 'multiplechoice', 'trueorfalse', 'completion']
 
 export default class OpenAIGpt extends GptBase {
@@ -260,7 +305,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,10 +349,16 @@ 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] 
+            }
+                            ] 
             //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);
@@ -316,7 +375,7 @@ export default class OpenAIGpt extends GptBase {
             }
 
             ////删除已经处理的文本
-            arrContent.splice(0, 4);
+            arrContent.splice(0, 1);
         }
         arrContent = [];  /// 释放内存
         ///发出信号，解析完毕
@@ -393,19 +452,27 @@ export default class OpenAIGpt extends GptBase {
 
         while (arrContent.length > 0 && !noMoreQuestionRetrive) {
             ////每次最多送MESSAGE_LENGTH句话给openai
-            let subarray = arrContent.slice(0, MESSAGE_LENGTH);
             /**
              * 每种类型的题目进行遍历
              */
+            console.log('arrContent.length', arrContent.length)
             noMoreQuestionRetrive = true;
             for (const key of QUESTION_TYPE) {
                 ///还需要抓取题目
                 if (remainCount[key] > 0) {
                     noMoreQuestionRetrive = false;
 
-                    let itemCount = Math.min(remainCount[key], Math.ceil(subarray.length * sectionCount[key]));
-                    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]);
@@ -417,13 +484,15 @@ 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);  ///把第一个角色定位的问法删除
                 }
             }
+            
             ////删除已经处理的文本
             arrContent.splice(0, MESSAGE_LENGTH);
         }
+        console.log('parseover')
         ///发出信号，解析完毕
         this.emit('parseover', { type: 'question', items: paperReturned })
         return { successed: true, score: totalscore, paper: paperReturned }
@@ -552,8 +621,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;
@@ -564,8 +633,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/stabilityai.ts

@@ -78,6 +78,8 @@ export interface StabilityOption {
     'negative'?:string,
     'engine'?:string,
     'endpoint'?:string
+    'denoising_strength'?:number,
+    'hr_scale'?:number
 }
 
 export interface StabilityResult extends ApiResult {

package/src/stabilityplusai.ts

@@ -20,10 +20,10 @@ export default class StabilityPlusAI extends StabilityAI {
                 url: `${paramOption.endpoint || this.apiSetting.endpoint}/sdapi/v1/txt2img`,
                 data: {
                     "enable_hr": false,
-                    "denoising_strength": 0,
+                    "denoising_strength": paramOption.denoising_strength || this.apiOption.denoising_strength ||  0.5,
                     "firstphase_width": 0,
                     "firstphase_height": 0,
-                    "hr_scale": 2,
+                    "hr_scale": paramOption.hr_scale || this.apiOption.hr_scale || 2,
                     "hr_upscaler": "string",
                     "hr_second_pass_steps": 0,
                     "hr_resize_x": 0,
@@ -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,
@@ -64,6 +64,7 @@ export default class StabilityPlusAI extends StabilityAI {
             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)