doomiaichat 7.0.4 → 7.1.4

package/dist/corzauthorization.d.ts

@@ -0,0 +1,19 @@
+export declare class CorzAuthorization {
+    private appid;
+    private accessToken;
+    private expiresAt;
+    private pemfile;
+    private secret;
+    private sessionName;
+    constructor(appid: string, setting: Record<string, any>);
+    /**
+     * 获取授权令牌
+     * @returns
+     */
+    getAccessToken(): Promise<string | null>;
+    /**
+     * 进行授权
+     * @returns
+     */
+    private doAuthorize;
+}

package/dist/corzauthorization.js

@@ -0,0 +1,79 @@
+"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 });
+exports.CorzAuthorization = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const api_1 = require("@coze/api");
+class CorzAuthorization {
+    constructor(appid, setting) {
+        this.appid = appid;
+        this.expiresAt = 0;
+        this.secret = setting["keyid"];
+        this.pemfile = setting["pemfile"] || "private.pem";
+        this.sessionName = setting["sessionName"] || "default";
+    }
+    /**
+     * 获取授权令牌
+     * @returns
+     */
+    getAccessToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 检查令牌是否存在且未过期,如果有效直接放回
+            if (this.accessToken && Date.now() < this.expiresAt)
+                return this.accessToken;
+            // 开始新的授权
+            const result = yield this.doAuthorize();
+            if (!result.successed)
+                return null;
+            // 缓存授权令牌和过期时间
+            this.accessToken = result.accessToken;
+            // 将 expires_in 转换为绝对时间戳
+            this.expiresAt = result.expires_in * 1000; // 将秒转换为毫秒
+            return this.accessToken;
+        });
+    }
+    /**
+     * 进行授权
+     * @returns
+     */
+    doAuthorize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // 提取您的 COZE API 授权参数
+                //const keyid = "H7rAk-5s0TPOs9-rXnCr7pvkPhpJZGArT__UuMyhbkg";
+                const aud = "api.coze.cn";
+                // 读取私钥
+                const fileFullPath = path_1.default.join(process.cwd(), this.pemfile);
+                if (!fs_1.default.existsSync(fileFullPath))
+                    return { successed: false, error: `${fileFullPath} not existed` };
+                const privateKey = fs_1.default.readFileSync(fileFullPath).toString();
+                // 获取JWT令牌
+                const result = yield (0, api_1.getJWTToken)({
+                    baseURL: api_1.COZE_CN_BASE_URL,
+                    appId: this.appid,
+                    aud,
+                    keyid: this.secret,
+                    privateKey,
+                    sessionName: this.sessionName,
+                });
+                return { successed: true, accessToken: result.access_token, expires_in: result.expires_in };
+            }
+            catch (error) {
+                return { successed: true, error };
+            }
+        });
+    }
+}
+exports.CorzAuthorization = CorzAuthorization;

package/dist/corzbot.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 扣子智能体
+ */
+import { CozeAPI, EnterMessage } from '@coze/api';
+import GptBase from "./gptbase";
+import { CorzAuthorization } from './corzauthorization';
+export default class CorzBot extends GptBase {
+    private authorizationProvider;
+    private setting;
+    protected botid: string;
+    private apiKey;
+    private lastThinkingMessage;
+    /**
+     *
+     * @param apikey 调用AI中台 的key
+     * @param botid  智能体信息
+     */
+    constructor(authorizationProvider: CorzAuthorization, setting?: any);
+    private createClient;
+    /**
+     * 发起一次会话
+     */
+    private createCoversation;
+    /**
+         * 组装请求参数
+         * @param message
+         * @param callChatOption
+         * @param attach
+         * @param _axiosOption
+         */
+    getRequestStream<T>(client: CozeAPI, message: EnterMessage[], callChatOption?: any): Promise<T>;
+    /**
+      * 非流式传输聊天请求
+      * @param chatText
+      * @param callChatOption
+      * @param _axiosOption
+      */
+    chatRequest(message: any[] | string, callChatOption?: any, _axiosOption?: any): Promise<any>;
+    /**
+     * 解析深度思考的JSON内容
+     * @param content
+     * @param status
+     * @returns
+     */
+    private parseDeepThinkingJson;
+    /**
+     * 流式传输聊天请求
+     * @param chatText
+     * @param callChatOption
+     * @param attach
+     * @param _axiosOption
+     * @returns
+     */
+    chatRequestInStream(message: any[] | string, callChatOption?: any, attach?: any, _axiosOption?: any): Promise<any>;
+}

package/dist/corzbot.js

