doomiaichat 7.1.7 → 7.1.9

package/dist/corzbot.d.ts

@@ -4,10 +4,12 @@
 import { CozeAPI, EnterMessage } from '@coze/api';
 import GptBase from "./gptbase";
 import { CorzAuthorization } from './corzauthorization';
+import { ApiResult } from './declare';
 export default class CorzBot extends GptBase {
     private authorizationProvider;
     private setting;
     protected botid: string;
+    protected workflowid: string;
     private apiKey;
     private lastThinkingMessage;
     /**
@@ -21,20 +23,32 @@ export default class CorzBot extends GptBase {
      * 发起一次会话
      */
     createCoversation(client?: CozeAPI): Promise<string | null>;
+    setVariables(params: any): Promise<ApiResult>;
     /**
-         * 组装请求参数
-         * @param message
-         * @param callChatOption
-         * @param attach
-         * @param _axiosOption
-         */
+     * 获取设置的变量
+     * @returns
+     */
+    getVariables(params: any): Promise<any>;
+    /**
+     * 组装请求参数
+     * @param message
+     * @param callChatOption
+     * @param attach
+     * @param _axiosOption
+     */
     getRequestStream<T>(client: CozeAPI, message: EnterMessage[], callChatOption?: any): Promise<T>;
     /**
-      * 非流式传输聊天请求
-      * @param chatText
-      * @param callChatOption
-      * @param _axiosOption
-      */
+     * 同步调用的问答请求需要获取会话详情
+     * @param chatid
+     * @param conversation_id
+     */
+    private getChatDetail;
+    /**
+     * 非流式传输聊天请求
+     * @param chatText
+     * @param callChatOption
+     * @param _axiosOption
+     */
     chatRequest(message: any[] | string, callChatOption?: any, _axiosOption?: any): Promise<any>;
     /**
      * 解析深度思考的JSON内容

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;
@@ -55,6 +54,7 @@ class CorzBot extends gptbase_1.default {
         this.lastThinkingMessage = { action: '', textposition: 0 };
         ////初始化扣子客户端
         this.botid = this.setting['botid'] || this.setting['botID'];
+        this.workflowid = this.setting['workflowid'];
         this.apiKey = this.setting['apiKey'];
     }
     createClient() {
@@ -75,7 +75,8 @@ class CorzBot extends gptbase_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const czApi = client !== null && client !== void 0 ? client : yield this.createClient();
-                const result = yield czApi.conversations.create({ bot_id: this.botid });
+                const params = this.botid ? { bot_id: this.botid } : {};
+                const result = yield czApi.conversations.create(params);
                 return result.id;
             }
             catch (error) {
@@ -84,19 +85,41 @@ class CorzBot extends gptbase_1.default {
             }
         });
     }
+    setVariables(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield this.createClient();
+            const cozeParams = Object.assign({}, this.botid ? { bot_id: this.botid } : {}, params);
+            client.variables.update(cozeParams);
+            return { successed: true };
+        });
+    }
     /**
-         * 组装请求参数
-         * @param message
-         * @param callChatOption
-         * @param attach
-         * @param _axiosOption
-         */
+     * 获取设置的变量
+     * @returns
+     */
+    getVariables(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield this.createClient();
+            const cozeParams = Object.assign({}, { bot_id: this.botid }, params);
+            const data = yield client.variables.retrieve(cozeParams);
+            if (data)
+                return Object.assign({ successed: true }, data);
+            return { successed: false, error: 'get variables failed' };
+        });
+    }
+    /**
+     * 组装请求参数
+     * @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) {
+            if (!this.workflowid) {
                 const req = {
                     bot_id: this.botid,
                     additional_messages: message,
@@ -109,7 +132,8 @@ class CorzBot extends gptbase_1.default {
             const worflowreq = {
                 bot_id: this.botid,
                 additional_messages: message,
-                workflow_id: callChatOption.workflowid,
+                ext: callChatOption.ext,
+                workflow_id: this.workflowid,
                 conversation_id,
                 parameters: Object.assign({}, this.setting.customVariables || {}, callChatOption.customVariables || {}),
             };
@@ -117,11 +141,30 @@ class CorzBot extends gptbase_1.default {
         });
     }
     /**
-      * 非流式传输聊天请求
-      * @param chatText
-      * @param callChatOption
-      * @param _axiosOption
-      */
+     * 同步调用的问答请求需要获取会话详情
+     * @param chatid
+     * @param conversation_id
+     */
+    getChatDetail(client, conversation_id, chatid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const maxWaitTime = 120000; // 最大等待120秒
+            const startTime = Date.now();
+            while ((Date.now() - startTime) < maxWaitTime) {
+                const chatinfo = yield client.chat.retrieve(conversation_id, chatid);
+                // 状态已经是完成了，可以去获取对话的内容了
+                if (chatinfo.status === api_1.ChatStatus.COMPLETED)
+                    return { usage: chatinfo.usage, messages: yield client.chat.messages.list(conversation_id, chatid) };
+                yield new Promise(resolve => setTimeout(resolve, 1500)); // 等待1500ms
+            }
+            return null;
+        });
+    }
+    /**
+     * 非流式传输聊天请求
+     * @param chatText
+     * @param callChatOption
+     * @param _axiosOption
+     */
     chatRequest(message, callChatOption = {}, _axiosOption = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!message)
