doomiaichat 1.0.2 → 1.1.0

package/dist/index.d.ts

@@ -29,6 +29,49 @@ export declare class AIChat extends EventEmitter {
      * @param {*} s2
      */
     getScentenseSimilarity(s1: string, s2: string, axiosOption?: any): Promise<ChatReponse>;
+    /**
+      * 获得一种内容的相似说法
+     * 比如：
+     * 你今年多大？
+     * 相似问法：您是哪一年出生的
+     * 您今年贵庚？
+     * @param {*} content
+     * @param {需要出来的数量} count
+     */
+    getSimilarityContent(content: string, count?: number, axiosOption?: AxiosRequestConfig): Promise<ChatReponse>;
+    /**
+     * 从指定的文本内容中生成相关的问答
+     * @param {*} content
+     * @param {*} count
+     * @param {*} axiosOption
+     * @returns
+     */ generateQuestionsFromContent(content: string, count?: number, axiosOption?: AxiosRequestConfig): Promise<ChatReponse>;
+    /**
+     * 解析Faq返回的问题
+     * @param {*} messages
+     * @returns
+     */
+    private pickUpFaqContent;
+    /**
+     * 从指定的文本内容中生成一张试卷
+     * @param {*} content
+     * @param {试卷的参数} paperOption
+     * totalscore: 试卷总分，默认100
+     * section: {type:[0,1,2,3]为单选、多选、判断、填空题型  count:生成多少道  score:本段分数}
+     * @param {*} axiosOption
+     * @returns
+     */ generateExaminationPaperFromContent(content: string, paperOption?: any, axiosOption?: AxiosRequestConfig): Promise<ExaminationPaperResult>;
+    /**
+     * 从答复中得到题目
+     * @param {*} result
+     *
+     */
+    private pickUpQuestions;
+    /**
+     * 将一段很长的文本，按1024长度来划分到多个中
+     * @param {*} content
+     */
+    private splitLongText;
 }
 /**
  * Api封装后的返回结果
@@ -56,8 +99,37 @@ export interface ChatReponse {
  * 调用OpenAI Api的参数约定
  */
 export interface CallChatApiOption {
-    model?: string;
-    maxtoken?: number;
-    temperature?: number;
-    replyCounts?: number;
+    'model'?: string;
+    'maxtoken'?: number;
+    'temperature'?: number;
+    'replyCounts'?: number;
+}
+/**
+ * 调用OpenAI Api的参数约定
+ */
+export interface FaqResultResponse {
+    'question': string;
+    'answer'?: string;
+    'keywords'?: Array<string>;
+}
+/**
+ * 调用OpenAI Api的参数约定
+ */
+export interface ExaminationPaperResult {
+    /**
+    * return the result of api called
+    * @type {boolean}
+    */
+    'successed': boolean;
+    'score': number;
+    'paper': any;
+}
+/**
+ * 调用OpenAI Api的参数约定
+ */
+export interface QuestionItemResultResponse {
+    'question': string;
+    'answer'?: Array<string>;
+    'choice'?: Array<string>;
+    'score'?: number;
 }

package/dist/index.js

@@ -9,6 +9,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { Configuration, OpenAIApi } from "openai";
 import { EventEmitter } from "events";
