doomiaichat 2.1.0 → 2.3.0

package/src/openai.ts

@@ -1,6 +1,7 @@
 import { Configuration, OpenAIApi, ChatCompletionRequestMessage } from "openai"
-import { EventEmitter } from "events";
-import { OpenAIApiParameters, ChatReponse, OutlineSummaryItem, SummaryReponse, FaqItem, ExaminationPaperResult, EmotionResult, SimilarityResult, QuestionItem } from './declare'
+// import { EventEmitter } from "events";
+import GptBase from "./gptbase"
+import { OpenAIApiParameters, ChatReponse, OutlineSummaryItem, SummaryReponse, FaqItem, ExaminationPaperResult, EmotionResult, SimilarityResult, QuestionItem, CommentResult } from './declare'
 const SECTION_LENGTH = 1600;     ///每2400个字符分成一组
 const MESSAGE_LENGTH = 1;      ///每次送8句话给openai 进行解析，送多了，会报错
 //请将答案放在最后,标记为答案：()
@@ -13,7 +14,7 @@ const QUESTION_TEXT_MAPPING: any = {
 
 const QUESTION_TYPE: string[] = ['singlechoice', 'multiplechoice', 'trueorfalse', 'completion']
 
-export default class OpenAIGpt extends EventEmitter {
+export default class OpenAIGpt extends GptBase {
     protected readonly apiKey: string;
     private aiApi: OpenAIApi | undefined;
     protected readonly chatModel: string;
@@ -34,8 +35,8 @@ export default class OpenAIGpt extends EventEmitter {
     /**
      * 初始化OpenAI 的聊天对象Api
      */
-    createOpenAI(apiKey:string):OpenAIApi {
-        return  new OpenAIApi(new Configuration({ apiKey }))
+    createOpenAI(apiKey: string): OpenAIApi {
+        return new OpenAIApi(new Configuration({ apiKey }))
     }
     /**
      * 向OpenAI发送一个聊天请求
@@ -43,22 +44,22 @@ export default class OpenAIGpt extends EventEmitter {
      */
     public async chatRequest(chatText: string | Array<any>, callChatOption: OpenAIApiParameters, axiosOption: any = {}): Promise<ChatReponse> {
         if (!chatText) return { successed: false, error: { errcode: 2, errmsg: '缺失聊天的内容' } };
-        if (!this.aiApi){
+        if (!this.aiApi) {
             this.aiApi = this.createOpenAI(this.apiKey);
             //return { successed: false, error: { errcode: 1, errmsg: '聊天机器人无效' } };
-        } 
+        }
 
         let message: Array<ChatCompletionRequestMessage> = typeof (chatText) == 'string' ?
             [{ role: 'user', content: chatText }] : chatText;
         // console.log('message', message)
         try {
-            const response= await this.aiApi.createChatCompletion({
-                    model: callChatOption?.model || this.chatModel,
-                    messages: message,
-                    temperature: Number(callChatOption?.temperature || this.temperature),
-                    max_tokens: Number(callChatOption?.maxtoken || this.maxtoken),
-                    n: Number(callChatOption?.replyCounts || 1) || 1
-                }, axiosOption);
+            const response = await this.aiApi.createChatCompletion({
+                model: callChatOption?.model || this.chatModel,
+                messages: message,
+                temperature: Number(callChatOption?.temperature || this.temperature),
+                max_tokens: Number(callChatOption?.maxtoken || this.maxtoken),
+                n: Number(callChatOption?.replyCounts || 1) || 1
+            }, axiosOption);
             return { successed: true, message: response.data.choices };
         } catch (error) {
             console.log('result is error ', error)
@@ -67,7 +68,36 @@ export default class OpenAIGpt extends EventEmitter {
 
     }
 
-
+    /**
+     * 点评问题回答的评价
+     * @param question 
+     * @param answer 
+     * @param axiosOption 
+     */
+    async commentQuestionAnswer(question: string, answer: string, axiosOption: any = { timeout: 30000 }): Promise<CommentResult>{
+        if (!question || !answer) return { successed: false, error: { errcode: 2, errmsg: '缺失参数' } }
+        let message = [
+            {role:'system',content:'你是一名专业的培训师。'},
+            { role: 'user', content: `问题题干:“${question}”`},
+            { role: 'user', content: `回答内容:“${answer}”` },
+            { role: 'user', content: `请根据以上的回答内容进行点评，给出一段不超过200字的评语，以及0-100的得分。最终结果按照{"comment":"评语","score":80}的JSON结构输出` }
+        ]
+        const result = await this.chatRequest(message, {}, axiosOption);
+        if (result.successed && result.message) {
+            let value = result.message[0].message.content.trim();
+            let replyJson = this.fixedJsonString(value);
+            ///能够提取到内容
+            if (replyJson.length)return { successed: true,...replyJson[0] }
+            ///回答的内容非JSON格式，自己来提取算了
+            console.log('自己组装')
+            let matched = value.match(/\d+分/g),score=0;
+            if (matched && matched.length){
+                score =Number(matched[0].replace('分',''));
+            }
+            return {successed:true,comment:value,score}
+        }
+        return { successed: false};
+    }
     /**
      * 判断一句话的表达情绪
      * @param {*} s1 
@@ -171,7 +201,7 @@ export default class OpenAIGpt extends EventEmitter {
         ///没20句话分为一组，适应大文件内容多次请求组合结果
         ///每一句话需要产生的题目
         let questions4EverySentense: number = count / arrContent.length; //Math.ceil(arrContent.length / 20);
-        let faqs: Array<FaqItem> = [], gotted: number = 0;
+        let faqs: FaqItem[] = [], gotted: number = 0;
         while (arrContent.length > 0 && gotted < count) {
             questions4EverySentense = (count - gotted) / arrContent.length
             ////每次最多送MESSAGE_LENGTH句话给openai
@@ -180,7 +210,7 @@ export default class OpenAIGpt extends EventEmitter {
             //subarray.push({ role: 'user', content:'请根据上述内容,给出一道提问与答案以及答案关键词，按照先问题内容，再标准答案，再关键词的顺序输出,关键词之间用、分开'})
             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)
+            // 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)
@@ -200,7 +230,7 @@ export default class OpenAIGpt extends EventEmitter {
         arrContent = [];  /// 释放内存
         ///发出信号，解析完毕
         this.emit('parseover', { type: 'qa', items: faqs })
-        return { successed: true, message: faqs };
+        return { successed: true, message: faqs.slice(0, count) };
     }
 
     /**
@@ -240,16 +270,18 @@ export default class OpenAIGpt extends EventEmitter {
      */
     protected pickUpFaqContent(messages: Array<any>): Array<FaqItem> {
         let answerString = messages[0].message.content.trim().replace(/\t|\n|\v|\r|\f/g, '');
-        const firstsybmol = answerString.indexOf("[");   ////必须过滤出来数组
-        const lastsybmol = answerString.lastIndexOf("]");
+        // 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)
+        // console.log('answerString', answerString)
+        // if (firstsybmol < 0 || lastsybmol < 0 || lastsybmol <= firstsybmol) return [];
+        // answerString = answerString.substr(firstsybmol, lastsybmol - firstsybmol + 1);
+        // console.log('answerString', answerString)
+        let jsonObj = this.fixedJsonString(answerString);
+        if (!jsonObj.length) return []
         try {
             //let jsonObj = JSON.parse(answerString);
-            let jsonObj = eval(answerString);
+            //let jsonObj = eval(answerString);
             jsonObj.map((item: FaqItem) => {
                 let realKeyword: string[] = [];
                 let keywords: string[] = (item.keywords + '').split(',');
@@ -348,29 +380,32 @@ export default class OpenAIGpt extends EventEmitter {
      */
     protected pickUpQuestions(result: Array<any>, count: number, questiontype: string, score: number = 1): Array<QuestionItem> {
         let answerString = result[0].message.content.trim().replace(/\t|\n|\v|\r|\f/g, '');
-        const firstsybmol = answerString.indexOf("[");   ////必须过滤出来数组
-        const lastsybmol = answerString.lastIndexOf("]");
+        // 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)
+        // console.log('answerString', answerString)
+        // if (firstsybmol < 0 || lastsybmol < 0 || lastsybmol <= firstsybmol) return [];
+        // answerString = answerString.substr(firstsybmol, lastsybmol - firstsybmol + 1);
+        // console.log('answerString', answerString)
+        let jsonObj = this.fixedJsonString(answerString);
+        if (!jsonObj.length) return []
         let returnItems: QuestionItem[] = [];
         try {
-            let jsonObj = JSON.parse(answerString);
-            returnItems = jsonObj.map((questionitem: QuestionItem) => {
-                console.log('answer item', questionitem);
+            // let jsonObj = JSON.parse(answerString);
+            returnItems = jsonObj.map((questionitem: any) => {
+                console.log('answer item from jsonObj', questionitem);
                 if (questionitem.choice && Array.isArray(questionitem.choice) && questiontype != 'completion') {
                     questionitem.fullanswer = (questionitem.answer + '').replace(/,|[^ABCDE]/g, '');
                     questionitem.score = score;
                     if (questionitem.choice) {
                         questionitem.choice = questionitem.choice.map((item: string, index: number) => {
-                            let seqNo = String.fromCharCode(65 + 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(),
+                                content: (item + '').replace(correctReg, '').trim(),
                                 iscorrect: (questionitem.fullanswer || '').indexOf(seqNo) >= 0 ? 1 : 0
                                 //|| jsonObj.fullanswer.indexOf(m))
                             }
@@ -396,7 +431,7 @@ export default class OpenAIGpt extends EventEmitter {
                 }
                 ///单选题验证
                 if (questiontype == 'singlechoice') {
-                    let rightAnswer = questionitem.choice ? questionitem.choice.filter(item => { return item.iscorrect === 1 }) : [];
+                    let rightAnswer = questionitem.choice ? questionitem.choice.filter((item: { iscorrect: number; }) => { return item.iscorrect === 1 }) : [];
                     ///单选题的正确选项大于了1个
                     if (rightAnswer.length != 1 || !questionitem.answer || questionitem.answer.length !== 1) return null;
                     ///正确选项和答案不一致
@@ -404,7 +439,7 @@ export default class OpenAIGpt extends EventEmitter {
                 }
                 ///多选题验证
                 if (questiontype == 'multiplechoice') {
-                    let rightAnswer = questionitem.choice ? questionitem.choice.filter(item => { return item.iscorrect === 1 }) : [];
+                    let rightAnswer = questionitem.choice ? questionitem.choice.filter((item: { iscorrect: number; }) => { return item.iscorrect === 1 }) : [];
                     ///单选题的正确选项大于了1个
                     if (rightAnswer.length === 0 || !questionitem.answer || questionitem.answer.length === 0) return null;
                 }
@@ -415,43 +450,54 @@ export default class OpenAIGpt extends EventEmitter {
             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; });
     }
+    /**
+     * 验证JSON字符串是否是真正可转换为JSON的合法格式
+     * 这里只能做一个最简单的处理，就是用两端的符号
+     * @param jsonstr 
+     */
+    protected fixedJsonString(jsonstr: string): any[] {
+        console.log('original json string:', jsonstr)
+        ///检查返回的是不是一个数组对象（我们需要的是数组对象)
+        let firstBracketSymbol = jsonstr.indexOf("[");   ////必须过滤出来数组
+        let lastBracketSymbol = jsonstr.lastIndexOf("]");
+        ///第一个花括号出现的位置，如果花括号出现的位置早于 [ ,则默认返回的对象不是一个数组，仅仅是一个对象，
+        ///则需要我们用中括号包住
+        let firstBraceSymbol = jsonstr.indexOf("{");
+        let lastBraceSymbol = jsonstr.lastIndexOf("}");
+        ///返回的不是一个数组结构的,只是一个{}，我们帮他完成数组拼接
+        if (firstBraceSymbol >= 0 && 
+            firstBraceSymbol < (firstBracketSymbol >= 0 ? firstBracketSymbol:1000) && 
+            lastBraceSymbol > firstBraceSymbol && 
+            lastBraceSymbol >= 0 && lastBraceSymbol > lastBracketSymbol){
+
+            jsonstr = '[' + jsonstr.substr(firstBraceSymbol, lastBraceSymbol - firstBraceSymbol + 1); +']';
+            firstBracketSymbol = 0;
+            lastBracketSymbol = jsonstr.length-1;
+        }
+        else if (firstBracketSymbol < 0 || lastBracketSymbol < 0 || lastBracketSymbol <= firstBracketSymbol){
+            return [];
+        }
+        jsonstr = jsonstr.substr(firstBracketSymbol, lastBracketSymbol - firstBracketSymbol + 1);
+        ///尽量处理一些能够一眼识别出来的JSON错误
+        jsonstr = jsonstr.replace(/}{/g,'},{');
+        let mutilitems = jsonstr.split('][');
+        ///确实存在多个数组拼接在一起，中间没有逗号隔开的了
+        let retObject:any[] = [];
+        for(let str of mutilitems){
+            if (!str.startsWith('[')) str = '[' + str;
+            if (!str.endsWith(']')) str =  str+']';
+            // console.log('json str', str)
+            try{
+                let jsonObj = eval(str);
+                retObject = retObject.concat(jsonObj);
+            }catch(err){
+                console.log('json error', str)
+            }
+        }
+        return retObject;
+    }
+
     /**
      * 将一段很长的文本，按1024长度来划分到多个中
      * @param {*} content 
@@ -474,4 +520,5 @@ export default class OpenAIGpt extends EventEmitter {
         }
         return message;
     }
+
 }

package/src/openaiprovider.ts

@@ -1,32 +0,0 @@
-/**
-* 语音转文字服务商工厂
-*/
-import OpenAIGpt from './openai';
-import AzureAI from './azureai'
-/**
- * OpenAI/NLP 的服务提供商 OpenAI,微软，百度文心(待接入)，google(待接入)
- */
-export const AIProviderEnum = {
-    OPENAI: 'openai',
-    MICROSOFT: 'microsoft',
-    BAIDU: 'baidu',
-    GOOGLE:'google'
-} as const;
-export type AIProviderEnum = typeof AIProviderEnum[keyof typeof AIProviderEnum];
-/**
- * 根据类型创建不同的TTS引擎对象
- * @param {*} provider 
- * @param {*} apikey 
- * @param {*} setting 
- * @returns 
- */
-export function createAIInstance(provider: AIProviderEnum, apikey: string, setting: any): OpenAIGpt | null {
-    let { model, maxtoken, temperature,endpoint,engine,version } = setting;
-    switch (provider) {
-        case AIProviderEnum.OPENAI: 
-            return new OpenAIGpt(apikey, { model, maxtoken, temperature });
-        case AIProviderEnum.MICROSOFT: 
-            return new AzureAI(apikey, { endpoint, engine, version }, { model, maxtoken, temperature }, );
-        default: return null;
-    }
-};