@@ -139,31 +182,29 @@ class CorzBot extends gptbase_1.default {
             ////如果参数中用的是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 };
+            const response = !this.workflowid ? yield client.chat.create(params) : yield client.workflows.runs.create(params);
+            if (this.workflowid && response.msg === 'Success') {
+                const resp = response.data;
+                try {
+                    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 }] };
+                }
             }
-            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' }
+            if (!this.workflowid && response.conversation_id && response.id) {
+                const ccd = response;
+                const chatData = yield this.getChatDetail(client, ccd.conversation_id, ccd.id);
+                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: false, error: { message: '聊天未完成' } };
         });
     }
     /**
@@ -173,13 +214,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 +236,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 +251,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 +280,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' });
@@ -257,13 +297,13 @@ 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 = [];
+            const stream = !this.workflowid ? client.chat.stream(params) : client.workflows.runs.stream(params);
+            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,18 +321,25 @@ 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);
                                         }
                                     }
                                     thinkingStatus = result.status;
@@ -318,21 +365,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/dist/gptbase.d.ts

@@ -23,6 +23,16 @@ export default abstract class GptBase extends EventEmitter {
      * @returns
      */
     createCoversation(_client?: any): Promise<string | null>;
+    /**
+     * 设置智能体的变量
+     * @returns
+     */
+    setVariables(_params: any): Promise<ApiResult>;
+    /**
+     * 获取智能体的变量
+     * @returns
+     */
+    getVariables(_params: any): Promise<any>;
     /**
      * 流式的聊天模式
      * @param chatText

package/dist/gptbase.js

@@ -31,6 +31,22 @@ class GptBase extends events_1.EventEmitter {
             return null;
         });
     }
+    /**
+     * 设置智能体的变量
+     * @returns
+     */
+    setVariables(_params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return { successed: true };
+        });
+    }
+    /**
+     * 获取智能体的变量
+     * @returns
+     */
+    getVariables(_params) {
+        return __awaiter(this, void 0, void 0, function* () { return { successed: false }; });
+    }
     /**
      * 流式的聊天模式
      * @param chatText

package/package.json

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

package/src/corzbot.ts

@@ -1,50 +1,61 @@
 /**
  * 扣子智能体
  */
