doomiaichat 2.0.0 → 2.1.0

package/dist/azureai.d.ts

@@ -0,0 +1,14 @@
+import { AzureOpenAIPatameters, ChatReponse, OpenAIApiParameters } from "./declare";
+import OpenAIGpt from "./openai";
+export default class AzureAI extends OpenAIGpt {
+    protected readonly azureSetting: AzureOpenAIPatameters;
+    constructor(apiKey: string, azureOption: AzureOpenAIPatameters, apiOption?: OpenAIApiParameters);
+    /**
+     * ZAure OpenAI 最新的URL地址
+     */
+    get BaseUrl(): string;
+    /**
+     * 请求GPT接口
+     */
+    chatRequest(chatText: string | Array<any>, paramOption: OpenAIApiParameters, axiosOption?: any): Promise<ChatReponse>;
+}

package/dist/azureai.js

@@ -0,0 +1,73 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const openai_1 = __importDefault(require("./openai"));
+class AzureAI extends openai_1.default {
+    constructor(apiKey, azureOption, apiOption = {}) {
+        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() {
+        return `${this.azureSetting.endpoint}/openai/deployments/${this.azureSetting.engine}/chat/completions?api-version=${this.azureSetting.version || '2023-03-15-preview'}`;
+    }
+    /**
+     * 请求GPT接口
+     */
+    chatRequest(chatText, paramOption, axiosOption = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = 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),
+                // })
+                let param = Object.assign(Object.assign({}, axiosOption), { method: "post", data: {
+                        messages,
+                        temperature: Number((paramOption === null || paramOption === void 0 ? void 0 : paramOption.temperature) || this.temperature),
+                        max_tokens: Number((paramOption === null || paramOption === void 0 ? void 0 : paramOption.maxtoken) || this.maxtoken),
+                    }, url: this.BaseUrl });
+                console.log('axiosOption', param);
+                const response = yield (0, axios_1.default)(param);
+                if (response.data.choices) {
+                    return { successed: true, message: response.data.choices };
+                }
+                return Object.assign({ successed: false }, response.data);
+            }
+            catch (error) {
+                console.log('result is error ', error);
+                return { successed: false, error };
+            }
+        });
+    }
+}
+exports.default = AzureAI;

package/dist/index.d.ts

