@coze/realtime-api 1.0.4-beta.2 → 1.0.5

package/dist/umd/index.js

@@ -7,10 +7,17 @@
 })(self, ()=>(()=>{
         "use strict";
         var __webpack_modules__ = {
+            "../../common/temp/default/node_modules/.pnpm/ws@8.18.0/node_modules/ws/browser.js": function(module1) {
+                module1.exports = function() {
+                    throw new Error("ws does not work in the browser. Browser clients must use the native WebSocket object");
+                };
+            },
             "?666e": function() {
             /* (ignored) */ },
             "?79fd": function() {
             /* (ignored) */ },
+            "?8dee": function() {
+            /* (ignored) */ },
             "?9050": function() {
             /* (ignored) */ }
         };
@@ -247,8 +254,6 @@
                     if ((null == error ? void 0 : error.detail) && msg !== error.detail) list.push(`detail: ${error.detail}`);
                     const logId = (null == error ? void 0 : error.logid) || (null == headers ? void 0 : headers['x-tt-logid']);
                     if (logId) list.push(`logid: ${logId}`);
-                    const help_doc = null == error ? void 0 : error.help_doc;
-                    if (help_doc) list.push(`help doc: ${help_doc}`);
                     return list.join(', ');
                 }
                 if (status) return `http status code: ${status} (no body)`;
@@ -271,16 +276,15 @@
                 return new error_APIError(status, error, message, headers);
             }
             constructor(status, error, message, headers){
-                var _error_error, _error_error1;
+                var _error_detail, _error_error;
                 super(`${error_APIError.makeMessage(status, error, message, headers)}`);
                 this.status = status;
                 this.headers = headers;
-                this.logid = null == headers ? void 0 : headers['x-tt-logid'];
+                this.logid = (null == error ? void 0 : null === (_error_detail = error.detail) || void 0 === _error_detail ? void 0 : _error_detail.logid) || (null == headers ? void 0 : headers['x-tt-logid']);
                 // this.error = error;
                 this.code = null == error ? void 0 : error.code;
                 this.msg = null == error ? void 0 : error.msg;
                 this.detail = null == error ? void 0 : null === (_error_error = error.error) || void 0 === _error_error ? void 0 : _error_error.detail;
-                this.help_doc = null == error ? void 0 : null === (_error_error1 = error.error) || void 0 === _error_error1 ? void 0 : _error_error1.help_doc;
                 this.rawError = error;
             }
         }
@@ -3932,10 +3936,705 @@
                 return response.data;
             }
         }