-import { CozeAPI,
+import {
+    CozeAPI,
     COZE_CN_BASE_URL,
     ChatEventType,
-    RoleType, 
+    RoleType,
     StreamChatReq,
     EnterMessage,
     ChatWorkflowReq,
+    // CreateChatReq,
+    // ChatStatus,
+    VariableUpdateReq,
+    VariableRetrieveReq,
     CreateChatReq,
-    ChatStatus} from '@coze/api';
+    RunWorkflowReq,
+    RunWorkflowData,
+    CreateChatData,
+    ChatStatus
+} 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',
+    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 };
+    protected workflowid: 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={}) {
+    constructor(private authorizationProvider: CorzAuthorization, private setting: any = {}) {
         super();
         ////初始化扣子客户端
         this.botid = this.setting['botid'] || this.setting['botID'];
+        this.workflowid = this.setting['workflowid'];
         this.apiKey = this.setting['apiKey'];
     }
     private async createClient(): Promise<CozeAPI> {
@@ -57,90 +68,125 @@ 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 params = this.botid ? { bot_id: this.botid } : {};
+            const result = await czApi.conversations.create(params)
             return result.id;
-        }catch(error){
+        } catch (error) {
             console.error('createCoversation error in coze api');
             return null;
         }
     }
+
+    override async setVariables(params: any): Promise<ApiResult> {
+        const client = await this.createClient();
+        const cozeParams: VariableUpdateReq = Object.assign({}, this.botid ? { bot_id: this.botid } : {}, params);
+        client.variables.update(cozeParams)
+        return { successed: true };
+    }
     /**
-         * 组装请求参数
-         * @param message 
-         * @param callChatOption 
-         * @param attach 
-         * @param _axiosOption 
-         */
+     * 获取设置的变量
+     * @returns 
+     */
+    override async getVariables(params: any): Promise<any> {
+        const client = await this.createClient();
+        const cozeParams: VariableRetrieveReq = Object.assign({}, { bot_id: this.botid }, params);
+        const data = await client.variables.retrieve(cozeParams);
+        if (data) return { successed: true, ...data }
+        return { successed: false, error: 'get variables failed' };
+    }
+    /**
+     * 组装请求参数
+     * @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) {
+        if (!this.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  || {});
+            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,
+            ext: callChatOption.ext,
+            workflow_id: this.workflowid,//callChatOption.workflowid,
             conversation_id,
-            parameters: Object.assign({}, this.setting.customVariables || {}, callChatOption.customVariables  || {}),
+            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> {
+     * 同步调用的问答请求需要获取会话详情
+     * @param chatid 
+     * @param conversation_id 
+     */
+    private async getChatDetail(client: CozeAPI, conversation_id: string, chatid: string) {
+        const maxWaitTime = 120000; // 最大等待120秒
+        const startTime = Date.now();
+        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)};
+            await new Promise(resolve => setTimeout(resolve, 1500)); // 等待1500ms
+        }
+        return null; 
+    }
+    /**
+     * 非流式传输聊天请求
+     * @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_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 };
+        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);
+        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 }]};
+            } catch (error) {
+                return { successed: true, message: [{ role: 'assistant', type: 'answer', content: resp }] };
+            }
         }
-        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' }
+        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){
+                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: false, error: { message: '聊天未完成' } };
+        
     }
     /**
      * 解析深度思考的JSON内容
@@ -148,53 +194,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 +260,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,38 +273,44 @@ 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 = !this.workflowid ? client.chat.stream(params as StreamChatReq) : client.workflows.runs.stream(params as RunWorkflowReq);
+        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);
                             }
                         }
                         thinkingStatus = result.status;
@@ -270,13 +327,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)
             }

package/src/gptbase.ts

@@ -28,6 +28,19 @@ export default abstract class GptBase extends EventEmitter {
     async createCoversation(_client?:any):Promise<string|null> {
         return null;
     }
+
+    /**
+     * 设置智能体的变量
+     * @returns 
+     */
+    async setVariables(_params: any):Promise<ApiResult> {
+        return { successed: true };
+    }
+    /**
+     * 获取智能体的变量
+     * @returns 
+     */
+    async getVariables(_params: any): Promise<any> { return {successed: false}}
     /**
      * 流式的聊天模式
      * @param chatText