@@ -0,0 +1,296 @@
+"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 __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 扣子智能体
+ */
+const api_1 = require("@coze/api");
+const gptbase_1 = __importDefault(require("./gptbase"));
+var DeepThinkingStatus;
+(function (DeepThinkingStatus) {
+    DeepThinkingStatus[DeepThinkingStatus["None"] = 0] = "None";
+    DeepThinkingStatus[DeepThinkingStatus["Thinking"] = 1] = "Thinking";
+    DeepThinkingStatus[DeepThinkingStatus["ReasonOutput"] = 2] = "ReasonOutput";
+    DeepThinkingStatus[DeepThinkingStatus["ThinkingOver"] = 3] = "ThinkingOver";
+})(DeepThinkingStatus || (DeepThinkingStatus = {}));
+class CorzBot extends gptbase_1.default {
+    // protected client: CozeAPI;
+    /**
+     *
+     * @param apikey 调用AI中台 的key
+     * @param botid  智能体信息
+     */
+    constructor(authorizationProvider, setting = {}) {
+        super();
+        this.authorizationProvider = authorizationProvider;
+        this.setting = setting;
+        this.lastThinkingMessage = { action: '', textposition: 0 };
+        ////初始化扣子客户端
+        this.botid = this.setting['botid'];
+        this.apiKey = this.setting['apiKey'];
+    }
+    createClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 存在AppKey则使用AppKey进行认证
+            if (this.apiKey)
+                return new api_1.CozeAPI({ baseURL: api_1.COZE_CN_BASE_URL, token: this.apiKey });
+            const accessToken = yield this.authorizationProvider.getAccessToken();
+            if (!accessToken)
+                throw new Error('get access token failed');
+            return new api_1.CozeAPI({ baseURL: api_1.COZE_CN_BASE_URL, token: accessToken });
+        });
+    }
+    /**
+     * 发起一次会话
+     */
+    createCoversation(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield client.conversations.create({
+                bot_id: this.botid,
+            });
+            return result.id;
+        });
+    }
+    /**
+         * 组装请求参数
+         * @param message
+         * @param callChatOption
+         * @param attach
+         * @param _axiosOption
+         */
+    getRequestStream(client, message, callChatOption = {}) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            //简单的对话请求
+            const conversation_id = (_a = callChatOption.session_id) !== null && _a !== void 0 ? _a : yield this.createCoversation(client);
+            if (!callChatOption.workflowid) {
+                const req = {
+                    bot_id: this.botid,
+                    additional_messages: message,
+                    user_id: callChatOption.userid || callChatOption.cozeUserID,
+                    conversation_id
+                };
+                req.custom_variables = Object.assign({}, this.setting.customVariables || {}, callChatOption.customVariables || {});
+                return req;
+            }
+            const worflowreq = {
+                bot_id: this.botid,
+                additional_messages: message,
+                workflow_id: callChatOption.workflowid,
+                conversation_id,
+                parameters: Object.assign({}, this.setting.customVariables || {}, callChatOption.customVariables || {}),
+            };
+            return worflowreq;
+        });
+    }
+    /**
+      * 非流式传输聊天请求
+      * @param chatText
+      * @param callChatOption
+      * @param _axiosOption
+      */
+    chatRequest(message, callChatOption = {}, _axiosOption = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!message)
+                this.emit('chaterror', { successed: false, error: 'no message in chat' });
+            ///如果是字符，则组装成API需要的消息
+            if (typeof message === 'string')
+                message = [
+                    {
+                        role: api_1.RoleType.User,
+                        content_type: 'text',
+                        content: message
+                    }
+                ];
+            const client = yield this.createClient();
+            ////如果参数中用的是Workflow，则调用对话流来输出结果
+            ////否则用智能体的对话来输出结果
+            const params = yield this.getRequestStream(client, message, callChatOption);
+            const response = yield client.chat.createAndPoll(params);
+            if (response.chat.status === api_1.ChatStatus.COMPLETED && response.messages) {
+                const message = response.messages.filter(x => x.type === 'answer').map(item => ({
+                    role: item.role,
+                    type: item.type,
+                    content: item.content,
+                }));
+                const follow_up = response.messages.filter(x => x.type === 'follow_up').map(item => ({
+                    role: item.role,
+                    type: item.type,
+                    content: item.content,
+                }));
+                return { successed: true, message, follow_up, usage: response.chat.usage };
+            }
+            return { successed: false, error: { message: '聊天未完成', status: response.chat.status } };
+            // for await (const part of stream) {
+            //     if (part.event === ChatEventType.ERROR) return { successed: false, error: part.data.msg }
+            //     ////在流式传输中，提取相关推荐问题
+            //     if (part.event === ChatEventType.CONVERSATION_MESSAGE_COMPLETED) {
+            //         const { type, content, conversation_id } = part.data;
+            //         ///回答全部结束
+            //         if (type === 'answer') return { successed: true, message: [{ message: { content } }], session_id: conversation_id };
+            //     }
+            // }
+            //return { successed: false, error:'unknow' }
+        });
+    }
+    /**
+     * 解析深度思考的JSON内容
+     * @param content
+     * @param status
+     * @returns
+     */
+    parseDeepThinkingJson(content, status) {
+        const thinkingEndIndex = content.indexOf("\"}");
+        const thinkingStartIndex = status === DeepThinkingStatus.Thinking ? content.indexOf("{\"process_msg") : content.indexOf("{\"reasoning_content");
+        let jsonStr = null;
+        try {
+            jsonStr = content.substring(thinkingStartIndex, thinkingEndIndex >= 0 ? thinkingEndIndex : undefined) + "\"}";
+            // 转换JSON的时候需要将非法字符过滤掉
+            const thinkingObject = JSON.parse(jsonStr.replace(/[\x00-\x1F\x7F]/g, ''));
+            // 需要将内容的原文返回
+            const originalContent = jsonStr.split('":"')[1];
+            // 如果正确的解析JSON，并且当前有包含JSON结束的字符，则把当前思考的JSON内容替换掉
+            if (thinkingEndIndex >= 0)
+                content = content.substring(thinkingEndIndex + 2);
+            // 判断整个思考过程是否结束
+            if (status === DeepThinkingStatus.ReasonOutput && thinkingEndIndex >= 0)
+                status = DeepThinkingStatus.ThinkingOver;
+            // 判断当前是否从前期思考切换到思考内容输出
+            if (status === DeepThinkingStatus.Thinking && content.indexOf("{\"reasoning_content") >= 0)
+                status = DeepThinkingStatus.ReasonOutput;
+            //const removeOutputContent = content.replace(originalContent!.substring(1, originalContent!.length - 2),"")
+            let thinkingContent = originalContent === null || originalContent === void 0 ? void 0 : originalContent.substring(0, originalContent.length - 2); //.replace(lastContent, '');
+            const outputLength = (thinkingContent === null || thinkingContent === void 0 ? void 0 : thinkingContent.length) || 0;
+            const thinkingAction = Object.keys(thinkingObject)[0];
+            // 用lastThinkingMessage来记录上一次的思考内容，避免重复输出内容，导致的网络传输内容过多
+            if (this.lastThinkingMessage.action === thinkingAction && this.lastThinkingMessage.textposition) {
+                thinkingContent = thinkingContent.substring(this.lastThinkingMessage.textposition);
+            }
+            this.lastThinkingMessage = thinkingEndIndex >= 0 ? { action: thinkingAction, textposition: 0 } : { action: thinkingAction, textposition: outputLength };
+            return { successed: true, thinking: {
+                    action: thinkingAction,
+                    text: thinkingContent //Object.values(thinkingObject)[0]
+                }, content, status };
+        }
+        catch (error) {
+            console.error('解析JSON出错了:' + jsonStr);
+            // 当前解析出错，等待下一次解析
+            return { successed: false, content, status };
+        }
+    }
+    /**
+     * 流式传输聊天请求
+     * @param chatText
+     * @param callChatOption
+     * @param attach
+     * @param _axiosOption
+     * @returns
+     */
+    chatRequestInStream(message, callChatOption = {}, attach, _axiosOption) {
+        var _a, e_1, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!message)
+                this.emit('chaterror', { successed: false, error: 'no message in chat' });
+            ///如果是字符，则组装成API需要的消息
+            if (typeof message === 'string')
+                message = [
+                    {
+                        role: api_1.RoleType.User,
+                        content_type: 'text',
+                        content: message
+                    }
+                ];
+            const client = yield this.createClient();
+            ////如果参数中用的是Workflow，则调用对话流来输出结果
+            ////否则用智能体的对话来输出结果
+            let requestid = Math.ceil(Math.random() * (new Date().getTime() * Math.random()) / 1000), index = 0;
+            const params = yield this.getRequestStream(client, message, callChatOption);
+            const stream = !callChatOption.workflowid ? client.chat.stream(params) : client.workflows.chat.stream(params);
+            let deltaindex = 0, fullanswer = [], followup = [];
+            let deepThinking = '', thinkingStatus = DeepThinkingStatus.None; // 是否在深度思考中
+            try {
+                for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a;) {
+                    _c = stream_1_1.value;
+                    _d = false;
+                    try {
+                        const part = _c;
+                        if (part.event === api_1.ChatEventType.ERROR)
+                            return this.emit('chaterror', { successed: false, error: 'call failed' });
+                        if (part.event === api_1.ChatEventType.CONVERSATION_MESSAGE_DELTA) {
+                            let { conversation_id, content_type, type, role, content } = part.data;
+                            // 如果存在深度思考，则一开始就会带有相关的关键信息
+                            if (deltaindex === 0 && content.startsWith("{\"process_msg")) {
+                                thinkingStatus = DeepThinkingStatus.Thinking;
+                                deltaindex++;
+                            }
+                            // 如果在深度思考中，则不输出消息
+                            if (thinkingStatus !== DeepThinkingStatus.None &&
+                                thinkingStatus !== DeepThinkingStatus.ThinkingOver) {
+                                deepThinking += content;
+                                const result = this.parseDeepThinkingJson(deepThinking, thinkingStatus);
+                                if (result.successed) {
+                                    deepThinking = result.content;
+                                    this.emit('chatthinking', result.thinking);
+                                    thinkingStatus = result.status;
+                                }
+                                if (thinkingStatus != DeepThinkingStatus.ThinkingOver)
+                                    continue;
+                                // 将排除了thinking之后的消息内容要带下去成为正式的输出内容
+                                content = deepThinking;
+                            }
+                            fullanswer.push(content);
+                            let output = { successed: true, type, content_type, role, requestid, segment: content, text: fullanswer.join(''), index: index++, session_id: conversation_id };
+                            if (attach)
+                                output = Object.assign({}, output, attach);
+                            this.emit('chattext', output);
+                        }
+                        ////在流式传输中，提取相关推荐问题
+                        if (part.event === api_1.ChatEventType.CONVERSATION_MESSAGE_COMPLETED) {
+                            const { type, content } = part.data;
+                            if (type === 'follow_up')
+                                followup.push(content);
+                        }
+                        ///整个对话结束
+                        if (part.event === api_1.ChatEventType.CONVERSATION_CHAT_COMPLETED) {
+                            const { conversation_id } = part.data;
+                            let output = { successed: true, followup, type: 'answer', content_type: 'text', role: api_1.RoleType.Assistant, requestid, segment: null, text: fullanswer.join(''), index: index++, session_id: conversation_id };
+                            if (attach)
+                                output = Object.assign({}, output, attach);
+                            this.emit('chatdone', output);
+                        }
+                    }
+                    finally {
+                        _d = true;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = stream_1.return)) yield _b.call(stream_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return { successed: true, requestid };
+        });
+    }
+}
+exports.default = CorzBot;

