doomiaichat 1.4.5 → 2.1.0

package/dist/index.js

@@ -1,363 +1,27 @@
 "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());
-    });
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 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 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'];
-class AIChat extends events_1.EventEmitter {
-    /**
-     *
-     * @param apiKey 调用OpenAI 的key
-     * @param apiOption
-     */
-    constructor(apiKey, apiOption = {}) {
-        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.temperature = apiOption.temperature || 0.9;
-    }
-    /**
-     * 向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.chatRobot)
-                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.chatRobot.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) {
-                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: '根据上述内容精简，提炼摘要内容，并将摘要逐条放入JSON数组结构输出' });
-                let result = yield this.chatRequest(subarray, {}, axiosOption);
-                if (result.successed && result.message) {
-                    try {
-                        let jsonObjItems = JSON.parse(result.message[0].content);
-                        console.log('result.message[0].content', result.message[0].content);
-                        if (Array.isArray(jsonObjItems))
-                            summary = summary.concat(jsonObjItems);
-                    }
-                    catch (error) {
-                        console.log('result.message[0].content', error, result.message[0].content);
-                    }
-                }
-                ////删除已经处理的文本
-                arrContent.splice(0, MESSAGE_LENGTH);
-            }
-            return { successed: true, 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);
-            ///没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;
-    }
-}
-exports.AIChat = AIChat;
+exports.AIFactory = void 0;
+exports.AIFactory = __importStar(require("./openaiprovider"));

package/dist/openai.d.ts

@@ -0,0 +1,94 @@
+/// <reference types="node" />
+import { OpenAIApi, ChatCompletionRequestMessage } from "openai";
+import { EventEmitter } from "events";
+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?: any): 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?: any): Promise<ChatReponse>;
+    /**
+     * 提取内容的中心思想摘要
+     * @param content
+     * @param axiosOption
+     */
+    getSummaryOfContent(content: string | Array<any>, axiosOption?: any): Promise<SummaryReponse>;
+    /**
+     * 从指定的文本内容中生成相关的问答
+     * @param {*} content
+     * @param {*} count
+     * @param {*} axiosOption
+     * @returns
+     */ generateQuestionsFromContent(content: string, count?: number, axiosOption?: any): Promise<ChatReponse>;
+    /**
+     * 从指定的文本内容中生成相关的问答
+     * @param {*} content
+     * @param {*} count
+     * @param {*} axiosOption
+     * @returns
+     */ generateQuestionsFromContent_Orgin(content: string, count?: number, promotion?: string | null, sliceslength?: number, axiosOption?: any): 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?: any): 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>;
+}