flowscale 1.3.0 → 1.3.1

package/dist/index.d.ts

@@ -75,6 +75,7 @@ export declare class FlowscaleAPI {
     private emitExecuteWorkflowAsyncIntermediateResponse;
     private formatUnknownError;
     private sleep;
+    private normalizeGetOutputResponse;
     private resolveGlobalFetch;
     private consumeRunEventsStream;
     private safeReadResponseText;

package/dist/index.js

@@ -236,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() === '') {
@@ -261,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');
                         }
@@ -278,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) {
@@ -289,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, {
@@ -303,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) {
@@ -319,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;
@@ -372,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;
@@ -413,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.'
@@ -443,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
@@ -460,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, {
@@ -483,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*/];
                 }
             });
         });
@@ -509,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:
@@ -520,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');
                         }
@@ -685,6 +723,55 @@ 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowscale",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "An NPM library for communicating with the Flowscale APIs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",