package/dist/deepseek.d.ts

@@ -0,0 +1,5 @@
+import OpenAI from 'openai';
+import OpenAIGpt from './openai';
+export default class DeepSeek extends OpenAIGpt {
+    createOpenAI(apiKey: string): OpenAI;
+}

package/dist/deepseek.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const openai_1 = __importDefault(require("openai"));
+const openai_2 = __importDefault(require("./openai"));
+class DeepSeek extends openai_2.default {
+    createOpenAI(apiKey) {
+        return new openai_1.default({
+            baseURL: 'https://api.deepseek.com',
+            apiKey
+        });
+    }
+}
+exports.default = DeepSeek;

package/dist/gptprovider.d.ts

@@ -8,8 +8,10 @@ export declare const GptProviderEnum: {
     readonly OPENAIPROXY: "openaiproxy";
     readonly MICROSOFT: "microsoft";
     readonly AIMP: "aimp";
+    readonly CORZ: "corz";
     readonly BAIDU: "baidu";
     readonly DOUBAO: "doubao";
+    readonly DEEPSEEK: "deepseek";
     readonly GOOGLE: "google";
     readonly STABILITY: "stability";
     readonly STABILITY2: "stability2";

package/dist/gptprovider.js

@@ -9,6 +9,8 @@ exports.createGpt = exports.GptProviderEnum = void 0;
 * 语音转文字服务商工厂
 */
 const openai_1 = __importDefault(require("./openai"));
+const deepseek_1 = __importDefault(require("./deepseek"));
+const corzbot_1 = __importDefault(require("./corzbot"));
 const openaiproxy_1 = __importDefault(require("./openaiproxy"));
 const azureai_1 = __importDefault(require("./azureai"));
 const stabilityai_1 = __importDefault(require("./stabilityai"));
@@ -16,6 +18,9 @@ const stabilityplusai_1 = __importDefault(require("./stabilityplusai"));
 const baiduai_1 = __importDefault(require("./baiduai"));
 const aimp_1 = __importDefault(require("./aimp"));
 const doubaoai_1 = __importDefault(require("./doubaoai"));
+const corzauthorization_1 = require("./corzauthorization");
+// 扣子的身份认证应用
+const corzAuth = new Map();
 /**
  * OpenAI/NLP 的服务提供商 OpenAI,微软，百度文心(待接入)，google(待接入)
  */
@@ -24,8 +29,10 @@ exports.GptProviderEnum = {
     OPENAIPROXY: 'openaiproxy',
     MICROSOFT: 'microsoft',
     AIMP: 'aimp',
+    CORZ: 'corz',
     BAIDU: 'baidu',
     DOUBAO: 'doubao',
+    DEEPSEEK: 'deepseek',
     GOOGLE: 'google',
     STABILITY: 'stability',
     STABILITY2: 'stability2',
@@ -42,6 +49,8 @@ function createGpt(provider, apikey, setting) {
     switch (provider) {
         case exports.GptProviderEnum.OPENAI:
             return new openai_1.default(apikey + '', { model, maxtoken, temperature, embedding, top_p, presence_penalty, frequency_penalty });
+        case exports.GptProviderEnum.DEEPSEEK:
+            return new deepseek_1.default(apikey + '', { model, maxtoken, temperature, embedding, top_p, presence_penalty, frequency_penalty });
         case exports.GptProviderEnum.OPENAIPROXY:
             return new openaiproxy_1.default(apikey + '', { serviceurl }, { model, maxtoken, temperature, embedding, top_p, presence_penalty, frequency_penalty });
         case exports.GptProviderEnum.MICROSOFT:
@@ -51,6 +60,13 @@ function createGpt(provider, apikey, setting) {
             return new baiduai_1.default(cred);
         case exports.GptProviderEnum.AIMP:
             return new aimp_1.default(apikey + '', { endpoint, agentid });
+        case exports.GptProviderEnum.CORZ:
+            let authorizationProvider = corzAuth.get(apikey + '');
+            if (!authorizationProvider) {
+                authorizationProvider = new corzauthorization_1.CorzAuthorization(apikey + '', setting);
+                corzAuth.set(apikey + '', authorizationProvider);
+            }
+            return new corzbot_1.default(authorizationProvider, setting);
         case exports.GptProviderEnum.DOUBAO:
             return new doubaoai_1.default(apikey + '', { model, maxtoken, temperature, top_p, presence_penalty, frequency_penalty });
         case exports.GptProviderEnum.STABILITY:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doomiaichat",
-  "version": "7.0.4",
+  "version": "7.1.4",
   "description": "Doomisoft OpenAI",
   "main": "dist/index.js",
   "scripts": {
@@ -17,7 +17,8 @@
   },
   "dependencies": {
     "@azure/openai": "^1.0.0-beta.11",
-    "axios": "^1.3.4",
+    "@coze/api": "^1.1.0",
+    "axios": "^1.8.4",
     "openai": "^4.29.0"
   }
 }

package/src/corzauthorization.ts

@@ -0,0 +1,59 @@
+import fs  from 'fs';
+import path from 'path';
+import { getJWTToken, COZE_CN_BASE_URL } from '@coze/api';
+export class CorzAuthorization {
+    private accessToken: string | null |undefined;
+    private expiresAt: number = 0;
+    private pemfile: string;
+    private secret: string;
+    private sessionName: string;
+    constructor(private appid: string,setting:Record<string,any>) {
+        this.secret = setting["keyid"];
+        this.pemfile = setting["pemfile"] ||  "private.pem"
+        this.sessionName = setting["sessionName"] || "default";
+    }
+    /**
+     * 获取授权令牌
+     * @returns 
+     */
+    async getAccessToken():Promise<string|null> {
+        // 检查令牌是否存在且未过期,如果有效直接放回
+        if (this.accessToken && Date.now() < this.expiresAt) return this.accessToken;
+        // 开始新的授权
+        const result = await this.doAuthorize();
+        if (!result.successed) return null;
+        // 缓存授权令牌和过期时间
+        this.accessToken = result.accessToken!;
+        // 将 expires_in 转换为绝对时间戳
+        this.expiresAt = result.expires_in! * 1000; // 将秒转换为毫秒
+        return this.accessToken;
+    }
+    /**
+     * 进行授权
+     * @returns 
+     */
+    private async doAuthorize(): Promise<{ successed: boolean, accessToken?: string, expires_in?: number,error?:any }> {
+        try {
+            // 提取您的 COZE API 授权参数
+            //const keyid = "H7rAk-5s0TPOs9-rXnCr7pvkPhpJZGArT__UuMyhbkg";
+            const aud = "api.coze.cn";
+            // 读取私钥
+            const fileFullPath =path.join(process.cwd(), this.pemfile);
+            if (!fs.existsSync(fileFullPath)) return { successed: false, error: `${fileFullPath} not existed`}
+            const privateKey = fs.readFileSync(fileFullPath).toString();
+
+            // 获取JWT令牌
+            const result = await getJWTToken({
+                baseURL: COZE_CN_BASE_URL,
+                appId:this.appid,
+                aud,
+                keyid:this.secret,
+                privateKey,
+                sessionName:this.sessionName,
+            });
+            return {successed: true, accessToken: result.access_token, expires_in: result.expires_in}
+        } catch (error) {
+            return { successed: true, error }
+        } 
+    }
+}

package/src/corzbot.ts

@@ -0,0 +1,242 @@
+/**
+ * 扣子智能体
+ */
+import { CozeAPI,
+    COZE_CN_BASE_URL,
+    ChatEventType,
+    RoleType, 
+    StreamChatReq,
+    EnterMessage,
+    ChatWorkflowReq,
+    CreateChatReq,
+    ChatStatus} from '@coze/api';
+import GptBase from "./gptbase"
+import { CorzAuthorization } from './corzauthorization';
+enum DeepThinkingStatus {
+    None,
+    Thinking,
+    ReasonOutput,
+    ThinkingOver
+}
+type TThinkingMessage = { action: string, textposition: number }
+export default class CorzBot extends GptBase {
+    protected botid: string;
+    private apiKey:string;
+    private lastThinkingMessage: TThinkingMessage = { action: '', textposition:0 };
+    // protected client: CozeAPI;
+    /**
+     * 
+     * @param apikey 调用AI中台 的key
+     * @param botid  智能体信息 
+     */
+    constructor(private authorizationProvider: CorzAuthorization,private setting: any={}) {
+        super();
+        ////初始化扣子客户端
+        this.botid = this.setting['botid'];
+        this.apiKey = this.setting['apiKey'];
+    }
+    private async createClient(): Promise<CozeAPI> {
+        // 存在AppKey则使用AppKey进行认证
+        if (this.apiKey) return new CozeAPI({ baseURL: COZE_CN_BASE_URL, token: this.apiKey });
+        const accessToken = await this.authorizationProvider.getAccessToken();
+        if (!accessToken) throw new Error('get access token failed');
+        return new CozeAPI({ baseURL: COZE_CN_BASE_URL, token: accessToken });
+    }
+    /**
+     * 发起一次会话
+     */
+    private async createCoversation(client: CozeAPI):Promise<string>{
+        const result = await client.conversations.create({
+            bot_id: this.botid,
+        })
+        return result.id;
+    }
+    /**
+         * 组装请求参数
+         * @param message 
+         * @param callChatOption 
+         * @param attach 
+         * @param _axiosOption 
+         */
+    async getRequestStream<T>(client: CozeAPI, message: EnterMessage[], callChatOption: any = {}): Promise<T> {
+        //简单的对话请求
+        const conversation_id = callChatOption.session_id ?? await this.createCoversation(client);
+        if (!callChatOption.workflowid) {
+            const req: StreamChatReq = {
+                bot_id: this.botid,
+                additional_messages: message,
+                user_id: callChatOption.userid || callChatOption.cozeUserID,
+                conversation_id
+            }
+            req.custom_variables = Object.assign({}, this.setting.customVariables || {}, callChatOption.customVariables  || {});
+            return req as T;
+        }
+        const worflowreq: ChatWorkflowReq = {
+            bot_id: this.botid,
+            additional_messages: message,
+            workflow_id: callChatOption.workflowid,
+            conversation_id,
+            parameters: Object.assign({}, this.setting.customVariables || {}, callChatOption.customVariables  || {}),
+        }
+        return worflowreq as T;
+    }
+    /**
+      * 非流式传输聊天请求
+      * @param chatText 
+      * @param callChatOption 
+      * @param _axiosOption 
+      */
+    public async chatRequest(message: any[]|string, callChatOption: any={}, _axiosOption: any = {}): Promise<any> {
+        if (!message) this.emit('chaterror', { successed: false, error: 'no message in chat' });
+        ///如果是字符，则组装成API需要的消息
+        if (typeof message === 'string') message = [
+            {
+                role: RoleType.User,
+                content_type:'text' ,
+                content: message
+            }
+        ];
+        const client = await this.createClient();
+        ////如果参数中用的是Workflow，则调用对话流来输出结果
+        ////否则用智能体的对话来输出结果
+        const params =await this.getRequestStream(client, message, callChatOption);
+        const response = await client.chat.createAndPoll(params as CreateChatReq);
+        if (response.chat.status === ChatStatus.COMPLETED && response.messages) {
+            const message = response.messages.filter(x=>x.type==='answer').map(item => ({
+                role: item.role,
+                type: item.type,
+                content: item.content,
+            }));
+            const follow_up = response.messages.filter(x => x.type === 'follow_up').map(item => ({
+                role: item.role,
+                type: item.type,
+                content: item.content,
+            }));
+            return { successed: true, message, follow_up,usage: response.chat.usage };
+        }
+        return { successed: false, error: { message: '聊天未完成', status: response.chat.status } };
+        // for await (const part of stream) {
+        //     if (part.event === ChatEventType.ERROR) return { successed: false, error: part.data.msg }
+        //     ////在流式传输中，提取相关推荐问题
+        //     if (part.event === ChatEventType.CONVERSATION_MESSAGE_COMPLETED) {
+        //         const { type, content, conversation_id } = part.data;
+        //         ///回答全部结束
+        //         if (type === 'answer') return { successed: true, message: [{ message: { content } }], session_id: conversation_id };
+        //     }
+        // }
+        //return { successed: false, error:'unknow' }
+    }
+    /**
+     * 解析深度思考的JSON内容
+     * @param content 
+     * @param status 
+     * @returns 
+     */
+    private parseDeepThinkingJson(content: string,status: DeepThinkingStatus) {
+        const thinkingEndIndex = content.indexOf("\"}");
+        const thinkingStartIndex = status === DeepThinkingStatus.Thinking ? content.indexOf("{\"process_msg") : content.indexOf("{\"reasoning_content");
+        let jsonStr = null;
+        try{
+            jsonStr = content.substring(thinkingStartIndex, thinkingEndIndex >= 0 ? thinkingEndIndex : undefined) +"\"}";
+            // 转换JSON的时候需要将非法字符过滤掉
+            const thinkingObject = JSON.parse(jsonStr.replace(/[\x00-\x1F\x7F]/g, ''));
+            // 需要将内容的原文返回
+            const originalContent = jsonStr.split('":"')[1];
+            // 如果正确的解析JSON，并且当前有包含JSON结束的字符，则把当前思考的JSON内容替换掉
+            if (thinkingEndIndex >= 0) content = content.substring(thinkingEndIndex+2);
+            // 判断整个思考过程是否结束
+            if (status === DeepThinkingStatus.ReasonOutput && thinkingEndIndex >= 0) status = DeepThinkingStatus.ThinkingOver;
+            // 判断当前是否从前期思考切换到思考内容输出
+            if (status === DeepThinkingStatus.Thinking && content.indexOf("{\"reasoning_content") >= 0) status=DeepThinkingStatus.ReasonOutput;
+            //const removeOutputContent = content.replace(originalContent!.substring(1, originalContent!.length - 2),"")
+            let thinkingContent = originalContent?.substring(0, originalContent.length - 2)//.replace(lastContent, '');
+            const outputLength = thinkingContent?.length || 0;
+            const thinkingAction = Object.keys(thinkingObject)[0];
+            // 用lastThinkingMessage来记录上一次的思考内容，避免重复输出内容，导致的网络传输内容过多
+            if (this.lastThinkingMessage.action === thinkingAction && this.lastThinkingMessage.textposition){
+                thinkingContent = thinkingContent!.substring(this.lastThinkingMessage.textposition)
+            }
+            this.lastThinkingMessage = thinkingEndIndex >= 0 ? { action: thinkingAction!, textposition:0 } : { action: thinkingAction!, textposition: outputLength }
+
+            return { successed: true,thinking:{
+                action: thinkingAction, 
+                text: thinkingContent//Object.values(thinkingObject)[0]
+            }, content, status}
+        }
+        catch(error){
+            console.error('解析JSON出错了:' + jsonStr)
+            // 当前解析出错，等待下一次解析
+            return { successed: false, content, status }
+        }
+    }
+    /**
+     * 流式传输聊天请求
+     * @param chatText 
+     * @param callChatOption 
+     * @param attach 
+     * @param _axiosOption 
+     * @returns 
+     */
+    override async chatRequestInStream(message: any[]|string, callChatOption: any={}, attach?: any, _axiosOption?: any): Promise<any> {
+        if (!message) this.emit('chaterror', { successed: false, error: 'no message in chat' });
+        ///如果是字符，则组装成API需要的消息
+        if (typeof message === 'string') message = [
+            {
+                role: RoleType.User,
+                content_type: 'text',
+                content: message
+            }
+        ];
+        const client = await this.createClient();
+        ////如果参数中用的是Workflow，则调用对话流来输出结果
+        ////否则用智能体的对话来输出结果
+        let requestid = Math.ceil(Math.random() * (new Date().getTime() * Math.random()) / 1000), index=0;
+        const params =await this.getRequestStream(client, message, callChatOption);
+        const stream = !callChatOption.workflowid? client.chat.stream(params as StreamChatReq) : client.workflows.chat.stream(params as ChatWorkflowReq);
+        let deltaindex = 0, fullanswer: string[] = [], followup: string[] = [];
+        let deepThinking = '', thinkingStatus = DeepThinkingStatus.None; // 是否在深度思考中
+        for await (const part of stream) {
+            if (part.event === ChatEventType.ERROR) return this.emit('chaterror', { successed: false, error: 'call failed' });
+            if (part.event === ChatEventType.CONVERSATION_MESSAGE_DELTA) {
+                let { conversation_id, content_type,type, role, content } = part.data;
+                // 如果存在深度思考，则一开始就会带有相关的关键信息
+                if (deltaindex === 0 && content.startsWith("{\"process_msg")) {
+                    thinkingStatus=DeepThinkingStatus.Thinking;
+                    deltaindex++;
+                }
+                // 如果在深度思考中，则不输出消息
+                if (thinkingStatus !== DeepThinkingStatus.None &&
+                    thinkingStatus !== DeepThinkingStatus.ThinkingOver
+                ){
+                    deepThinking += content;
+                    const result = this.parseDeepThinkingJson(deepThinking, thinkingStatus)
+                    if (result.successed){
+                        deepThinking = result.content;
+                        this.emit('chatthinking', result.thinking);
+                        thinkingStatus = result.status;
+                    }
+                    if (thinkingStatus != DeepThinkingStatus.ThinkingOver) continue;
+                    // 将排除了thinking之后的消息内容要带下去成为正式的输出内容
+                    content = deepThinking;
+                }
+                fullanswer.push(content);
+                let output = { successed: true, type, content_type, role, requestid, segment: content, text: fullanswer.join(''), index: index++, session_id: conversation_id };
+                if (attach) output = Object.assign({}, output, attach);
+                this.emit('chattext', output)
+            }
+            ////在流式传输中，提取相关推荐问题
+            if (part.event === ChatEventType.CONVERSATION_MESSAGE_COMPLETED) {
+                const { type, content} = part.data;
+                if (type ==='follow_up') followup.push(content);
+            }
+            ///整个对话结束
+            if (part.event === ChatEventType.CONVERSATION_CHAT_COMPLETED) {
+                const { conversation_id} = part.data;
+                let output = { successed: true, followup, type: 'answer', content_type: 'text', role:RoleType.Assistant, requestid, segment: null, text: fullanswer.join(''), index: index++, session_id: conversation_id };
+                if (attach) output = Object.assign({}, output, attach);
+                this.emit('chatdone', output)
+            }
+        }
+        return { successed: true, requestid }
+    }
+}

package/src/deepseek.ts

@@ -0,0 +1,11 @@
+import OpenAI from 'openai';
+import OpenAIGpt from './openai';
+export default class DeepSeek extends OpenAIGpt{
+    override createOpenAI(apiKey: string): OpenAI {
+        return new OpenAI({ 
+            baseURL: 'https://api.deepseek.com',
+            apiKey 
+        })
+    }
+
+}

package/src/gptprovider.ts

@@ -3,6 +3,8 @@
 * 语音转文字服务商工厂
 */
 import OpenAIGpt from './openai';
+import DeepSeek from './deepseek';
+import CorzBot from './corzbot'
 import OpenAIProxt from './openaiproxy';
 import AzureAI from './azureai'
 import StabilityAI from './stabilityai'
@@ -11,6 +13,9 @@ import BaiduWenXinAI, { ApiCredential } from './baiduai'
 import AIMiddlePlatform  from './aimp';
 import DouBaoAI from './doubaoai'
 import GptBase from './gptbase';
+import { CorzAuthorization } from './corzauthorization'
+// 扣子的身份认证应用
+const corzAuth: Map<string, CorzAuthorization> = new Map();
 /**
  * OpenAI/NLP 的服务提供商 OpenAI,微软，百度文心(待接入)，google(待接入)
  */
@@ -19,8 +24,10 @@ export const GptProviderEnum = {
     OPENAIPROXY:'openaiproxy',
     MICROSOFT: 'microsoft',
     AIMP: 'aimp',   ///AI 中台业务
+    CORZ:'corz',
     BAIDU: 'baidu',
     DOUBAO:'doubao',
+    DEEPSEEK:'deepseek',
     GOOGLE:'google',
     STABILITY:'stability',
     STABILITY2: 'stability2',
@@ -38,6 +45,8 @@ export function createGpt(provider: GptProviderEnum, apikey: string|ApiCredentia
     switch (provider) {
         case GptProviderEnum.OPENAI: 
             return new OpenAIGpt(apikey + '', { model, maxtoken, temperature, embedding, top_p, presence_penalty, frequency_penalty });
+        case GptProviderEnum.DEEPSEEK:
+            return new DeepSeek(apikey + '', { model, maxtoken, temperature, embedding, top_p, presence_penalty, frequency_penalty });
         case GptProviderEnum.OPENAIPROXY:
             return new OpenAIProxt(apikey + '', { serviceurl}, { model, maxtoken, temperature, embedding, top_p, presence_penalty, frequency_penalty });
         case GptProviderEnum.MICROSOFT: 
@@ -47,6 +56,13 @@ export function createGpt(provider: GptProviderEnum, apikey: string|ApiCredentia
             return new BaiduWenXinAI(cred);
         case GptProviderEnum.AIMP:
             return new AIMiddlePlatform(apikey+'',{ endpoint,agentid });
+        case GptProviderEnum.CORZ:
+            let authorizationProvider  = corzAuth.get(apikey + '');  
+            if (!authorizationProvider) {
+                authorizationProvider = new CorzAuthorization(apikey + '',setting);
+                corzAuth.set(apikey + '', authorizationProvider);
+            }
+            return new CorzBot(authorizationProvider!, setting);
         case GptProviderEnum.DOUBAO:
             return new DouBaoAI(apikey + '', { model, maxtoken, temperature, top_p, presence_penalty, frequency_penalty })
         case GptProviderEnum.STABILITY: