doomiaichat 1.4.4 → 2.0.0

package/dist/openai.d.ts

@@ -0,0 +1,95 @@
+/// <reference types="node" />
+import { OpenAIApi, ChatCompletionRequestMessage } from "openai";
+import { EventEmitter } from "events";
+import { AxiosRequestConfig } from "axios";
+import { OpenAIApiParameters, ChatReponse, SummaryReponse, FaqItem, ExaminationPaperResult, EmotionResult, SimilarityResult, QuestionItem } from './declare';
+export default class OpenAIGpt extends EventEmitter {
+    protected readonly apiKey: string;
+    private aiApi;
+    protected readonly chatModel: string;
+    protected readonly maxtoken: number;
+    protected readonly temperature: number;
+    /**
+     *
+     * @param apiKey 调用OpenAI 的key
+     * @param apiOption
+     */
+    constructor(apiKey: string, apiOption?: OpenAIApiParameters);
+    /**
+     * 初始化OpenAI 的聊天对象Api
+     */
+    createOpenAI(apiKey: string): OpenAIApi;
+    /**
+     * 向OpenAI发送一个聊天请求
+     * @param {*} chatText
+     */
+    chatRequest(chatText: string | Array<any>, callChatOption: OpenAIApiParameters, axiosOption?: AxiosRequestConfig): Promise<ChatReponse>;
+    /**
+     * 判断一句话的表达情绪
+     * @param {*} s1
+     * @param {*} axiosOption
+     */
+    getScentenceEmotional(s1: string, axiosOption?: any): Promise<EmotionResult>;
+    /**
+     * 获取两句话的相似度取值
+     * @param {*} s1
+     * @param {*} s2
+     */
+    getScentenseSimilarity(s1: string, s2: string, axiosOption?: any): Promise<SimilarityResult>;
+    /**
+      * 获得一种内容的相似说法
+     * 比如：
+     * 你今年多大？
+     * 相似问法：您是哪一年出生的
+     * 您今年贵庚？
+     * @param {*} content
+     * @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
+     * @param {*} count
+     * @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
+     * @returns
+     */
+    protected pickUpFaqContent(messages: Array<any>): Array<FaqItem>;
+    /**
+     * 从指定的文本内容中生成一张试卷
+     * @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
+     *
+     */
+    protected pickUpQuestions(result: Array<any>, count: number, questiontype: string, score?: number): Array<QuestionItem>;
+    /**
+     * 将一段很长的文本，按1024长度来划分到多个中
+     * @param {*} content
+     */
+    protected splitLongText(content: string, len?: number): Array<ChatCompletionRequestMessage>;
+}

package/dist/openai.js

