@runware/sdk-js 1.1.48-beta-vectorize → 1.1.48

package/dist/esm/Runware/Runware-base.js

@@ -0,0 +1,1002 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunwareBase = void 0;
+// @ts-ignore
+const async_retry_1 = require("./async-retry");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+// let allImages: IImage[] = [];
+class RunwareBase {
+    constructor({ apiKey, url = utils_1.BASE_RUNWARE_URLS.PRODUCTION, shouldReconnect = true, globalMaxRetries = 2, timeoutDuration = utils_1.TIMEOUT_DURATION, }) {
+        this._listeners = [];
+        // _globalMessages: any[] = [];
+        this._globalMessages = {};
+        this._globalImages = [];
+        this.ensureConnectionUUID = null;
+        this.isWebsocketReadyState = () => { var _a; return ((_a = this._ws) === null || _a === void 0 ? void 0 : _a.readyState) === 1; };
+        // protected addListener({
+        //   lis,
+        //   check,
+        // }: {
+        //   lis: (v: any) => any;
+        //   check: (v: any) => any;
+        //   groupKey?: string;
+        // }): { destroy: Function } {
+        //   this._ws.onmessage = (e: any) => {
+        //     const m = JSON.parse(e.data);
+        //     if (m?.error) {
+        //       lis(m);
+        //     } else if (check(m)) {
+        //       lis(m);
+        //     }
+        //   };
+        //   return
+        //     destroy: () => {},
+        //   };
+        // }
+        this.isInvalidAPIKey = () => {
+            var _a, _b;
+            return ((_b = (_a = this._connectionError) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.code) === "invalidApiKey";
+        };
+        // We moving to an array format, it make sense to consolidate all request to an array here
+        this.send = (msg) => {
+            this._ws.send(JSON.stringify([msg]));
+        };
+        this.uploadImage = async (file) => {
+            try {
+                return await (0, async_retry_1.asyncRetry)(async () => {
+                    const taskUUID = (0, utils_1.getUUID)();
+                    if (typeof file === "string" && (0, utils_1.isValidUUID)(file)) {
+                        return {
+                            imageURL: file,
+                            imageUUID: file,
+                            taskUUID,
+                            taskType: types_1.ETaskType.IMAGE_UPLOAD,
+                        };
+                    }
+                    const imageBase64 = typeof file === "string" ? file : await (0, utils_1.fileToBase64)(file);
+                    return {
+                        imageURL: imageBase64,
+                        imageUUID: imageBase64,
+                        taskUUID,
+                        taskType: types_1.ETaskType.IMAGE_UPLOAD,
+                    };
+                });
+            }
+            catch (e) {
+                throw e;
+            }
+        };
+        this.controlNetPreProcess = async ({ inputImage, preProcessorType, height, width, outputType, outputFormat, highThresholdCanny, lowThresholdCanny, includeHandsAndFaceOpenPose, includeCost, outputQuality, customTaskUUID, retry, includeGenerationTime, includePayload, }) => {
+            const totalRetry = retry || this._globalMaxRetries;
+            let lis = undefined;
+            const startTime = Date.now();
+            try {
+                return await (0, async_retry_1.asyncRetry)(async () => {
+                    await this.ensureConnection();
+                    const image = await this.uploadImage(inputImage);
+                    if (!(image === null || image === void 0 ? void 0 : image.imageUUID))
+                        return null;
+                    const taskUUID = customTaskUUID || (0, utils_1.getUUID)();
+                    const payload = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ inputImage: image.imageUUID, taskType: types_1.ETaskType.IMAGE_CONTROL_NET_PRE_PROCESS, taskUUID,
+                        preProcessorType }, (0, utils_1.evaluateNonTrue)({ key: "height", value: height })), (0, utils_1.evaluateNonTrue)({ key: "width", value: width })), (0, utils_1.evaluateNonTrue)({ key: "outputType", value: outputType })), (0, utils_1.evaluateNonTrue)({ key: "outputFormat", value: outputFormat })), (0, utils_1.evaluateNonTrue)({ key: "includeCost", value: includeCost })), (0, utils_1.evaluateNonTrue)({
+                        key: "highThresholdCanny",
+                        value: highThresholdCanny,
+                    })), (0, utils_1.evaluateNonTrue)({
+                        key: "lowThresholdCanny",
+                        value: lowThresholdCanny,
+                    })), (0, utils_1.evaluateNonTrue)({
+                        key: "includeHandsAndFaceOpenPose",
+                        value: includeHandsAndFaceOpenPose,
+                    })), (outputQuality ? { outputQuality } : {}));
+                    this.send(Object.assign({}, payload));
+                    lis = this.globalListener({
+                        taskUUID,
+                    });
+                    const guideImage = (await (0, utils_1.getIntervalWithPromise)(({ resolve, reject }) => {
+                        const uploadedImage = this.getSingleMessage({
+                            taskUUID,
+                        });
+                        if (!uploadedImage)
+                            return;
+                        if (uploadedImage === null || uploadedImage === void 0 ? void 0 : uploadedImage.error) {
+                            reject(uploadedImage);
+                            return true;
+                        }
+                        if (uploadedImage) {
+                            // delete this._globalMessages[taskUUID];
+                            resolve(uploadedImage);
+                            return true;
+                        }
+                    }, {
+                        debugKey: "unprocessed-image",
+                        timeoutDuration: this._timeoutDuration,
+                    }));
+                    lis.destroy();
+                    this.insertAdditionalResponse({
+                        response: guideImage,
+                        payload: includePayload ? payload : undefined,
+                        startTime: includeGenerationTime ? startTime : undefined,
+                    });
+                    return guideImage;
+                }, {
+                    maxRetries: totalRetry,
+                    callback: () => {
+                        lis === null || lis === void 0 ? void 0 : lis.destroy();
+                    },
+                });
+            }
+            catch (e) {
+                throw e;
+            }
+        };
+        this.requestImageToText = async ({ inputImage, includeCost, customTaskUUID, retry, includePayload, includeGenerationTime, }) => {
+            const totalRetry = retry || this._globalMaxRetries;
+            let lis = undefined;
+            const startTime = Date.now();
+            try {
+                return await (0, async_retry_1.asyncRetry)(async () => {
+                    await this.ensureConnection();
+                    const imageUploaded = inputImage
+                        ? await this.uploadImage(inputImage)
+                        : null;
+                    const taskUUID = customTaskUUID || (0, utils_1.getUUID)();
+                    const payload = Object.assign({ taskUUID, taskType: types_1.ETaskType.IMAGE_CAPTION, inputImage: imageUploaded === null || imageUploaded === void 0 ? void 0 : imageUploaded.imageUUID }, (0, utils_1.evaluateNonTrue)({ key: "includeCost", value: includeCost }));
+                    this.send(payload);
+                    lis = this.globalListener({
+                        taskUUID,
+                    });
+                    const response = await (0, utils_1.getIntervalWithPromise)(({ resolve, reject }) => {
+                        const newReverseClip = this.getSingleMessage({
+                            taskUUID,
+                        });
+                        if (!newReverseClip)
+                            return;
+                        if (newReverseClip === null || newReverseClip === void 0 ? void 0 : newReverseClip.error) {
+                            reject(newReverseClip);
+                            return true;
+                        }
+                        if (newReverseClip) {
+                            delete this._globalMessages[taskUUID];
+                            resolve(newReverseClip);
+                            return true;
+                        }
+                    }, {
+                        debugKey: "remove-image-background",
+                        timeoutDuration: this._timeoutDuration,
+                    });
+                    lis.destroy();
+                    this.insertAdditionalResponse({
+                        response: response,
+                        payload: includePayload ? payload : undefined,
+                        startTime: includeGenerationTime ? startTime : undefined,
+                    });
+                    return response;
+                }, {
+                    maxRetries: totalRetry,
+                    callback: () => {
+                        lis === null || lis === void 0 ? void 0 : lis.destroy();
+                    },
+                });
+            }
+            catch (e) {
+                throw e;
+            }
+        };
+        this.removeImageBackground = async (payload) => {
+            return this.baseSingleRequest({
+                payload: Object.assign(Object.assign({}, payload), { taskType: types_1.ETaskType.IMAGE_BACKGROUND_REMOVAL }),
+                debugKey: "remove-image-background",
+            });
+        };
+        this.removeBackground = async (payload) => {
+            var _a;
+            const { skipResponse } = payload, rest = __rest(payload, ["skipResponse"]);
+            try {
+                const deliveryMethod = rest.deliveryMethod;
+                const request = await this.baseSingleRequest({
+                    payload: Object.assign(Object.assign({}, rest), { taskType: types_1.ETaskType.REMOVE_BACKGROUND }),
+                    debugKey: "remove-background",
+                });
+                if (skipResponse) {
+                    return request;
+                }
+                if (deliveryMethod === "async") {
+                    const taskUUID = request === null || request === void 0 ? void 0 : request.taskUUID;
+                    const numberResults = (_a = payload === null || payload === void 0 ? void 0 : payload.numberResults) !== null && _a !== void 0 ? _a : 1;
+                    return this.pollForAsyncResults({
+                        taskUUID,
+                        numberResults,
+                    });
+                }
+                // If not async, just return the initial result
+                return request;
+            }
+            catch (e) {
+                throw e;
+            }
+        };
+        this.videoInference = async (payload) => {
+            var _a;
+            const { skipResponse, inputAudios, referenceVideos } = payload, rest = __rest(payload, ["skipResponse", "inputAudios", "referenceVideos"]);
+            try {
+                const request = await this.baseSingleRequest({
+                    payload: Object.assign(Object.assign(Object.assign(Object.assign({}, rest), ((inputAudios === null || inputAudios === void 0 ? void 0 : inputAudios.length) && { inputAudios })), ((referenceVideos === null || referenceVideos === void 0 ? void 0 : referenceVideos.length) && { referenceVideos })), { deliveryMethod: "async", taskType: types_1.ETaskType.VIDEO_INFERENCE }),
+                    debugKey: "video-inference",
+                });
+                if (skipResponse) {
+                    return request;
+                }
+                const taskUUID = request === null || request === void 0 ? void 0 : request.taskUUID;
+                const numberResults = (_a = payload === null || payload === void 0 ? void 0 : payload.numberResults) !== null && _a !== void 0 ? _a : 1;
+                return this.pollForAsyncResults({
+                    taskUUID,
+                    numberResults,
+                    resultKey: "videoUUID"
+                });
+            }
+            catch (e) {
+                throw e;
+            }
+        };
+        this.getResponse = async (payload) => {
+            const taskUUID = payload.taskUUID;
+            // const mock = getRandomTaskResponses({ count: 2, taskUUID });
+            return this.baseSingleRequest({
+                payload: Object.assign(Object.assign({}, payload), { customTaskUUID: taskUUID, taskType: types_1.ETaskType.GET_RESPONSE }),
+                isMultiple: true,
+                debugKey: "async-results",
+            });
+        };
+        this.upscaleGan = async ({ inputImage, upscaleFactor, outputType, outputFormat, includeCost, outputQuality, customTaskUUID, retry, includeGenerationTime, includePayload, }) => {
+            const totalRetry = retry || this._globalMaxRetries;
+            let lis = undefined;
+            const startTime = Date.now();
+            try {
+                return await (0, async_retry_1.asyncRetry)(async () => {
+                    await this.ensureConnection();
+                    let imageUploaded;
+                    imageUploaded = await this.uploadImage(inputImage);
+                    const taskUUID = customTaskUUID || (0, utils_1.getUUID)();
+                    const payload = Object.assign(Object.assign(Object.assign(Object.assign({ taskUUID, inputImage: imageUploaded === null || imageUploaded === void 0 ? void 0 : imageUploaded.imageUUID, taskType: types_1.ETaskType.IMAGE_UPSCALE, upscaleFactor }, (0, utils_1.evaluateNonTrue)({ key: "includeCost", value: includeCost })), (outputType ? { outputType } : {})), (outputQuality ? { outputQuality } : {})), (outputFormat ? { outputFormat } : {}));
+                    this.send(payload);
+                    lis = this.globalListener({
+                        taskUUID,
+                    });
+                    const response = await (0, utils_1.getIntervalWithPromise)(({ resolve, reject }) => {
+                        const newUpscaleGan = this.getSingleMessage({ taskUUID });
+                        if (!newUpscaleGan)
+                            return;
+                        if (newUpscaleGan === null || newUpscaleGan === void 0 ? void 0 : newUpscaleGan.error) {
+                            reject(newUpscaleGan);
+                            return true;
+                        }
+                        if (newUpscaleGan) {
+                            delete this._globalMessages[taskUUID];
+                            resolve(newUpscaleGan);
+                            return true;
+                        }
+                    }, { debugKey: "upscale-gan", timeoutDuration: this._timeoutDuration });
+                    lis.destroy();
+                    this.insertAdditionalResponse({
+                        response,
+                        payload: includePayload ? payload : undefined,
+                        startTime: includeGenerationTime ? startTime : undefined,
+                    });
+                    return response;
+                }, {
+                    maxRetries: totalRetry,
+                    callback: () => {
+                        lis === null || lis === void 0 ? void 0 : lis.destroy();
+                    },
+                });
+            }
+            catch (e) {
+                throw e;
+            }
+        };
+        this.enhancePrompt = async ({ prompt, promptMaxLength = 380, promptVersions = 1, includeCost, customTaskUUID, retry, includeGenerationTime, includePayload, }) => {
+            const totalRetry = retry || this._globalMaxRetries;
+            let lis = undefined;
+            const startTime = Date.now();
+            try {
+                return await (0, async_retry_1.asyncRetry)(async () => {
+                    await this.ensureConnection();
+                    const taskUUID = customTaskUUID || (0, utils_1.getUUID)();
+                    const payload = Object.assign(Object.assign({ prompt,
+                        taskUUID,
+                        promptMaxLength,
+                        promptVersions }, (0, utils_1.evaluateNonTrue)({ key: "includeCost", value: includeCost })), { taskType: types_1.ETaskType.PROMPT_ENHANCE });
+                    this.send(payload);
+                    lis = this.globalListener({
+                        taskUUID,
+                    });
+                    const response = await (0, utils_1.getIntervalWithPromise)(({ resolve, reject }) => {
+                        const reducedPrompt = this._globalMessages[taskUUID];
+                        if (reducedPrompt === null || reducedPrompt === void 0 ? void 0 : reducedPrompt.error) {
+                            reject(reducedPrompt);
+                            return true;
+                        }
+                        if ((reducedPrompt === null || reducedPrompt === void 0 ? void 0 : reducedPrompt.length) >= promptVersions) {
+                            delete this._globalMessages[taskUUID];
+                            resolve(reducedPrompt);
+                            return true;
+                        }
+                    }, {
+                        debugKey: "enhance-prompt",
+                        timeoutDuration: this._timeoutDuration,
+                    });
+                    lis.destroy();
+                    this.insertAdditionalResponse({
+                        response: response,
+                        payload: includePayload ? payload : undefined,
+                        startTime: includeGenerationTime ? startTime : undefined,
+                    });
+                    return response;
+                }, {
+                    maxRetries: totalRetry,
+                    callback: () => {
+                        lis === null || lis === void 0 ? void 0 : lis.destroy();
+                    },
+                });
+            }
+            catch (e) {
+                throw e;
+            }
+        };
+        this.modelUpload = async (payload) => {
+            // This is written to destructure the payload from the additional parameters
+            const { onUploadStream, retry, customTaskUUID } = payload, addModelPayload = __rest(payload, ["onUploadStream", "retry", "customTaskUUID"]);
+            const totalRetry = retry || this._globalMaxRetries;
+            let lis = undefined;
+            try {
+                return await (0, async_retry_1.asyncRetry)(async () => {
+                    await this.ensureConnection();
+                    const taskUUID = customTaskUUID || (0, utils_1.getUUID)();
+                    this.send(Object.assign(Object.assign({}, addModelPayload), { taskUUID, taskType: types_1.ETaskType.MODEL_UPLOAD }));
+                    let result;
+                    let errorResult;
+                    lis = this.listenToUpload({
+                        taskUUID,
+                        onUploadStream: (response, error) => {
+                            onUploadStream === null || onUploadStream === void 0 ? void 0 : onUploadStream(response, error);
+                            if ((response === null || response === void 0 ? void 0 : response.status) === "ready") {
+                                result = response;
+                            }
+                            else if (error) {
+                                errorResult = error;
+                            }
+                        },
+                    });
+                    const modelUploadResponse = await (0, utils_1.getIntervalWithPromise)(({ resolve, reject }) => {
+                        if (result) {
+                            resolve(result);
+                            return true;
+                        }
+                        else if (errorResult) {
+                            reject(errorResult);
+                            return false;
+                        }
+                    }, {
+                        shouldThrowError: false,
+                        timeoutDuration: 60 * 60 * 1000,
+                    });
+                    return modelUploadResponse;
+                }, {
+                    maxRetries: totalRetry,
+                    callback: () => {
+                        lis === null || lis === void 0 ? void 0 : lis.destroy();
+                    },
+                });
+            }
+            catch (e) {
+                throw e;
+            }
+        };
+        this.photoMaker = async (payload, moreOptions) => {
+            // This is written to destructure the payload from the additional parameters
+            const { onPartialImages, retry, customTaskUUID, numberResults, includeGenerationTime, includePayload } = payload, photoMakerPayload = __rest(payload, ["onPartialImages", "retry", "customTaskUUID", "numberResults", "includeGenerationTime", "includePayload"]);
+            const totalRetry = retry || this._globalMaxRetries;
+            let lis = undefined;
+            let taskUUIDs = [];
+            let retryCount = 0;
+            const startTime = Date.now();
+            try {
+                return await (0, async_retry_1.asyncRetry)(async () => {
+                    await this.ensureConnection();
+                    retryCount++;
+                    const imagesWithSimilarTask = this._globalImages.filter((img) => taskUUIDs.includes(img.taskUUID));
+                    const taskUUID = customTaskUUID || (0, utils_1.getUUID)();
+                    taskUUIDs.push(taskUUID);
+                    const imageRemaining = numberResults - imagesWithSimilarTask.length;
+                    const payload = Object.assign(Object.assign(Object.assign(Object.assign({}, photoMakerPayload), (photoMakerPayload.seed
+                        ? { seed: photoMakerPayload.seed }
+                        : { seed: (0, utils_1.getRandomSeed)() })), (moreOptions !== null && moreOptions !== void 0 ? moreOptions : {})), { taskUUID, taskType: types_1.ETaskType.PHOTO_MAKER, numberResults });
+                    this.send(Object.assign(Object.assign({}, payload), { numberResults: imageRemaining }));
+                    lis = this.listenToImages({
+                        onPartialImages,
+                        taskUUID: taskUUID,
+                        groupKey: utils_1.LISTEN_TO_IMAGES_KEY.REQUEST_IMAGES,
+                        requestPayload: includePayload ? payload : undefined,
+                        startTime: includeGenerationTime ? startTime : undefined,
+                    });
+                    const promise = await this.getSimilarImages({
+                        taskUUID: taskUUIDs,
+                        numberResults,
+                        lis,
+                    });
+                    lis.destroy();
+                    return promise;
+                }, {
+                    maxRetries: totalRetry,
+                    callback: () => {
+                        lis === null || lis === void 0 ? void 0 : lis.destroy();
+                    },
+                });
+            }
+            catch (e) {
+                if (e.taskUUID) {
+                    throw e;
+                }
+                if (retryCount >= totalRetry) {
+                    return this.handleIncompleteImages({
+                        taskUUIDs,
+                        error: e,
+                    });
+                }
+            }
+        };
+        this.modelSearch = async (payload) => {
+            return this.baseSingleRequest({
+                payload: Object.assign(Object.assign({}, payload), { taskType: types_1.ETaskType.MODEL_SEARCH }),
+                debugKey: "model-search",
+            });
+        };
+        this.imageMasking = async (payload) => {
+            return this.baseSingleRequest({
+                payload: Object.assign(Object.assign({}, payload), { taskType: types_1.ETaskType.IMAGE_MASKING }),
+                debugKey: "image-masking",
+            });
+        };
+        this.imageUpload = async (payload) => {
+            return this.baseSingleRequest({
+                payload: Object.assign(Object.assign({}, payload), { taskType: types_1.ETaskType.IMAGE_UPLOAD }),
+                debugKey: "image-upload",
+            });
+        };
+        this.baseSingleRequest = async ({ payload, debugKey, isMultiple, }) => {
+            const { retry, customTaskUUID, includePayload, includeGenerationTime } = payload, restPayload = __rest(payload, ["retry", "customTaskUUID", "includePayload", "includeGenerationTime"]);
+            const totalRetry = retry || this._globalMaxRetries;
+            let lis = undefined;
+            const startTime = Date.now();
+            try {
+                return await (0, async_retry_1.asyncRetry)(async () => {
+                    await this.ensureConnection();
+                    const taskUUID = customTaskUUID || (0, utils_1.getUUID)();
+                    const payload = Object.assign(Object.assign({}, restPayload), { taskUUID });
+                    this.send(payload);
+                    lis = this.globalListener({
+                        taskUUID,
+                    });
+                    const response = await (0, utils_1.getIntervalWithPromise)(({ resolve, reject }) => {
+                        // console.log("multiple", isMultiple);
+                        const response = isMultiple
+                            ? this.getMultipleMessages({ taskUUID })
+                            : this.getSingleMessage({ taskUUID });
+                        if (!response)
+                            return;
+                        if (response === null || response === void 0 ? void 0 : response.error) {
+                            reject(response);
+                            return true;
+                        }
+                        if (response) {
+                            delete this._globalMessages[taskUUID];
+                            resolve(response);
+                            return true;
+                        }
+                    }, {
+                        debugKey,
+                        timeoutDuration: this._timeoutDuration,
+                    });
+                    this.insertAdditionalResponse({
+                        response: response,
+                        payload: includePayload ? payload : undefined,
+                        startTime: includeGenerationTime ? startTime : undefined,
+                    });
+                    lis.destroy();
+                    return response;
+                }, {
+                    maxRetries: totalRetry,
+                    callback: () => {
+                        lis === null || lis === void 0 ? void 0 : lis.destroy();
+                    },
+                });
+            }
+            catch (e) {
+                throw e;
+            }
+        };
+        this.getSingleMessage = ({ taskUUID }) => {
+            var _a;
+            const value = (_a = this._globalMessages[taskUUID]) === null || _a === void 0 ? void 0 : _a[0];
+            const errorValue = this._globalMessages[taskUUID];
+            if (!value && !errorValue)
+                return null;
+            return (errorValue === null || errorValue === void 0 ? void 0 : errorValue.error) ? errorValue : value;
+        };
+        this.getMultipleMessages = ({ taskUUID }) => {
+            var _a;
+            // console.log("global", this._globalMessages);
+            const value = (_a = this._globalMessages[taskUUID]) === null || _a === void 0 ? void 0 : _a[0];
+            const mainValue = this._globalMessages[taskUUID];
+            if (!value && !mainValue)
+                return null;
+            return mainValue;
+        };
+        this.insertAdditionalResponse = ({ response, payload, startTime, }) => {
+            if (!payload && !startTime)
+                return;
+            const res = response;
+            res.additionalResponse = {};
+            if (!!payload) {
+                response.additionalResponse.payload = payload;
+            }
+            if (!!startTime) {
+                response.additionalResponse.generationTime =
+                    Date.now() - startTime;
+            }
+        };
+        this.disconnect = async () => {
+            var _a, _b, _c, _d;
+            this._shouldReconnect = false;
+            (_b = (_a = this._ws) === null || _a === void 0 ? void 0 : _a.terminate) === null || _b === void 0 ? void 0 : _b.call(_a);
+            (_d = (_c = this._ws) === null || _c === void 0 ? void 0 : _c.close) === null || _d === void 0 ? void 0 : _d.call(_c);
+        };
+        this.connected = () => this.isWebsocketReadyState() && !!this._connectionSessionUUID;
+        this._apiKey = apiKey;
+        this._url = url;
+        this._sdkType = types_1.SdkType.CLIENT;
+        this._shouldReconnect = shouldReconnect;
+        this._globalMaxRetries = globalMaxRetries;
+        this._timeoutDuration = timeoutDuration;
+    }
+    /**
+     * Shared polling logic for async results.
+     * @param taskUUID - The task UUID to poll for.
+     * @param numberResults - Number of results expected.
+     * @param resultKey - Key to identify results (default is "mediaUUID" - "videoUUID" is legacy).
+     * @returns Promise resolving to array of results.
+     */
+    async pollForAsyncResults({ taskUUID, numberResults, resultKey = "mediaUUID" }) {
+        const allResults = new Map();
+        await (0, utils_1.getIntervalAsyncWithPromise)(async ({ resolve, reject }) => {
+            try {
+                const results = await this.getResponse({ taskUUID });
+                // Add results to the collection
+                for (const result of results || []) {
+                    const key = result[resultKey];
+                    if (typeof key === "string") {
+                        allResults.set(key, result);
+                    }
+                }
+                // Check completion AFTER updating the collection
+                const isComplete = allResults.size === numberResults;
+                if (isComplete) {
+                    resolve(Array.from(allResults.values()));
+                    return true; // Signal to clear the interval
+                }
+                return false;
+            }
+            catch (err) {
+                reject(err);
+                return true;
+            }
+        }, {
+            debugKey: "async-response",
+            pollingInterval: 2 * 1000,
+            timeoutDuration: 10 * 60 * 1000,
+        });
+        return Array.from(allResults.values());
+    }
+    static async initialize(props) {
+        try {
+            const instance = new this(props);
+            await instance.ensureConnection();
+            return instance;
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    addListener({ lis, 
+    // check,
+    groupKey, taskUUID, }) {
+        const listener = (msg) => {
+            var _a, _b, _c;
+            const arrayMessage = Array.isArray(msg === null || msg === void 0 ? void 0 : msg.data) ? msg.data : [msg.data];
+            const arrayErrors = ((_a = msg === null || msg === void 0 ? void 0 : msg[0]) === null || _a === void 0 ? void 0 : _a.errors)
+                ? (_b = msg === null || msg === void 0 ? void 0 : msg[0]) === null || _b === void 0 ? void 0 : _b.errors
+                : Array.isArray(msg === null || msg === void 0 ? void 0 : msg.errors)
+                    ? msg.errors
+                    : [msg.errors];
+            const filteredMessage = arrayMessage.filter((v) => ((v === null || v === void 0 ? void 0 : v.taskUUID) || (v === null || v === void 0 ? void 0 : v.taskType)) === taskUUID);
+            const filteredErrors = arrayErrors.filter((v) => ((v === null || v === void 0 ? void 0 : v.taskUUID) || (v === null || v === void 0 ? void 0 : v.taskType)) === taskUUID);
+            if (filteredErrors.length) {
+                lis({ error: Object.assign({}, ((_c = arrayErrors[0]) !== null && _c !== void 0 ? _c : {})) });
+                return;
+            }
+            if (filteredMessage.length) {
+                lis({ [taskUUID]: arrayMessage });
+                return;
+            }
+        };
+        const groupListener = { key: taskUUID || (0, utils_1.getUUID)(), listener, groupKey };
+        this._listeners.push(groupListener);
+        const destroy = () => {
+            this._listeners = (0, utils_1.removeListener)(this._listeners, groupListener);
+        };
+        return {
+            destroy,
+        };
+    }
+    connect() {
+        this._ws.onopen = (e) => {
+            if (this._connectionSessionUUID) {
+                this.send({
+                    taskType: types_1.ETaskType.AUTHENTICATION,
+                    apiKey: this._apiKey,
+                    connectionSessionUUID: this._connectionSessionUUID,
+                });
+            }
+            else {
+                this.send({ apiKey: this._apiKey, taskType: types_1.ETaskType.AUTHENTICATION });
+            }
+            this.addListener({
+                taskUUID: types_1.ETaskType.AUTHENTICATION,
+                lis: (m) => {
+                    var _a, _b;
+                    if (m === null || m === void 0 ? void 0 : m.error) {
+                        this._connectionError = m;
+                        return;
+                    }
+                    this._connectionSessionUUID =
+                        (_b = (_a = m === null || m === void 0 ? void 0 : m[types_1.ETaskType.AUTHENTICATION]) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.connectionSessionUUID;
+                    this._connectionError = undefined;
+                },
+            });
+        };
+        this._ws.onmessage = (e) => {
+            var _a;
+            const data = JSON.parse(e.data);
+            for (const lis of this._listeners) {
+                const result = (_a = lis === null || lis === void 0 ? void 0 : lis.listener) === null || _a === void 0 ? void 0 : _a.call(lis, data);
+                if (result)
+                    return;
+            }
+        };
+        this._ws.onclose = (e) => {
+            // console.log("closing");
+            // console.log("invalid", this._invalidAPIkey);
+            if (this.isInvalidAPIKey()) {
+                return;
+            }
+        };
+    }
+    destroy(lis) {
+        (0, utils_1.removeFromAray)(this._listeners, lis);
+    }
+    listenToImages({ onPartialImages, taskUUID, groupKey, requestPayload, startTime, }) {
+        return this.addListener({
+            taskUUID: taskUUID,
+            lis: (m) => {
+                var _a, _b;
+                let images = (_a = m === null || m === void 0 ? void 0 : m[taskUUID]) === null || _a === void 0 ? void 0 : _a.filter((img) => img.taskUUID === taskUUID);
+                if (m.error) {
+                    onPartialImages === null || onPartialImages === void 0 ? void 0 : onPartialImages(images, (m === null || m === void 0 ? void 0 : m.error) && m);
+                    this._globalError = m;
+                }
+                else {
+                    images = images.map((image) => {
+                        this.insertAdditionalResponse({
+                            response: image,
+                            payload: requestPayload ? requestPayload : undefined,
+                            startTime: startTime ? startTime : undefined,
+                        });
+                        return Object.assign({}, image);
+                    });
+                    onPartialImages === null || onPartialImages === void 0 ? void 0 : onPartialImages(images, (m === null || m === void 0 ? void 0 : m.error) && m);
+                    if (this._sdkType === types_1.SdkType.CLIENT) {
+                        // this._globalImages = [...this._globalImages, ...m.images];
+                        this._globalImages = [
+                            ...this._globalImages,
+                            ...((_b = m === null || m === void 0 ? void 0 : m[taskUUID]) !== null && _b !== void 0 ? _b : []).map((image) => {
+                                this.insertAdditionalResponse({
+                                    response: image,
+                                    payload: requestPayload ? requestPayload : undefined,
+                                    startTime: startTime ? startTime : undefined,
+                                });
+                                return Object.assign({}, image);
+                            }),
+                        ];
+                    }
+                    else {
+                        this._globalImages = [...this._globalImages, ...images];
+                    }
+                }
+            },
+            groupKey,
+        });
+    }
+    listenToUpload({ onUploadStream, taskUUID, }) {
+        return this.addListener({
+            taskUUID: taskUUID,
+            lis: (m) => {
+                var _a;
+                const error = m === null || m === void 0 ? void 0 : m.error;
+                const result = (_a = m === null || m === void 0 ? void 0 : m[taskUUID]) === null || _a === void 0 ? void 0 : _a[0];
+                let response = (result === null || result === void 0 ? void 0 : result.taskUUID) === taskUUID ? result : null;
+                if (response || error) {
+                    onUploadStream === null || onUploadStream === void 0 ? void 0 : onUploadStream(response || undefined, error);
+                }
+            },
+        });
+    }
+    globalListener({ taskUUID }) {
+        return this.addListener({
+            // check: (m) => {
+            //   const value = accessDeepObject({
+            //     key: responseKey,
+            //     data: m,
+            //     useZero: false,
+            //   });
+            //   return !!value;
+            // },
+            // check: responseKey,
+            taskUUID: taskUUID,
+            lis: (m) => {
+                if (m.error) {
+                    this._globalMessages[taskUUID] = m;
+                    return;
+                }
+                // console.log("m", m);
+                const value = (0, utils_1.accessDeepObject)({
+                    key: taskUUID,
+                    data: m,
+                    useZero: false,
+                });
+                // console.log({ value });
+                if (Array.isArray(value)) {
+                    value.forEach((v) => {
+                        var _a;
+                        this._globalMessages[v.taskUUID] = [
+                            ...((_a = this._globalMessages[v.taskUUID]) !== null && _a !== void 0 ? _a : []),
+                            v,
+                        ];
+                    });
+                }
+                else {
+                    this._globalMessages[value.taskUUID] = value;
+                }
+            },
+        });
+    }
+    // includePayload?: boolean
+    // includeGenerationTime?: boolean
+    async requestImages(_a, moreOptions) {
+        var { outputType, outputFormat, uploadEndpoint, checkNSFW, positivePrompt, negativePrompt, seedImage, maskImage, strength, height, width, model, steps, scheduler, seed, CFGScale, clipSkip, usePromptWeighting, promptWeighting, numberResults = 1, onPartialImages, includeCost, customTaskUUID, retry, refiner, maskMargin, outputQuality, controlNet, lora, embeddings, ipAdapters, providerSettings, outpaint, acceleratorOptions, advancedFeatures, referenceImages, includeGenerationTime, includePayload } = _a, rest = __rest(_a, ["outputType", "outputFormat", "uploadEndpoint", "checkNSFW", "positivePrompt", "negativePrompt", "seedImage", "maskImage", "strength", "height", "width", "model", "steps", "scheduler", "seed", "CFGScale", "clipSkip", "usePromptWeighting", "promptWeighting", "numberResults", "onPartialImages", "includeCost", "customTaskUUID", "retry", "refiner", "maskMargin", "outputQuality", "controlNet", "lora", "embeddings", "ipAdapters", "providerSettings", "outpaint", "acceleratorOptions", "advancedFeatures", "referenceImages", "includeGenerationTime", "includePayload"]);
+        let lis = undefined;
+        let requestObject = undefined;
+        let taskUUIDs = [];
+        let retryCount = 0;
+        const totalRetry = retry || this._globalMaxRetries;
+        try {
+            await this.ensureConnection();
+            let seedImageUUID = null;
+            let maskImageUUID = null;
+            let controlNetData = [];
+            if (seedImage) {
+                const uploadedImage = await this.uploadImage(seedImage);
+                if (!uploadedImage)
+                    return [];
+                seedImageUUID = uploadedImage.imageUUID;
+            }
+            if (maskImage) {
+                const uploadedMaskInitiator = await this.uploadImage(maskImage);
+                if (!uploadedMaskInitiator)
+                    return [];
+                maskImageUUID = uploadedMaskInitiator.imageUUID;
+            }
+            if (controlNet === null || controlNet === void 0 ? void 0 : controlNet.length) {
+                for (let i = 0; i < controlNet.length; i++) {
+                    const controlData = controlNet[i];
+                    const { endStep, startStep, weight, guideImage, controlMode, startStepPercentage, endStepPercentage, model: controlNetModel, } = controlData;
+                    const imageUploaded = guideImage
+                        ? await this.uploadImage(guideImage)
+                        : null;
+                    controlNetData.push(Object.assign(Object.assign(Object.assign({ guideImage: imageUploaded === null || imageUploaded === void 0 ? void 0 : imageUploaded.imageUUID, model: controlNetModel, endStep,
+                        startStep,
+                        weight }, (0, utils_1.evaluateNonTrue)({
+                        key: "startStepPercentage",
+                        value: startStepPercentage,
+                    })), (0, utils_1.evaluateNonTrue)({
+                        key: "endStepPercentage",
+                        value: endStepPercentage,
+                    })), { controlMode: controlMode || types_1.EControlMode.CONTROL_NET }));
+                }
+            }
+            requestObject = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ taskType: types_1.ETaskType.IMAGE_INFERENCE, model, positivePrompt: positivePrompt }, (negativePrompt ? { negativePrompt } : {})), (height ? { height } : {})), (width ? { width } : {})), { numberResults }), (outputType ? { outputType } : {})), (outputFormat ? { outputFormat } : {})), (uploadEndpoint ? { uploadEndpoint } : {})), (0, utils_1.evaluateNonTrue)({ key: "checkNSFW", value: checkNSFW })), (0, utils_1.evaluateNonTrue)({ key: "strength", value: strength })), (0, utils_1.evaluateNonTrue)({ key: "CFGScale", value: CFGScale })), (0, utils_1.evaluateNonTrue)({ key: "clipSkip", value: clipSkip })), (0, utils_1.evaluateNonTrue)({ key: "maskMargin", value: maskMargin })), (0, utils_1.evaluateNonTrue)({
+                key: "usePromptWeighting",
+                value: usePromptWeighting,
+            })), (0, utils_1.evaluateNonTrue)({ key: "steps", value: steps })), (promptWeighting ? { promptWeighting } : {})), (seed ? { seed: seed } : {})), (scheduler ? { scheduler } : {})), (refiner ? { refiner } : {})), (outpaint ? { outpaint } : {})), (0, utils_1.evaluateNonTrue)({ key: "includeCost", value: includeCost })), (seedImageUUID ? { seedImage: seedImageUUID } : {})), (maskImageUUID ? { maskImage: maskImageUUID } : {})), (outputQuality ? { outputQuality } : {})), (controlNetData.length ? { controlNet: controlNetData } : {})), ((lora === null || lora === void 0 ? void 0 : lora.length) ? { lora: lora } : {})), ((embeddings === null || embeddings === void 0 ? void 0 : embeddings.length) ? { embeddings } : {})), ((ipAdapters === null || ipAdapters === void 0 ? void 0 : ipAdapters.length) ? { ipAdapters } : {})), (providerSettings ? { providerSettings } : {})), (acceleratorOptions ? { acceleratorOptions } : {})), (advancedFeatures ? { advancedFeatures } : {})), ((referenceImages === null || referenceImages === void 0 ? void 0 : referenceImages.length) ? { referenceImages } : {})), rest), (moreOptions !== null && moreOptions !== void 0 ? moreOptions : {}));
+            const startTime = Date.now();
+            return await (0, async_retry_1.asyncRetry)(async () => {
+                retryCount++;
+                lis === null || lis === void 0 ? void 0 : lis.destroy();
+                const imagesWithSimilarTask = this._globalImages.filter((img) => taskUUIDs.includes(img.taskUUID));
+                const taskUUID = customTaskUUID || (0, utils_1.getUUID)();
+                taskUUIDs.push(taskUUID);
+                const imageRemaining = numberResults - imagesWithSimilarTask.length;
+                const newRequestObject = Object.assign(Object.assign({}, requestObject), { taskUUID: taskUUID, numberResults: imageRemaining });
+                this.send(newRequestObject);
+                // const generationTime = endTime - startTime;
+                lis = this.listenToImages({
+                    onPartialImages,
+                    taskUUID: taskUUID,
+                    groupKey: utils_1.LISTEN_TO_IMAGES_KEY.REQUEST_IMAGES,
+                    requestPayload: includePayload ? newRequestObject : undefined,
+                    startTime: includeGenerationTime ? startTime : undefined,
+                });
+                const promise = await this.getSimilarImages({
+                    taskUUID: taskUUIDs,
+                    numberResults,
+                    lis,
+                });
+                lis.destroy();
+                return promise;
+            }, {
+                maxRetries: totalRetry,
+                callback: () => {
+                    lis === null || lis === void 0 ? void 0 : lis.destroy();
+                },
+            });
+        }
+        catch (e) {
+            if (retryCount >= totalRetry) {
+                return this.handleIncompleteImages({ taskUUIDs, error: e });
+            }
+            throw e;
+        }
+    }
+    async ensureConnection() {
+        var _a;
+        let isConnected = this.connected();
+        if (isConnected || this._url === utils_1.BASE_RUNWARE_URLS.TEST)
+            return;
+        const retryInterval = 2000;
+        const pollingInterval = 200;
+        // const pollingInterval = this._sdkType === SdkType.CLIENT ? 200 : 2000;
+        try {
+            if (this.isInvalidAPIKey()) {
+                throw this._connectionError;
+            }
+            return new Promise((resolve, reject) => {
+                //  const isConnected =
+                let retry = 0;
+                const MAX_RETRY = 30;
+                const localConnectionUUID = (0, utils_1.getUUID)();
+                let retryIntervalId;
+                let pollingIntervalId;
+                const clearAllIntervals = () => {
+                    this.ensureConnectionUUID = null;
+                    clearInterval(retryIntervalId);
+                    clearInterval(pollingIntervalId);
+                };
+                if (this._sdkType === types_1.SdkType.SERVER) {
+                    retryIntervalId = setInterval(async () => {
+                        try {
+                            const hasConnected = this.connected();
+                            // only one instance should be responsible for making the call again, not other ensureConnection
+                            let shouldCallServer = false;
+                            if (!this.ensureConnectionUUID ||
+                                localConnectionUUID === this.ensureConnectionUUID) {
+                                if (!this.ensureConnectionUUID) {
+                                    this.ensureConnectionUUID = localConnectionUUID;
+                                }
+                                shouldCallServer = true;
+                            }
+                            // Retry every (retryInterval % retry) => 60s
+                            // every 20 seconds (ie. => retry is 10 (20s), retry is 20 (40s))
+                            const SHOULD_RETRY = retry % 10 === 0 && shouldCallServer;
+                            if (hasConnected) {
+                                clearAllIntervals();
+                                resolve(true);
+                            }
+                            else if (retry >= MAX_RETRY) {
+                                clearAllIntervals();
+                                reject(new Error("Retry timed out"));
+                            }
+                            else {
+                                if (SHOULD_RETRY) {
+                                    this.connect();
+                                }
+                                retry++;
+                            }
+                        }
+                        catch (error) {
+                            clearAllIntervals();
+                            reject(error);
+                        }
+                    }, retryInterval);
+                }
+                pollingIntervalId = setInterval(async () => {
+                    const hasConnected = this.connected();
+                    if (hasConnected) {
+                        clearAllIntervals();
+                        resolve(true);
+                        return;
+                    }
+                    if (!!this.isInvalidAPIKey()) {
+                        clearAllIntervals();
+                        reject(this._connectionError);
+                        return;
+                    }
+                }, pollingInterval);
+            });
+        }
+        catch (e) {
+            this.ensureConnectionUUID = null;
+            this._connectionError = undefined;
+            throw ((_a = this._connectionError) !== null && _a !== void 0 ? _a : "Could not connect to server. Ensure your API key is correct");
+        }
+    }
+    async getSimilarImages({ taskUUID, numberResults, shouldThrowError, lis, }) {
+        return (await (0, utils_1.getIntervalWithPromise)(({ resolve, reject, intervalId }) => {
+            var _a;
+            const taskUUIDs = Array.isArray(taskUUID) ? taskUUID : [taskUUID];
+            const imagesWithSimilarTask = this._globalImages.filter((img) => taskUUIDs.includes(img.taskUUID));
+            if (this._globalError) {
+                const newData = this._globalError;
+                this._globalError = undefined;
+                // throw errorData[0]
+                clearInterval(intervalId);
+                (_a = (reject)) === null || _a === void 0 ? void 0 : _a(newData);
+                return true;
+            }
+            // onPartialImages?.(imagesWithSimilarTask)
+            else if (imagesWithSimilarTask.length >= numberResults) {
+                // lis?.destroy();
+                clearInterval(intervalId);
+                this._globalImages = this._globalImages.filter((img) => !taskUUIDs.includes(img.taskUUID));
+                resolve([...imagesWithSimilarTask].slice(0, numberResults));
+                return true;
+                // Resolve the promise with the data
+            }
+        }, {
+            debugKey: "getting images",
+            shouldThrowError,
+            timeoutDuration: this._timeoutDuration,
+        }));
+    }
+    handleIncompleteImages({ taskUUIDs, error, }) {
+        const imagesWithSimilarTask = this._globalImages.filter((img) => taskUUIDs.includes(img.taskUUID));
+        if (imagesWithSimilarTask.length > 1) {
+            this._globalImages = this._globalImages.filter((img) => !taskUUIDs.includes(img.taskUUID));
+            return imagesWithSimilarTask;
+        }
+        else {
+            throw error;
+        }
+    }
+}
+exports.RunwareBase = RunwareBase;