doomiaichat 7.1.7 → 7.1.8

package/dist/corzbot.js

@@ -37,9 +37,8 @@ var DeepThinkingStatus;
 (function (DeepThinkingStatus) {
     DeepThinkingStatus[DeepThinkingStatus["None"] = 0] = "None";
     DeepThinkingStatus[DeepThinkingStatus["Thinking"] = 1] = "Thinking";
-    DeepThinkingStatus[DeepThinkingStatus["ReasonOutput"] = 2] = "ReasonOutput";
-    DeepThinkingStatus[DeepThinkingStatus["CardResource"] = 3] = "CardResource";
-    DeepThinkingStatus[DeepThinkingStatus["ThinkingOver"] = 4] = "ThinkingOver";
+    DeepThinkingStatus[DeepThinkingStatus["ContentOutput"] = 2] = "ContentOutput";
+    DeepThinkingStatus[DeepThinkingStatus["ThinkingOver"] = 3] = "ThinkingOver";
 })(DeepThinkingStatus || (DeepThinkingStatus = {}));
 class CorzBot extends gptbase_1.default {
     // protected client: CozeAPI;
@@ -173,13 +172,13 @@ class CorzBot extends gptbase_1.default {
      * @returns
      */
     parseDeepThinkingJson(content, status) {
-        var _a;
-        const thinkingEndIndex = content.indexOf("\"}");
         // const thinkingStartIndex = status === DeepThinkingStatus.Thinking ? content.indexOf("{\"process_msg") : 
         //                            (status===DeepThinkingStatus.ReasonOutput ? content.indexOf("{\"reasoning_content") : content.indexOf("{\"card_resource")) ;
-        const thinkingStartIndex = (_a = [content.indexOf("{\"process_msg"),
+        const tagLocation = [content.indexOf("{\"process_msg"),
             content.indexOf("{\"reasoning_content"),
-            content.indexOf("{\"card_resource")].find(x => x >= 0)) !== null && _a !== void 0 ? _a : -1;
+            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 };
@@ -195,14 +194,12 @@ class CorzBot extends gptbase_1.default {
             if (thinkingEndIndex >= 0)
                 content = content.substring(thinkingEndIndex + 2);
             // 如果正常输出了卡片资源，并且json结束 card_resource 只有一个，所以一旦结束，则整个思考过程完毕
-            if (status === DeepThinkingStatus.CardResource && thinkingEndIndex >= 0)
-                status = DeepThinkingStatus.ThinkingOver;
+            // if (status === DeepThinkingStatus.ContentOutput && thinkingEndIndex >= 0)  status = DeepThinkingStatus.ThinkingOver;
             // 判断整个思考过程是否到达等待卡片资源(有可能智能体输出不了卡片资源) reasoning_content 只有一个，所以一旦结束，则进入下一个阶段 card_resource
-            if (status === DeepThinkingStatus.ReasonOutput && thinkingEndIndex >= 0)
-                status = DeepThinkingStatus.CardResource;
+            //if (status === DeepThinkingStatus.ContentOutput && thinkingEndIndex >= 0) status = DeepThinkingStatus.ContentOutput;
             // 判断当前是否从前期思考切换到思考内容输出
-            if (status === DeepThinkingStatus.Thinking && thinkingAction === DeepThinkingAction.content)
-                status = DeepThinkingStatus.ReasonOutput;
+            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);
@@ -212,15 +209,17 @@ class CorzBot extends gptbase_1.default {
                 thinkingContent = thinkingContent.substring(this.lastThinkingMessage.textposition);
             }
             this.lastThinkingMessage = thinkingEndIndex >= 0 ? { action: thinkingAction, textposition: 0 } : { action: thinkingAction, textposition: outputLength };
-            return { successed: true, thinking: {
+            return {
+                successed: true, thinking: {
                     action: thinkingAction,
                     text: thinkingContent,
                     completed: thinkingEndIndex >= 0
-                }, content, status };
+                }, content, status
+            };
         }
         catch (error) {
             // 如果在content之后发生了错误，可能该智能体输出不了卡片类型的数据，则输出的内容已经是正文了
-            if (status === DeepThinkingStatus.CardResource) {
+            if (status === DeepThinkingStatus.ContentOutput) {
                 status = DeepThinkingStatus.ThinkingOver;
                 return { successed: true, content, status };
             }
@@ -239,7 +238,6 @@ class CorzBot extends gptbase_1.default {
      */
     chatRequestInStream(message, callChatOption = {}, attach, _axiosOption) {
         var _a, e_1, _b, _c;
-        var _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
             if (!message)
                 this.emit('chaterror', { successed: false, error: 'no message in chat' });
@@ -258,12 +256,12 @@ 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 = !callChatOption.workflowid ? client.chat.stream(params) : client.workflows.chat.stream(params);
-            let deltaindex = 0, fullanswer = [], followup = [];
+            let deltaindex = 0, fullanswer = [], followup = [], cardData = [];
             let deepThinking = '', thinkingStatus = DeepThinkingStatus.None, cardResource = ''; // 是否在深度思考中
             try {
-                for (var _f = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a;) {
+                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;
-                    _f = false;
+                    _d = false;
                     try {
                         const part = _c;
                         if (part.event === api_1.ChatEventType.ERROR)
@@ -281,20 +279,40 @@ class CorzBot extends gptbase_1.default {
                                 deepThinking += content;
                                 const result = this.parseDeepThinkingJson(deepThinking, thinkingStatus);
                                 if (result.successed) {
-                                    // 如果不是卡片资源，则发送thinking事件，并更新thinkingStatus
-                                    if (thinkingStatus !== DeepThinkingStatus.CardResource) {
+                                    const thinking = result.thinking;
+                                    if (thinking) {
                                         deepThinking = result.content;
-                                        this.emit('chatthinking', result.thinking);
-                                    }
-                                    else if (thinkingStatus === DeepThinkingStatus.CardResource) {
-                                        cardResource += (_d = result.thinking) === null || _d === void 0 ? void 0 : _d.text;
-                                        // 卡片流结束，解析卡片资源数据
-                                        if ((_e = result.thinking) === null || _e === void 0 ? void 0 : _e.completed) {
-                                            const cardData = cardResource.replace(/[\x00-\x1F\x7F]/g, '').split('|').map((item) => (0, querystring_1.parse)(item));
-                                            // 将卡片资源返回给客户端
-                                            this.emit('chatcard', cardData);
+                                        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);
                                         }
                                     }
+                                    // 如果不是卡片资源，则发送thinking事件，并更新thinkingStatus
+                                    // if(thinkingStatus !== DeepThinkingStatus.CardResource){
+                                    //     deepThinking = result.content;
+                                    //     this.emit('chatthinking', result.thinking);
+                                    // } else if (thinkingStatus === DeepThinkingStatus.CardResource) {
+                                    //     cardResource += result.thinking?.text;
+                                    //     // 卡片流结束，解析卡片资源数据
+                                    //     if (result.thinking?.completed){
+                                    //         const cardData:any[] = cardResource.replace(/[\x00-\x1F\x7F]/g, '').split('|').map((item:string)=>parse(item));
+                                    //         // 将卡片资源返回给客户端
+                                    //         this.emit('chatcard', cardData);
+                                    //     }
+                                    // }
                                     thinkingStatus = result.status;
                                 }
                                 if (thinkingStatus != DeepThinkingStatus.ThinkingOver)
@@ -318,21 +336,21 @@ class CorzBot extends gptbase_1.default {
                         ///整个对话结束
                         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 };
+                            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 (attach)
                                 output = Object.assign({}, output, attach);
                             this.emit('chatdone', output);
                         }
                     }
                     finally {
-                        _f = true;
+                        _d = true;
                     }
                 }
             }
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
-                    if (!_f && !_a && (_b = stream_1.return)) yield _b.call(stream_1);
+                    if (!_d && !_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.7",
+  "version": "7.1.8",
   "description": "Doomisoft OpenAI",
   "main": "dist/index.js",
   "scripts": {

package/src/corzbot.ts

@@ -1,47 +1,48 @@
 /**
  * 扣子智能体
  */
-import { CozeAPI,
+import {
+    CozeAPI,
     COZE_CN_BASE_URL,
     ChatEventType,
-    RoleType, 
+    RoleType,
     StreamChatReq,
     EnterMessage,
     ChatWorkflowReq,
     CreateChatReq,
-    ChatStatus} from '@coze/api';
+    ChatStatus
+} from '@coze/api';
 import GptBase from "./gptbase"
 import { CorzAuthorization } from './corzauthorization';
 import { parse } from 'querystring'
 
 // 定义深度思考的动作
 enum DeepThinkingAction {
-    process =  'process_msg',
-    content ='reasoning_content',
+    process = 'process_msg',
+    content = 'reasoning_content',
     card = 'card_resource'
 }
 // 定义深度思考的状态
 enum DeepThinkingStatus {
     None,
     Thinking,
-    ReasonOutput,
-    CardResource,
+    ContentOutput,
     ThinkingOver
 }
 // 智能体思考时输出的动作
-
+type CardType = { type: number, tag: string }
 type TThinkingMessage = { action: string, textposition: number }
 export default class CorzBot extends GptBase {
     protected botid: string;
-    private apiKey:string;
-    private lastThinkingMessage: TThinkingMessage = { action: '', textposition:0 };
+    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={}) {
+    constructor(private authorizationProvider: CorzAuthorization, private setting: any = {}) {
         super();
         ////初始化扣子客户端
         this.botid = this.setting['botid'] || this.setting['botID'];
@@ -57,12 +58,12 @@ export default class CorzBot extends GptBase {
     /**
      * 发起一次会话
      */
-    override async createCoversation(client?: CozeAPI):Promise<string|null>{
-        try{
-            const czApi = client?? await this.createClient();
-            const result = await czApi.conversations.create({ bot_id: this.botid})
+    override async createCoversation(client?: CozeAPI): Promise<string | null> {
+        try {
+            const czApi = client ?? await this.createClient();
+            const result = await czApi.conversations.create({ bot_id: this.botid })
             return result.id;
-        }catch(error){
+        } catch (error) {
             console.error('createCoversation error in coze api');
             return null;
         }
@@ -84,7 +85,7 @@ export default class CorzBot extends GptBase {
                 user_id: callChatOption.userid || callChatOption.cozeUserID,
                 conversation_id
             }
-            req.custom_variables = Object.assign({}, this.setting.customVariables || {}, callChatOption.customVariables  || {});
+            req.custom_variables = Object.assign({}, this.setting.customVariables || {}, callChatOption.customVariables || {});
             return req as T;
         }
         const worflowreq: ChatWorkflowReq = {
@@ -92,7 +93,7 @@ export default class CorzBot extends GptBase {
             additional_messages: message,
             workflow_id: callChatOption.workflowid,
             conversation_id,
-            parameters: Object.assign({}, this.setting.customVariables || {}, callChatOption.customVariables  || {}),
+            parameters: Object.assign({}, this.setting.customVariables || {}, callChatOption.customVariables || {}),
         }
         return worflowreq as T;
     }
@@ -102,23 +103,23 @@ export default class CorzBot extends GptBase {
       * @param callChatOption 
       * @param _axiosOption 
       */
-    public async chatRequest(message: any[]|string, callChatOption: any={}, _axiosOption: any = {}): Promise<any> {
+    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_type: 'text',
                 content: message
             }
         ];
         const client = await this.createClient();
         ////如果参数中用的是Workflow，则调用对话流来输出结果
         ////否则用智能体的对话来输出结果
-        const params = await this.getRequestStream(client,message, callChatOption);
+        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 => ({
+            const message = response.messages.filter(x => x.type === 'answer').map(item => ({
                 role: item.role,
                 type: item.type,
                 content: item.content,
@@ -128,7 +129,7 @@ export default class CorzBot extends GptBase {
                 type: item.type,
                 content: item.content,
             }));
-            return { successed: true, message, follow_up,usage: response.chat.usage };
+            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) {
@@ -148,53 +149,58 @@ export default class CorzBot extends GptBase {
      * @param status 
      * @returns 
      */
-    private parseDeepThinkingJson(content: string,status: DeepThinkingStatus) {
-        const thinkingEndIndex = content.indexOf("\"}");
+    private parseDeepThinkingJson(content: string, status: DeepThinkingStatus) {
+
         // const thinkingStartIndex = status === DeepThinkingStatus.Thinking ? content.indexOf("{\"process_msg") : 
         //                            (status===DeepThinkingStatus.ReasonOutput ? content.indexOf("{\"reasoning_content") : content.indexOf("{\"card_resource")) ;
-        const thinkingStartIndex = [content.indexOf("{\"process_msg"), 
-                                    content.indexOf("{\"reasoning_content"), 
-                                    content.indexOf("{\"card_resource")].find(x=>x>=0)??-1;
+        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};
+        if (thinkingStartIndex < 0) return { successed: true, content, status: DeepThinkingStatus.ThinkingOver };
         let jsonStr = null;
-        try{
-            jsonStr = content.substring(thinkingStartIndex, thinkingEndIndex >= 0 ? thinkingEndIndex : undefined) +"\"}";
+        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);
+            if (thinkingEndIndex >= 0) content = content.substring(thinkingEndIndex + 2);
             // 如果正常输出了卡片资源，并且json结束 card_resource 只有一个，所以一旦结束，则整个思考过程完毕
-            if (status === DeepThinkingStatus.CardResource && thinkingEndIndex >= 0)  status = DeepThinkingStatus.ThinkingOver;
+            // if (status === DeepThinkingStatus.ContentOutput && thinkingEndIndex >= 0)  status = DeepThinkingStatus.ThinkingOver;
             // 判断整个思考过程是否到达等待卡片资源(有可能智能体输出不了卡片资源) reasoning_content 只有一个，所以一旦结束，则进入下一个阶段 card_resource
-            if (status === DeepThinkingStatus.ReasonOutput && thinkingEndIndex >= 0) status = DeepThinkingStatus.CardResource;
+            //if (status === DeepThinkingStatus.ContentOutput && thinkingEndIndex >= 0) status = DeepThinkingStatus.ContentOutput;
             // 判断当前是否从前期思考切换到思考内容输出
-            if (status === DeepThinkingStatus.Thinking && thinkingAction === DeepThinkingAction.content) status = DeepThinkingStatus.ReasonOutput;
+            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){
+            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 }
+            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}
+            return {
+                successed: true, thinking: {
+                    action: thinkingAction,
+                    text: thinkingContent,//Object.values(thinkingObject)[0]
+                    completed: thinkingEndIndex >= 0
+                }, content, status
+            }
         }
-        catch(error){
+        catch (error) {
             // 如果在content之后发生了错误，可能该智能体输出不了卡片类型的数据，则输出的内容已经是正文了
-            if (status === DeepThinkingStatus.CardResource) {
+            if (status === DeepThinkingStatus.ContentOutput) {
                 status = DeepThinkingStatus.ThinkingOver;
-                return {successed: true, content, status};
+                return { successed: true, content, status };
             }
             console.error('解析JSON出错了:', jsonStr, status)
             // 当前解析出错，等待下一次解析
@@ -209,7 +215,7 @@ export default class CorzBot extends GptBase {
      * @param _axiosOption 
      * @returns 
      */
-    override async chatRequestInStream(message: any[]|string, callChatOption: any={}, attach?: any, _axiosOption?: any): Promise<any> {
+    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 = [
@@ -222,40 +228,59 @@ export default class CorzBot extends GptBase {
         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,cardResource=''; // 是否在深度思考中
+        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[] = [], 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;
+                let { conversation_id, content_type, type, role, content } = part.data;
                 // 如果存在深度思考，则一开始就会带有相关的关键信息
                 if (deltaindex === 0 && content.startsWith("{\"process_msg")) {
-                    thinkingStatus=DeepThinkingStatus.Thinking;
+                    thinkingStatus = DeepThinkingStatus.Thinking;
                     deltaindex++;
                 }
                 // 如果在深度思考中，则不输出消息
-                if (thinkingStatus !== DeepThinkingStatus.None 
+                if (thinkingStatus !== DeepThinkingStatus.None
                     && thinkingStatus !== DeepThinkingStatus.ThinkingOver
-                ){
+                ) {
                     deepThinking += content;
                     const result = this.parseDeepThinkingJson(deepThinking, thinkingStatus)
-                    if (result.successed ){
-                        // 如果不是卡片资源，则发送thinking事件，并更新thinkingStatus
-                        if(thinkingStatus !== DeepThinkingStatus.CardResource){
+                    if (result.successed) {
+                        const thinking = result.thinking;
+                        if (thinking) {
                             deepThinking = result.content;
-                            this.emit('chatthinking', result.thinking);
-                        } else if (thinkingStatus === DeepThinkingStatus.CardResource) {
-                            cardResource += result.thinking?.text;
-                            // 卡片流结束，解析卡片资源数据
-                            if (result.thinking?.completed){
-                                const cardData:any[] = cardResource.replace(/[\x00-\x1F\x7F]/g, '').split('|').map((item:string)=>parse(item));
-                                // 将卡片资源返回给客户端
-                                this.emit('chatcard', cardData);
+                            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);
+                                }
+                            } else {
+                                this.emit('chatthinking', result.thinking);
                             }
                         }
+                        // 如果不是卡片资源，则发送thinking事件，并更新thinkingStatus
+                        // if(thinkingStatus !== DeepThinkingStatus.CardResource){
+                        //     deepThinking = result.content;
+                        //     this.emit('chatthinking', result.thinking);
+                        // } else if (thinkingStatus === DeepThinkingStatus.CardResource) {
+                        //     cardResource += result.thinking?.text;
+                        //     // 卡片流结束，解析卡片资源数据
+                        //     if (result.thinking?.completed){
+                        //         const cardData:any[] = cardResource.replace(/[\x00-\x1F\x7F]/g, '').split('|').map((item:string)=>parse(item));
+                        //         // 将卡片资源返回给客户端
+                        //         this.emit('chatcard', cardData);
+                        //     }
+                        // }
                         thinkingStatus = result.status;
                     }
                     if (thinkingStatus != DeepThinkingStatus.ThinkingOver) continue;
@@ -270,13 +295,13 @@ export default class CorzBot extends GptBase {
             }
             ////在流式传输中，提取相关推荐问题
             if (part.event === ChatEventType.CONVERSATION_MESSAGE_COMPLETED) {
-                const { type, content} = part.data;
-                if (type ==='follow_up') followup.push(content);
+                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 };
+                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 (attach) output = Object.assign({}, output, attach);
                 this.emit('chatdone', output)
             }