flowscale 1.2.0 → 1.3.1

package/dist/index.js

@@ -78,12 +78,9 @@ var axios_1 = __importDefault(require("axios"));
 var FlowscaleAPI = /** @class */ (function () {
     function FlowscaleAPI(config) {
         var _this = this;
-        this.ws = null;
-        this.wsConnected = false;
-        this.reconnectAttempts = 0;
-        this.reconnectTimeout = null;
         this.proxyMode = false;
         this.customHeaders = {};
+        this.fetchImpl = null;
         // Validate required configuration
         if (!config) {
             throw new Error('FlowscaleAPI configuration is required');
@@ -123,7 +120,7 @@ var FlowscaleAPI = /** @class */ (function () {
         this.baseUrl = config.baseUrl.trim();
         this.maxRetries = config.maxRetries || 3;
         this.retryDelay = config.retryDelay || 1000;
-        this.WebSocketImpl = config.WebSocketImpl || (typeof WebSocket !== 'undefined' ? WebSocket : null);
+        this.fetchImpl = config.fetchImpl || this.resolveGlobalFetch();
         this.client = axios_1.default.create({
             baseURL: this.baseUrl,
             timeout: config.timeout || 6000000, // Default 6000s timeout instead of Axios default 0 (no timeout)
@@ -239,13 +236,13 @@ var FlowscaleAPI = /** @class */ (function () {
      */
     FlowscaleAPI.prototype.executeWorkflowAsync = function (workflowId_1, data_1, groupId_1) {
         return __awaiter(this, arguments, void 0, function (workflowId, data, groupId, pollIntervalMs, timeoutMs, returnAllOutputsOrOptions) {
-            var _a, returnAllOutputs, onIntermediateResponse, startTime, executeResponse, runId, resolvedWorkflowId, run_status, output_names, runResponse, attempts, outputPromises, outputResults, successfulOutputs, pendingOutputs, hasErrors, _i, outputResults_1, result, deprecationWarning, legacyResponse, allOutputsResponse, error_1;
+            var _a, returnAllOutputs, onIntermediateResponse, startTime, executeResponse, runId, resolvedWorkflowId, run_status, output_names, runResponse, attempts, runResponse, latestOutputNames, outputPromises, outputResults, successfulOutputs, pendingOutputs, hasErrors, _i, outputResults_1, result, deprecationWarning, legacyResponse, allOutputsResponse, error_1;
             var _this = this;
-            var _b, _c, _d, _e, _f;
+            var _b, _c, _d, _e, _f, _g, _h, _j;
             if (pollIntervalMs === void 0) { pollIntervalMs = 2000; }
             if (timeoutMs === void 0) { timeoutMs = 600000; }
-            return __generator(this, function (_g) {
-                switch (_g.label) {
+            return __generator(this, function (_k) {
+                switch (_k.label) {
                     case 0:
                         // Validate inputs
                         if (!workflowId || typeof workflowId !== 'string' || workflowId.trim() === '') {
@@ -264,7 +261,7 @@ var FlowscaleAPI = /** @class */ (function () {
                         startTime = Date.now();
                         return [4 /*yield*/, this.executeWorkflow(workflowId, data, groupId)];
                     case 1:
-                        executeResponse = _g.sent();
+                        executeResponse = _k.sent();
                         if (!((_b = executeResponse === null || executeResponse === void 0 ? void 0 : executeResponse.data) === null || _b === void 0 ? void 0 : _b.run_id)) {
                             throw new Error('No run ID returned from workflow execution');
                         }
@@ -281,10 +278,10 @@ var FlowscaleAPI = /** @class */ (function () {
                                 response: executeResponse,
                             })];
                     case 2:
-                        _g.sent();
+                        _k.sent();
                         run_status = "queued";
                         output_names = [];
-                        _g.label = 3;
+                        _k.label = 3;
                     case 3:
                         if (!(output_names.length === 0)) return [3 /*break*/, 8];
                         if (Date.now() - startTime > timeoutMs) {
@@ -292,7 +289,7 @@ var FlowscaleAPI = /** @class */ (function () {
                         }
                         return [4 /*yield*/, this.getRun(runId)];
                     case 4:
-                        runResponse = _g.sent();
+                        runResponse = _k.sent();
                         run_status = ((_d = runResponse === null || runResponse === void 0 ? void 0 : runResponse.data) === null || _d === void 0 ? void 0 : _d.status) || "queued";
                         output_names = ((_e = runResponse === null || runResponse === void 0 ? void 0 : runResponse.data) === null || _e === void 0 ? void 0 : _e.output_names) || [];
                         return [4 /*yield*/, this.emitExecuteWorkflowAsyncIntermediateResponse(onIntermediateResponse, {
@@ -306,15 +303,15 @@ var FlowscaleAPI = /** @class */ (function () {
                                 response: runResponse,
                             })];
                     case 5:
-                        _g.sent();
+                        _k.sent();
                         if (run_status === 'failed' || run_status === 'cancelled') {
                             throw new Error("Run ".concat(runId, " failed with status: ").concat(run_status));
                         }
                         if (!(output_names.length === 0)) return [3 /*break*/, 7];
                         return [4 /*yield*/, this.sleep(pollIntervalMs)];
                     case 6:
-                        _g.sent();
-                        _g.label = 7;
+                        _k.sent();
+                        _k.label = 7;
                     case 7: return [3 /*break*/, 3];
                     case 8:
                         if (!output_names || output_names.length === 0) {
@@ -322,15 +319,39 @@ var FlowscaleAPI = /** @class */ (function () {
                         }
                         this.logInfo("Found ".concat(output_names.length, " outputs to wait for: ").concat(output_names.join(', ')));
                         attempts = 0;
-                        _g.label = 9;
+                        _k.label = 9;
                     case 9:
-                        if (!true) return [3 /*break*/, 21];
+                        if (!true) return [3 /*break*/, 23];
                         if (Date.now() - startTime > timeoutMs) {
                             throw new Error("Workflow execution timed out after ".concat(timeoutMs, "ms"));
                         }
-                        _g.label = 10;
+                        _k.label = 10;
                     case 10:
-                        _g.trys.push([10, 17, , 20]);
+                        _k.trys.push([10, 19, , 22]);
+                        return [4 /*yield*/, this.getRun(runId)];
+                    case 11:
+                        runResponse = _k.sent();
+                        run_status = ((_g = runResponse === null || runResponse === void 0 ? void 0 : runResponse.data) === null || _g === void 0 ? void 0 : _g.status) || run_status;
+                        latestOutputNames = ((_h = runResponse === null || runResponse === void 0 ? void 0 : runResponse.data) === null || _h === void 0 ? void 0 : _h.output_names) || [];
+                        if (latestOutputNames.length > 0) {
+                            output_names = latestOutputNames;
+                        }
+                        return [4 /*yield*/, this.emitExecuteWorkflowAsyncIntermediateResponse(onIntermediateResponse, {
+                                type: 'run_status',
+                                timestamp: new Date().toISOString(),
+                                run_id: runId,
+                                workflow_id: resolvedWorkflowId,
+                                attempt: attempts,
+                                run_status: run_status,
+                                output_names: output_names,
+                                progress: ((_j = runResponse === null || runResponse === void 0 ? void 0 : runResponse.data) === null || _j === void 0 ? void 0 : _j.progress) || undefined,
+                                response: runResponse,
+                            })];
+                    case 12:
+                        _k.sent();
+                        if (run_status === 'failed' || run_status === 'cancelled') {
+                            throw new Error("Run ".concat(runId, " failed with status: ").concat(run_status));
+                        }
                         outputPromises = output_names.map(function (outputName) { return __awaiter(_this, void 0, void 0, function () {
                             var output, error_2;
                             var _a;
@@ -375,8 +396,8 @@ var FlowscaleAPI = /** @class */ (function () {
                             });
                         }); });
                         return [4 /*yield*/, Promise.all(outputPromises)];
-                    case 11:
-                        outputResults = _g.sent();
+                    case 13:
+                        outputResults = _k.sent();
                         successfulOutputs = [];
                         pendingOutputs = [];
                         hasErrors = false;
@@ -416,9 +437,9 @@ var FlowscaleAPI = /** @class */ (function () {
                         if (hasErrors) {
                             throw new Error('One or more workflow outputs failed');
                         }
-                        if (!(pendingOutputs.length === 0)) return [3 /*break*/, 15];
+                        if (!(pendingOutputs.length === 0)) return [3 /*break*/, 17];
                         this.logInfo("All ".concat(successfulOutputs.length, " outputs completed successfully"));
-                        if (!(returnAllOutputs === false || (returnAllOutputs === undefined && successfulOutputs.length === 1))) return [3 /*break*/, 13];
+                        if (!(returnAllOutputs === false || (returnAllOutputs === undefined && successfulOutputs.length === 1))) return [3 /*break*/, 15];
                         deprecationWarning = {
                             message: successfulOutputs.length > 1
                                 ? 'Single output format is deprecated. This workflow returned multiple outputs but only the first is shown.'
@@ -446,10 +467,10 @@ var FlowscaleAPI = /** @class */ (function () {
                                 completed_outputs: successfulOutputs.map(function (output) { return output.filename; }),
                                 response: legacyResponse,
                             })];
-                    case 12:
-                        _g.sent();
+                    case 14:
+                        _k.sent();
                         return [2 /*return*/, legacyResponse];
-                    case 13:
+                    case 15:
                         allOutputsResponse = {
                             status: 'success',
                             data: successfulOutputs
@@ -463,18 +484,18 @@ var FlowscaleAPI = /** @class */ (function () {
                                 completed_outputs: successfulOutputs.map(function (output) { return output.filename; }),
                                 response: allOutputsResponse,
                             })];
-                    case 14:
-                        _g.sent();
+                    case 16:
+                        _k.sent();
                         return [2 /*return*/, allOutputsResponse];
-                    case 15:
+                    case 17:
                         // If some outputs are still pending, continue polling
                         this.logDebug("".concat(pendingOutputs.length, " outputs still pending: ").concat(pendingOutputs.join(', ')));
                         return [4 /*yield*/, this.sleep(pollIntervalMs)];
-                    case 16:
-                        _g.sent();
-                        return [3 /*break*/, 20];
-                    case 17:
-                        error_1 = _g.sent();
+                    case 18:
+                        _k.sent();
+                        return [3 /*break*/, 22];
+                    case 19:
+                        error_1 = _k.sent();
                         // Log the error but continue polling
                         this.logWarn("Error polling for outputs (attempt ".concat(attempts, "):"), error_1);
                         return [4 /*yield*/, this.emitExecuteWorkflowAsyncIntermediateResponse(onIntermediateResponse, {
@@ -486,22 +507,22 @@ var FlowscaleAPI = /** @class */ (function () {
                                 output_names: output_names,
                                 error: this.formatUnknownError(error_1),
                             })];
-                    case 18:
-                        _g.sent();
+                    case 20:
+                        _k.sent();
                         // After several failures, increase polling interval to avoid excessive requests
                         if (attempts > 5) {
                             pollIntervalMs = Math.min(pollIntervalMs * 1.5, 10000); // Increase interval, max 10s
                         }
                         // Wait before retrying
                         return [4 /*yield*/, this.sleep(pollIntervalMs)];
-                    case 19:
+                    case 21:
                         // Wait before retrying
-                        _g.sent();
-                        return [3 /*break*/, 20];
-                    case 20:
+                        _k.sent();
+                        return [3 /*break*/, 22];
+                    case 22:
                         attempts++;
                         return [3 /*break*/, 9];
-                    case 21: return [2 /*return*/];
+                    case 23: return [2 /*return*/];
                 }
             });
         });
@@ -512,7 +533,7 @@ var FlowscaleAPI = /** @class */ (function () {
      */
     FlowscaleAPI.prototype.getOutput = function (filename) {
         return __awaiter(this, void 0, void 0, function () {
-            var error_3, axiosError;
+            var response, error_3, axiosError;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -523,21 +544,35 @@ var FlowscaleAPI = /** @class */ (function () {
                         _a.label = 1;
                     case 1:
                         _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.makeRequest('get', '/api/v1/runs/output', {
+                        return [4 /*yield*/, this.client.get('/api/v1/runs/output', {
                                 params: { filename: filename },
+                                // We need to inspect HTTP status directly (204 is a valid "not ready" response).
+                                validateStatus: function () { return true; },
                             })];
-                    case 2: return [2 /*return*/, _a.sent()];
-                    case 3:
-                        error_3 = _a.sent();
-                        axiosError = error_3;
-                        if (axiosError.response && axiosError.response.status === 204) {
+                    case 2:
+                        response = _a.sent();
+                        if (response.status === 204) {
                             return [2 /*return*/, null]; // No output found
                         }
-                        else if (axiosError.response && axiosError.response.status === 504) {
+                        else if (response.status === 504) {
                             this.logWarn('Received 504 Gateway Timeout, retrying...');
                             // For 504 errors specifically, we'll return null to allow the polling to continue
                             return [2 /*return*/, null];
                         }
+                        else if (response.status === 408) {
+                            throw new Error('Run Timeout');
+                        }
+                        if (response.status < 200 || response.status >= 300) {
+                            throw new Error("Error: ".concat(response.status, " ").concat(response.statusText, " - ").concat(JSON.stringify(response.data)));
+                        }
+                        return [2 /*return*/, this.normalizeGetOutputResponse(response.data)];
+                    case 3:
+                        error_3 = _a.sent();
+                        axiosError = error_3;
+                        if (axiosError.response && axiosError.response.status === 504) {
+                            this.logWarn('Received 504 Gateway Timeout, retrying...');
+                            return [2 /*return*/, null];
+                        }
                         else if (axiosError.response && axiosError.response.status === 408) {
                             throw new Error('Run Timeout');
                         }
@@ -594,6 +629,39 @@ var FlowscaleAPI = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Subscribes to run events from the SSE endpoint.
+     * @param runId - The run ID to stream events for.
+     * @param options - SSE subscription options and callbacks.
+     * @returns Connection handle with `close()` and `done` promise.
+     */
+    FlowscaleAPI.prototype.subscribeRunEvents = function (runId, options) {
+        if (options === void 0) { options = {}; }
+        if (!runId || typeof runId !== 'string' || runId.trim() === '') {
+            throw new Error('Run ID is required and must be a non-empty string');
+        }
+        if (options.fromSeq !== undefined && options.fromSeq < 0) {
+            throw new Error('fromSeq must be greater than or equal to 0');
+        }
+        if (!this.fetchImpl) {
+            throw new Error('SSE streaming requires a fetch implementation. ' +
+                'In Node.js < 18, pass `fetchImpl` in FlowscaleAPI config.');
+        }
+        var abortController = new AbortController();
+        if (options.signal) {
+            if (options.signal.aborted) {
+                abortController.abort();
+            }
+            else {
+                options.signal.addEventListener('abort', function () { return abortController.abort(); }, { once: true });
+            }
+        }
+        var done = this.consumeRunEventsStream(runId, options, abortController.signal);
+        return {
+            close: function () { return abortController.abort(); },
+            done: done,
+        };
+    };
     FlowscaleAPI.prototype.resolveExecuteWorkflowAsyncOptions = function (returnAllOutputsOrOptions) {
         if (returnAllOutputsOrOptions == null ||
             typeof returnAllOutputsOrOptions === 'boolean') {
@@ -655,6 +723,400 @@ var FlowscaleAPI = /** @class */ (function () {
             });
         });
     };
+    FlowscaleAPI.prototype.normalizeGetOutputResponse = function (payload) {
+        if (!payload || typeof payload !== 'object') {
+            return null;
+        }
+        if (typeof payload.status === 'string') {
+            return payload;
+        }
+        // Handle payloads that omit top-level status but still contain useful output data.
+        if (payload.data && typeof payload.data === 'object') {
+            if (payload.data.errors) {
+                return {
+                    status: 'error',
+                    data: {
+                        errors: payload.data.errors,
+                    },
+                };
+            }
+            if (payload.data.progress) {
+                return {
+                    status: 'in_progress',
+                    data: payload.data,
+                };
+            }
+            if (payload.data.download_url ||
+                payload.data.file_content ||
+                payload.data.generation_status) {
+                return {
+                    status: 'success',
+                    data: payload.data,
+                };
+            }
+        }
+        // Legacy shape fallback: response data returned directly without wrapping.
+        if (payload.download_url || payload.file_content || payload.generation_status) {
+            return {
+                status: 'success',
+                data: payload,
+            };
+        }
+        if (payload.errors) {
+            return {
+                status: 'error',
+                data: {
+                    errors: payload.errors,
+                },
+            };
+        }
+        return null;
+    };
+    FlowscaleAPI.prototype.resolveGlobalFetch = function () {
+        var globalScope = typeof globalThis !== 'undefined'
+            ? globalThis
+            : (typeof window !== 'undefined' ? window : undefined);
+        if (globalScope && typeof globalScope.fetch === 'function') {
+            return globalScope.fetch.bind(globalScope);
+        }
+        return null;
+    };
+    FlowscaleAPI.prototype.consumeRunEventsStream = function (runId, options, signal) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, headers_1, response, contentType, errorText, error_5, normalizedError;
+            var _this = this;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _c.trys.push([0, 8, 10, 12]);
+                        url = new URL("/api/v1/runs/".concat(encodeURIComponent(runId), "/events"), this.baseUrl);
+                        if (options.fromSeq !== undefined) {
+                            url.searchParams.set('from_seq', String(options.fromSeq));
+                        }
+                        headers_1 = {
+                            Accept: 'text/event-stream',
+                        };
+                        if (!this.proxyMode && this.apiKey) {
+                            headers_1['X-API-KEY'] = this.apiKey;
+                        }
+                        Object.keys(this.customHeaders).forEach(function (key) {
+                            headers_1[key] = _this.customHeaders[key];
+                        });
+                        return [4 /*yield*/, this.fetchImpl(url.toString(), {
+                                method: 'GET',
+                                headers: headers_1,
+                                signal: signal,
+                            })];
+                    case 1:
+                        response = _c.sent();
+                        contentType = ((_b = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get) === null || _b === void 0 ? void 0 : _b.call(_a, 'content-type')) || null;
+                        return [4 /*yield*/, this.invokeRunEventsCallback(options.onOpen, {
+                                status: response.status,
+                                contentType: contentType,
+                            })];
+                    case 2:
+                        _c.sent();
+                        if (!!response.ok) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.safeReadResponseText(response)];
+                    case 3:
+                        errorText = _c.sent();
+                        throw new Error("Failed to stream run events: ".concat(response.status, " ").concat(response.statusText) +
+                            (errorText ? " - ".concat(errorText) : ''));
+                    case 4:
+                        if (!(contentType && contentType.includes('application/json'))) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.consumeRunEventsSnapshotResponse(response, options)];
+                    case 5:
+                        _c.sent();
+                        return [2 /*return*/];
+                    case 6:
+                        if (!response.body || typeof response.body.getReader !== 'function') {
+                            throw new Error('SSE response body is not readable in this environment');
+                        }
+                        return [4 /*yield*/, this.consumeSSEReadableStream(response.body.getReader(), options, signal)];
+                    case 7:
+                        _c.sent();
+                        return [3 /*break*/, 12];
+                    case 8:
+                        error_5 = _c.sent();
+                        if (signal.aborted) {
+                            return [2 /*return*/];
+                        }
+                        normalizedError = error_5 instanceof Error ? error_5 : new Error(this.formatUnknownError(error_5));
+                        return [4 /*yield*/, this.invokeRunEventsCallback(options.onError, normalizedError)];
+                    case 9:
+                        _c.sent();
+                        if (!options.onError) {
+                            throw normalizedError;
+                        }
+                        return [3 /*break*/, 12];
+                    case 10: return [4 /*yield*/, this.invokeRunEventsCallback(options.onClose)];
+                    case 11:
+                        _c.sent();
+                        return [7 /*endfinally*/];
+                    case 12: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FlowscaleAPI.prototype.safeReadResponseText = function (response) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, response.text()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        _1 = _a.sent();
+                        return [2 /*return*/, ''];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FlowscaleAPI.prototype.consumeRunEventsSnapshotResponse = function (response, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var snapshot, _2, events, _i, events_1, event_1, payload;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        snapshot = null;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, response.json()];
+                    case 2:
+                        snapshot = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        _2 = _a.sent();
+                        return [2 /*return*/];
+                    case 4:
+                        events = snapshot === null || snapshot === void 0 ? void 0 : snapshot.events;
+                        if (!Array.isArray(events)) {
+                            return [2 /*return*/];
+                        }
+                        _i = 0, events_1 = events;
+                        _a.label = 5;
+                    case 5:
+                        if (!(_i < events_1.length)) return [3 /*break*/, 8];
+                        event_1 = events_1[_i];
+                        payload = event_1 === null || event_1 === void 0 ? void 0 : event_1.payload;
+                        return [4 /*yield*/, this.invokeRunEventsCallback(options.onEvent, {
+                                id: event_1 === null || event_1 === void 0 ? void 0 : event_1.sequence,
+                                data: payload,
+                                raw: JSON.stringify(payload !== null && payload !== void 0 ? payload : null),
+                            })];
+                    case 6:
+                        _a.sent();
+                        _a.label = 7;
+                    case 7:
+                        _i++;
+                        return [3 /*break*/, 5];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FlowscaleAPI.prototype.consumeSSEReadableStream = function (reader, options, signal) {
+        return __awaiter(this, void 0, void 0, function () {
+            var decoder, buffer, eventId, eventType, dataLines, emitEvent, processLine, processBuffer, _a, done, value;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        decoder = new TextDecoder();
+                        buffer = '';
+                        dataLines = [];
+                        emitEvent = function () { return __awaiter(_this, void 0, void 0, function () {
+                            var raw, parsedData, id, eventPayload;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (dataLines.length === 0) {
+                                            eventId = undefined;
+                                            eventType = undefined;
+                                            return [2 /*return*/];
+                                        }
+                                        raw = dataLines.join('\n');
+                                        parsedData = raw;
+                                        try {
+                                            parsedData = JSON.parse(raw);
+                                        }
+                                        catch (_) {
+                                            // Keep raw text when payload is not JSON.
+                                        }
+                                        id = this.parseSSEEventId(eventId);
+                                        eventPayload = {
+                                            id: id,
+                                            event: eventType,
+                                            data: parsedData,
+                                            raw: raw,
+                                        };
+                                        return [4 /*yield*/, this.invokeRunEventsCallback(options.onEvent, eventPayload)];
+                                    case 1:
+                                        _a.sent();
+                                        eventId = undefined;
+                                        eventType = undefined;
+                                        dataLines = [];
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        processLine = function (line) { return __awaiter(_this, void 0, void 0, function () {
+                            var separatorIndex, field, value;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!(line === '')) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, emitEvent()];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                    case 2:
+                                        if (line.startsWith(':')) {
+                                            return [2 /*return*/];
+                                        }
+                                        separatorIndex = line.indexOf(':');
+                                        field = line;
+                                        value = '';
+                                        if (separatorIndex >= 0) {
+                                            field = line.slice(0, separatorIndex);
+                                            value = line.slice(separatorIndex + 1);
+                                            if (value.startsWith(' ')) {
+                                                value = value.slice(1);
+                                            }
+                                        }
+                                        switch (field) {
+                                            case 'id':
+                                                eventId = value;
+                                                break;
+                                            case 'event':
+                                                eventType = value;
+                                                break;
+                                            case 'data':
+                                                dataLines.push(value);
+                                                break;
+                                            default:
+                                                break;
+                                        }
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        processBuffer = function () {
+                            var args_1 = [];
+                            for (var _i = 0; _i < arguments.length; _i++) {
+                                args_1[_i] = arguments[_i];
+                            }
+                            return __awaiter(_this, __spreadArray([], args_1, true), void 0, function (flushFinalLine) {
+                                var newlineIndex, line, line;
+                                if (flushFinalLine === void 0) { flushFinalLine = false; }
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            if (!true) return [3 /*break*/, 2];
+                                            newlineIndex = buffer.indexOf('\n');
+                                            if (newlineIndex < 0) {
+                                                return [3 /*break*/, 2];
+                                            }
+                                            line = buffer.slice(0, newlineIndex);
+                                            buffer = buffer.slice(newlineIndex + 1);
+                                            if (line.endsWith('\r')) {
+                                                line = line.slice(0, -1);
+                                            }
+                                            return [4 /*yield*/, processLine(line)];
+                                        case 1:
+                                            _a.sent();
+                                            return [3 /*break*/, 0];
+                                        case 2:
+                                            if (!(flushFinalLine && buffer.length > 0)) return [3 /*break*/, 4];
+                                            line = buffer;
+                                            buffer = '';
+                                            if (line.endsWith('\r')) {
+                                                line = line.slice(0, -1);
+                                            }
+                                            return [4 /*yield*/, processLine(line)];
+                                        case 3:
+                                            _a.sent();
+                                            _a.label = 4;
+                                        case 4: return [2 /*return*/];
+                                    }
+                                });
+                            });
+                        };
+                        _b.label = 1;
+                    case 1:
+                        if (!!signal.aborted) return [3 /*break*/, 5];
+                        return [4 /*yield*/, reader.read()];
+                    case 2:
+                        _a = _b.sent(), done = _a.done, value = _a.value;
+                        if (done) {
+                            return [3 /*break*/, 5];
+                        }
+                        if (!value) return [3 /*break*/, 4];
+                        buffer += decoder.decode(value, { stream: true });
+                        return [4 /*yield*/, processBuffer()];
+                    case 3:
+                        _b.sent();
+                        _b.label = 4;
+                    case 4: return [3 /*break*/, 1];
+                    case 5:
+                        buffer += decoder.decode();
+                        return [4 /*yield*/, processBuffer(true)];
+                    case 6:
+                        _b.sent();
+                        return [4 /*yield*/, emitEvent()];
+                    case 7:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FlowscaleAPI.prototype.parseSSEEventId = function (eventId) {
+        if (eventId === undefined || eventId === '') {
+            return undefined;
+        }
+        var numeric = Number(eventId);
+        if (!Number.isNaN(numeric) && Number.isFinite(numeric)) {
+            return numeric;
+        }
+        return eventId;
+    };
+    FlowscaleAPI.prototype.invokeRunEventsCallback = function (callback, payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_6;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!callback) {
+                            return [2 /*return*/];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 6, , 7]);
+                        if (!(payload === undefined)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, callback()];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, callback(payload)];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        error_6 = _a.sent();
+                        this.logWarn('Run events callback failed:', error_6);
+                        return [3 /*break*/, 7];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Helper method to append data to FormData.
      */
@@ -759,7 +1221,7 @@ var FlowscaleAPI = /** @class */ (function () {
                     case 0:
                         retries = 0;
                         _loop_2 = function () {
-                            var response, _b, error_5, axiosError, isTimeout, delay_1;
+                            var response, _b, error_7, axiosError, isTimeout, delay_1;
                             return __generator(this, function (_c) {
                                 switch (_c.label) {
                                     case 0:
@@ -777,13 +1239,13 @@ var FlowscaleAPI = /** @class */ (function () {
                                         response = _b;
                                         return [2 /*return*/, { value: response.data }];
                                     case 5:
-                                        error_5 = _c.sent();
-                                        axiosError = error_5;
+                                        error_7 = _c.sent();
+                                        axiosError = error_7;
                                         isTimeout = axiosError.code === 'ECONNABORTED' ||
                                             (axiosError.response && axiosError.response.status === 504);
                                         // Only retry on timeout errors or if we're in the browser (not Node.js)
                                         if (!isTimeout && this_2.isNode) {
-                                            this_2.handleError(error_5);
+                                            this_2.handleError(error_7);
                                         }
                                         retries++;
                                         // If we've tried max times, handle the error
@@ -793,7 +1255,7 @@ var FlowscaleAPI = /** @class */ (function () {
                                                 return [2 /*return*/, { value: { status: "success", data: {} } }];
                                             }
                                             else {
-                                                this_2.handleError(error_5);
+                                                this_2.handleError(error_7);
                                             }
                                         }
                                         this_2.logWarn("Attempt ".concat(retries, "/").concat(this_2.maxRetries, " failed, retrying in ").concat(this_2.retryDelay * Math.pow(2, retries - 1), "ms..."));
@@ -823,127 +1285,6 @@ var FlowscaleAPI = /** @class */ (function () {
             });
         });
     };
-    /**
-     * Connects to the WebSocket API endpoint and sets up event handlers.
-     * @param options - Configuration options for the WebSocket connection
-     * @returns A function that can be called to disconnect the WebSocket
-     */
-    FlowscaleAPI.prototype.connectWebSocket = function (options) {
-        var _this = this;
-        var _a, _b, _c;
-        if (options === void 0) { options = {}; }
-        if (!this.WebSocketImpl) {
-            throw new Error('WebSocket functionality is not available. ' +
-                (this.isNode ?
-                    'For Node.js environments, install the "ws" library and pass it as WebSocketImpl in the config:\n' +
-                        'npm install ws\n' +
-                        'const WebSocket = require("ws");\n' +
-                        'new FlowscaleAPI({ ..., WebSocketImpl: WebSocket })' :
-                    'WebSocket is not supported in this environment.'));
-        }
-        // Default options
-        var reconnect = (_a = options.reconnect) !== null && _a !== void 0 ? _a : true;
-        var reconnectInterval = (_b = options.reconnectInterval) !== null && _b !== void 0 ? _b : 5000;
-        var maxReconnectAttempts = (_c = options.maxReconnectAttempts) !== null && _c !== void 0 ? _c : 5;
-        // Close any existing connection and clear reconnection timeout
-        this.disconnectWebSocket();
-        // Format the WebSocket URL
-        var wsUrl = new URL('/api/v1/ws/subscribe', this.baseUrl);
-        wsUrl.protocol = wsUrl.protocol.replace('https', 'wss');
-        // Add API key only if not in proxy mode
-        if (!this.proxyMode && this.apiKey) {
-            wsUrl.searchParams.append('api_key', this.apiKey);
-        }
-        // Note: In proxy mode, authentication should be handled by the proxy server
-        // Create a new WebSocket connection
-        this.ws = new this.WebSocketImpl(wsUrl.toString());
-        this.reconnectAttempts = 0;
-        // Set up event handlers
-        if (this.ws) {
-            this.ws.onopen = function () {
-                _this.logInfo('WebSocket connection established');
-                _this.wsConnected = true;
-                _this.reconnectAttempts = 0;
-                if (options.onOpen)
-                    options.onOpen();
-            };
-            this.ws.onmessage = function (event) {
-                try {
-                    var message = JSON.parse(event.data);
-                    if (options.onMessage)
-                        options.onMessage(message);
-                }
-                catch (error) {
-                    _this.logError('Failed to parse WebSocket message:', error);
-                    if (options.onError)
-                        options.onError(new ErrorEvent('error', { error: error }));
-                }
-            };
-            this.ws.onclose = function (event) {
-                _this.logInfo("WebSocket connection closed: ".concat(event.code, " ").concat(event.reason));
-                _this.wsConnected = false;
-                // Attempt to reconnect if enabled and not already reconnecting
-                if (reconnect && _this.reconnectAttempts < maxReconnectAttempts && !_this.reconnectTimeout) {
-                    _this.reconnectAttempts++;
-                    _this.logInfo("Attempting to reconnect (".concat(_this.reconnectAttempts, "/").concat(maxReconnectAttempts, ")..."));
-                    _this.reconnectTimeout = setTimeout(function () {
-                        _this.reconnectTimeout = null;
-                        _this.connectWebSocket(options);
-                    }, reconnectInterval);
-                }
-                if (options.onClose)
-                    options.onClose(event);
-            };
-            this.ws.onerror = function (error) {
-                _this.logError('WebSocket error:', error);
-                if (options.onError)
-                    options.onError(error);
-            };
-        }
-        // Return a function to disconnect
-        return function () { return _this.disconnectWebSocket(); };
-    };
-    /**
-     * Disconnects the WebSocket connection if it exists.
-     */
-    FlowscaleAPI.prototype.disconnectWebSocket = function () {
-        // Clear any pending reconnection timeout
-        if (this.reconnectTimeout) {
-            clearTimeout(this.reconnectTimeout);
-            this.reconnectTimeout = null;
-        }
-        if (this.ws) {
-            this.ws.close();
-            this.ws = null;
-            this.wsConnected = false;
-        }
-        // Reset reconnection attempts
-        this.reconnectAttempts = 0;
-    };
-    /**
-     * Sends a message through the WebSocket connection.
-     * @param message - The message to send
-     * @returns Whether the message was sent successfully
-     */
-    FlowscaleAPI.prototype.sendWebSocketMessage = function (message) {
-        if (message === undefined || message === null) {
-            this.logError('Message cannot be null or undefined');
-            return false;
-        }
-        if (!this.ws || !this.wsConnected) {
-            this.logError('WebSocket is not connected');
-            return false;
-        }
-        try {
-            var messageString = typeof message === 'string' ? message : JSON.stringify(message);
-            this.ws.send(messageString);
-            return true;
-        }
-        catch (error) {
-            this.logError('Error sending WebSocket message:', error);
-            return false;
-        }
-    };
     /**
      * Updates custom headers for authentication (useful for refreshing JWT tokens)
      * @param headers - Object containing header key-value pairs
@@ -964,19 +1305,6 @@ var FlowscaleAPI = /** @class */ (function () {
     FlowscaleAPI.prototype.getCustomHeaders = function () {
         return __assign({}, this.customHeaders);
     };
-    /**
-     * Checks if the WebSocket connection is currently open.
-     * @returns True if the WebSocket is connected, false otherwise
-     */
-    FlowscaleAPI.prototype.isWebSocketConnected = function () {
-        var _a;
-        if (!this.ws || !this.wsConnected) {
-            return false;
-        }
-        // Handle both browser WebSocket and Node.js 'ws' library
-        var OPEN_STATE = ((_a = this.WebSocketImpl) === null || _a === void 0 ? void 0 : _a.OPEN) || 1; // WebSocket.OPEN = 1
-        return this.ws.readyState === OPEN_STATE;
-    };
     return FlowscaleAPI;
 }());
 exports.FlowscaleAPI = FlowscaleAPI;