+const SECTION_LENGTH = 256; ///每256个字符分成一组
+const MESSAGE_LENGTH = 8; ///每次送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数组中包含填空答案' //请将答案放在最后,标记为答案：()
+};
+const QUESTION_TYPE = ['singlechoice', 'multiplechoice', 'trueorfalse', 'completion'];
 export class AIChat extends EventEmitter {
     /**
      *
@@ -83,4 +93,221 @@ export class AIChat extends EventEmitter {
             return this.chatRequest(messages, { maxtoken: 32 }, axiosOption);
         });
     }
+    /**
+      * 获得一种内容的相似说法
+     * 比如：
+     * 你今年多大？
+     * 相似问法：您是哪一年出生的
+     * 您今年贵庚？
+     * @param {*} content
+     * @param {需要出来的数量} count
+     */
+    getSimilarityContent(content, count = 1, axiosOption = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let chnReg = /([\u4e00-\u9fa5]|[\ufe30-\uffa0])/.test(content); ///检查源话是否含有中文内容
+            let engReg = /[a-zA-Z]/.test(content); ///检查源话是否含有英文内容
+            ///如果源话是全中文，那么结果中不应该出来英文的相似说法，如果源话是全英文，则结果不能出现全中文的说法
+            let prefix = (!chnReg && engReg) ? '请用完整的英文表达,' : ((chnReg && !engReg) ? '请用完整的中文表达,' : '');
+            const text = `${prefix}生成与下面句子意思相同的内容"${content}"`;
+            let result = yield this.chatRequest(this.splitLongText(text), { replyCounts: count }, axiosOption);
+            if (!result.successed || !result.message)
+                return result;
+            let replys = result.message.map(item => { return item.message.content.trim(); });
+            return { successed: true, message: replys };
+        });
+    }
+    /**
+     * 从指定的文本内容中生成相关的问答
+     * @param {*} content
+     * @param {*} count
+     * @param {*} axiosOption
+     * @returns
+     */ //并在答案末尾处必须给出答案内容中的关键词
+    generateQuestionsFromContent(content, count = 1, axiosOption = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let arrContent = this.splitLongText(content);
+            ///没20句话分为一组，适应大文件内容多次请求组合结果
+            ///每一句话需要产生的题目
+            let questions4EverySentense = count / arrContent.length; //Math.ceil(arrContent.length / 20);
+            let faqs = [], gotted = 0;
+            while (arrContent.length > 0 && gotted < count) {
+                ////每次最多送MESSAGE_LENGTH句话给openai
+                let subarray = arrContent.slice(0, MESSAGE_LENGTH);
+                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);
+                if (result.successed && result.message) {
+                    let msgs = this.pickUpFaqContent(result.message);
+                    if (msgs.length) {
+                        ///对外发送检出问答题的信号
+                        this.emit('parseout', { type: 'qa', items: msgs });
+                        gotted += msgs.length; //result.message.length;
+                        //  console.log('gotted=', gotted)
+                        faqs = faqs.concat(msgs);
+                    }
+                }
+                ////删除已经处理的文本
+                arrContent.splice(0, MESSAGE_LENGTH);
+            }
+            arrContent = []; /// 释放内存
+            ///发出信号，解析完毕
+            this.emit('parseover', { type: 'qa', items: faqs });
+            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(',');
+                }
+                return jsonObj;
+            }
+            catch (err) {
+                console.log('JSON error', content, err);
+                return { question: null };
+            }
+        });
+        return replys.filter(n => { return n.question != null; });
+    }
+    /**
+     * 从指定的文本内容中生成一张试卷
+     * @param {*} content
+     * @param {试卷的参数} paperOption
+     * totalscore: 试卷总分，默认100
+     * section: {type:[0,1,2,3]为单选、多选、判断、填空题型  count:生成多少道  score:本段分数}
+     * @param {*} axiosOption
+     * @returns
+     */ //并在答案末尾处必须给出答案内容中的关键词
+    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 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,
+                trueorfalse: (((_c = paperOption.trueorfalse) === null || _c === void 0 ? void 0 : _c.count) || 0) / arrContent.length,
+                completion: (((_d = paperOption.completion) === null || _d === void 0 ? void 0 : _d.count) || 0) / arrContent.length
+            };
+            ///剩余待生成的题目数量
+            let remainCount = {
+                singlechoice: ((_e = paperOption.singlechoice) === null || _e === void 0 ? void 0 : _e.count) || 0,
+                multiplechoice: ((_f = paperOption.multiplechoice) === null || _f === void 0 ? void 0 : _f.count) || 0,
+                trueorfalse: ((_g = paperOption.trueorfalse) === null || _g === void 0 ? void 0 : _g.count) || 0,
+                completion: ((_h = paperOption.completion) === null || _h === void 0 ? void 0 : _h.count) || 0
+            };
+            ///每种类型的题目的分数
+            let ITEM_SCORE = {
+                singlechoice: ((_j = paperOption.singlechoice) === null || _j === void 0 ? void 0 : _j.score) || 0,
+                multiplechoice: ((_k = paperOption.multiplechoice) === null || _k === void 0 ? void 0 : _k.score) || 0,
+                trueorfalse: ((_l = paperOption.trueorfalse) === null || _l === void 0 ? void 0 : _l.score) || 0,
+                completion: ((_m = paperOption.completion) === null || _m === void 0 ? void 0 : _m.score) || 0
+            };
+            ///最后生成出来的结果
+            let paperReturned = {
+                singlechoice: [], multiplechoice: [], trueorfalse: [], completion: []
+            }, noMoreQuestionRetrive = false, totalscore = 0;
+            while (arrContent.length > 0 && !noMoreQuestionRetrive) {
+                ////每次最多送MESSAGE_LENGTH句话给openai
+                let subarray = arrContent.slice(0, MESSAGE_LENGTH);
+                /**
+                 * 每种类型的题目进行遍历
+                 */
+                noMoreQuestionRetrive = true;
+                for (const key of QUESTION_TYPE) {
+                    ///还需要抓取题目
+                    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);
+                        if (result.successed && result.message) {
+                            //console.log('paper result', key, result.message.length)
+                            let pickedQuestions = this.pickUpQuestions(result.message, key, ITEM_SCORE[key]);
+                            if (pickedQuestions.length) {
+                                ///对外发送检出题目的信号
+                                this.emit('parseout', { type: 'question', name: key, items: pickedQuestions });
+                                paperReturned[key] = paperReturned[key].concat(pickedQuestions);
+                                remainCount[key] = remainCount[key] - pickedQuestions.length;
+                                totalscore = totalscore + pickedQuestions.length * ITEM_SCORE[key];
+                            }
+                        }
+                        subarray.splice(subarray.length - 1, 1); ///把最后的问法删除
+                    }
+                }
+                ////删除已经处理的文本
+                arrContent.splice(0, MESSAGE_LENGTH);
+            }
+            ///发出信号，解析完毕
+            this.emit('parseover', { type: 'question', items: paperReturned });
+            return { successed: true, score: totalscore, paper: paperReturned };
+        });
+    }
+    /**
+     * 从答复中得到题目
+     * @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
+                        };
+                    });
+                }
+                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长度来划分到多个中
+     * @param {*} content
+     */
+    splitLongText(content, len = SECTION_LENGTH) {
+        let start = 0, message = [], length = content.length;
+        while (start < length) {
+            const subtext = content.substr(start, len);
+            if (subtext)
+                message.push({ role: 'user', content: subtext });
+            start += len;
+        }
+        return message;
+    }
 }