@@ -1,179 +1 @@
-/// <reference types="node" />
-import { EventEmitter } from "events";
-import { AxiosRequestConfig } from "axios";
-export declare class AIChat extends EventEmitter {
-    private readonly chatRobot;
-    private readonly chatModel;
-    private readonly maxtoken;
-    private readonly temperature;
-    /**
-     *
-     * @param apiKey 调用OpenAI 的key
-     * @param apiOption
-     */
-    constructor(apiKey: string, apiOption?: CallChatApiOption);
-    /**
-     * 向OpenAI发送一个聊天请求
-     * @param {*} chatText
-     */
-    chatRequest(chatText: string | Array<any>, callChatOption: CallChatApiOption, 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
-     */
-    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;
-}
-interface ApiResult {
-    /**
-     * return the result of api called
-     * @type {boolean}
-     */
-    'successed': boolean;
-    /**
-     * The error info
-     * @type {any}
-     * @memberof ChatReponse
-     */
-    'error'?: any;
-}
-/**
- * Api封装后的返回结果
- */
-export interface ChatReponse extends ApiResult {
-    /**
-     * The name of the user in a multi-user chat
-     * @type {Array<any>}
-     * @memberof ChatReponse
-     */
-    'message'?: Array<any>;
-}
-interface OutlineSummaryItem {
-    /**
-     * The name of the user in a multi-user chat
-     * @type {Array<any>}
-     * @memberof SummaryReponse
-     */
-    'outline'?: string;
-    'summary'?: Array<string>;
-}
-/**
- * 摘要信息
- */
-export interface SummaryReponse extends ApiResult {
-    /**
-     * The name of the user in a multi-user chat
-     * @type {Array<any>}
-     * @memberof SummaryReponse
-     */
-    'article'?: Array<OutlineSummaryItem>;
-}
-/**
- * 调用OpenAI Api的参数约定
- */
-export interface CallChatApiOption {
-    'model'?: string;
-    'maxtoken'?: number;
-    'temperature'?: number;
-    'replyCounts'?: number;
-}
-/**
- * 调用OpenAI Api的参数约定
- */
-export interface FaqItem {
-    'question': string;
-    'answer'?: string;
-    'keywords'?: Array<string>;
-}
-/**
- * 调用OpenAI Api的参数约定
- */
-export interface ExaminationPaperResult extends ApiResult {
-    'score': number;
-    'paper': any;
-}
-/**
- * 调用OpenAI Api的参数约定
- */
-export interface QuestionItem {
-    'question': string;
-    'fullanswer'?: string;
-    'answer'?: Array<string>;
-    'choice'?: any[];
-    'score'?: number;
-}
-/**
- * 调用OpenAI Api的参数约定
- */
-export interface SimilarityResult extends ApiResult {
-    'value'?: number;
-}
-/**
- * 调用OpenAI Api的参数约定
- */
-export interface EmotionResult extends ApiResult {
-    'emotion'?: string;
-}
-export {};
+export * as AIFactory from "./openaiprovider";

package/dist/index.js

@@ -1,509 +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 = 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"]}]的结构输出' //请将答案放在最后,标记为答案：()
-};
-// singlechoice: '你是一名专业的培训老师,根据以下内容,生成@ITEMCOUNT@道单选题,每道题目4个选项,每道题的选项中的元素用大写字母ABCD开头,每道题的只能有一个正确答案,最终结果按照[{"question":"","choice":[],"answer":[]}]的JSON数组输出',
-//     multiplechoice: '你是一名专业的培训老师,根据以下内容,请生成@ITEMCOUNT@道多选题,提供4个选项,答案至少1个以上选项,请按照{"question":"","choice":[],"answer":[]}的JSON结构输出,choice中的元素用大写字母ABCD开头,answer数组中包含正确答案选项',  //请将答案放在最后,标记为答案：()
-//         trueorfalse: '你是一名专业的培训老师,根据以下内容,请生成@ITEMCOUNT@道判断题,请按照{"question":"","choice":["A.正确","B.错误"],"answer":[]}的JSON结构输出,answer数组中包含一个元素,"正确"或"错误"', //标记为答案：(正确或错误)
-//             completion: '你是一名专业的培训老师,根据以下内容,请生成@ITEMCOUNT@道填空题,每道题目1个填空,请按照{"question":"","answer":[]}的JSON结构输出,answer数组中包含填空答案' //请将答案放在最后,标记为答案：()
-const QUESTION_TYPE = ['singlechoice', 'multiplechoice', 'trueorfalse', 'completion'];
-class AIChat extends events_1.EventEmitter {
-    /**
-     *
-     * @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 || 2048;
-        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) {
-                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;
-                        //  console.log('gotted=', gotted)
-                        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 [];
-        }
-        // 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, 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) });
-                        console.log(subarray);
-                        let result = yield this.chatRequest(subarray, { replyCounts: 1 }, axiosOption);
-                        if (result.successed && result.message) {
-                            //console.log('paper result', key, result.message.length)
-                            let pickedQuestions = this.pickUpQuestions(result.message, 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.AIChat = AIChat;
+exports.AIFactory = void 0;
+exports.AIFactory = __importStar(require("./openaiprovider"));

package/dist/openai.d.ts

@@ -1,7 +1,6 @@
 /// <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;
@@ -23,7 +22,7 @@ export default class OpenAIGpt extends EventEmitter {
      * 向OpenAI发送一个聊天请求
      * @param {*} chatText
      */
-    chatRequest(chatText: string | Array<any>, callChatOption: OpenAIApiParameters, axiosOption?: AxiosRequestConfig): Promise<ChatReponse>;
+    chatRequest(chatText: string | Array<any>, callChatOption: OpenAIApiParameters, axiosOption?: any): Promise<ChatReponse>;
     /**
      * 判断一句话的表达情绪
      * @param {*} s1
@@ -45,27 +44,27 @@ export default class OpenAIGpt extends EventEmitter {
      * @param {*} content
      * @param {需要出来的数量} count
      */
-    getSimilarityContent(content: string, count?: number, axiosOption?: AxiosRequestConfig): Promise<ChatReponse>;
+    getSimilarityContent(content: string, count?: number, axiosOption?: any): Promise<ChatReponse>;
     /**
      * 提取内容的中心思想摘要
      * @param content
      * @param axiosOption
      */
-    getSummaryOfContent(content: string | Array<any>, axiosOption?: AxiosRequestConfig): Promise<SummaryReponse>;
+    getSummaryOfContent(content: string | Array<any>, axiosOption?: any): Promise<SummaryReponse>;
     /**
      * 从指定的文本内容中生成相关的问答
      * @param {*} content
      * @param {*} count
      * @param {*} axiosOption
      * @returns
-     */ generateQuestionsFromContent(content: string, count?: number, axiosOption?: AxiosRequestConfig): Promise<ChatReponse>;
+     */ 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?: AxiosRequestConfig): Promise<ChatReponse>;
+     */ generateQuestionsFromContent_Orgin(content: string, count?: number, promotion?: string | null, sliceslength?: number, axiosOption?: any): Promise<ChatReponse>;
     /**
      * 解析Faq返回的问题
      * @param {*} messages
@@ -80,7 +79,7 @@ export default class OpenAIGpt extends EventEmitter {
      * section: {type:[0,1,2,3]为单选、多选、判断、填空题型  count:生成多少道  score:本段分数}
      * @param {*} axiosOption
      * @returns
-     */ generateExaminationPaperFromContent(content: string, paperOption?: any, axiosOption?: AxiosRequestConfig): Promise<ExaminationPaperResult>;
+     */ generateExaminationPaperFromContent(content: string, paperOption?: any, axiosOption?: any): Promise<ExaminationPaperResult>;
     /**
      * 从答复中得到题目
      * @param {*} result

package/dist/openaiprovider.d.ts

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

package/dist/openaiprovider.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAIInstance = exports.AIProviderEnum = void 0;
+/**
+* 语音转文字服务商工厂
+*/
+const openai_1 = __importDefault(require("./openai"));
+const azureai_1 = __importDefault(require("./azureai"));
+/**
+ * OpenAI/NLP 的服务提供商 OpenAI,微软，百度文心(待接入)，google(待接入)
+ */
+exports.AIProviderEnum = {
+    OPENAI: 'openai',
+    MICROSOFT: 'microsoft',
+    BAIDU: 'baidu',
+    GOOGLE: 'google'
+};
+/**
+ * 根据类型创建不同的TTS引擎对象
+ * @param {*} provider
+ * @param {*} apikey
+ * @param {*} setting
+ * @returns
+ */
+function createAIInstance(provider, apikey, setting) {
+    let { model, maxtoken, temperature, endpoint, engine, version } = setting;
+    switch (provider) {
+        case exports.AIProviderEnum.OPENAI:
+            return new openai_1.default(apikey, { model, maxtoken, temperature });
+        case exports.AIProviderEnum.MICROSOFT:
+            return new azureai_1.default(apikey, { endpoint, engine, version }, { model, maxtoken, temperature });
+        default: return null;
+    }
+}
+exports.createAIInstance = createAIInstance;
+;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doomiaichat",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Doomisoft OpenAI",
   "main": "dist/index.js",
   "scripts": {
@@ -16,6 +16,7 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
+    "axios": "^1.3.4",
     "openai": "^3.2.1"
   }
 }

