doomiaichat 1.4.4 → 2.0.0

package/dist/declare.d.ts

@@ -0,0 +1,99 @@
+interface ApiResult {
+    /**
+     * return the result of api called
+     * @type {boolean}
+     */
+    'successed': boolean;
+    /**
+     * The error info
+     * @type {any}
+     * @memberof ChatReponse
+     */
+    'error'?: any;
+}
+/**
+ * Api封装后的返回结果
+ */
+export interface ChatReponse extends ApiResult {
+    /**
+     * The name of the user in a multi-user chat
+     * @type {Array<any>}
+     * @memberof ChatReponse
+     */
+    'message'?: Array<any>;
+}
+export interface OutlineSummaryItem {
+    /**
+     * The name of the user in a multi-user chat
+     * @type {Array<any>}
+     * @memberof SummaryReponse
+     */
+    'outline'?: string;
+    'summary'?: Array<string>;
+}
+/**
+ * 摘要信息
+ */
+export interface SummaryReponse extends ApiResult {
+    /**
+     * The name of the user in a multi-user chat
+     * @type {Array<any>}
+     * @memberof SummaryReponse
+     */
+    'article'?: Array<OutlineSummaryItem>;
+}
+/**
+ * 调用OpenAI Api的参数约定
+ */
+export interface OpenAIApiParameters {
+    'model'?: string;
+    'maxtoken'?: number;
+    'temperature'?: number;
+    'replyCounts'?: number;
+}
+/**
+ * Azure 上的OpenAI的链接参数
+ */
+export interface AzureOpenAIPatameters {
+    'endpoint': string;
+    'engine': string;
+    'version'?: string;
+}
+/**
+ * 调用OpenAI Api的参数约定
+ */
+export interface FaqItem {
+    'question': string;
+    'answer'?: string;
+    'keywords'?: Array<string>;
+}
+/**
+ * 调用OpenAI Api的参数约定
+ */
+export interface ExaminationPaperResult extends ApiResult {
+    'score': number;
+    'paper': any;
+}
+/**
+ * 调用OpenAI Api的参数约定
+ */
+export interface QuestionItem {
+    'question': string;
+    'fullanswer'?: string;
+    'answer'?: Array<string>;
+    'choice'?: any[];
+    'score'?: number;
+}
+/**
+ * 调用OpenAI Api的参数约定
+ */
+export interface SimilarityResult extends ApiResult {
+    'value'?: number;
+}
+/**
+ * 调用OpenAI Api的参数约定
+ */
+export interface EmotionResult extends ApiResult {
+    'emotion'?: string;
+}
+export {};

package/dist/declare.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -39,6 +39,12 @@ export declare class AIChat extends EventEmitter {
      * @param {需要出来的数量} count
      */
     getSimilarityContent(content: string, count?: number, axiosOption?: AxiosRequestConfig): Promise<ChatReponse>;
+    /**
+     * 提取内容的中心思想摘要
+     * @param content
+     * @param axiosOption
+     */
+    getSummaryOfContent(content: string | Array<any>, axiosOption?: AxiosRequestConfig): Promise<SummaryReponse>;
     /**
      * 从指定的文本内容中生成相关的问答
      * @param {*} content
@@ -46,6 +52,13 @@ export declare class AIChat extends EventEmitter {
      * @param {*} axiosOption
      * @returns
      */ generateQuestionsFromContent(content: string, count?: number, axiosOption?: AxiosRequestConfig): Promise<ChatReponse>;
+    /**
+     * 从指定的文本内容中生成相关的问答
+     * @param {*} content
+     * @param {*} count
+     * @param {*} axiosOption
+     * @returns
+     */ generateQuestionsFromContent_Orgin(content: string, count?: number, promotion?: string | null, sliceslength?: number, axiosOption?: AxiosRequestConfig): Promise<ChatReponse>;
     /**
      * 解析Faq返回的问题
      * @param {*} messages
@@ -97,6 +110,26 @@ export interface ChatReponse extends ApiResult {
      */
     'message'?: Array<any>;
 }
+interface OutlineSummaryItem {
+    /**
+     * The name of the user in a multi-user chat
+     * @type {Array<any>}
+     * @memberof SummaryReponse
+     */
+    'outline'?: string;
+    'summary'?: Array<string>;
+}
+/**
+ * 摘要信息
+ */
+export interface SummaryReponse extends ApiResult {
+    /**
+     * The name of the user in a multi-user chat
+     * @type {Array<any>}
+     * @memberof SummaryReponse
+     */
+    'article'?: Array<OutlineSummaryItem>;
+}
 /**
  * 调用OpenAI Api的参数约定
  */
@@ -126,8 +159,9 @@ export interface ExaminationPaperResult extends ApiResult {
  */
 export interface QuestionItem {
     'question': string;
+    'fullanswer'?: string;
     'answer'?: Array<string>;
-    'choice'?: Array<string>;
+    'choice'?: any[];
     'score'?: number;
 }
 /**

package/dist/index.js

@@ -12,15 +12,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AIChat = void 0;
 const openai_1 = require("openai");
 const events_1 = require("events");
-const SECTION_LENGTH = 256; ///每256个字符分成一组
-const MESSAGE_LENGTH = 8; ///每次送8句话给openai 进行解析，送多了，会报错
+const SECTION_LENGTH = 1600; ///每2400个字符分成一组
+const MESSAGE_LENGTH = 1; ///每次送8句话给openai 进行解析，送多了，会报错
 //请将答案放在最后,标记为答案：()
 const QUESTION_TEXT_MAPPING = {
-    singlechoice: ',根据以上内容,生成1道单选题,每道题目4个选项,请按照{"question":"","choice":[],"answer":[]}的JSON结构输出,choice中的元素用大写字母ABCD开头,answer数组中包含一个正确答案',
-    multiplechoice: ',根据以上内容,请生成1道多选题,提供4个选项,答案至少1个以上选项,请按照{"question":"","choice":[],"answer":[]}的JSON结构输出,choice中的元素用大写字母ABCD开头,answer数组中包含正确答案选项',
-    trueorfalse: ',根据以上内容,请生成1道判断题,请按照{"question":"","choice":["A.正确","B.错误"],"answer":[]}的JSON结构输出,answer数组中包含一个元素,"正确"或"错误"',
-    completion: ',根据以上内容,请生成1道填空题,每道题目1个填空,请按照{"question":"","answer":[]}的JSON结构输出,answer数组中包含填空答案' //请将答案放在最后,标记为答案：()
+    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"]}]的结构输出' //请将答案放在最后,标记为答案：()
 };
+// singlechoice: '你是一名专业的培训老师,根据以下内容,生成@ITEMCOUNT@道单选题,每道题目4个选项,每道题的选项中的元素用大写字母ABCD开头,每道题的只能有一个正确答案,最终结果按照[{"question":"","choice":[],"answer":[]}]的JSON数组输出',
+//     multiplechoice: '你是一名专业的培训老师,根据以下内容,请生成@ITEMCOUNT@道多选题,提供4个选项,答案至少1个以上选项,请按照{"question":"","choice":[],"answer":[]}的JSON结构输出,choice中的元素用大写字母ABCD开头,answer数组中包含正确答案选项',  //请将答案放在最后,标记为答案：()
+//         trueorfalse: '你是一名专业的培训老师,根据以下内容,请生成@ITEMCOUNT@道判断题,请按照{"question":"","choice":["A.正确","B.错误"],"answer":[]}的JSON结构输出,answer数组中包含一个元素,"正确"或"错误"', //标记为答案：(正确或错误)
+//             completion: '你是一名专业的培训老师,根据以下内容,请生成@ITEMCOUNT@道填空题,每道题目1个填空,请按照{"question":"","answer":[]}的JSON结构输出,answer数组中包含填空答案' //请将答案放在最后,标记为答案：()
 const QUESTION_TYPE = ['singlechoice', 'multiplechoice', 'trueorfalse', 'completion'];
 class AIChat extends events_1.EventEmitter {
     /**
@@ -32,7 +36,7 @@ class AIChat extends events_1.EventEmitter {
         super();
         this.chatRobot = new openai_1.OpenAIApi(new openai_1.Configuration({ apiKey }));
         this.chatModel = apiOption.model || 'gpt-3.5-turbo';
-        this.maxtoken = apiOption.maxtoken || 1024;
+        this.maxtoken = apiOption.maxtoken || 2048;
         this.temperature = apiOption.temperature || 0.9;
     }
     /**
@@ -59,6 +63,7 @@ class AIChat extends events_1.EventEmitter {
                 return { successed: true, message: response.data.choices };
             }
             catch (error) {
+                console.log('result is error ', error);
                 return { successed: false, error };
             }
         });
@@ -135,6 +140,36 @@ class AIChat extends events_1.EventEmitter {
             return { successed: true, message: replys };
         });
     }
+    /**
+     * 提取内容的中心思想摘要
+     * @param content
+     * @param axiosOption
+     */
+    getSummaryOfContent(content, axiosOption = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const arrContent = typeof (content) == 'string' ? this.splitLongText(content) : content;
+            let summary = [];
+            while (arrContent.length > 0) {
+                let subarray = arrContent.slice(0, MESSAGE_LENGTH);
+                subarray.push({ role: 'user', content: '根据上述内容精简，提炼内容提纲及摘要内容，每项摘要内容尽量精简数据化不超过100字，结果严格按照[{outline:"提纲标题","summary":["摘要内容1","摘要内容2","摘要内容3"]}]的JSON结构输出' });
+                let result = yield this.chatRequest(subarray, {}, axiosOption);
+                if (result.successed && result.message) {
+                    try {
+                        // console.log('result.message[0].content', result.message[0].message.content)
+                        let jsonObjItems = JSON.parse(result.message[0].message.content);
+                        if (Array.isArray(jsonObjItems))
+                            summary = summary.concat(jsonObjItems);
+                    }
+                    catch (error) {
+                        console.log('result.message[0].content', error);
+                    }
+                }
+                ////删除已经处理的文本
+                arrContent.splice(0, MESSAGE_LENGTH);
+            }
+            return { successed: true, article: summary };
+        });
+    }
     /**
      * 从指定的文本内容中生成相关的问答
      * @param {*} content
@@ -144,19 +179,23 @@ class AIChat extends events_1.EventEmitter {
      */ //并在答案末尾处必须给出答案内容中的关键词
     generateQuestionsFromContent(content, count = 1, axiosOption = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            let arrContent = this.splitLongText(content);
+            let arrContent = this.splitLongText(content, 300);
             ///没20句话分为一组，适应大文件内容多次请求组合结果
             ///每一句话需要产生的题目
             let questions4EverySentense = count / arrContent.length; //Math.ceil(arrContent.length / 20);
             let faqs = [], gotted = 0;
             while (arrContent.length > 0 && gotted < count) {
+                questions4EverySentense = (count - gotted) / arrContent.length;
                 ////每次最多送MESSAGE_LENGTH句话给openai
-                let subarray = arrContent.slice(0, MESSAGE_LENGTH);
+                let subarray = arrContent.slice(0, 4);
                 let itemCount = Math.min(Math.ceil(subarray.length * questions4EverySentense), count - gotted);
                 //subarray.push({ role: 'user', content:'请根据上述内容,给出一道提问与答案以及答案关键词，按照先问题内容，再标准答案，再关键词的顺序输出,关键词之间用、分开'})
-                subarray.push({ role: 'user', content: '请根据上述内容,给出一道提问与答案以及答案关键词，按照{"question":"","answer":"","keywords":[]}的JSON结构输出,keywords数组中的关键词必须存在于答案内容中' });
-                let result = yield this.chatRequest(subarray, { replyCounts: itemCount }, axiosOption);
+                subarray.unshift({ role: 'system', content: `你是一位专业培训师,从以下内容中提取${itemCount}条提问及答案，并从答案内容提取出至少2个关键词，最终结果按照[{"question":"提问内容","answer":"答案内容","keywords":["关键词1","关键词2"]}]的JSON数组结构输出。` });
+                //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);
                     if (msgs.length) {
                         ///对外发送检出问答题的信号
@@ -167,7 +206,7 @@ class AIChat extends events_1.EventEmitter {
                     }
                 }
                 ////删除已经处理的文本
-                arrContent.splice(0, MESSAGE_LENGTH);
+                arrContent.splice(0, 4);
             }
             arrContent = []; /// 释放内存
             ///发出信号，解析完毕
@@ -175,27 +214,86 @@ class AIChat extends events_1.EventEmitter {
             return { successed: true, message: faqs };
         });
     }
