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

package/dist/esm/index.js

@@ -1,9 +1,16 @@
 /*! For license information please see index.js.LICENSE.txt */
 var __webpack_modules__ = {
+    "../../common/temp/default/node_modules/.pnpm/ws@8.18.0/node_modules/ws/browser.js": function(module) {
+        module.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) */ }
 };
@@ -229,8 +236,6 @@ class error_APIError extends CozeError {
             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)`;
@@ -253,16 +258,15 @@ class error_APIError extends CozeError {
         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;
     }
 }
@@ -3914,10 +3918,705 @@ class Templates extends APIResource {
         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);
+    }
+}
+// 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 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;
+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
@@ -4016,6 +4715,9 @@ const getBrowserClientUserAgent = ()=>{
     };
     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) {
@@ -4028,6 +4730,23 @@ const getBrowserClientUserAgent = ()=>{
         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;
@@ -4039,7 +4758,7 @@ async function fetchAPI(url) {
     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);
@@ -4105,6 +4824,9 @@ function isAxiosStatic(instance) {
 /**
  * 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();
@@ -4129,6 +4851,26 @@ function isAxiosStatic(instance) {
         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);
@@ -4176,6 +4918,14 @@ function isAxiosStatic(instance) {
     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;
     }
@@ -4188,6 +4938,7 @@ function isAxiosStatic(instance) {
     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;
@@ -4215,7 +4966,7 @@ class CozeAPI extends core_APIClient {
     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);
     }
 }
 /**
@@ -42370,7 +43121,8 @@ class RealtimeClient extends RealtimeEventHandler {
                 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);