doomiaichat 7.1.10 → 7.1.11

package/dist/corzbot.d.ts

@@ -8,10 +8,10 @@ import { ApiResult } from './declare';
 export default class CorzBot extends GptBase {
     private authorizationProvider;
     private setting;
-    protected botid: string;
-    protected workflowid: string;
+    private botid;
+    private workflowid;
+    private talkflowid;
     private apiKey;
-    private lastThinkingMessage;
     /**
      *
      * @param apikey 调用AI中台 的key
@@ -23,6 +23,11 @@ export default class CorzBot extends GptBase {
      * 发起一次会话
      */
     createCoversation(client?: CozeAPI): Promise<string | null>;
+    /**
+     * 设置Coze的变量
+     * @param params
+     * @returns
+     */
     setVariables(params: any): Promise<ApiResult>;
     /**
      * 获取设置的变量
@@ -50,6 +55,13 @@ export default class CorzBot extends GptBase {
      * @param _axiosOption
      */
     chatRequest(message: any[] | string, callChatOption?: any, _axiosOption?: any): Promise<any>;
+    /**
+     * 提取XML标签中间的内容，
+     * @param xmlStr
+     * @param tagName
+     * @returns
+     */
+    extractXmlContent(xmlStr: string, tagName: string): string;
     /**
      * 解析深度思考的JSON内容
      * @param content

package/dist/corzbot.js

@@ -25,23 +25,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const api_1 = require("@coze/api");
 const gptbase_1 = __importDefault(require("./gptbase"));
 const querystring_1 = require("querystring");
-// 定义深度思考的动作
-var DeepThinkingAction;
-(function (DeepThinkingAction) {
-    DeepThinkingAction["process"] = "process_msg";
-    DeepThinkingAction["content"] = "reasoning_content";
-    DeepThinkingAction["card"] = "card_resource";
-})(DeepThinkingAction || (DeepThinkingAction = {}));
+// 定义深度思考的动作标签
+// 这是小鹭里面专用的几个思考动作标签
+const DeepThinkingAction = {
+    thinking: { start: '<xiaolu-think>', end: '</xiaolu-think>', tag: 'xiaolu-think' },
+    reasoning: { start: '<xiaolu-reason>', end: '</xiaolu-reason>', tag: 'xiaolu-reason' },
+    card: { start: '<xiaolu-card>', end: '</xiaolu-card>', tag: 'xiaolu-card' },
+};
 // 定义深度思考的状态
 var DeepThinkingStatus;
 (function (DeepThinkingStatus) {
     DeepThinkingStatus[DeepThinkingStatus["None"] = 0] = "None";
     DeepThinkingStatus[DeepThinkingStatus["Thinking"] = 1] = "Thinking";
-    DeepThinkingStatus[DeepThinkingStatus["ContentOutput"] = 2] = "ContentOutput";
-    DeepThinkingStatus[DeepThinkingStatus["ThinkingOver"] = 3] = "ThinkingOver";
+    // ContentOutput,
+    DeepThinkingStatus[DeepThinkingStatus["ThinkingOver"] = 2] = "ThinkingOver";
 })(DeepThinkingStatus || (DeepThinkingStatus = {}));
+// type TThinkingMessage = { action: string, textposition: number }
 class CorzBot extends gptbase_1.default {
-    // protected client: CozeAPI;
     /**
      *
      * @param apikey 调用AI中台 的key
@@ -51,10 +51,18 @@ class CorzBot extends gptbase_1.default {
         super();
         this.authorizationProvider = authorizationProvider;
         this.setting = setting;
-        this.lastThinkingMessage = { action: '', textposition: 0 };
+        this.botid = null; // 智能体id
+        this.workflowid = null; // 工作流id
+        this.talkflowid = null; // 对话流id
         ////初始化扣子客户端
-        this.botid = this.setting['botid'] || this.setting['botID'];
-        this.workflowid = this.setting['workflowid'];
+        if (this.setting.workflowid)
+            this.workflowid = this.setting.workflowid;
+        else if (this.setting.talkflowid)
+            this.talkflowid = this.setting.talkflowid;
+        else if (this.setting.botid || this.setting.botID)
+            this.botid = this.setting.botid || this.setting.botID;
+        else
+            throw new Error('no botid or talkflowid or workflowid setting for coze');
         this.apiKey = this.setting['apiKey'];
     }
     createClient() {
@@ -85,6 +93,11 @@ class CorzBot extends gptbase_1.default {
             }
         });
     }
+    /**
+     * 设置Coze的变量
+     * @param params
+     * @returns
+     */
     setVariables(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const client = yield this.createClient();
@@ -119,24 +132,33 @@ class CorzBot extends gptbase_1.default {
         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 (!this.workflowid) {
+            if (this.botid) {
                 const req = {
                     bot_id: this.botid,
                     additional_messages: message,
                     user_id: callChatOption.userid || callChatOption.cozeUserID,
-                    conversation_id
+                    conversation_id,
+                    parameters: Object.assign({ request_src: 1 }, callChatOption.parameters || {}),
                 };
                 req.custom_variables = Object.assign({}, this.setting.customVariables || {}, callChatOption.customVariables || {});
                 return req;
             }
+            if (this.workflowid) {
+                const worflowreq = {
+                    ext: callChatOption.ext,
+                    workflow_id: this.workflowid,
+                    is_async: false,
+                    // parameters: Object.assign({ input: message[0]?.content }, this.setting.customVariables || {}, callChatOption.customVariables || {}),
+                    parameters: Object.assign({ request_src: 1 }, callChatOption.parameters || {}, { input: (_b = message[0]) === null || _b === void 0 ? void 0 : _b.content })
+                };
+                return worflowreq;
+            }
             const worflowreq = {
-                bot_id: this.botid,
                 additional_messages: message,
                 ext: callChatOption.ext,
-                workflow_id: this.workflowid,
+                workflow_id: this.talkflowid,
                 conversation_id,
-                is_async: false,
-                parameters: Object.assign({ input: (_b = message[0]) === null || _b === void 0 ? void 0 : _b.content }, this.setting.customVariables || {}, callChatOption.customVariables || {}),
+                parameters: Object.assign({ request_src: 1 }, callChatOption.parameters || {}) //Object.assign({}, this.setting.customVariables || {}, callChatOption.customVariables || {}),
                 //parameters: { input: message[0]?.content }
             };
             return worflowreq;
@@ -184,7 +206,7 @@ class CorzBot extends gptbase_1.default {
             ////如果参数中用的是Workflow，则调用对话流来输出结果
             ////否则用智能体的对话来输出结果
             const params = yield this.getRequestStream(client, message, callChatOption);
-            const response = !this.workflowid ? yield client.chat.create(params) : yield client.workflows.runs.create(params);
+            const response = this.botid ? yield client.chat.create(params) : yield client.workflows.runs.create(params);
             if (this.workflowid && response.msg === 'Success') {
                 const resp = response.data;
                 try {
@@ -209,68 +231,57 @@ class CorzBot extends gptbase_1.default {
             return { successed: false, error: { message: '聊天未完成' } };
         });
     }
+    /**
+     * 提取XML标签中间的内容，
+     * @param xmlStr
+     * @param tagName
+     * @returns
+     */
+    extractXmlContent(xmlStr, tagName) {
+        // 构建匹配标签的正则（支持任意空白字符和大小写）
+        const regex = new RegExp(`<\\s*${tagName}\\s*>([\\s\\S]*?)<\\s*\\/\\s*${tagName}\\s*>`, 'i');
+        const match = xmlStr.match(regex);
+        if (match && match[1])
+            return match[1].trim();
+        return ''; // 未找到标签或内容
+    }
     /**
      * 解析深度思考的JSON内容
      * @param content
      * @param status
      * @returns
      */
-    parseDeepThinkingJson(content, status) {
+    parseDeepThinkingJson(content) {
         // const thinkingStartIndex = status === DeepThinkingStatus.Thinking ? content.indexOf("{\"process_msg") : 
         //                            (status===DeepThinkingStatus.ReasonOutput ? content.indexOf("{\"reasoning_content") : content.indexOf("{\"card_resource")) ;
-        const tagLocation = [content.indexOf("{\"process_msg"),
-            content.indexOf("{\"reasoning_content"),
-            content.indexOf("{\"card_resource")].filter(x => x >= 0);
-        const thinkingStartIndex = tagLocation.length > 0 ? Math.min(...tagLocation) : -1;
-        const thinkingEndIndex = content.indexOf("\"}");
-        // 如果没有找到相关的JSON内容，则直接返回
-        if (thinkingStartIndex < 0)
-            return { successed: true, content, status: DeepThinkingStatus.ThinkingOver };
-        let jsonStr = null;
-        try {
-            jsonStr = content.substring(thinkingStartIndex, thinkingEndIndex >= 0 ? thinkingEndIndex : undefined) + "\"}";
-            // 转换JSON的时候需要将非法字符过滤掉
-            const thinkingObject = JSON.parse(jsonStr.replace(/[\x00-\x1F\x7F]/g, ''));
-            const thinkingAction = Object.keys(thinkingObject)[0];
-            // 需要将内容的原文返回
-            const originalContent = jsonStr.split('":"')[1];
-            // 如果正确的解析JSON，并且当前有包含JSON结束的字符，则把当前思考的JSON内容替换掉
-            if (thinkingEndIndex >= 0)
-                content = content.substring(thinkingEndIndex + 2);
-            // 如果正常输出了卡片资源，并且json结束 card_resource 只有一个，所以一旦结束，则整个思考过程完毕
-            // if (status === DeepThinkingStatus.ContentOutput && thinkingEndIndex >= 0)  status = DeepThinkingStatus.ThinkingOver;
-            // 判断整个思考过程是否到达等待卡片资源(有可能智能体输出不了卡片资源) reasoning_content 只有一个，所以一旦结束，则进入下一个阶段 card_resource
-            //if (status === DeepThinkingStatus.ContentOutput && thinkingEndIndex >= 0) status = DeepThinkingStatus.ContentOutput;
-            // 判断当前是否从前期思考切换到思考内容输出
-            if (status === DeepThinkingStatus.Thinking && thinkingAction !== DeepThinkingAction.process)
-                status = DeepThinkingStatus.ContentOutput;
-            //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);
-            const outputLength = (thinkingContent === null || thinkingContent === void 0 ? void 0 : thinkingContent.length) || 0;
-            // 用lastThinkingMessage来记录上一次的思考内容，避免重复输出内容，导致的网络传输内容过多
-            if (this.lastThinkingMessage.action === thinkingAction && this.lastThinkingMessage.textposition) {
-                thinkingContent = thinkingContent.substring(this.lastThinkingMessage.textposition);
+        const xmlTagLocation = [content.indexOf(DeepThinkingAction.thinking.start),
+            content.indexOf(DeepThinkingAction.reasoning.start),
+            content.indexOf(DeepThinkingAction.card.start)];
+        let minLocation = 10000, minIndex = -1;
+        // 找到最小的并且大于0 的位置的下标
+        xmlTagLocation.forEach((x, index) => {
+            if (x >= 0 && x < minLocation) {
+                minLocation = x;
+                minIndex = index;
             }
-            this.lastThinkingMessage = thinkingEndIndex >= 0 ? { action: thinkingAction, textposition: 0 } : { action: thinkingAction, textposition: outputLength };
-            return {
-                successed: true, thinking: {
-                    action: thinkingAction,
-                    text: thinkingContent,
-                    completed: thinkingEndIndex >= 0
-                }, content, status
-            };
-        }
-        catch (error) {
-            // 如果在content之后发生了错误，可能该智能体输出不了卡片类型的数据，则输出的内容已经是正文了
-            if (status === DeepThinkingStatus.ContentOutput) {
-                status = DeepThinkingStatus.ThinkingOver;
-                return { successed: true, content, status };
-            }
-            console.error('解析JSON出错了:', jsonStr, status);
-            // 当前解析出错，等待下一次解析
-            return { successed: false, content, status };
-        }
+        });
+        // const tagLocation = xmlTagLocation.filter(x => x >= 0);
+        const thinkingStartIndex = minIndex >= 0 ? minLocation : -1; //tagLocation.length > 0 ? Math.min(...tagLocation) : -1;
+        if (thinkingStartIndex < 0)
+            return { content, status: DeepThinkingStatus.ThinkingOver };
+        const currentAction = [DeepThinkingAction.thinking, DeepThinkingAction.reasoning, DeepThinkingAction.card][minIndex];
+        const currentActionIsOver = content.indexOf(currentAction.end, thinkingStartIndex);
+        const thinkingEndIndex = currentActionIsOver >= 0 ? currentActionIsOver : content.indexOf('</', thinkingStartIndex);
+        const thinkingContent = this.extractXmlContent(content.substring(thinkingStartIndex, thinkingEndIndex >= 0 ? thinkingEndIndex : undefined) + currentAction.end, currentAction.tag); //"\"}";
+        if (currentActionIsOver >= 0)
+            content = content.substring(currentActionIsOver + currentAction.end.length);
+        return {
+            thinking: {
+                action: currentAction,
+                text: thinkingContent,
+                completed: currentActionIsOver >= 0
+            }, content
+        };
     }
     /**
      * 流式传输聊天请求
@@ -282,6 +293,7 @@ class CorzBot extends gptbase_1.default {
      */
     chatRequestInStream(message, callChatOption = {}, attach, _axiosOption) {
         var _a, e_1, _b, _c;
+        var _d, _e, _f;
         return __awaiter(this, void 0, void 0, function* () {
             if (!message)
                 this.emit('chaterror', { successed: false, error: 'no message in chat' });
@@ -299,56 +311,59 @@ class CorzBot extends gptbase_1.default {
             ////否则用智能体的对话来输出结果
             let requestid = Math.ceil(Math.random() * (new Date().getTime() * Math.random()) / 1000), index = 0;
             const params = yield this.getRequestStream(client, message, callChatOption);
-            const stream = !this.workflowid ? client.chat.stream(params) : client.workflows.runs.stream(params);
+            const stream = this.botid ? client.chat.stream(params) :
+                (this.workflowid ? client.workflows.runs.stream(params) :
+                    client.workflows.chat.stream(params));
             let deltaindex = 0, fullanswer = [], followup = [], cardData = [];
             let deepThinking = '', thinkingStatus = DeepThinkingStatus.None, cardResource = ''; // 是否在深度思考中
             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;) {
+                for (var _g = 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;
+                    _g = 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 (part.event === api_1.ChatEventType.CONVERSATION_MESSAGE_DELTA ||
+                            part.event === api_1.WorkflowEventType.MESSAGE) {
+                            let { conversation_id, content_type, type = 'answer', role = 'assistant', content, reasoning_content: reasoning } = part.data;
+                            if (!content && reasoning) {
+                                this.emit('chatthinking', { text: reasoning, completed: false, action: 'deep-thinking' });
+                                continue;
+                            }
                             // 如果存在深度思考，则一开始就会带有相关的关键信息
-                            if (deltaindex === 0 && content.startsWith("{\"process_msg")) {
+                            if (deltaindex === 0 && content.startsWith("<xiaolu-")) {
                                 thinkingStatus = DeepThinkingStatus.Thinking;
                                 deltaindex++;
                             }
                             // 如果在深度思考中，则不输出消息
-                            if (thinkingStatus !== DeepThinkingStatus.None
-                                && thinkingStatus !== DeepThinkingStatus.ThinkingOver) {
+                            if (thinkingStatus === DeepThinkingStatus.Thinking) {
                                 deepThinking += content;
-                                const result = this.parseDeepThinkingJson(deepThinking, thinkingStatus);
-                                if (result.successed) {
-                                    const thinking = result.thinking;
-                                    if (thinking) {
-                                        deepThinking = result.content;
-                                        if (thinking.action === DeepThinkingAction.card) {
-                                            cardResource += result.thinking.text;
-                                            // 卡片流结束，解析卡片资源数据
-                                            if (result.thinking.completed) {
-                                                const allCards = cardResource.replace(/[\x00-\x1F\x7F]/g, '').split('|');
-                                                for (const item of allCards) {
-                                                    const cardinfo = (0, querystring_1.parse)(item);
-                                                    if (cardinfo.type && cardinfo.tag)
-                                                        cardData.push({ type: Number(cardinfo.type), tag: cardinfo.tag });
-                                                }
-                                                // 将卡片资源返回给客户端
-                                                this.emit('chatcard', cardData);
+                                const result = this.parseDeepThinkingJson(deepThinking);
+                                const thinking = result.thinking;
+                                if (thinking) {
+                                    deepThinking = result.content;
+                                    if (thinking.action === DeepThinkingAction.card) {
+                                        cardResource += result.thinking.text;
+                                        // 卡片流结束，解析卡片资源数据
+                                        if (result.thinking.completed) {
+                                            const allCards = cardResource.replace(/[\x00-\x1F\x7F]/g, '').split('|');
+                                            for (const item of allCards) {
+                                                const cardinfo = (0, querystring_1.parse)(item);
+                                                if (cardinfo.type && cardinfo.tag)
+                                                    cardData.push({ type: Number(cardinfo.type), tag: cardinfo.tag });
                                             }
+                                            // 将卡片资源返回给客户端
+                                            this.emit('chatcard', cardData);
                                         }
-                                        else {
-                                            this.emit('chatthinking', result.thinking);
-                                        }
                                     }
-                                    thinkingStatus = result.status;
+                                    else {
+                                        this.emit('chatthinking', { text: result.thinking.text, completed: result.thinking.completed, action: (_d = thinking.action) === null || _d === void 0 ? void 0 : _d.tag });
+                                    }
                                 }
-                                if (thinkingStatus != DeepThinkingStatus.ThinkingOver)
+                                if (result.status != DeepThinkingStatus.ThinkingOver)
                                     continue;
-                                // thinkingStatus = DeepThinkingStatus.None;
+                                thinkingStatus = DeepThinkingStatus.ThinkingOver;
                                 // 将排除了thinking之后的消息内容要带下去成为正式的输出内容
                                 content = deepThinking;
                             }
@@ -360,28 +375,29 @@ class CorzBot extends gptbase_1.default {
                         }
                         ////在流式传输中，提取相关推荐问题
                         if (part.event === api_1.ChatEventType.CONVERSATION_MESSAGE_COMPLETED) {
-                            const { type, content } = part.data;
+                            const { type, content } = (_e = part.data) !== null && _e !== void 0 ? _e : {};
                             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, cards: cardData.length ? cardData : null, followup, type: 'answer', content_type: 'text', role: api_1.RoleType.Assistant, requestid, segment: null, text: fullanswer.join(''), index: index++, session_id: conversation_id };
+                        if (part.event === api_1.ChatEventType.CONVERSATION_CHAT_COMPLETED ||
+                            part.event === api_1.WorkflowEventType.DONE) {
+                            const { conversation_id, content } = (_f = (part.data)) !== null && _f !== void 0 ? _f : {};
+                            let output = { successed: true, cards: cardData.length ? cardData : null, followup, type: 'answer', content_type: 'text', role: api_1.RoleType.Assistant, requestid, segment: null, text: content !== null && content !== void 0 ? content : fullanswer.join(''), index: index++, session_id: conversation_id };
                             if (attach)
                                 output = Object.assign({}, output, attach);
                             this.emit('chatdone', output);
                         }
                     }
                     finally {
-                        _d = true;
+                        _g = 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);
+                    if (!_g && !_a && (_b = stream_1.return)) yield _b.call(stream_1);
                 }
                 finally { if (e_1) throw e_1.error; }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doomiaichat",
-  "version": "7.1.10",
+  "version": "7.1.11",
   "description": "Doomisoft OpenAI",
   "main": "dist/index.js",
   "scripts": {

package/src/corzbot.ts

@@ -17,35 +17,37 @@ import {
     RunWorkflowReq,
     RunWorkflowData,
     CreateChatData,
-    ChatStatus
+    ChatStatus,
+    WorkflowEventType,
+    ChatWorkflowReq
 } from '@coze/api';
 import GptBase from "./gptbase"
 import { CorzAuthorization } from './corzauthorization';
 import { parse } from 'querystring'
 import { ApiResult } from './declare';
 
-// 定义深度思考的动作
-enum DeepThinkingAction {
-    process = 'process_msg',
-    content = 'reasoning_content',
-    card = 'card_resource'
+// 定义深度思考的动作标签
+// 这是小鹭里面专用的几个思考动作标签
+const DeepThinkingAction: any = {
+    thinking: { start: '<xiaolu-think>', end: '</xiaolu-think>', tag: 'xiaolu-think' },
+    reasoning: { start: '<xiaolu-reason>', end: '</xiaolu-reason>', tag: 'xiaolu-reason' },
+    card: { start: '<xiaolu-card>', end: '</xiaolu-card>', tag: 'xiaolu-card' },
 }
 // 定义深度思考的状态
 enum DeepThinkingStatus {
     None,
     Thinking,
-    ContentOutput,
+    // ContentOutput,
     ThinkingOver
 }
 // 智能体思考时输出的动作
 type CardType = { type: number, tag: string }
-type TThinkingMessage = { action: string, textposition: number }
+// type TThinkingMessage = { action: string, textposition: number }
 export default class CorzBot extends GptBase {
-    protected botid: string;
-    protected workflowid: string;
+    private botid: string | null = null;         // 智能体id
+    private workflowid: string | null = null;    // 工作流id
+    private talkflowid: string | null = null;   // 对话流id
     private apiKey: string;
-    private lastThinkingMessage: TThinkingMessage = { action: '', textposition: 0 };
-    // protected client: CozeAPI;
     /**
      * 
      * @param apikey 调用AI中台 的key
@@ -54,8 +56,15 @@ export default class CorzBot extends GptBase {
     constructor(private authorizationProvider: CorzAuthorization, private setting: any = {}) {
         super();
         ////初始化扣子客户端
-        this.botid = this.setting['botid'] || this.setting['botID'];
-        this.workflowid = this.setting['workflowid'];
+        
+        if (this.setting.workflowid) 
+            this.workflowid = this.setting.workflowid;
+        else if (this.setting.talkflowid)
+            this.talkflowid = this.setting.talkflowid;
+        else if (this.setting.botid || this.setting.botID)
+            this.botid = this.setting.botid || this.setting.botID;
+        else
+            throw new Error('no botid or talkflowid or workflowid setting for coze');
         this.apiKey = this.setting['apiKey'];
     }
     private async createClient(): Promise<CozeAPI> {
@@ -79,7 +88,11 @@ export default class CorzBot extends GptBase {
             return null;
         }
     }
-
+    /**
+     * 设置Coze的变量
+     * @param params 
+     * @returns 
+     */
     override async setVariables(params: any): Promise<ApiResult> {
         const client = await this.createClient();
         const cozeParams: VariableUpdateReq = Object.assign({}, this.botid ? { bot_id: this.botid } : {}, params);
@@ -107,24 +120,33 @@ export default class CorzBot extends GptBase {
     async getRequestStream<T>(client: CozeAPI, message: EnterMessage[], callChatOption: any = {}): Promise<T> {
         //简单的对话请求
         const conversation_id = callChatOption.session_id ?? await this.createCoversation(client);
-        if (!this.workflowid) {
+        if (this.botid) {
             const req: StreamChatReq = {
                 bot_id: this.botid,
                 additional_messages: message,
                 user_id: callChatOption.userid || callChatOption.cozeUserID,
-                conversation_id
+                conversation_id,
+                parameters: Object.assign({ request_src:1 }, callChatOption.parameters || {}),
             }
             req.custom_variables = Object.assign({}, this.setting.customVariables || {}, callChatOption.customVariables || {});
             return req as T;
         }
-        const worflowreq: any = {
-            bot_id: this.botid,
+        if (this.workflowid){
+            const worflowreq: RunWorkflowReq = {
+                ext: callChatOption.ext,
+                workflow_id: this.workflowid,//callChatOption.workflowid,
+                is_async: false,
+                // parameters: Object.assign({ input: message[0]?.content }, this.setting.customVariables || {}, callChatOption.customVariables || {}),
+                parameters: Object.assign({ request_src :1},callChatOption.parameters || {}, { input: message[0]?.content})
+            }
+            return worflowreq as T;
+        }
+        const worflowreq: ChatWorkflowReq = {
             additional_messages: message,
             ext: callChatOption.ext,
-            workflow_id: this.workflowid,//callChatOption.workflowid,
+            workflow_id: this.talkflowid!,//callChatOption.workflowid,
             conversation_id,
-            is_async:false,
-            parameters: Object.assign({ input: message[0]?.content }, this.setting.customVariables || {}, callChatOption.customVariables || {}),
+            parameters: Object.assign({request_src:1},callChatOption.parameters || {}) //Object.assign({}, this.setting.customVariables || {}, callChatOption.customVariables || {}),
             //parameters: { input: message[0]?.content }
         }
         return worflowreq as T;
@@ -140,10 +162,10 @@ export default class CorzBot extends GptBase {
         while ((Date.now() - startTime) < maxWaitTime) {
             const chatinfo = await client.chat.retrieve(conversation_id, chatid);
             // 状态已经是完成了，可以去获取对话的内容了
-            if (chatinfo.status === ChatStatus.COMPLETED)  return { usage: chatinfo.usage, messages: await client.chat.messages.list(conversation_id, chatid)};
+            if (chatinfo.status === ChatStatus.COMPLETED) return { usage: chatinfo.usage, messages: await client.chat.messages.list(conversation_id, chatid) };
             await new Promise(resolve => setTimeout(resolve, 1500)); // 等待1500ms
         }
-        return null; 
+        return null;
     }
     /**
      * 非流式传输聊天请求
@@ -162,15 +184,15 @@ export default class CorzBot extends GptBase {
             }
         ];
         const client = await this.createClient();
-        
+
         ////如果参数中用的是Workflow，则调用对话流来输出结果
         ////否则用智能体的对话来输出结果
         const params = await this.getRequestStream(client, message, callChatOption);
-        const response = !this.workflowid ? await client.chat.create(params as CreateChatReq) : await client.workflows.runs.create(params as RunWorkflowReq);
+        const response = this.botid ? await client.chat.create(params as CreateChatReq) :await client.workflows.runs.create(params as RunWorkflowReq);
         if (this.workflowid && (response as RunWorkflowData).msg === 'Success') {
             const resp = (response as RunWorkflowData).data;
             try {
-                return { successed: true, message: [{ role: 'assistant', type:'answer', content: JSON.parse(resp).data }]};
+                return { successed: true, message: [{ role: 'assistant', type: 'answer', content: JSON.parse(resp).data }] };
             } catch (error) {
                 return { successed: true, message: [{ role: 'assistant', type: 'answer', content: resp }] };
             }
@@ -178,17 +200,30 @@ export default class CorzBot extends GptBase {
         if (!this.workflowid && (response as CreateChatData).conversation_id && (response as CreateChatData).id) {
             const ccd = response as CreateChatData;
             const chatData = await this.getChatDetail(client, ccd.conversation_id, ccd.id);
-            if (chatData){
+            if (chatData) {
                 const message = chatData.messages.filter(x => x.type === 'answer').map(item => ({
                     role: item.role,
                     type: item.type,
                     content: item.content,
                 }));
-                return { successed: true, message, usage: chatData.usage,session_id:ccd.conversation_id };
+                return { successed: true, message, usage: chatData.usage, session_id: ccd.conversation_id };
             }
         }
         return { successed: false, error: { message: '聊天未完成' } };
-        
+
+    }
+    /**
+     * 提取XML标签中间的内容，
+     * @param xmlStr 
+     * @param tagName 
+     * @returns 
+     */
+    extractXmlContent(xmlStr: string, tagName: string): string {
+        // 构建匹配标签的正则（支持任意空白字符和大小写）
+        const regex = new RegExp(`<\\s*${tagName}\\s*>([\\s\\S]*?)<\\s*\\/\\s*${tagName}\\s*>`, 'i');
+        const match = xmlStr.match(regex);
+        if (match && match[1]) return match[1].trim();
+        return ''; // 未找到标签或内容
     }
     /**
      * 解析深度思考的JSON内容
@@ -196,63 +231,35 @@ export default class CorzBot extends GptBase {
      * @param status 
      * @returns 
      */
-    private parseDeepThinkingJson(content: string, status: DeepThinkingStatus) {
-
+    private parseDeepThinkingJson(content: string) {
         // const thinkingStartIndex = status === DeepThinkingStatus.Thinking ? content.indexOf("{\"process_msg") : 
         //                            (status===DeepThinkingStatus.ReasonOutput ? content.indexOf("{\"reasoning_content") : content.indexOf("{\"card_resource")) ;
-        const tagLocation = [content.indexOf("{\"process_msg"),
-        content.indexOf("{\"reasoning_content"),
-        content.indexOf("{\"card_resource")].filter(x => x >= 0);
-        const thinkingStartIndex = tagLocation.length > 0 ? Math.min(...tagLocation) : -1;
-        const thinkingEndIndex = content.indexOf("\"}");
-        // 如果没有找到相关的JSON内容，则直接返回
-        if (thinkingStartIndex < 0) return { successed: true, content, status: DeepThinkingStatus.ThinkingOver };
-        let jsonStr = null;
-        try {
-            jsonStr = content.substring(thinkingStartIndex, thinkingEndIndex >= 0 ? thinkingEndIndex : undefined) + "\"}";
-            // 转换JSON的时候需要将非法字符过滤掉
-            const thinkingObject = JSON.parse(jsonStr.replace(/[\x00-\x1F\x7F]/g, ''));
-            const thinkingAction = Object.keys(thinkingObject)[0];
-            // 需要将内容的原文返回
-            const originalContent = jsonStr.split('":"')[1];
-            // 如果正确的解析JSON，并且当前有包含JSON结束的字符，则把当前思考的JSON内容替换掉
-            if (thinkingEndIndex >= 0) content = content.substring(thinkingEndIndex + 2);
-            // 如果正常输出了卡片资源，并且json结束 card_resource 只有一个，所以一旦结束，则整个思考过程完毕
-            // if (status === DeepThinkingStatus.ContentOutput && thinkingEndIndex >= 0)  status = DeepThinkingStatus.ThinkingOver;
-            // 判断整个思考过程是否到达等待卡片资源(有可能智能体输出不了卡片资源) reasoning_content 只有一个，所以一旦结束，则进入下一个阶段 card_resource
-            //if (status === DeepThinkingStatus.ContentOutput && thinkingEndIndex >= 0) status = DeepThinkingStatus.ContentOutput;
-            // 判断当前是否从前期思考切换到思考内容输出
-            if (status === DeepThinkingStatus.Thinking && thinkingAction !== DeepThinkingAction.process)
-                status = DeepThinkingStatus.ContentOutput;
-            //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)
-            const outputLength = thinkingContent?.length || 0;
-
-            // 用lastThinkingMessage来记录上一次的思考内容，避免重复输出内容，导致的网络传输内容过多
-            if (this.lastThinkingMessage.action === thinkingAction && this.lastThinkingMessage.textposition) {
-                thinkingContent = thinkingContent!.substring(this.lastThinkingMessage.textposition)
+        const xmlTagLocation = [content.indexOf(DeepThinkingAction.thinking.start),
+        content.indexOf(DeepThinkingAction.reasoning.start),
+        content.indexOf(DeepThinkingAction.card.start)];
+        let minLocation = 10000, minIndex = -1;
+        // 找到最小的并且大于0 的位置的下标
+        xmlTagLocation.forEach((x, index) => {
+            if (x >= 0 && x < minLocation) {
+                minLocation = x;
+                minIndex = index;
             }
-            this.lastThinkingMessage = thinkingEndIndex >= 0 ? { action: thinkingAction!, textposition: 0 } : { action: thinkingAction!, textposition: outputLength }
-
-            return {
-                successed: true, thinking: {
-                    action: thinkingAction,
-                    text: thinkingContent,//Object.values(thinkingObject)[0]
-                    completed: thinkingEndIndex >= 0
-                }, content, status
-            }
-        }
-        catch (error) {
-            // 如果在content之后发生了错误，可能该智能体输出不了卡片类型的数据，则输出的内容已经是正文了
-            if (status === DeepThinkingStatus.ContentOutput) {
-                status = DeepThinkingStatus.ThinkingOver;
-                return { successed: true, content, status };
-            }
-            console.error('解析JSON出错了:', jsonStr, status)
-            // 当前解析出错，等待下一次解析
-            return { successed: false, content, status }
-        }
+        });
+        // const tagLocation = xmlTagLocation.filter(x => x >= 0);
+        const thinkingStartIndex = minIndex >= 0 ? minLocation : -1; //tagLocation.length > 0 ? Math.min(...tagLocation) : -1;
+        if (thinkingStartIndex < 0) return { content, status: DeepThinkingStatus.ThinkingOver };
+        const currentAction = [DeepThinkingAction.thinking, DeepThinkingAction.reasoning, DeepThinkingAction.card][minIndex];
+        const currentActionIsOver = content.indexOf(currentAction.end, thinkingStartIndex);
+        const thinkingEndIndex = currentActionIsOver >= 0 ? currentActionIsOver: content.indexOf('</', thinkingStartIndex);
+        const thinkingContent = this.extractXmlContent(content.substring(thinkingStartIndex, thinkingEndIndex >= 0 ? thinkingEndIndex : undefined) + currentAction.end, currentAction.tag);  //"\"}";
+        if (currentActionIsOver >= 0) content = content.substring(currentActionIsOver + currentAction.end.length);
+        return { 
+            thinking: {
+                action: currentAction,
+                text: thinkingContent,//Object.values(thinkingObject)[0]
+                completed: currentActionIsOver >= 0
+            }, content};
+       
     }
     /**
      * 流式传输聊天请求
@@ -277,48 +284,51 @@ export default class CorzBot extends GptBase {
         ////否则用智能体的对话来输出结果
         let requestid = Math.ceil(Math.random() * (new Date().getTime() * Math.random()) / 1000), index = 0;
         const params = await this.getRequestStream(client, message, callChatOption);
-        const stream = !this.workflowid ? client.chat.stream(params as StreamChatReq) : client.workflows.runs.stream(params as RunWorkflowReq);
+        const stream = this.botid ? client.chat.stream(params as StreamChatReq) : 
+            (this.workflowid ? client.workflows.runs.stream(params as RunWorkflowReq) : 
+            client.workflows.chat.stream(params as ChatWorkflowReq)) ;
         let deltaindex = 0, fullanswer: string[] = [], followup: string[] = [], cardData: CardType[] = [];
         let deepThinking = '', thinkingStatus = DeepThinkingStatus.None, cardResource = ''; // 是否在深度思考中
         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 (part.event === ChatEventType.CONVERSATION_MESSAGE_DELTA ||
+                part.event === WorkflowEventType.MESSAGE
+            ) {
+                let { conversation_id, content_type, type = 'answer', role = 'assistant', content, reasoning_content: reasoning } = part.data as any;
+                if (!content&& reasoning) {
+                    this.emit('chatthinking', { text: reasoning, completed: false, action: 'deep-thinking' });
+                    continue;
+                }
                 // 如果存在深度思考，则一开始就会带有相关的关键信息
-                if (deltaindex === 0 && content.startsWith("{\"process_msg")) {
+                if (deltaindex === 0 && content.startsWith("<xiaolu-")) {
                     thinkingStatus = DeepThinkingStatus.Thinking;
                     deltaindex++;
                 }
                 // 如果在深度思考中，则不输出消息
-                if (thinkingStatus !== DeepThinkingStatus.None
-                    && thinkingStatus !== DeepThinkingStatus.ThinkingOver
-                ) {
+                if (thinkingStatus === DeepThinkingStatus.Thinking) {
                     deepThinking += content;
-                    const result = this.parseDeepThinkingJson(deepThinking, thinkingStatus)
-                    if (result.successed) {
-                        const thinking = result.thinking;
-                        if (thinking) {
-                            deepThinking = result.content;
-                            if (thinking.action === DeepThinkingAction.card) {
-                                cardResource += result.thinking.text;
-                                // 卡片流结束，解析卡片资源数据
-                                if (result.thinking.completed) {
-                                    const allCards = cardResource.replace(/[\x00-\x1F\x7F]/g, '').split('|')
-                                    for (const item of allCards) {
-                                        const cardinfo: any = parse(item);
-                                        if (cardinfo.type && cardinfo.tag) cardData.push({ type: Number(cardinfo.type), tag: cardinfo.tag })
-                                    }
-                                    // 将卡片资源返回给客户端
-                                    this.emit('chatcard', cardData);
+                    const result = this.parseDeepThinkingJson(deepThinking)
+                    const thinking = result.thinking;
+                    if (thinking) {
+                        deepThinking = result.content;
+                        if (thinking.action === DeepThinkingAction.card) {
+                            cardResource += result.thinking.text;
+                            // 卡片流结束，解析卡片资源数据
+                            if (result.thinking.completed) {
+                                const allCards = cardResource.replace(/[\x00-\x1F\x7F]/g, '').split('|')
+                                for (const item of allCards) {
+                                    const cardinfo: any = parse(item);
+                                    if (cardinfo.type && cardinfo.tag) cardData.push({ type: Number(cardinfo.type), tag: cardinfo.tag })
                                 }
-                            } else {
-                                this.emit('chatthinking', result.thinking);
+                                // 将卡片资源返回给客户端
+                                this.emit('chatcard', cardData);
                             }
+                        } else {
+                            this.emit('chatthinking', { text: result.thinking.text, completed: result.thinking.completed, action: thinking.action?.tag });
                         }
-                        thinkingStatus = result.status;
                     }
-                    if (thinkingStatus != DeepThinkingStatus.ThinkingOver) continue;
-                    // thinkingStatus = DeepThinkingStatus.None;
+                    if (result.status != DeepThinkingStatus.ThinkingOver) continue;
+                    thinkingStatus = DeepThinkingStatus.ThinkingOver;
                     // 将排除了thinking之后的消息内容要带下去成为正式的输出内容
                     content = deepThinking;
                 }
@@ -329,13 +339,15 @@ export default class CorzBot extends GptBase {
             }
             ////在流式传输中，提取相关推荐问题
             if (part.event === ChatEventType.CONVERSATION_MESSAGE_COMPLETED) {
-                const { type, content } = part.data;
+                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, cards: cardData.length ? cardData : null, followup, type: 'answer', content_type: 'text', role: RoleType.Assistant, requestid, segment: null, text: fullanswer.join(''), index: index++, session_id: conversation_id };
+            if (part.event === ChatEventType.CONVERSATION_CHAT_COMPLETED ||
+                part.event === WorkflowEventType.DONE
+            ) {
+                const { conversation_id, content } =( part.data )?? {} as any;
+                let output = { successed: true, cards: cardData.length ? cardData : null, followup, type: 'answer', content_type: 'text', role: RoleType.Assistant, requestid, segment: null, text: content??fullanswer.join(''), index: index++, session_id: conversation_id };
                 if (attach) output = Object.assign({}, output, attach);
                 this.emit('chatdone', output)
             }