+    /**
+     * 从指定的文本内容中生成相关的问答
+     * @param {*} content
+     * @param {*} count
+     * @param {*} axiosOption
+     * @returns
+     */ //并在答案末尾处必须给出答案内容中的关键词
+    generateQuestionsFromContent_Orgin(content, count = 1, promotion = null, sliceslength = SECTION_LENGTH, axiosOption = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let arrContent = this.splitLongText(content, sliceslength || 300);
+            ///没20句话分为一组，适应大文件内容多次请求组合结果
+            ///每一句话需要产生的题目
+            let questions4EverySentense = count / arrContent.length; //Math.ceil(arrContent.length / 20);
+            let faqs = [], gotted = 0;
+            while (arrContent.length > 0 && gotted < count) {
+                questions4EverySentense = (count - gotted) / arrContent.length;
+                ////每次最多送MESSAGE_LENGTH句话给openai
+                let subarray = arrContent.slice(0, 4);
+                let itemCount = Math.min(Math.ceil(subarray.length * questions4EverySentense), count - gotted);
+                subarray.unshift({ role: 'system', content: promotion || `你是一位专业培训师,从以下内容中提取${itemCount}条提问及答案，并从答案内容提取出至少2个关键词，最终结果按照[{"question":"提问内容","answer":"答案内容","keywords":["关键词1","关键词2"]}]的JSON数组结构输出。` });
+                let result = yield this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
+                if (result.successed && result.message) {
+                    let answer = result.message.map(i => { return i.message.content.trim().replace(/\t|\n|\v|\r|\f/g, ''); });
+                    faqs = faqs.concat(answer);
+                }
+                ////删除已经处理的文本
+                arrContent.splice(0, 4);
+            }
+            arrContent = []; /// 释放内存
+            return { successed: true, message: faqs };
+        });
+    }
     /**
      * 解析Faq返回的问题
      * @param {*} messages
      * @returns
      */
     pickUpFaqContent(messages) {
-        let replys = messages.map(item => {
-            let content = item.message.content.trim().replace(/\t|\n|\v|\r|\f/g, '');
-            try {
-                let jsonObj = JSON.parse(content);
-                if (!Array.isArray(jsonObj.keywords)) {
-                    jsonObj.keywords = (jsonObj.keywords || '').split(',');
+        let answerString = messages[0].message.content.trim().replace(/\t|\n|\v|\r|\f/g, '');
+        const firstsybmol = answerString.indexOf("["); ////必须过滤出来数组
+        const lastsybmol = answerString.lastIndexOf("]");
+        console.log('answerString', answerString);
+        if (firstsybmol < 0 || lastsybmol < 0 || lastsybmol <= firstsybmol)
+            return [];
+        answerString = answerString.substr(firstsybmol, lastsybmol - firstsybmol + 1);
+        console.log('answerString', answerString);
+        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 jsonObj;
-            }
-            catch (err) {
-                console.log('JSON error', content, err);
-                return { question: null };
-            }
-        });
-        return replys.filter(n => { return n.question != null; });
+                item.keywords = realKeyword;
+                return item;
+            });
+            return jsonObj;
+        }
+        catch (err) {
+            console.log('JSON error', err);
+            return [];
+        }
+        // let replys = messages.map(item => {
+        //     let content = item.message.content.trim().replace(/\t|\n|\v|\r|\f/g, '');
+        //     try {
+        //         let jsonObj = JSON.parse(content);
+        //         if (!Array.isArray(jsonObj.keywords)) {
+        //             jsonObj.keywords = (jsonObj.keywords || '').split(',')
+        //         }
+        //         return jsonObj ;
+        //     } catch (err) {
+        //         console.log('JSON error', content, err)
+        //         return {question:null};
+        //     }
+        // })
+        // return replys.filter(n => { return n.question != null });
     }
     /**
      * 从指定的文本内容中生成一张试卷
@@ -209,7 +307,7 @@ class AIChat extends events_1.EventEmitter {
     generateExaminationPaperFromContent(content, paperOption = {}, axiosOption = {}) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         return __awaiter(this, void 0, void 0, function* () {
-            let arrContent = this.splitLongText(content);
+            let arrContent = this.splitLongText(content, 1024);
             let sectionCount = {
                 singlechoice: (((_a = paperOption.singlechoice) === null || _a === void 0 ? void 0 : _a.count) || 0) / arrContent.length,
                 multiplechoice: (((_b = paperOption.multiplechoice) === null || _b === void 0 ? void 0 : _b.count) || 0) / arrContent.length,
@@ -245,13 +343,13 @@ class AIChat extends events_1.EventEmitter {
                     ///还需要抓取题目
                     if (remainCount[key] > 0) {
                         noMoreQuestionRetrive = false;
-                        subarray.push({ role: 'user', content: QUESTION_TEXT_MAPPING[key] });
                         let itemCount = Math.min(remainCount[key], Math.ceil(subarray.length * sectionCount[key]));
-                        console.log(QUESTION_TEXT_MAPPING[key], itemCount);
-                        let result = yield this.chatRequest(subarray, { replyCounts: itemCount }, axiosOption);
+                        subarray.unshift({ role: 'system', content: QUESTION_TEXT_MAPPING[key].replace('@ITEMCOUNT@', itemCount) });
+                        console.log(subarray);
+                        let result = yield this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
                         if (result.successed && result.message) {
                             //console.log('paper result', key, result.message.length)
-                            let pickedQuestions = this.pickUpQuestions(result.message, key, ITEM_SCORE[key]);
+                            let pickedQuestions = this.pickUpQuestions(result.message, itemCount, key, ITEM_SCORE[key]);
                             if (pickedQuestions.length) {
                                 ///对外发送检出题目的信号
                                 this.emit('parseout', { type: 'question', name: key, items: pickedQuestions });
@@ -260,7 +358,8 @@ class AIChat extends events_1.EventEmitter {
                                 totalscore = totalscore + pickedQuestions.length * ITEM_SCORE[key];
                             }
                         }
-                        subarray.splice(subarray.length - 1, 1); ///把最后的问法删除
+                        subarray.splice(0, 1); ///把第一个角色定位的问法删除
+                        // subarray.splice(subarray.length - 1, 1);  ///把第一个角色定位的问法删除
                     }
                 }
                 ////删除已经处理的文本
@@ -276,44 +375,113 @@ class AIChat extends events_1.EventEmitter {
      * @param {*} result
      *
      */