+        class chat_Chat extends APIResource {
+            async create(botId, options) {
+                const apiUrl = `/v1/chat?bot_id=${botId}`;
+                return await this._client.makeWebsocket(apiUrl, options);
+            }
+        }
+        class transcriptions_Transcriptions extends APIResource {
+            async create(options) {
+                const apiUrl = '/v1/audio/transcriptions';
+                return await this._client.makeWebsocket(apiUrl, options);
+            }
+        }
+        class speech_Speech extends APIResource {
+            async create(options) {
+                const apiUrl = '/v1/audio/speech';
+                return await this._client.makeWebsocket(apiUrl, options);
+            }
+        }
+        class websockets_audio_Audio extends APIResource {
+            constructor(...args){
+                super(...args), this.speech = new speech_Speech(this._client), this.transcriptions = new transcriptions_Transcriptions(this._client);
+            }
+        }
+        class Websockets extends APIResource {
+            constructor(...args){
+                super(...args), this.audio = new websockets_audio_Audio(this._client), this.chat = new chat_Chat(this._client);
+            }
+        }
+        // EXTERNAL MODULE: ../../common/temp/default/node_modules/.pnpm/ws@8.18.0/node_modules/ws/browser.js
+        var ws_browser = __webpack_require__("../../common/temp/default/node_modules/.pnpm/ws@8.18.0/node_modules/ws/browser.js");
+        var browser_default = /*#__PURE__*/ __webpack_require__.n(ws_browser);
+        /*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */ /* global Reflect, Promise */ var extendStatics = function(d, b) {
+            extendStatics = Object.setPrototypeOf || ({
+                __proto__: []
+            }) instanceof Array && function(d, b) {
+                d.__proto__ = b;
+            } || function(d, b) {
+                for(var p in b)if (b.hasOwnProperty(p)) d[p] = b[p];
+            };
+            return extendStatics(d, b);
+        };
+        function __extends(d, b) {
+            extendStatics(d, b);
+            function __() {
+                this.constructor = d;
+            }
+            d.prototype = null === b ? Object.create(b) : (__.prototype = b.prototype, new __());
+        }
+        function __values(o) {
+            var m = "function" == typeof Symbol && o[Symbol.iterator], i = 0;
+            if (m) return m.call(o);
+            return {
+                next: function() {
+                    if (o && i >= o.length) o = void 0;
+                    return {
+                        value: o && o[i++],
+                        done: !o
+                    };
+                }
+            };
+        }
+        function __read(o, n) {
+            var m = "function" == typeof Symbol && o[Symbol.iterator];
+            if (!m) return o;
+            var i = m.call(o), r, ar = [], e;
+            try {
+                while((void 0 === n || n-- > 0) && !(r = i.next()).done)ar.push(r.value);
+            } catch (error) {
+                e = {
+                    error: error
+                };
+            } finally{
+                try {
+                    if (r && !r.done && (m = i["return"])) m.call(i);
+                } finally{
+                    if (e) throw e.error;
+                }
+            }
+            return ar;
+        }
+        function __spread() {
+            for(var ar = [], i = 0; i < arguments.length; i++)ar = ar.concat(__read(arguments[i]));
+            return ar;
+        }
+        var reconnecting_websocket_mjs_Event = /** @class */ function() {
+            function Event1(type, target) {
+                this.target = target;
+                this.type = type;
+            }
+            return Event1;
+        }();
+        var reconnecting_websocket_mjs_ErrorEvent = /** @class */ function(_super) {
+            __extends(ErrorEvent, _super);
+            function ErrorEvent(error, target) {
+                var _this = _super.call(this, 'error', target) || this;
+                _this.message = error.message;
+                _this.error = error;
+                return _this;
+            }
+            return ErrorEvent;
+        }(reconnecting_websocket_mjs_Event);
+        var reconnecting_websocket_mjs_CloseEvent = /** @class */ function(_super) {
+            __extends(CloseEvent, _super);
+            function CloseEvent(code, reason, target) {
+                if (void 0 === code) code = 1000;
+                if (void 0 === reason) reason = '';
+                var _this = _super.call(this, 'close', target) || this;
+                _this.wasClean = true;
+                _this.code = code;
+                _this.reason = reason;
+                return _this;
+            }
+            return CloseEvent;
+        }(reconnecting_websocket_mjs_Event);
+        /*!
+ * Reconnecting WebSocket
+ * by Pedro Ladaria <pedro.ladaria@gmail.com>
+ * https://github.com/pladaria/reconnecting-websocket
+ * License MIT
+ */ var getGlobalWebSocket = function() {
+            if ('undefined' != typeof WebSocket) // @ts-ignore
+            return WebSocket;
+        };
+        /**
+ * Returns true if given argument looks like a WebSocket class
+ */ var isWebSocket = function(w) {
+            return void 0 !== w && !!w && 2 === w.CLOSING;
+        };
+        var DEFAULT = {
+            maxReconnectionDelay: 10000,
+            minReconnectionDelay: 1000 + 4000 * Math.random(),
+            minUptime: 5000,
+            reconnectionDelayGrowFactor: 1.3,
+            connectionTimeout: 4000,
+            maxRetries: 1 / 0,
+            maxEnqueuedMessages: 1 / 0,
+            startClosed: false,
+            debug: false
+        };
+        var reconnecting_websocket_mjs_ReconnectingWebSocket = /** @class */ function() {
+            function ReconnectingWebSocket(url, protocols, options) {
+                var _this = this;
+                if (void 0 === options) options = {};
+                this._listeners = {
+                    error: [],
+                    message: [],
+                    open: [],
+                    close: []
+                };
+                this._retryCount = -1;
+                this._shouldReconnect = true;
+                this._connectLock = false;
+                this._binaryType = 'blob';
+                this._closeCalled = false;
+                this._messageQueue = [];
+                /**
+         * An event listener to be called when the WebSocket connection's readyState changes to CLOSED
+         */ this.onclose = null;
+                /**
+         * An event listener to be called when an error occurs
+         */ this.onerror = null;
+                /**
+         * An event listener to be called when a message is received from the server
+         */ this.onmessage = null;
+                /**
+         * An event listener to be called when the WebSocket connection's readyState changes to OPEN;
+         * this indicates that the connection is ready to send and receive data
+         */ this.onopen = null;
+                this._handleOpen = function(event) {
+                    _this._debug('open event');
+                    var _a = _this._options.minUptime, minUptime = void 0 === _a ? DEFAULT.minUptime : _a;
+                    clearTimeout(_this._connectTimeout);
+                    _this._uptimeTimeout = setTimeout(function() {
+                        return _this._acceptOpen();
+                    }, minUptime);
+                    _this._ws.binaryType = _this._binaryType;
+                    // send enqueued messages (messages sent before websocket open event)
+                    _this._messageQueue.forEach(function(message) {
+                        return _this._ws.send(message);
+                    });
+                    _this._messageQueue = [];
+                    if (_this.onopen) _this.onopen(event);
+                    _this._listeners.open.forEach(function(listener) {
+                        return _this._callEventListener(event, listener);
+                    });
+                };
+                this._handleMessage = function(event) {
+                    _this._debug('message event');
+                    if (_this.onmessage) _this.onmessage(event);
+                    _this._listeners.message.forEach(function(listener) {
+                        return _this._callEventListener(event, listener);
+                    });
+                };
+                this._handleError = function(event) {
+                    _this._debug('error event', event.message);
+                    _this._disconnect(void 0, 'TIMEOUT' === event.message ? 'timeout' : void 0);
+                    if (_this.onerror) _this.onerror(event);
+                    _this._debug('exec error listeners');
+                    _this._listeners.error.forEach(function(listener) {
+                        return _this._callEventListener(event, listener);
+                    });
+                    _this._connect();
+                };
+                this._handleClose = function(event) {
+                    _this._debug('close event');
+                    _this._clearTimeouts();
+                    if (_this._shouldReconnect) _this._connect();
+                    if (_this.onclose) _this.onclose(event);
+                    _this._listeners.close.forEach(function(listener) {
+                        return _this._callEventListener(event, listener);
+                    });
+                };
+                this._url = url;
+                this._protocols = protocols;
+                this._options = options;
+                if (this._options.startClosed) this._shouldReconnect = false;
+                this._connect();
+            }
+            Object.defineProperty(ReconnectingWebSocket, "CONNECTING", {
+                get: function() {
+                    return 0;
+                },
+                enumerable: true,
+                configurable: true
+            });
+            Object.defineProperty(ReconnectingWebSocket, "OPEN", {
+                get: function() {
+                    return 1;
+                },
+                enumerable: true,
+                configurable: true
+            });
+            Object.defineProperty(ReconnectingWebSocket, "CLOSING", {
+                get: function() {
+                    return 2;
+                },
+                enumerable: true,
+                configurable: true
+            });
+            Object.defineProperty(ReconnectingWebSocket, "CLOSED", {
+                get: function() {
+                    return 3;
+                },
+                enumerable: true,
+                configurable: true
+            });
+            Object.defineProperty(ReconnectingWebSocket.prototype, "CONNECTING", {
+                get: function() {
+                    return ReconnectingWebSocket.CONNECTING;
+                },
+                enumerable: true,
+                configurable: true
+            });
+            Object.defineProperty(ReconnectingWebSocket.prototype, "OPEN", {
+                get: function() {
+                    return ReconnectingWebSocket.OPEN;
+                },
+                enumerable: true,
+                configurable: true
+            });
+            Object.defineProperty(ReconnectingWebSocket.prototype, "CLOSING", {
+                get: function() {
+                    return ReconnectingWebSocket.CLOSING;
+                },
+                enumerable: true,
+                configurable: true
+            });
+            Object.defineProperty(ReconnectingWebSocket.prototype, "CLOSED", {
+                get: function() {
+                    return ReconnectingWebSocket.CLOSED;
+                },
+                enumerable: true,
+                configurable: true
+            });
+            Object.defineProperty(ReconnectingWebSocket.prototype, "binaryType", {
+                get: function() {
+                    return this._ws ? this._ws.binaryType : this._binaryType;
+                },
+                set: function(value) {
+                    this._binaryType = value;
+                    if (this._ws) this._ws.binaryType = value;
+                },
+                enumerable: true,
+                configurable: true
+            });
+            Object.defineProperty(ReconnectingWebSocket.prototype, "retryCount", {
+                /**
+         * Returns the number or connection retries
+         */ get: function() {
+                    return Math.max(this._retryCount, 0);
+                },
+                enumerable: true,
+                configurable: true
+            });
+            Object.defineProperty(ReconnectingWebSocket.prototype, "bufferedAmount", {
+                /**
+         * The number of bytes of data that have been queued using calls to send() but not yet
+         * transmitted to the network. This value resets to zero once all queued data has been sent.
+         * This value does not reset to zero when the connection is closed; if you keep calling send(),
+         * this will continue to climb. Read only
+         */ get: function() {
+                    var bytes = this._messageQueue.reduce(function(acc, message) {
+                        if ('string' == typeof message) acc += message.length; // not byte size
+                        else if (message instanceof Blob) acc += message.size;
+                        else acc += message.byteLength;
+                        return acc;
+                    }, 0);
+                    return bytes + (this._ws ? this._ws.bufferedAmount : 0);
+                },
+                enumerable: true,
+                configurable: true
+            });
+            Object.defineProperty(ReconnectingWebSocket.prototype, "extensions", {
+                /**
+         * The extensions selected by the server. This is currently only the empty string or a list of
+         * extensions as negotiated by the connection
+         */ get: function() {
+                    return this._ws ? this._ws.extensions : '';
+                },
+                enumerable: true,
+                configurable: true
+            });
+            Object.defineProperty(ReconnectingWebSocket.prototype, "protocol", {
+                /**
+         * A string indicating the name of the sub-protocol the server selected;
+         * this will be one of the strings specified in the protocols parameter when creating the
+         * WebSocket object
+         */ get: function() {
+                    return this._ws ? this._ws.protocol : '';
+                },
+                enumerable: true,
+                configurable: true
+            });
+            Object.defineProperty(ReconnectingWebSocket.prototype, "readyState", {
+                /**
+         * The current state of the connection; this is one of the Ready state constants
+         */ get: function() {
+                    if (this._ws) return this._ws.readyState;
+                    return this._options.startClosed ? ReconnectingWebSocket.CLOSED : ReconnectingWebSocket.CONNECTING;
+                },
+                enumerable: true,
+                configurable: true
+            });
+            Object.defineProperty(ReconnectingWebSocket.prototype, "url", {
+                /**
+         * The URL as resolved by the constructor
+         */ get: function() {
+                    return this._ws ? this._ws.url : '';
+                },
+                enumerable: true,
+                configurable: true
+            });
+            /**
+     * Closes the WebSocket connection or connection attempt, if any. If the connection is already
+     * CLOSED, this method does nothing
+     */ ReconnectingWebSocket.prototype.close = function(code, reason) {
+                if (void 0 === code) code = 1000;
+                this._closeCalled = true;
+                this._shouldReconnect = false;
+                this._clearTimeouts();
+                if (!this._ws) {
+                    this._debug('close enqueued: no ws instance');
+                    return;
+                }
+                if (this._ws.readyState === this.CLOSED) {
+                    this._debug('close: already closed');
+                    return;
+                }
+                this._ws.close(code, reason);
+            };
+            /**
+     * Closes the WebSocket connection or connection attempt and connects again.
+     * Resets retry counter;
+     */ ReconnectingWebSocket.prototype.reconnect = function(code, reason) {
+                this._shouldReconnect = true;
+                this._closeCalled = false;
+                this._retryCount = -1;
+                if (this._ws && this._ws.readyState !== this.CLOSED) {
+                    this._disconnect(code, reason);
+                    this._connect();
+                } else this._connect();
+            };
+            /**
+     * Enqueue specified data to be transmitted to the server over the WebSocket connection
+     */ ReconnectingWebSocket.prototype.send = function(data) {
+                if (this._ws && this._ws.readyState === this.OPEN) {
+                    this._debug('send', data);
+                    this._ws.send(data);
+                } else {
+                    var _a = this._options.maxEnqueuedMessages, maxEnqueuedMessages = void 0 === _a ? DEFAULT.maxEnqueuedMessages : _a;
+                    if (this._messageQueue.length < maxEnqueuedMessages) {
+                        this._debug('enqueue', data);
+                        this._messageQueue.push(data);
+                    }
+                }
+            };
+            /**
+     * Register an event handler of a specific event type
+     */ ReconnectingWebSocket.prototype.addEventListener = function(type, listener) {
+                if (this._listeners[type]) // @ts-ignore
+                this._listeners[type].push(listener);
+            };
+            ReconnectingWebSocket.prototype.dispatchEvent = function(event) {
+                var e_1, _a;
+                var listeners = this._listeners[event.type];
+                if (listeners) try {
+                    for(var listeners_1 = __values(listeners), listeners_1_1 = listeners_1.next(); !listeners_1_1.done; listeners_1_1 = listeners_1.next()){
+                        var listener = listeners_1_1.value;
+                        this._callEventListener(event, listener);
+                    }
+                } catch (e_1_1) {
+                    e_1 = {
+                        error: e_1_1
+                    };
+                } finally{
+                    try {
+                        if (listeners_1_1 && !listeners_1_1.done && (_a = listeners_1.return)) _a.call(listeners_1);
+                    } finally{
+                        if (e_1) throw e_1.error;
+                    }
+                }
+                return true;
+            };
+            /**
+     * Removes an event listener
+     */ ReconnectingWebSocket.prototype.removeEventListener = function(type, listener) {
+                if (this._listeners[type]) // @ts-ignore
+                this._listeners[type] = this._listeners[type].filter(function(l) {
+                    return l !== listener;
+                });
+            };
+            ReconnectingWebSocket.prototype._debug = function() {
+                var args = [];
+                for(var _i = 0; _i < arguments.length; _i++)args[_i] = arguments[_i];
+                if (this._options.debug) // not using spread because compiled version uses Symbols
+                // tslint:disable-next-line
+                console.log.apply(console, __spread([
+                    'RWS>'
+                ], args));
+            };
+            ReconnectingWebSocket.prototype._getNextDelay = function() {
+                var _a = this._options, _b = _a.reconnectionDelayGrowFactor, reconnectionDelayGrowFactor = void 0 === _b ? DEFAULT.reconnectionDelayGrowFactor : _b, _c = _a.minReconnectionDelay, minReconnectionDelay = void 0 === _c ? DEFAULT.minReconnectionDelay : _c, _d = _a.maxReconnectionDelay, maxReconnectionDelay = void 0 === _d ? DEFAULT.maxReconnectionDelay : _d;
+                var delay = 0;
+                if (this._retryCount > 0) {
+                    delay = minReconnectionDelay * Math.pow(reconnectionDelayGrowFactor, this._retryCount - 1);
+                    if (delay > maxReconnectionDelay) delay = maxReconnectionDelay;
+                }
+                this._debug('next delay', delay);
+                return delay;
+            };
+            ReconnectingWebSocket.prototype._wait = function() {
+                var _this = this;
+                return new Promise(function(resolve) {
+                    setTimeout(resolve, _this._getNextDelay());
+                });
+            };
+            ReconnectingWebSocket.prototype._getNextUrl = function(urlProvider) {
+                if ('string' == typeof urlProvider) return Promise.resolve(urlProvider);
+                if ('function' == typeof urlProvider) {
+                    var url = urlProvider();
+                    if ('string' == typeof url) return Promise.resolve(url);
+                    if (!!url.then) return url;
+                }
+                throw Error('Invalid URL');
+            };
+            ReconnectingWebSocket.prototype._connect = function() {
+                var _this = this;
+                if (this._connectLock || !this._shouldReconnect) return;
+                this._connectLock = true;
+                var _a = this._options, _b = _a.maxRetries, maxRetries = void 0 === _b ? DEFAULT.maxRetries : _b, _c = _a.connectionTimeout, connectionTimeout = void 0 === _c ? DEFAULT.connectionTimeout : _c, _d = _a.WebSocket, WebSocket1 = void 0 === _d ? getGlobalWebSocket() : _d;
+                if (this._retryCount >= maxRetries) {
+                    this._debug('max retries reached', this._retryCount, '>=', maxRetries);
+                    return;
+                }
+                this._retryCount++;
+                this._debug('connect', this._retryCount);
+                this._removeListeners();
+                if (!isWebSocket(WebSocket1)) throw Error('No valid WebSocket class provided');
+                this._wait().then(function() {
+                    return _this._getNextUrl(_this._url);
+                }).then(function(url) {
+                    // close could be called before creating the ws
+                    if (_this._closeCalled) return;
+                    _this._debug('connect', {
+                        url: url,
+                        protocols: _this._protocols
+                    });
+                    _this._ws = _this._protocols ? new WebSocket1(url, _this._protocols) : new WebSocket1(url);
+                    _this._ws.binaryType = _this._binaryType;
+                    _this._connectLock = false;
+                    _this._addListeners();
+                    _this._connectTimeout = setTimeout(function() {
+                        return _this._handleTimeout();
+                    }, connectionTimeout);
+                });
+            };
+            ReconnectingWebSocket.prototype._handleTimeout = function() {
+                this._debug('timeout event');
+                this._handleError(new reconnecting_websocket_mjs_ErrorEvent(Error('TIMEOUT'), this));
+            };
+            ReconnectingWebSocket.prototype._disconnect = function(code, reason) {
+                if (void 0 === code) code = 1000;
+                this._clearTimeouts();
+                if (!this._ws) return;
+                this._removeListeners();
+                try {
+                    this._ws.close(code, reason);
+                    this._handleClose(new reconnecting_websocket_mjs_CloseEvent(code, reason, this));
+                } catch (error) {
+                // ignore
+                }
+            };
+            ReconnectingWebSocket.prototype._acceptOpen = function() {
+                this._debug('accept open');
+                this._retryCount = 0;
+            };
+            ReconnectingWebSocket.prototype._callEventListener = function(event, listener) {
+                if ('handleEvent' in listener) // @ts-ignore
+                listener.handleEvent(event);
+                else // @ts-ignore
+                listener(event);
+            };
+            ReconnectingWebSocket.prototype._removeListeners = function() {
+                if (!this._ws) return;
+                this._debug('removeListeners');
+                this._ws.removeEventListener('open', this._handleOpen);
+                this._ws.removeEventListener('close', this._handleClose);
+                this._ws.removeEventListener('message', this._handleMessage);
+                // @ts-ignore
+                this._ws.removeEventListener('error', this._handleError);
+            };
+            ReconnectingWebSocket.prototype._addListeners = function() {
+                if (!this._ws) return;
+                this._debug('addListeners');
+                this._ws.addEventListener('open', this._handleOpen);
+                this._ws.addEventListener('close', this._handleClose);
+                this._ws.addEventListener('message', this._handleMessage);
+                // @ts-ignore
+                this._ws.addEventListener('error', this._handleError);
+            };
+            ReconnectingWebSocket.prototype._clearTimeouts = function() {
+                clearTimeout(this._connectTimeout);
+                clearTimeout(this._uptimeTimeout);
+            };
+            return ReconnectingWebSocket;
+        }();
+        /* ESM default export */ const reconnecting_websocket_mjs = reconnecting_websocket_mjs_ReconnectingWebSocket;
+        // Common types (not exported)
+        // Keep all existing exports but use the base types where applicable
+        var types_WebsocketsEventType = /*#__PURE__*/ function(WebsocketsEventType) {
+            // Common
+            /** SDK error */ WebsocketsEventType["CLIENT_ERROR"] = "client_error";
+            /** Connection closed */ WebsocketsEventType["CLOSED"] = "closed";
+            // Error
+            /** Received error event */ WebsocketsEventType["ERROR"] = "error";
+            // v1/audio/speech
+            /** Send text to server */ WebsocketsEventType["INPUT_TEXT_BUFFER_APPEND"] = "input_text_buffer.append";
+            /** No text to send, after audio all received, can close connection */ WebsocketsEventType["INPUT_TEXT_BUFFER_COMPLETE"] = "input_text_buffer.complete";
+            /** Send speech config to server */ WebsocketsEventType["SPEECH_UPDATE"] = "speech.update";
+            /** Received `speech.updated` event */ WebsocketsEventType["SPEECH_UPDATED"] = "speech.updated";
+            /** After speech created */ WebsocketsEventType["SPEECH_CREATED"] = "speech.created";
+            /** Received `input_text_buffer.complete` event */ WebsocketsEventType["INPUT_TEXT_BUFFER_COMPLETED"] = "input_text_buffer.completed";
+            /** Received `speech.update` event */ WebsocketsEventType["SPEECH_AUDIO_UPDATE"] = "speech.audio.update";
+            /** All audio received, can close connection */ WebsocketsEventType["SPEECH_AUDIO_COMPLETED"] = "speech.audio.completed";
+            // v1/audio/transcriptions
+            /** Send audio to server */ WebsocketsEventType["INPUT_AUDIO_BUFFER_APPEND"] = "input_audio_buffer.append";
+            /** No audio to send, after text all received, can close connection */ WebsocketsEventType["INPUT_AUDIO_BUFFER_COMPLETE"] = "input_audio_buffer.complete";
+            /** Send transcriptions config to server */ WebsocketsEventType["TRANSCRIPTIONS_UPDATE"] = "transcriptions.update";
+            /** Send `input_audio_buffer.clear` event */ WebsocketsEventType["INPUT_AUDIO_BUFFER_CLEAR"] = "input_audio_buffer.clear";
+            /** After transcriptions created */ WebsocketsEventType["TRANSCRIPTIONS_CREATED"] = "transcriptions.created";
+            /** Received `input_audio_buffer.complete` event */ WebsocketsEventType["INPUT_AUDIO_BUFFER_COMPLETED"] = "input_audio_buffer.completed";
+            /** Received `transcriptions.update` event */ WebsocketsEventType["TRANSCRIPTIONS_MESSAGE_UPDATE"] = "transcriptions.message.update";
+            /** All audio received, can close connection */ WebsocketsEventType["TRANSCRIPTIONS_MESSAGE_COMPLETED"] = "transcriptions.message.completed";
+            /** Received `input_audio_buffer.cleared` event */ WebsocketsEventType["INPUT_AUDIO_BUFFER_CLEARED"] = "input_audio_buffer.cleared";
+            /** Received `transcriptions.updated` event */ WebsocketsEventType["TRANSCRIPTIONS_UPDATED"] = "transcriptions.updated";
+            // v1/chat
+            /** Send chat config to server */ WebsocketsEventType["CHAT_UPDATE"] = "chat.update";
+            /** Send tool outputs to server */ WebsocketsEventType["CONVERSATION_CHAT_SUBMIT_TOOL_OUTPUTS"] = "conversation.chat.submit_tool_outputs";
+            /** After chat created */ WebsocketsEventType["CHAT_CREATED"] = "chat.created";
+            /** After chat updated */ WebsocketsEventType["CHAT_UPDATED"] = "chat.updated";
+            /** Audio AST completed, chat started */ WebsocketsEventType["CONVERSATION_CHAT_CREATED"] = "conversation.chat.created";
+            /** Message created */ WebsocketsEventType["CONVERSATION_MESSAGE_CREATE"] = "conversation.message.create";
+            /** Clear conversation */ WebsocketsEventType["CONVERSATION_CLEAR"] = "conversation.clear";
+            /** Chat in progress */ WebsocketsEventType["CONVERSATION_CHAT_IN_PROGRESS"] = "conversation.chat.in_progress";
+            /** Get agent text message update */ WebsocketsEventType["CONVERSATION_MESSAGE_DELTA"] = "conversation.message.delta";
+            /** Need plugin submit */ WebsocketsEventType["CONVERSATION_CHAT_REQUIRES_ACTION"] = "conversation.chat.requires_action";
+            /** Message completed */ WebsocketsEventType["CONVERSATION_MESSAGE_COMPLETED"] = "conversation.message.completed";
+            /** Get agent audio message update */ WebsocketsEventType["CONVERSATION_AUDIO_DELTA"] = "conversation.audio.delta";
+            /** Audio message completed */ WebsocketsEventType["CONVERSATION_AUDIO_COMPLETED"] = "conversation.audio.completed";
+            /** All message received, can close connection */ WebsocketsEventType["CONVERSATION_CHAT_COMPLETED"] = "conversation.chat.completed";
+            /** Chat failed */ WebsocketsEventType["CONVERSATION_CHAT_FAILED"] = "conversation.chat.failed";
+            /** Received `conversation.cleared` event */ WebsocketsEventType["CONVERSATION_CLEARED"] = "conversation.cleared";
+            return WebsocketsEventType;
+        }({});
+        class WebSocketAPI {
+            // Standard WebSocket properties
+            get readyState() {
+                return this.rws.readyState;
+            }
+            // Standard WebSocket methods
+            send(data) {
+                return this.rws.send(JSON.stringify(data));
+            }
+            close(code, reason) {
+                return this.rws.close(code, reason);
+            }
+            reconnect(code, reason) {
+                return this.rws.reconnect(code, reason);
+            }
+            // Event listener methods
+            addEventListener(type, listener) {
+                this.rws.addEventListener(type, listener);
+            }
+            removeEventListener(type, listener) {
+                this.rws.removeEventListener(type, listener);
+            }
+            constructor(url, options = {}){
+                // Event handler methods
+                this.onmessage = null;
+                this.onopen = null;
+                this.onclose = null;
+                this.onerror = null;
+                const separator = url.includes('?') ? '&' : '?';
+                const { authorization } = options.headers || {};
+                this.rws = new reconnecting_websocket_mjs(`${url}${separator}authorization=${authorization}`, [], {
+                    WebSocket: utils_isBrowser() ? window.WebSocket : class extends browser_default() {
+                        constructor(url2, protocols){
+                            super(url2, protocols, {
+                                headers: options.headers
+                            });
+                        }
+                    },
+                    ...options
+                });
+                this.rws.addEventListener('message', (event)=>{
+                    try {
+                        var _this_onmessage, _this;
+                        const data = JSON.parse(event.data);
+                        null === (_this_onmessage = (_this = this).onmessage) || void 0 === _this_onmessage || _this_onmessage.call(_this, data, event);
+                    } catch (error) {
+                        console.error('WebSocketAPI onmessage error', error);
+                    }
+                });
+                this.rws.addEventListener('open', (event)=>{
+                    var _this_onopen, _this;
+                    null === (_this_onopen = (_this = this).onopen) || void 0 === _this_onopen || _this_onopen.call(_this, event);
+                });
+                this.rws.addEventListener('close', (event)=>{
+                    var _this_onclose, _this;
+                    null === (_this_onclose = (_this = this).onclose) || void 0 === _this_onclose || _this_onclose.call(_this, event);
+                });
+                this.rws.addEventListener('error', (event)=>{
+                    var _event_target__req_res, _event_target__req, _event_target, _event_target__req_res1, _event_target__req1, _event_target1, _this_onerror, _this;
+                    const statusCode = null === (_event_target = event.target) || void 0 === _event_target ? void 0 : null === (_event_target__req = _event_target._req) || void 0 === _event_target__req ? void 0 : null === (_event_target__req_res = _event_target__req.res) || void 0 === _event_target__req_res ? void 0 : _event_target__req_res.statusCode;
+                    const rawHeaders = (null === (_event_target1 = event.target) || void 0 === _event_target1 ? void 0 : null === (_event_target__req1 = _event_target1._req) || void 0 === _event_target__req1 ? void 0 : null === (_event_target__req_res1 = _event_target__req1.res) || void 0 === _event_target__req_res1 ? void 0 : _event_target__req_res1.rawHeaders) || [];
+                    const logidIndex = rawHeaders.findIndex((header)=>'X-Tt-Logid' === header);
+                    const logid = -1 !== logidIndex ? rawHeaders[logidIndex + 1] : void 0;
+                    const error = {
+                        id: '0',
+                        event_type: types_WebsocketsEventType.ERROR,
+                        data: {
+                            code: -1,
+                            msg: 'WebSocket error'
+                        },
+                        detail: {
+                            logid
+                        }
+                    };
+                    if (401 === statusCode) {
+                        error.data.code = 401;
+                        error.data.msg = 'Unauthorized';
+                    } else if (403 === statusCode) {
+                        error.data.code = 403;
+                        error.data.msg = 'Forbidden';
+                    } else {
+                        error.data.code = 500;
+                        error.data.msg = String(null == event ? void 0 : event.error) || 'WebSocket error';
+                    }
+                    null === (_this_onerror = (_this = this).onerror) || void 0 === _this_onerror || _this_onerror.call(_this, error, event);
+                });
+            }
+        }
         // EXTERNAL MODULE: os (ignored)
         var os_ignored_ = __webpack_require__("?9050");
         var os_ignored_default = /*#__PURE__*/ __webpack_require__.n(os_ignored_);