@@ -0,0 +1,496 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const openai_1 = require("openai");
+const events_1 = require("events");
+const SECTION_LENGTH = 1600; ///每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_TYPE = ['singlechoice', 'multiplechoice', 'trueorfalse', 'completion'];
+class OpenAIGpt extends events_1.EventEmitter {
+    /**
+     *
+     * @param apiKey 调用OpenAI 的key
+     * @param apiOption
+     */
+    constructor(apiKey, apiOption = {}) {
+        super();
+        this.apiKey = apiKey;
+        this.chatModel = apiOption.model || 'gpt-3.5-turbo';
+        this.maxtoken = apiOption.maxtoken || 2048;
+        this.temperature = apiOption.temperature || 0.9;
+    }
+    /**
+     * 初始化OpenAI 的聊天对象Api
+     */
+    createOpenAI(apiKey) {
+        return new openai_1.OpenAIApi(new openai_1.Configuration({ apiKey }));
+    }
+    /**
+     * 向OpenAI发送一个聊天请求
+     * @param {*} chatText
+     */
+    chatRequest(chatText, callChatOption, axiosOption = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!chatText)
+                return { successed: false, error: { errcode: 2, errmsg: '缺失聊天的内容' } };
+            if (!this.aiApi) {
+                this.aiApi = this.createOpenAI(this.apiKey);
+                //return { successed: false, error: { errcode: 1, errmsg: '聊天机器人无效' } };
+            }
+            let message = typeof (chatText) == 'string' ?
+                [{ role: 'user', content: chatText }] : chatText;
+            // console.log('message', message)
+            try {
+                const response = yield this.aiApi.createChatCompletion({
+                    model: (callChatOption === null || callChatOption === void 0 ? void 0 : callChatOption.model) || this.chatModel,
+                    messages: message,
+                    temperature: Number((callChatOption === null || callChatOption === void 0 ? void 0 : callChatOption.temperature) || this.temperature),
+                    max_tokens: Number((callChatOption === null || callChatOption === void 0 ? void 0 : callChatOption.maxtoken) || this.maxtoken),
+                    n: Number((callChatOption === null || callChatOption === void 0 ? void 0 : callChatOption.replyCounts) || 1) || 1
+                }, axiosOption);
+                return { successed: true, message: response.data.choices };
+            }
+            catch (error) {
+                console.log('result is error ', error);
+                return { successed: false, error };
+            }
+        });
+    }
+    /**
+     * 判断一句话的表达情绪
+     * @param {*} s1
+     * @param {*} axiosOption
+     */
+    getScentenceEmotional(s1, axiosOption = { timeout: 30000 }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!s1)
+                return { successed: false, error: { errcode: 2, errmsg: '缺失参数' } };
+            const emotion = ['愤怒', '威胁', '讽刺', '愧疚', '兴奋', '友好', '消极', '生气', '正常'];
+            const messages = [
+                { role: 'user', content: s1 },
+                { role: 'user', content: `请分析上述内容的语言情绪,请从"${emotion.join(',')}"这些情绪中对应一个输出` },
+            ];
+            const result = yield this.chatRequest(messages, {}, axiosOption);
+            if (result.successed && result.message) {
+                let value = result.message[0].message.content.trim();
+                for (const word of emotion) {
+                    if (value.indexOf(word) >= 0)
+                        return { successed: true, emotion: word };
+                }
+            }
+            return { successed: true, emotion: '未知' };
+        });
+    }
+    /**
+     * 获取两句话的相似度取值
+     * @param {*} s1
+     * @param {*} s2
+     */
+    getScentenseSimilarity(s1, s2, axiosOption = { timeout: 30000 }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!s1 || !s2)
+                return { successed: false, error: { errcode: 2, errmsg: '缺失参数' } };
+            const messages = [
+                { role: 'user', content: s1 },
+                { role: 'user', content: s2 },
+                { role: 'user', content: '请从语义上对比以上两句话的相似度,请仅输出0至100之间的整数对比结果即可' },
+            ];
+            const result = yield this.chatRequest(messages, { maxtoken: 32 }, axiosOption);
+            if (result.successed && result.message) {
+                let value = result.message[0].message.content.replace(/[^\d]/g, "");
+                if (value > 100)
+                    value = Math.floor(value / 10);
+                return { successed: true, value: Number(value) };
+            }
+            return { successed: false, error: result.error, value: 0 };
+        });
+    }
+    /**
+      * 获得一种内容的相似说法
+     * 比如：
+     * 你今年多大？
+     * 相似问法：您是哪一年出生的
+     * 您今年贵庚？
+     * @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(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 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
+     * @param {*} count
+     * @param {*} axiosOption
+     * @returns
+     */ //并在答案末尾处必须给出答案内容中的关键词
+    generateQuestionsFromContent(content, count = 1, axiosOption = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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, 4);
+                let itemCount = Math.min(Math.ceil(subarray.length * questions4EverySentense), count - gotted);
+                //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);
+                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) {
+                        ///对外发送检出问答题的信号
+                        this.emit('parseout', { type: 'qa', items: msgs });
+                        gotted += msgs.length; //result.message.length;
+                        faqs = faqs.concat(msgs);
+                    }
+                }
+                ////删除已经处理的文本
+                arrContent.splice(0, 4);
+            }
+            arrContent = []; /// 释放内存
+            ///发出信号，解析完毕
+            this.emit('parseover', { type: 'qa', items: faqs });
+            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 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);
+                }
+                item.keywords = realKeyword;
+                return item;
+            });
+            return jsonObj;
+        }
+        catch (err) {
+            console.log('JSON error', err);
+            return [];
+        }
+    }
+    /**
+     * 从指定的文本内容中生成一张试卷
+     * @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, 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,
+                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;
+                        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 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, itemCount, 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(0, 1); ///把第一个角色定位的问法删除
+                        // 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, 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':
+                        questionitem.answer = (questionitem.answer + '').replace(/,|[^ABCDEFG]/g, '').split('').slice(0, 1);
+                        break;
+                    case 'multiplechoice':
+                        questionitem.answer = (questionitem.answer + '').replace(/,|[^ABCDEFG]/g, '').split('');
+                        break;
+                    case 'trueorfalse':
+                        questionitem.answer = [(questionitem.answer + '').indexOf('正确') >= 0 ? 'A' : 'B'];
+                        break;
+                }
+                ///单选题验证
+                if (questiontype == 'singlechoice') {
+                    let rightAnswer = questionitem.choice ? questionitem.choice.filter(item => { return item.iscorrect === 1; }) : [];
+                    ///单选题的正确选项大于了1个
+                    if (rightAnswer.length != 1 || !questionitem.answer || questionitem.answer.length !== 1)
+                        return null;
+                    ///正确选项和答案不一致
+                    if (rightAnswer[0].id.toUpperCase() != (questionitem.answer[0] || '').toUpperCase())
+                        return null;
+                }
+                ///多选题验证
+                if (questiontype == 'multiplechoice') {
+                    let rightAnswer = questionitem.choice ? questionitem.choice.filter(item => { return item.iscorrect === 1; }) : [];
+                    ///单选题的正确选项大于了1个
+                    if (rightAnswer.length === 0 || !questionitem.answer || questionitem.answer.length === 0)
+                        return null;
+                }
+                return questionitem;
+            });
+        }
+        catch (err) {
+            console.log('error happened:', err);
+        }
+        return returnItems.filter(i => { return i != null; }).slice(0, count);
+        // 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
+     */
+    splitLongText(content, len = SECTION_LENGTH) {
+        let start = 0, message = [], length = content.length;
+        while (start < length) {
+            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 += realLength || len;
+        }
+        return message;
+    }
+}
+exports.default = OpenAIGpt;

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "doomiaichat",
-  "version": "1.4.4",
+  "version": "2.0.0",
   "description": "Doomisoft OpenAI",
   "main": "dist/index.js",
   "scripts": {
     "build": "tsc"
   },