package/package.json

@@ -1,14 +1,12 @@
 {
   "name": "doomiaichat",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Doomisoft OpenAI",
   "main": "dist/index.js",
   "scripts": {
     "build": "tsc"
   },
-  "keywords": [
-    "ChatGpt"
-  ],
+  "keywords": ["ChatGpt"],
   "author": "Stephen.Shen",
   "license": "ISC",
   "devDependencies": {

package/src/index.ts

@@ -1,6 +1,17 @@
 import { Configuration, OpenAIApi, CreateChatCompletionResponse, ChatCompletionRequestMessage } from "openai"
 import { EventEmitter } from "events";
 import { AxiosRequestConfig, AxiosResponse } from "axios";
+const SECTION_LENGTH = 256;     ///每256个字符分成一组
+const MESSAGE_LENGTH = 8;      ///每次送8句话给openai 进行解析，送多了，会报错
+//请将答案放在最后,标记为答案：()
+const QUESTION_TEXT_MAPPING: any = {
+    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数组中包含填空答案' //请将答案放在最后,标记为答案：()
+}
+const QUESTION_TYPE:Array<string> = ['singlechoice', 'multiplechoice', 'trueorfalse', 'completion']
+
 export class AIChat extends EventEmitter {
     private readonly chatRobot: OpenAIApi;
     private readonly chatModel: string;
@@ -75,6 +86,220 @@ export class AIChat extends EventEmitter {
         ]
         return this.chatRequest(messages, {maxtoken:32}, axiosOption);
     }
+
+
+    /**
+      * 获得一种内容的相似说法
+     * 比如：
+     * 你今年多大？
+     * 相似问法：您是哪一年出生的
+     * 您今年贵庚？
+     * @param {*} content 
+     * @param {需要出来的数量} count 
+     */
+    async getSimilarityContent(content:string, count:number = 1, axiosOption:AxiosRequestConfig = {}):Promise<ChatReponse> {
+        let chnReg:boolean = /([\u4e00-\u9fa5]|[\ufe30-\uffa0])/.test(content)  ///检查源话是否含有中文内容
+        let engReg: boolean = /[a-zA-Z]/.test(content)  ///检查源话是否含有英文内容
+         ///如果源话是全中文，那么结果中不应该出来英文的相似说法，如果源话是全英文，则结果不能出现全中文的说法
+        let prefix = (!chnReg && engReg) ? '请用完整的英文表达,' : ((chnReg && !engReg) ? '请用完整的中文表达,':'')
+        const text = `${prefix}生成与下面句子意思相同的内容"${content}"`
+        let result = await this.chatRequest(this.splitLongText(text), { replyCounts: count }, axiosOption);
+        if (!result.successed || !result.message) return result;
+        let replys = result.message.map(item => { return item.message.content.trim(); })
+        return { successed: true, message: replys }
+    }
+
+    /**
+     * 从指定的文本内容中生成相关的问答
+     * @param {*} content 
+     * @param {*} count 
+     * @param {*} axiosOption 
+     * @returns 
+     *///并在答案末尾处必须给出答案内容中的关键词
+    async generateQuestionsFromContent(content:string, count:number = 1, axiosOption:AxiosRequestConfig = {}):Promise<ChatReponse> {
+        let arrContent = this.splitLongText(content);
+        ///没20句话分为一组，适应大文件内容多次请求组合结果
+        ///每一句话需要产生的题目
+        let questions4EverySentense:number = count / arrContent.length; //Math.ceil(arrContent.length / 20);
+        let faqs:Array<FaqResultResponse> = [], gotted:number = 0;
+        while (arrContent.length > 0 && gotted < count) {
+            ////每次最多送MESSAGE_LENGTH句话给openai
+            let subarray = arrContent.slice(0, MESSAGE_LENGTH);
+            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 = await this.chatRequest(subarray, { replyCounts: itemCount} , axiosOption);
+            if (result.successed && result.message) {
+                let msgs = this.pickUpFaqContent(result.message);
+                if (msgs.length) {
+                    ///对外发送检出问答题的信号
+                    this.emit('parseout', { type: 'qa', items: msgs })
+                    gotted += msgs.length; //result.message.length;
+                    //  console.log('gotted=', gotted)
+                    faqs = faqs.concat(msgs);
+                }
+
+            }
+            ////删除已经处理的文本
+            arrContent.splice(0, MESSAGE_LENGTH);
+
+        }
+        arrContent = [];  /// 释放内存
+        ///发出信号，解析完毕
+        this.emit('parseover', { type: 'qa', items: faqs })
+        return { successed: true, message: faqs };
+    }
+    /**
+     * 解析Faq返回的问题
+     * @param {*} messages 
+     * @returns 
+     */
+    private pickUpFaqContent(messages: Array<any>): Array<FaqResultResponse> {
+        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 });
+    }
+
+    /**
+     * 从指定的文本内容中生成一张试卷
+     * @param {*} content 
+     * @param {试卷的参数} paperOption 
+     * totalscore: 试卷总分，默认100
+     * section: {type:[0,1,2,3]为单选、多选、判断、填空题型  count:生成多少道  score:本段分数} 
+     * @param {*} axiosOption 
+     * @returns 
+     *///并在答案末尾处必须给出答案内容中的关键词
+    async generateExaminationPaperFromContent(content: string, paperOption: any = {}, axiosOption: AxiosRequestConfig = {}): Promise<ExaminationPaperResult> {
+        let arrContent = this.splitLongText(content);
+        let sectionCount: any = {
+            singlechoice: (paperOption.singlechoice?.count || 0) / arrContent.length,
+            multiplechoice: (paperOption.multiplechoice?.count || 0) / arrContent.length,
+            trueorfalse: (paperOption.trueorfalse?.count || 0) / arrContent.length,
+            completion: (paperOption.completion?.count || 0) / arrContent.length
+        };
+        ///剩余待生成的题目数量
+        let remainCount:any = {
+            singlechoice:paperOption.singlechoice?.count || 0,
+            multiplechoice: paperOption.multiplechoice?.count || 0,
+            trueorfalse: paperOption.trueorfalse?.count || 0,
+            completion: paperOption.completion?.count || 0
+        };
+        ///每种类型的题目的分数
+        let ITEM_SCORE: any = {
+            singlechoice: paperOption.singlechoice?.score || 0,
+            multiplechoice: paperOption.multiplechoice?.score || 0,
+            trueorfalse: paperOption.trueorfalse?.score || 0,
+            completion: paperOption.completion?.score || 0
+        };
+        ///最后生成出来的结果
+        let paperReturned: any = {
+            singlechoice: [], multiplechoice: [], trueorfalse: [], completion: []
+
+        }, noMoreQuestionRetrive:boolean = false, totalscore:number = 0;
+
+        while (arrContent.length > 0 && !noMoreQuestionRetrive) {
+            ////每次最多送MESSAGE_LENGTH句话给openai
+            let subarray = arrContent.slice(0, MESSAGE_LENGTH);
+            /**
+             * 每种类型的题目进行遍历
+             */
+            noMoreQuestionRetrive = true;
+            for (const key of QUESTION_TYPE) {
+                ///还需要抓取题目
+                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 = await this.chatRequest(subarray, { replyCounts: itemCount } , axiosOption);
+                    if (result.successed && result.message) {
+                        //console.log('paper result', key, result.message.length)
+                        let pickedQuestions = this.pickUpQuestions(result.message, key, ITEM_SCORE[key]);
+                        if (pickedQuestions.length) {
+                            ///对外发送检出题目的信号
+                            this.emit('parseout', { type: 'question', name: key, items: pickedQuestions })
+                            paperReturned[key] = paperReturned[key].concat(pickedQuestions);
+                            remainCount[key] = remainCount[key] - pickedQuestions.length;
+                            totalscore = totalscore + pickedQuestions.length * ITEM_SCORE[key];
+                        }
+                    }
+                    subarray.splice(subarray.length - 1, 1);  ///把最后的问法删除
+                }
+            }
+            ////删除已经处理的文本
+            arrContent.splice(0, MESSAGE_LENGTH);
+        }
+        ///发出信号，解析完毕
+        this.emit('parseover', { type: 'question', items: paperReturned })
+        return { successed: true, score: totalscore, paper: paperReturned  }
+    }
+    /**
+     * 从答复中得到题目
+     * @param {*} result
+     * 
+     */
+    private pickUpQuestions(result: Array<any>, questiontype: string, score: number = 1): Array<QuestionItemResultResponse> {
+        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长度来划分到多个中
+     * @param {*} content 
+     */
+    private splitLongText(content: string, len = SECTION_LENGTH): Array<ChatCompletionRequestMessage> {
+        let start = 0, message: Array<ChatCompletionRequestMessage> = [], length = content.length;
+        while (start < length) {
+            const subtext = content.substr(start, len);
+            if (subtext) message.push({ role: 'user', content: subtext })
+            start += len;
+        }
+        return message;
+    }
 }
 
 /**
@@ -103,8 +328,40 @@ export interface ChatReponse {
  * 调用OpenAI Api的参数约定
  */
 export interface CallChatApiOption{
-    model?:string,      ///模型名称
-    maxtoken?:number;    ///返回的最大token
-    temperature?:number;
-    replyCounts?:number;  ///返回多少答案
-}
+    'model'?:string,      ///模型名称
+    'maxtoken'?:number;    ///返回的最大token
+    'temperature'?:number;
+    'replyCounts'?:number;  ///返回多少答案
+}
+
+/**
+ * 调用OpenAI Api的参数约定
+ */
+export interface FaqResultResponse {
+    'question': string,      ///模型名称
+    'answer'?: string;    ///返回的最大token
+    'keywords'?: Array<string>;
+}
+
+/**
+ * 调用OpenAI Api的参数约定
+ */
+export interface ExaminationPaperResult {
+    /**
+    * return the result of api called
+    * @type {boolean}
+    */
+    'successed': boolean,
+    'score': number,      ///卷面总分
+    'paper': any
+}
+/**
+ * 调用OpenAI Api的参数约定
+ */
+export interface QuestionItemResultResponse {
+    'question': string,      ///模型名称
+    'answer'?: Array<string>;    ///返回的最大token
+    'choice'?: Array<string>;
+    'score'?:number;
+}
+