doomiaichat 7.1.5 → 7.1.6

package/dist/corzbot.js

@@ -24,12 +24,22 @@ 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 = {}));
+// 定义深度思考的状态
 var DeepThinkingStatus;
 (function (DeepThinkingStatus) {
     DeepThinkingStatus[DeepThinkingStatus["None"] = 0] = "None";
     DeepThinkingStatus[DeepThinkingStatus["Thinking"] = 1] = "Thinking";
     DeepThinkingStatus[DeepThinkingStatus["ReasonOutput"] = 2] = "ReasonOutput";
-    DeepThinkingStatus[DeepThinkingStatus["ThinkingOver"] = 3] = "ThinkingOver";
+    DeepThinkingStatus[DeepThinkingStatus["CardResource"] = 3] = "CardResource";
+    DeepThinkingStatus[DeepThinkingStatus["ThinkingOver"] = 4] = "ThinkingOver";
 })(DeepThinkingStatus || (DeepThinkingStatus = {}));
 class CorzBot extends gptbase_1.default {
     // protected client: CozeAPI;
@@ -158,28 +168,40 @@ 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") : content.indexOf("{\"reasoning_content");
+        // 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"),
+            content.indexOf("{\"reasoning_content"),
+            content.indexOf("{\"card_resource")].find(x => x >= 0)) !== null && _a !== void 0 ? _a : -1;
+        // 如果没有找到相关的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);
-            // 判断整个思考过程是否结束
-            if (status === DeepThinkingStatus.ReasonOutput && thinkingEndIndex >= 0)
+            // 如果正常输出了卡片资源，并且json结束 card_resource 只有一个，所以一旦结束，则整个思考过程完毕
+            if (status === DeepThinkingStatus.CardResource && thinkingEndIndex >= 0)
                 status = DeepThinkingStatus.ThinkingOver;
+            // 判断整个思考过程是否到达等待卡片资源(有可能智能体输出不了卡片资源) reasoning_content 只有一个，所以一旦结束，则进入下一个阶段 card_resource
+            if (status === DeepThinkingStatus.ReasonOutput && thinkingEndIndex >= 0)
+                status = DeepThinkingStatus.CardResource;
             // 判断当前是否从前期思考切换到思考内容输出
-            if (status === DeepThinkingStatus.Thinking && content.indexOf("{\"reasoning_content") >= 0)
+            if (status === DeepThinkingStatus.Thinking && thinkingAction === DeepThinkingAction.content)
                 status = DeepThinkingStatus.ReasonOutput;
+            //if (status === DeepThinkingStatus.Thinking && content.indexOf("{\"reasoning_content") >= 0) status=DeepThinkingStatus.ReasonOutput;
             //const removeOutputContent = content.replace(originalContent!.substring(1, originalContent!.length - 2),"")