-  "keywords": ["ChatGpt"],
+  "keywords": [
+    "ChatGpt"
+  ],
   "author": "Stephen.Shen",
   "license": "ISC",
   "devDependencies": {
-    "@types/node": "^18.15.0",
+    "@types/node": "^18.15.11",
     "typescript": "^4.9.5"
   },
   "dependencies": {

package/src/azureai.ts

@@ -0,0 +1,53 @@
+import { AzureOpenAIPatameters, ChatReponse, OpenAIApiParameters } from "./declare";
+import { AxiosRequestConfig, AxiosResponse, Axios } from "axios";
+import OpenAIGpt from "./openai" 
+import { ChatCompletionRequestMessage } from "openai";
+export default class AzureAI extends OpenAIGpt {
+    protected readonly apiKey: string;
+    protected readonly azureSetting: AzureOpenAIPatameters;
+    constructor(apiKey: string, azureOption:AzureOpenAIPatameters, apiOption: OpenAIApiParameters = {}) {
+        super(apiKey, apiOption);
+        this.azureSetting = azureOption;
+        if (!this.azureSetting.endpoint.toLowerCase().startsWith('https://') &&
+            !this.azureSetting.endpoint.toLowerCase().startsWith('https://')){
+            this.azureSetting.endpoint = 'https://' + this.azureSetting.endpoint;
+        }
+    }
+    /**
+     * ZAure OpenAI 最新的URL地址
+     */
+    get BaseUrl():string{
+        return `${this.azureSetting.endpoint}/openai/deployments/${this.azureSetting.engine}/chat/completions?api-version=${this.azureSetting.version ||'2023-03-15-preview'}`
+    }
+    /**
+     * 请求GPT接口
+     */
+    public async chatRequest(chatText: string | Array<any>, paramOption: OpenAIApiParameters, axiosOption: AxiosRequestConfig = {}): Promise<ChatReponse> {
+        if (!chatText) return { successed: false, error: { errcode: 2, errmsg: '缺失聊天的内容' } };
+        if (!axiosOption.headers )
+            axiosOption.headers = { 'api-key': this.apiKey,'Content-Type':'application/json'};
+        else{
+            axiosOption.headers['api-key']=this.apiKey;
+            axiosOption.headers['Content-Type'] = 'application/json';
+        }
+
+        let messages: Array<ChatCompletionRequestMessage> = typeof (chatText) == 'string' ?
+            [{ role: 'user', content: chatText }] : chatText;
+        let axios = new Axios(axiosOption)
+        try{
+            const response = await axios.post(this.BaseUrl, {
+                messages,
+                temperature: Number(paramOption?.temperature || this.temperature),
+                max_tokens: Number(paramOption?.maxtoken || this.maxtoken),
+            })
+            if (response.data.choices){
+                return { successed: true, message: response.data.choices };
+            }
+            return { successed: false, ...response.data };
+        } catch (error) {
+            console.log('result is error ', error)
+            return { successed: false, error };
+        }
+        
+    }
+}