package/src/azureai.ts

@@ -1,9 +1,8 @@
 import { AzureOpenAIPatameters, ChatReponse, OpenAIApiParameters } from "./declare";
-import { AxiosRequestConfig, AxiosResponse, Axios } from "axios";
+import 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);
@@ -22,7 +21,7 @@ export default class AzureAI extends OpenAIGpt {
     /**
      * 请求GPT接口
      */
-    public async chatRequest(chatText: string | Array<any>, paramOption: OpenAIApiParameters, axiosOption: AxiosRequestConfig = {}): Promise<ChatReponse> {
+    public override async chatRequest(chatText: string | Array<any>, paramOption: OpenAIApiParameters, axiosOption: any = {}): Promise<ChatReponse> {
         if (!chatText) return { successed: false, error: { errcode: 2, errmsg: '缺失聊天的内容' } };
         if (!axiosOption.headers )
             axiosOption.headers = { 'api-key': this.apiKey,'Content-Type':'application/json'};
@@ -33,13 +32,26 @@ export default class AzureAI extends OpenAIGpt {
 
         let messages: Array<ChatCompletionRequestMessage> = typeof (chatText) == 'string' ?
             [{ role: 'user', content: chatText }] : chatText;
-        let axios = new Axios(axiosOption)
+        //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),
-            })
+            // const response = await axios.post(this.BaseUrl, {
+            //     messages,
+            //     temperature: Number(paramOption?.temperature || this.temperature),
+            //     max_tokens: Number(paramOption?.maxtoken || this.maxtoken),
+            // })
+            let param = {
+                ...axiosOption,
+                method: "post",
+                data: {
+                    messages,
+                    temperature: Number(paramOption?.temperature || this.temperature),
+                    max_tokens: Number(paramOption?.maxtoken || this.maxtoken),
+                },
+                url: this.BaseUrl
+            };
+            console.log('axiosOption', param)
+
+            const response = await axios(param)
             if (response.data.choices){
                 return { successed: true, message: response.data.choices };
             }

package/src/openai.ts

@@ -1,6 +1,5 @@
-import { Configuration, OpenAIApi, CreateChatCompletionResponse, ChatCompletionRequestMessage } from "openai"
+import { Configuration, OpenAIApi, ChatCompletionRequestMessage } from "openai"
 import { EventEmitter } from "events";
-import { AxiosRequestConfig, AxiosResponse } from "axios";
 import { OpenAIApiParameters, ChatReponse, OutlineSummaryItem, SummaryReponse, FaqItem, ExaminationPaperResult, EmotionResult, SimilarityResult, QuestionItem } from './declare'
 const SECTION_LENGTH = 1600;     ///每2400个字符分成一组
 const MESSAGE_LENGTH = 1;      ///每次送8句话给openai 进行解析，送多了，会报错
@@ -42,7 +41,7 @@ export default class OpenAIGpt extends EventEmitter {
      * 向OpenAI发送一个聊天请求
      * @param {*} chatText 
      */
-    public async chatRequest(chatText: string | Array<any>, callChatOption: OpenAIApiParameters, axiosOption: AxiosRequestConfig = {}): Promise<ChatReponse> {
+    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){
             this.aiApi = this.createOpenAI(this.apiKey);
@@ -53,8 +52,7 @@ export default class OpenAIGpt extends EventEmitter {
             [{ role: 'user', content: chatText }] : chatText;
         // console.log('message', message)
         try {
-            const response: AxiosResponse<CreateChatCompletionResponse, any>
-                = await this.aiApi.createChatCompletion({
+            const response= await this.aiApi.createChatCompletion({
                     model: callChatOption?.model || this.chatModel,
                     messages: message,
                     temperature: Number(callChatOption?.temperature || this.temperature),
@@ -124,7 +122,7 @@ export default class OpenAIGpt extends EventEmitter {
      * @param {*} content 
      * @param {需要出来的数量} count 
      */
-    async getSimilarityContent(content: string, count: number = 1, axiosOption: AxiosRequestConfig = {}): Promise<ChatReponse> {
+    async getSimilarityContent(content: string, count: number = 1, axiosOption: any = {}): Promise<ChatReponse> {
         let chnReg: boolean = /([\u4e00-\u9fa5]|[\ufe30-\uffa0])/.test(content)  ///检查源话是否含有中文内容
         let engReg: boolean = /[a-zA-Z]/.test(content)  ///检查源话是否含有英文内容
         ///如果源话是全中文，那么结果中不应该出来英文的相似说法，如果源话是全英文，则结果不能出现全中文的说法
@@ -140,7 +138,7 @@ export default class OpenAIGpt extends EventEmitter {
      * @param content 
      * @param axiosOption 
      */
-    async getSummaryOfContent(content: string | Array<any>, axiosOption: AxiosRequestConfig = {}): Promise<SummaryReponse> {
+    async getSummaryOfContent(content: string | Array<any>, axiosOption: any = {}): Promise<SummaryReponse> {
         const arrContent = typeof (content) == 'string' ? this.splitLongText(content) : content;
         let summary: Array<OutlineSummaryItem> = [];
         while (arrContent.length > 0) {
@@ -168,7 +166,7 @@ export default class OpenAIGpt extends EventEmitter {
      * @param {*} axiosOption 
      * @returns 
      *///并在答案末尾处必须给出答案内容中的关键词
-    async generateQuestionsFromContent(content: string, count: number = 1, axiosOption: AxiosRequestConfig = {}): Promise<ChatReponse> {
+    async generateQuestionsFromContent(content: string, count: number = 1, axiosOption: any = {}): Promise<ChatReponse> {
         let arrContent = this.splitLongText(content, 300);
         ///没20句话分为一组，适应大文件内容多次请求组合结果
         ///每一句话需要产生的题目
@@ -212,7 +210,7 @@ export default class OpenAIGpt extends EventEmitter {
      * @param {*} axiosOption 
      * @returns 
      *///并在答案末尾处必须给出答案内容中的关键词
-    async generateQuestionsFromContent_Orgin(content: string, count: number = 1, promotion: string | null = null, sliceslength: number = SECTION_LENGTH, axiosOption: AxiosRequestConfig = {}): Promise<ChatReponse> {
+    async generateQuestionsFromContent_Orgin(content: string, count: number = 1, promotion: string | null = null, sliceslength: number = SECTION_LENGTH, axiosOption: any = {}): Promise<ChatReponse> {
         let arrContent = this.splitLongText(content, sliceslength || 300);
         ///没20句话分为一组，适应大文件内容多次请求组合结果
         ///每一句话需要产生的题目
@@ -278,7 +276,7 @@ export default class OpenAIGpt extends EventEmitter {
      * @param {*} axiosOption 
      * @returns 
      *///并在答案末尾处必须给出答案内容中的关键词
-    async generateExaminationPaperFromContent(content: string, paperOption: any = {}, axiosOption: AxiosRequestConfig = {}): Promise<ExaminationPaperResult> {
+    async generateExaminationPaperFromContent(content: string, paperOption: any = {}, axiosOption: any = {}): Promise<ExaminationPaperResult> {
         let arrContent = this.splitLongText(content, 1024);
         let sectionCount: any = {
             singlechoice: (paperOption.singlechoice?.count || 0) / arrContent.length,

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
     "files": [
-        "src/openai.ts"
+        "src/index.ts"
     ],
     "compilerOptions": {
         "target": "es2015",