-    pickUpQuestions(result, questiontype, score = 1) {
-        let item = result.map(m => {
-            ////防止输出的JSON格式不合法
-            try {
-                let jsonObj = JSON.parse(m.message.content);
-                jsonObj.score = score;
-                if (jsonObj.choice && Array.isArray(jsonObj.choice) && questiontype != 'completion') {
-                    jsonObj.fullanswer = (jsonObj.answer + '').replace(/,|[^ABCDE]/g, '');
-                    jsonObj.choice = jsonObj.choice.map((item, index) => {
-                        let seqNo = String.fromCharCode(65 + index);
-                        let correctReg = new RegExp(`${seqNo}.|${seqNo}`, 'ig');
-                        //let answer = jsonObj.fullanswer
-                        return {
-                            id: seqNo,
-                            content: item.replace(correctReg, '').trim(),
-                            iscorrect: (jsonObj.fullanswer.indexOf(seqNo) >= 0 || jsonObj.fullanswer.indexOf(m)) >= 0 ? 1 : 0
-                        };
-                    });
+    pickUpQuestions(result, count, questiontype, score = 1) {
+        let answerString = result[0].message.content.trim().replace(/\t|\n|\v|\r|\f/g, '');
+        const firstsybmol = answerString.indexOf("["); ////必须过滤出来数组
+        const lastsybmol = answerString.lastIndexOf("]");
+        console.log('answerString', answerString);
+        if (firstsybmol < 0 || lastsybmol < 0 || lastsybmol <= firstsybmol)
+            return [];
+        answerString = answerString.substr(firstsybmol, lastsybmol - firstsybmol + 1);
+        console.log('answerString', answerString);
+        let returnItems = [];
+        try {
+            let jsonObj = JSON.parse(answerString);
+            returnItems = jsonObj.map((questionitem) => {
+                console.log('answer item', 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 = String.fromCharCode(65 + index);
+                            let correctReg = new RegExp(`${seqNo}.|${seqNo}`, 'ig');
+                            //let answer = jsonObj.fullanswer
+                            return {
+                                id: seqNo,
+                                content: item.replace(correctReg, '').trim(),
+                                iscorrect: (questionitem.fullanswer || '').indexOf(seqNo) >= 0 ? 1 : 0
+                                //|| jsonObj.fullanswer.indexOf(m))
+                            };
+                        });
+                    }
+                    ///如果是非判断题，题目的选项数量小于2 ，则无效
+                    ///如果是判断题，题目的选项必须=2
+                    if (!questionitem.choice || (questiontype != 'trueorfalse' && questionitem.choice.length < 3) || (questiontype == 'trueorfalse' && questionitem.choice.length != 2)) {
+                        return null;
+                    }
                 }
                 switch (questiontype) {
                     case 'singlechoice':
-                        jsonObj.answer = (jsonObj.answer + '').replace(/,|[^ABCDEFG]/g, '').split('').slice(0, 1);
+                        questionitem.answer = (questionitem.answer + '').replace(/,|[^ABCDEFG]/g, '').split('').slice(0, 1);
                         break;
                     case 'multiplechoice':
-                        jsonObj.answer = (jsonObj.answer + '').replace(/,|[^ABCDEFG]/g, '').split('');
+                        questionitem.answer = (questionitem.answer + '').replace(/,|[^ABCDEFG]/g, '').split('');
                         break;
                     case 'trueorfalse':
-                        jsonObj.answer = [(jsonObj.answer + '').indexOf('正确') >= 0 ? 'A' : 'B'];
+                        questionitem.answer = [(questionitem.answer + '').indexOf('正确') >= 0 ? 'A' : 'B'];
                         break;
                 }
-                return jsonObj;
-            }
-            catch (err) {
-                console.log('error happened:', err);
-                return null;
-            }
-        });
-        return item.filter(i => { return i != null; });
+                ///单选题验证
+                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);
+        // let item = result.map(m => {
+        //     ////防止输出的JSON格式不合法
+        //     try {
+        //         let jsonObj = JSON.parse(m.message.content)
+        //         jsonObj.score = score;
+        //         if (jsonObj.choice && Array.isArray(jsonObj.choice) && questiontype != 'completion') {
+        //             jsonObj.fullanswer = (jsonObj.answer + '').replace(/,|[^ABCDE]/g, '');
+        //             jsonObj.choice = jsonObj.choice.map((item:string, index:number) => {
+        //                 let seqNo = String.fromCharCode(65 + index);
+        //                 let correctReg = new RegExp(`${seqNo}.|${seqNo}`, 'ig')
+        //                 //let answer = jsonObj.fullanswer
+        //                 return {
+        //                     id: seqNo,
+        //                     content: item.replace(correctReg, '').trim(),
+        //                     iscorrect: (jsonObj.fullanswer.indexOf(seqNo) >= 0 || jsonObj.fullanswer.indexOf(m)) >= 0 ? 1 : 0
+        //                 }
+        //             })
+        //         }
+        //         switch (questiontype) {
+        //             case 'singlechoice':
+        //                 jsonObj.answer = (jsonObj.answer + '').replace(/,|[^ABCDEFG]/g, '').split('').slice(0, 1);
+        //                 break;
+        //             case 'multiplechoice':
+        //                 jsonObj.answer = (jsonObj.answer + '').replace(/,|[^ABCDEFG]/g, '').split('');
+        //                 break;
+        //             case 'trueorfalse':
+        //                 jsonObj.answer = [(jsonObj.answer + '').indexOf('正确') >= 0 ? 'A' : 'B']
+        //                 break;
+        //         }
+        //         return jsonObj;
+        //     } catch (err) {
+        //         console.log('error happened:', err);
+        //         return null;
+        //     }
+        // })
+        // return item.filter(i => { return i != null; });
     }
     /**
      * 将一段很长的文本，按1024长度来划分到多个中
@@ -322,10 +490,18 @@ class AIChat extends events_1.EventEmitter {
     splitLongText(content, len = SECTION_LENGTH) {
         let start = 0, message = [], length = content.length;
         while (start < length) {
-            const subtext = content.substr(start, len);
+            let realLength = len;
+            ////以句号或引号进行分段，不要随意截取
+            for (let i = start + len; i >= start; i--) {
+                if (/[。”"?？]/.test(content[i] + '')) {
+                    realLength = i - start + 1;
+                    break;
+                }
+            }
+            const subtext = content.substr(start, realLength);
             if (subtext)
                 message.push({ role: 'user', content: subtext });
-            start += len;
+            start += realLength || len;
         }
         return message;
     }