-        var package_namespaceObject = JSON.parse('{"name":"@coze/api","version":"1.0.16","description":"Official Coze Node.js SDK for seamless AI integration into your applications | 扣子官方 Node.js SDK，助您轻松集成 AI 能力到应用中","keywords":["coze","ai","nodejs","sdk","chatbot","typescript"],"homepage":"https://github.com/coze-dev/coze-js/tree/main/packages/coze-js","bugs":{"url":"https://github.com/coze-dev/coze-js/issues"},"repository":{"type":"git","url":"https://github.com/coze-dev/coze-js.git","directory":"packages/coze-js"},"license":"MIT","author":"Leeight <leeight@gmail.com>","type":"module","exports":{".":"./src/index.ts"},"main":"src/index.ts","module":"src/index.ts","browser":{"crypto":false,"os":false,"jsonwebtoken":false},"types":"src/index.ts","files":["dist","LICENSE","README.md","README.zh-CN.md"],"scripts":{"build":"rm -rf dist && rslib build","format":"prettier --write .","lint":"eslint ./ --cache --quiet","start":"rm -rf dist && rslib build -w","test":"vitest","test:cov":"vitest --coverage --run"},"dependencies":{"jsonwebtoken":"^9.0.2"},"devDependencies":{"@coze-infra/eslint-config":"workspace:*","@coze-infra/ts-config":"workspace:*","@coze-infra/vitest-config":"workspace:*","@rslib/core":"0.0.18","@swc/core":"^1.3.14","@types/jsonwebtoken":"^9.0.0","@types/node":"^20","@types/uuid":"^9.0.1","@types/whatwg-fetch":"^0.0.33","@vitest/coverage-v8":"~2.1.4","axios":"^1.7.7","typescript":"^5.5.3","vitest":"~2.1.4"},"peerDependencies":{"axios":"^1.7.1"},"cozePublishConfig":{"exports":{".":{"require":"./dist/cjs/index.cjs","import":"./dist/esm/index.js","types":"./dist/types/index.d.ts"}},"main":"dist/cjs/index.cjs","module":"dist/esm/index.js","types":"dist/types/index.d.ts"}}'); // CONCATENATED MODULE: ../coze-js/src/version.ts
+        var package_namespaceObject = JSON.parse('{"name":"@coze/api","version":"1.0.20","description":"Official Coze Node.js SDK for seamless AI integration into your applications | 扣子官方 Node.js SDK，助您轻松集成 AI 能力到应用中","keywords":["coze","ai","nodejs","sdk","chatbot","typescript"],"homepage":"https://github.com/coze-dev/coze-js/tree/main/packages/coze-js","bugs":{"url":"https://github.com/coze-dev/coze-js/issues"},"repository":{"type":"git","url":"https://github.com/coze-dev/coze-js.git","directory":"packages/coze-js"},"license":"MIT","author":"Leeight <leeight@gmail.com>","type":"module","exports":{".":"./src/index.ts"},"main":"src/index.ts","module":"src/index.ts","browser":{"crypto":false,"os":false,"jsonwebtoken":false,"node-fetch":false},"types":"src/index.ts","files":["dist","LICENSE","README.md","README.zh-CN.md"],"scripts":{"build":"rslib build","format":"prettier --write .","lint":"eslint ./ --cache --quiet","start":"rslib build -w","test":"vitest","test:cov":"vitest --coverage --run"},"dependencies":{"jsonwebtoken":"^9.0.2","node-fetch":"^2.x","reconnecting-websocket":"^4.4.0","ws":"^8.11.0"},"devDependencies":{"@coze-infra/eslint-config":"workspace:*","@coze-infra/ts-config":"workspace:*","@coze-infra/vitest-config":"workspace:*","@rslib/core":"0.0.18","@swc/core":"^1.3.14","@types/jsonwebtoken":"^9.0.0","@types/node":"^20","@types/node-fetch":"^2.x","@types/uuid":"^9.0.1","@types/whatwg-fetch":"^0.0.33","@types/ws":"^8.5.1","@vitest/coverage-v8":"~2.1.4","axios":"^1.7.7","typescript":"^5.5.3","vitest":"~2.1.4"},"peerDependencies":{"axios":"^1.7.1"},"cozePublishConfig":{"exports":{".":{"require":"./dist/cjs/index.cjs","import":"./dist/esm/index.js","types":"./dist/types/index.d.ts"}},"main":"dist/cjs/index.cjs","module":"dist/esm/index.js","types":"dist/types/index.d.ts"}}'); // CONCATENATED MODULE: ../coze-js/src/version.ts
         const { version: version_version } = package_namespaceObject;
         const getEnv = ()=>{
             const nodeVersion = process.version.slice(1); // Remove 'v' prefix
@@ -4034,6 +4733,9 @@
             };
             return JSON.stringify(ua);
         };