-            let thinkingContent = originalContent === null || originalContent === void 0 ? void 0 : originalContent.substring(0, originalContent.length - 2); //.replace(lastContent, '');
+            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;
-            const thinkingAction = Object.keys(thinkingObject)[0];
             // 用lastThinkingMessage来记录上一次的思考内容，避免重复输出内容，导致的网络传输内容过多
             if (this.lastThinkingMessage.action === thinkingAction && this.lastThinkingMessage.textposition) {
                 thinkingContent = thinkingContent.substring(this.lastThinkingMessage.textposition);
@@ -187,11 +209,17 @@ class CorzBot extends gptbase_1.default {
             this.lastThinkingMessage = thinkingEndIndex >= 0 ? { action: thinkingAction, textposition: 0 } : { action: thinkingAction, textposition: outputLength };
             return { successed: true, thinking: {
                     action: thinkingAction,
-                    text: thinkingContent //Object.values(thinkingObject)[0]
+                    text: thinkingContent,
+                    completed: thinkingEndIndex >= 0
                 }, content, status };
         }
         catch (error) {
-            console.error('解析JSON出错了:' + jsonStr);
+            // 如果在content之后发生了错误，可能该智能体输出不了卡片类型的数据，则输出的内容已经是正文了
+            if (status === DeepThinkingStatus.CardResource) {
+                status = DeepThinkingStatus.ThinkingOver;
+                return { successed: true, content, status };
+            }
+            console.error('解析JSON出错了:', jsonStr, status);
             // 当前解析出错，等待下一次解析
             return { successed: false, content, status };
         }
@@ -206,6 +234,7 @@ 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' });
@@ -225,11 +254,11 @@ class CorzBot extends gptbase_1.default {
             const params = yield this.getRequestStream(client, message, callChatOption);
             const stream = !callChatOption.workflowid ? client.chat.stream(params) : client.workflows.chat.stream(params);
             let deltaindex = 0, fullanswer = [], followup = [];
-            let deepThinking = '', thinkingStatus = DeepThinkingStatus.None; // 是否在深度思考中
+            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 _f = 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;
+                    _f = false;
                     try {
                         const part = _c;
                         if (part.event === api_1.ChatEventType.ERROR)
@@ -242,17 +271,30 @@ class CorzBot extends gptbase_1.default {
                                 deltaindex++;
                             }
                             // 如果在深度思考中，则不输出消息
-                            if (thinkingStatus !== DeepThinkingStatus.None &&
-                                thinkingStatus !== DeepThinkingStatus.ThinkingOver) {
+                            if (thinkingStatus !== DeepThinkingStatus.None
+                                && thinkingStatus !== DeepThinkingStatus.ThinkingOver) {
                                 deepThinking += content;
                                 const result = this.parseDeepThinkingJson(deepThinking, thinkingStatus);
                                 if (result.successed) {
-                                    deepThinking = result.content;
-                                    this.emit('chatthinking', result.thinking);
+                                    // 如果不是卡片资源，则发送thinking事件，并更新thinkingStatus
+                                    if (thinkingStatus !== DeepThinkingStatus.CardResource) {
+                                        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);
+                                        }
+                                    }
                                     thinkingStatus = result.status;
                                 }
                                 if (thinkingStatus != DeepThinkingStatus.ThinkingOver)
                                     continue;
+                                // thinkingStatus = DeepThinkingStatus.None;
                                 // 将排除了thinking之后的消息内容要带下去成为正式的输出内容
                                 content = deepThinking;
                             }
@@ -278,14 +320,14 @@ class CorzBot extends gptbase_1.default {
                         }
                     }
                     finally {
-                        _d = true;
+                        _f = 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 (!_f && !_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.5",
+  "version": "7.1.6",
   "description": "Doomisoft OpenAI",
   "main": "dist/index.js",
   "scripts": {

package/src/corzbot.ts

@@ -12,12 +12,24 @@ import { CozeAPI,
     ChatStatus} from '@coze/api';
 import GptBase from "./gptbase"
 import { CorzAuthorization } from './corzauthorization';
+import { parse } from 'querystring'
+
+// 定义深度思考的动作
+enum DeepThinkingAction {
+    process =  'process_msg',
+    content ='reasoning_content',
+    card = 'card_resource'
+}
+// 定义深度思考的状态
 enum DeepThinkingStatus {
     None,
     Thinking,
     ReasonOutput,
+    CardResource,
     ThinkingOver
 }
+// 智能体思考时输出的动作
+
 type TThinkingMessage = { action: string, textposition: number }
 export default class CorzBot extends GptBase {
     protected botid: string;
@@ -134,24 +146,34 @@ export default class CorzBot extends GptBase {
      */
     private parseDeepThinkingJson(content: string,status: DeepThinkingStatus) {
         const thinkingEndIndex = content.indexOf("\"}");
-        const thinkingStartIndex = status === DeepThinkingStatus.Thinking ? content.indexOf("{\"process_msg") : content.indexOf("{\"reasoning_content");
+        // 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;
+        // 如果没有找到相关的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);
-            // 判断整个思考过程是否结束
-            if (status === DeepThinkingStatus.ReasonOutput && thinkingEndIndex >= 0) status = DeepThinkingStatus.ThinkingOver;
+            // 如果正常输出了卡片资源，并且json结束 card_resource 只有一个，所以一旦结束，则整个思考过程完毕
+            if (status === DeepThinkingStatus.CardResource && thinkingEndIndex >= 0)  status = DeepThinkingStatus.ThinkingOver;
+            // 判断整个思考过程是否到达等待卡片资源(有可能智能体输出不了卡片资源) reasoning_content 只有一个，所以一旦结束，则进入下一个阶段 card_resource
+            if (status === DeepThinkingStatus.ReasonOutput && thinkingEndIndex >= 0) status = DeepThinkingStatus.CardResource;
             // 判断当前是否从前期思考切换到思考内容输出
-            if (status === DeepThinkingStatus.Thinking && content.indexOf("{\"reasoning_content") >= 0) status=DeepThinkingStatus.ReasonOutput;
+            if (status === DeepThinkingStatus.Thinking && thinkingAction === DeepThinkingAction.content) status = DeepThinkingStatus.ReasonOutput;
+            //if (status === DeepThinkingStatus.Thinking && content.indexOf("{\"reasoning_content") >= 0) status=DeepThinkingStatus.ReasonOutput;
             //const removeOutputContent = content.replace(originalContent!.substring(1, originalContent!.length - 2),"")
-            let thinkingContent = originalContent?.substring(0, originalContent.length - 2)//.replace(lastContent, '');
+            let thinkingContent = originalContent?.substring(0, originalContent.length - 2)
             const outputLength = thinkingContent?.length || 0;
-            const thinkingAction = Object.keys(thinkingObject)[0];
+            
             // 用lastThinkingMessage来记录上一次的思考内容，避免重复输出内容，导致的网络传输内容过多
             if (this.lastThinkingMessage.action === thinkingAction && this.lastThinkingMessage.textposition){
                 thinkingContent = thinkingContent!.substring(this.lastThinkingMessage.textposition)
@@ -160,11 +182,17 @@ export default class CorzBot extends GptBase {
 
             return { successed: true,thinking:{
                 action: thinkingAction, 
-                text: thinkingContent//Object.values(thinkingObject)[0]
+                text: thinkingContent,//Object.values(thinkingObject)[0]
+                completed: thinkingEndIndex >= 0
             }, content, status}
         }
         catch(error){
-            console.error('解析JSON出错了:' + jsonStr)
+            // 如果在content之后发生了错误，可能该智能体输出不了卡片类型的数据，则输出的内容已经是正文了
+            if (status === DeepThinkingStatus.CardResource) {
+                status = DeepThinkingStatus.ThinkingOver;
+                return {successed: true, content, status};
+            }
+            console.error('解析JSON出错了:', jsonStr, status)
             // 当前解析出错，等待下一次解析
             return { successed: false, content, status }
         }
@@ -194,7 +222,7 @@ export default class CorzBot extends GptBase {
         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; // 是否在深度思考中
+        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) {
@@ -205,17 +233,29 @@ export default class CorzBot extends GptBase {
                     deltaindex++;
                 }
                 // 如果在深度思考中，则不输出消息
-                if (thinkingStatus !== DeepThinkingStatus.None &&
-                    thinkingStatus !== DeepThinkingStatus.ThinkingOver
+                if (thinkingStatus !== DeepThinkingStatus.None 
+                    && thinkingStatus !== DeepThinkingStatus.ThinkingOver
                 ){
                     deepThinking += content;
                     const result = this.parseDeepThinkingJson(deepThinking, thinkingStatus)
-                    if (result.successed){
-                        deepThinking = result.content;
-                        this.emit('chatthinking', result.thinking);
+                    if (result.successed ){
+                        // 如果不是卡片资源，则发送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;
+                    // thinkingStatus = DeepThinkingStatus.None;
                     // 将排除了thinking之后的消息内容要带下去成为正式的输出内容
                     content = deepThinking;
                 }