doomiaichat 7.1.8 → 7.1.10

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

@@ -54,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() {
@@ -74,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) {
@@ -83,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;
+        var _a, _b;
         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,
@@ -108,19 +132,41 @@ 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 || {}),
+                is_async: false,
+                parameters: Object.assign({ input: (_b = message[0]) === null || _b === void 0 ? void 0 : _b.content }, this.setting.customVariables || {}, callChatOption.customVariables || {}),
+                //parameters: { input: message[0]?.content }
             };
             return worflowreq;
         });
     }
     /**
-      * 非流式传输聊天请求
-      * @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)
@@ -138,31 +184,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 }] };
+                }
+            }
+            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: '聊天未完成', 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' }
+            return { successed: false, error: { message: '聊天未完成' } };
         });
     }
     /**
@@ -255,7 +299,7 @@ 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);
+            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 {
@@ -300,19 +344,6 @@ class CorzBot extends gptbase_1.default {
                                             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)

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.8",
+  "version": "7.1.10",
   "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

@@ -8,13 +8,21 @@ import {
     RoleType,
     StreamChatReq,
     EnterMessage,
-    ChatWorkflowReq,
+    // ChatWorkflowReq,
+    // CreateChatReq,
+    // ChatStatus,
+    VariableUpdateReq,
+    VariableRetrieveReq,
     CreateChatReq,
+    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 {
@@ -34,6 +42,7 @@ type CardType = { type: number, tag: string }
 type TThinkingMessage = { action: string, textposition: number }
 export default class CorzBot extends GptBase {
     protected botid: string;
+    protected workflowid: string;
     private apiKey: string;
     private lastThinkingMessage: TThinkingMessage = { action: '', textposition: 0 };
     // protected client: CozeAPI;
@@ -46,6 +55,7 @@ export default class CorzBot extends GptBase {
         super();
         ////初始化扣子客户端
         this.botid = this.setting['botid'] || this.setting['botID'];
+        this.workflowid = this.setting['workflowid'];
         this.apiKey = this.setting['apiKey'];
     }
     private async createClient(): Promise<CozeAPI> {
@@ -61,24 +71,43 @@ 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 })
+            const params = this.botid ? { bot_id: this.botid } : {};
+            const result = await czApi.conversations.create(params)
             return result.id;
         } 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 };
+    }
+    /**
+     * 获取设置的变量
+     * @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 
-         */
+     * 组装请求参数
+     * @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,
@@ -88,21 +117,40 @@ export default class CorzBot extends GptBase {
             req.custom_variables = Object.assign({}, this.setting.customVariables || {}, callChatOption.customVariables || {});
             return req as T;
         }
-        const worflowreq: ChatWorkflowReq = {
+        const worflowreq: any = {
             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 || {}),
+            is_async:false,
+            parameters: Object.assign({ input: message[0]?.content }, this.setting.customVariables || {}, callChatOption.customVariables || {}),
+            //parameters: { input: message[0]?.content }
         }
         return worflowreq as T;
     }
     /**
-      * 非流式传输聊天请求
-      * @param chatText 
-      * @param callChatOption 
-      * @param _axiosOption 
-      */
+     * 同步调用的问答请求需要获取会话详情
+     * @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需要的消息
@@ -114,34 +162,33 @@ export default class CorzBot extends GptBase {
             }
         ];
         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 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 }] };
+            }
+        }
+        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: '聊天未完成', 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' }
+        return { successed: false, error: { message: '聊天未完成' } };
+        
     }
     /**
      * 解析深度思考的JSON内容
@@ -230,7 +277,7 @@ export default class CorzBot extends GptBase {
         ////否则用智能体的对话来输出结果
         let requestid = Math.ceil(Math.random() * (new Date().getTime() * Math.random()) / 1000), index = 0;
         const params = await this.getRequestStream(client, message, callChatOption);
-        const stream = !callChatOption.workflowid ? client.chat.stream(params as StreamChatReq) : client.workflows.chat.stream(params as ChatWorkflowReq);
+        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) {
@@ -268,19 +315,6 @@ export default class CorzBot extends GptBase {
                                 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;

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