+        // EXTERNAL MODULE: node-fetch (ignored)
+        var node_fetch_ignored_ = __webpack_require__("?8dee");
+        var node_fetch_ignored_default = /*#__PURE__*/ __webpack_require__.n(node_fetch_ignored_);
         /* eslint-disable @typescript-eslint/no-explicit-any */ const fetcher_handleError = (error)=>{
             if (!error.isAxiosError && (!error.code || !error.message)) return new CozeError(`Unexpected error: ${error.message}`);
             if ('ECONNABORTED' === error.code && error.message.includes('timeout') || 'ETIMEDOUT' === error.code) {
@@ -4046,6 +4748,23 @@
                 return error_APIError.generate((null === (_error_response1 = error.response) || void 0 === _error_response1 ? void 0 : _error_response1.status) || 500, null === (_error_response2 = error.response) || void 0 === _error_response2 ? void 0 : _error_response2.data, error.message, null === (_error_response3 = error.response) || void 0 === _error_response3 ? void 0 : _error_response3.headers);
             }
         };
+        // node-fetch is used for streaming requests
+        const adapterFetch = async (options)=>{
+            const response = await node_fetch_ignored_default()(options.url, {
+                body: options.data,
+                ...options
+            });
+            return {
+                data: response.body,
+                ...response
+            };
+        };
+        const isSupportNativeFetch = ()=>{
+            if (utils_isBrowser()) return true;
+            // native fetch is supported in node 18.0.0 or higher
+            const version = process.version.slice(1);
+            return compareVersions(version, '18.0.0') >= 0;
+        };
         async function fetchAPI(url) {
             let options = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
             const axiosInstance = options.axiosInstance || lib_axios;
@@ -4057,7 +4776,7 @@
             const response = await axiosInstance({
                 url,
                 responseType: options.isStreaming ? 'stream' : 'json',
-                adapter: options.isStreaming ? 'fetch' : void 0,
+                adapter: options.isStreaming ? isSupportNativeFetch() ? 'fetch' : adapterFetch : void 0,
                 ...options
             }).catch((error)=>{
                 throw fetcher_handleError(error);
@@ -4123,6 +4842,9 @@
         /**
  * default coze  base URL is api.coze.com
  */ const constant_COZE_COM_BASE_URL = 'https://api.coze.com';
+        /**
+ * default base websocket URL is wss://ws.coze.com
+ */ const COZE_COM_BASE_WS_URL = 'wss://ws.coze.com';
         /* eslint-disable max-params */ class core_APIClient {
             async getToken() {
                 if ('function' == typeof this.token) return await this.token();
@@ -4147,6 +4869,26 @@
                 config.data = body;
                 return config;
             }
+            async buildWebsocketOptions(options) {
+                const token = await this.getToken();
+                const headers = {
+                    authorization: `Bearer ${token}`
+                };
+                if (utils_isBrowser()) headers['X-Coze-Client-User-Agent'] = getBrowserClientUserAgent();
+                else {
+                    headers['User-Agent'] = getUserAgent();
+                    headers['X-Coze-Client-User-Agent'] = getNodeClientUserAgent();
+                }
+                var _this__config_debug;
+                const config = mergeConfig({
+                    debug: null !== (_this__config_debug = this._config.debug) && void 0 !== _this__config_debug && _this__config_debug
+                }, this._config.websocketOptions, options, {
+                    headers
+                }, {
+                    headers: this.headers || {}
+                });
+                return config;
+            }
             async makeRequest(apiUrl, method, body, isStream, options) {
                 const fullUrl = `${this.baseURL}${apiUrl}`;
                 const fetchOptions = await this.buildOptions(method, body, options);
@@ -4194,6 +4936,14 @@
             async delete(apiUrl, isStream, options) {
                 return this.makeRequest(apiUrl, 'DELETE', void 0, isStream, options);
             }
+            async makeWebsocket(apiUrl, options) {
+                const fullUrl = `${this.baseWsURL}${apiUrl}`;
+                const websocketOptions = await this.buildWebsocketOptions(options);
+                this.debugLog(null == options ? void 0 : options.debug, `--- websocket url: ${fullUrl}`);
+                this.debugLog(null == options ? void 0 : options.debug, '--- websocket options:', websocketOptions);
+                const ws = new WebSocketAPI(fullUrl, websocketOptions);
+                return ws;
+            }
             getConfig() {
                 return this._config;
             }
@@ -4206,6 +4956,7 @@
             constructor(config){
                 this._config = config;
                 this.baseURL = config.baseURL || constant_COZE_COM_BASE_URL;
+                this.baseWsURL = config.baseWsURL || COZE_COM_BASE_WS_URL;
                 this.token = config.token;
                 this.axiosOptions = config.axiosOptions || {};
                 this.axiosInstance = config.axiosInstance;
@@ -4233,7 +4984,7 @@
             constructor(...args){
                 super(...args), this.bots = new Bots(this), this.chat = new Chat(this), this.conversations = new Conversations(this), this.files = new Files(this), /**
    * @deprecated
-   */ this.knowledge = new Knowledge(this), this.datasets = new Datasets(this), this.workflows = new Workflows(this), this.workspaces = new WorkSpaces(this), this.audio = new audio_Audio(this), this.templates = new Templates(this);
+   */ this.knowledge = new Knowledge(this), this.datasets = new Datasets(this), this.workflows = new Workflows(this), this.workspaces = new WorkSpaces(this), this.audio = new audio_Audio(this), this.templates = new Templates(this), this.websockets = new Websockets(this);
             }
         }
         /**
@@ -42388,7 +43139,8 @@
                         conversation_id: conversationId || void 0,
                         voice_id: voiceId && voiceId.length > 0 ? voiceId : void 0,
                         connector_id: this._config.connectorId,
-                        uid: this._config.userId || void 0
+                        uid: this._config.userId || void 0,
+                        workflow_id: this._config.workflowId || void 0
                     });
                 } catch (error) {
                     this.dispatch(event_handler_EventNames.ERROR, error);