@yetter/client 0.0.12 → 0.0.14

package/dist/client.js

@@ -1,37 +1,127 @@
 var _a;
 import { YetterImageClient } from "./api.js";
-import { EventSourcePolyfill } from 'event-source-polyfill';
-export class yetter {
-    static configure(options) {
-        if (options.apiKey) {
-            if (options.is_bearer) {
-                _a.apiKey = 'Bearer ' + options.apiKey;
-            }
-            else {
-                _a.apiKey = 'Key ' + options.apiKey;
+import { EventSourcePolyfill } from "event-source-polyfill";
+const DEFAULT_POLL_INTERVAL_MS = 2000;
+const DEFAULT_UPLOAD_TIMEOUT_MS = 5 * 60 * 1000;
+const STREAM_HEARTBEAT_TIMEOUT_MS = 120000;
+const DEFAULT_STREAM_SSE_MAX_CONSECUTIVE_ERRORS = 3;
+const DEFAULT_ENDPOINT = "https://api.yetter.ai";
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getEnvApiKey() {
+    return process.env.YTR_API_KEY || process.env.REACT_APP_YTR_API_KEY || "";
+}
+export class YetterClient {
+    constructor(options = {}) {
+        this.queue = {
+            submit: async (model, options) => {
+                const client = this.createApiClient();
+                return client.generate({
+                    model,
+                    ...options.input,
+                });
+            },
+            status: async (model, options) => {
+                const client = this.createApiClient();
+                const endpoint = client.getApiEndpoint();
+                const statusUrl = `${endpoint}/${model}/requests/${options.requestId}/status`;
+                const statusData = await client.getStatus({ url: statusUrl });
+                return {
+                    data: statusData,
+                    requestId: options.requestId,
+                };
+            },
+            result: async (model, options) => {
+                const client = this.createApiClient();
+                const endpoint = client.getApiEndpoint();
+                const responseUrl = `${endpoint}/${model}/requests/${options.requestId}`;
+                const responseData = await client.getResponse({ url: responseUrl });
+                return {
+                    data: responseData,
+                    requestId: options.requestId,
+                };
+            },
+        };
+        this.apiKey = "";
+        this.endpoint = options.endpoint || DEFAULT_ENDPOINT;
+        const envKey = getEnvApiKey();
+        if (envKey) {
+            this.apiKey = `Key ${envKey}`;
+        }
+        if (typeof options.apiKey === "string") {
+            this.setApiKey(options.apiKey, options.is_bearer);
+        }
+    }
+    setApiKey(rawApiKey, isBearer) {
+        const normalizedApiKey = rawApiKey.trim();
+        if (!normalizedApiKey) {
+            this.apiKey = "";
+            return;
+        }
+        this.apiKey = isBearer ? `Bearer ${normalizedApiKey}` : `Key ${normalizedApiKey}`;
+    }
+    assertApiKeyConfigured() {
+        if (!this.apiKey) {
+            throw new Error("API key is not configured. Call configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
+        }
+    }
+    createApiClient() {
+        this.assertApiKeyConfigured();
+        return new YetterImageClient({
+            apiKey: this.apiKey,
+            endpoint: this.endpoint,
+        });
+    }
+    getUploadTimeoutMs(options) {
+        if (typeof options.timeout === "number" && Number.isFinite(options.timeout) && options.timeout > 0) {
+            return options.timeout;
+        }
+        return DEFAULT_UPLOAD_TIMEOUT_MS;
+    }
+    async putWithTimeout(url, body, headers, timeoutMs) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            return await fetch(url, {
+                method: "PUT",
+                headers,
+                body,
+                signal: controller.signal,
+            });
+        }
+        catch (error) {
+            if ((error === null || error === void 0 ? void 0 : error.name) === "AbortError") {
+                throw new Error(`Upload request timed out after ${timeoutMs}ms`);
             }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    configure(options) {
+        if (typeof options.apiKey === "string") {
+            this.setApiKey(options.apiKey, options.is_bearer);
         }
         if (options.endpoint) {
-            _a.endpoint = options.endpoint;
+            this.endpoint = options.endpoint;
         }
     }
-    static async subscribe(model, options) {
+    async subscribe(model, options) {
         var _b;
-        if (!_a.apiKey) {
-            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
-        }
-        const client = new YetterImageClient({
-            apiKey: _a.apiKey,
-            endpoint: _a.endpoint
-        });
+        const client = this.createApiClient();
         const generateResponse = await client.generate({
-            model: model,
+            model,
             ...options.input,
         });
         let status = generateResponse.status;
         let lastStatusResponse;
         const startTime = Date.now();
-        const timeoutMilliseconds = 30 * 60 * 1000; // 30 minutes
+        const timeoutMilliseconds = 30 * 60 * 1000;
+        const pollIntervalMs = typeof options.pollIntervalMs === "number" && Number.isFinite(options.pollIntervalMs) && options.pollIntervalMs > 0
+            ? options.pollIntervalMs
+            : DEFAULT_POLL_INTERVAL_MS;
         while (status !== "COMPLETED" && status !== "ERROR" && status !== "CANCELLED") {
             if (Date.now() - startTime > timeoutMilliseconds) {
                 console.warn(`Subscription timed out after 30 minutes for request ID: ${generateResponse.request_id}. Attempting to cancel.`);
@@ -53,6 +143,9 @@ export class yetter {
                 if (options.onQueueUpdate) {
                     options.onQueueUpdate(lastStatusResponse);
                 }
+                if (status !== "COMPLETED" && status !== "ERROR" && status !== "CANCELLED") {
+                    await sleep(pollIntervalMs);
+                }
             }
             catch (error) {
                 console.error("Error during status polling:", error);
@@ -60,35 +153,36 @@ export class yetter {
             }
         }
         if (status === "ERROR") {
-            const errorMessage = ((_b = lastStatusResponse === null || lastStatusResponse === void 0 ? void 0 : lastStatusResponse.logs) === null || _b === void 0 ? void 0 : _b.map(log => log.message).join("\n")) || "Image generation failed.";
+            const errorMessage = ((_b = lastStatusResponse === null || lastStatusResponse === void 0 ? void 0 : lastStatusResponse.logs) === null || _b === void 0 ? void 0 : _b.map((log) => log.message).join("\n")) || "Image generation failed.";
             throw new Error(errorMessage);
         }
-        else if (status === "CANCELLED") {
+        if (status === "CANCELLED") {
             throw new Error("Image generation was cancelled by user.");
         }
-        const finalResponse = await client.getResponse({
+        return client.getResponse({
             url: generateResponse.response_url,
         });
-        return finalResponse;
     }
-    static async stream(model, options) {
-        if (!_a.apiKey) {
-            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
-        }
-        const client = new YetterImageClient({
-            apiKey: _a.apiKey,
-            endpoint: _a.endpoint
-        });
+    async stream(model, options) {
+        const client = this.createApiClient();
         const initialApiResponse = await client.generate({
-            model: model,
+            model,
             ...options.input,
         });
         const requestId = initialApiResponse.request_id;
         const responseUrl = initialApiResponse.response_url;
+        const statusUrl = initialApiResponse.status_url;
         const cancelUrl = initialApiResponse.cancel_url;
         const sseStreamUrl = `${client.getApiEndpoint()}/${model}/requests/${requestId}/status/stream`;
+        const streamPollIntervalMs = typeof options.pollIntervalMs === "number" && Number.isFinite(options.pollIntervalMs) && options.pollIntervalMs > 0
+            ? options.pollIntervalMs
+            : DEFAULT_POLL_INTERVAL_MS;
+        const maxConsecutiveSseErrors = typeof options.sseMaxConsecutiveErrors === "number" &&
+            Number.isFinite(options.sseMaxConsecutiveErrors) &&
+            options.sseMaxConsecutiveErrors > 0
+            ? Math.floor(options.sseMaxConsecutiveErrors)
+            : DEFAULT_STREAM_SSE_MAX_CONSECUTIVE_ERRORS;
         let eventSource;
-        // Setup the promise for the done() method
         let resolveDonePromise;
         let rejectDonePromise;
         const donePromise = new Promise((resolve, reject) => {
@@ -96,8 +190,6 @@ export class yetter {
             rejectDonePromise = reject;
         });
         const controller = {
-            // This will be used by the async iterator to pull events
-            // It needs a way to buffer events or signal availability
             events: [],
             resolvers: [],
             isClosed: false,
@@ -124,7 +216,6 @@ export class yetter {
                 else {
                     this.events.push(event);
                 }
-                // Check for terminal events to resolve/reject the donePromise
                 this.currentStatus = event.status;
             },
             error(err) {
@@ -159,7 +250,7 @@ export class yetter {
                 if (this.isClosed)
                     return;
                 this.isClosed = true;
-                this.resolvers.forEach(resolve => resolve({ value: undefined, done: true }));
+                this.resolvers.forEach((resolve) => resolve({ value: undefined, done: true }));
                 this.resolvers = [];
                 eventSource === null || eventSource === void 0 ? void 0 : eventSource.close();
             },
@@ -170,73 +261,158 @@ export class yetter {
                 if (this.isClosed) {
                     return Promise.resolve({ value: undefined, done: true });
                 }
-                return new Promise(resolve => this.resolvers.push(resolve));
-            }
-        };
-        eventSource = new EventSourcePolyfill(sseStreamUrl, {
-            headers: { 'Authorization': `${_a.apiKey}` },
-        });
-        eventSource.onopen = (event) => {
-            console.log("SSE Connection Opened:", event);
+                return new Promise((resolve) => this.resolvers.push(resolve));
+            },
         };
-        eventSource.addEventListener('data', (event) => {
-            // console.log("SSE 'data' event received, raw data:", event.data);
-            try {
-                const statusData = JSON.parse(event.data);
-                controller.push(statusData);
-            }
-            catch (e) {
-                console.error("Error parsing SSE 'data' event:", e, "Raw data:", event.data);
-                controller.error(new Error(`Error parsing SSE 'data' event: ${e.message}`));
+        let hasStartedFallbackPolling = false;
+        const terminalStatuses = new Set(["COMPLETED", "ERROR", "CANCELLED"]);
+        const startPollingFallback = async (reason) => {
+            if (controller.isClosed || hasStartedFallbackPolling) {
+                return;
             }
-        });
-        // when 'done' event is received, currentStatus can only be COMPLETED or CANCELLED
-        // TODO: remove currentStatus and branch two cases(COMPLETED and CANCELLED) by response status by responseUrl
-        // TODO: Determine whether raise error or not when response status is CANCELLED
-        //  => current code raise error when response status is CANCELLED because resolveDonePromise only get completed response
-        // => this mean that user expect only completed response from .done() method
-        eventSource.addEventListener('done', async (event) => {
-            // console.log("SSE 'done' event received, raw data:", event.data);
+            hasStartedFallbackPolling = true;
             try {
-                if (controller.currentStatus === "COMPLETED") {
-                    // Close SSE immediately to avoid any late 'error' events during await
-                    try {
-                        eventSource === null || eventSource === void 0 ? void 0 : eventSource.close();
+                console.warn(`Falling back to status polling for ${requestId}: ${reason}`);
+                while (!controller.isClosed) {
+                    const latestStatus = await client.getStatus({ url: statusUrl });
+                    controller.push(latestStatus);
+                    if (terminalStatuses.has(latestStatus.status)) {
+                        if (latestStatus.status === "COMPLETED") {
+                            const response = await client.getResponse({ url: responseUrl });
+                            controller.done(response);
+                        }
+                        else if (latestStatus.status === "CANCELLED") {
+                            controller.cancel();
+                        }
+                        else {
+                            controller.error(new Error(`Stream reported ERROR for ${requestId}`));
+                        }
+                        return;
                     }
-                    catch { }
-                    const response = await client.getResponse({ url: responseUrl });
-                    controller.done(response);
-                }
-                else if (controller.currentStatus === "CANCELLED") {
-                    controller.cancel();
+                    await sleep(streamPollIntervalMs);
                 }
             }
-            catch (e) {
-                console.error("Error parsing SSE 'done' event:", e, "Raw data:", event.data);
-                controller.error(new Error(`Error parsing SSE 'done' event: ${e.message}`));
-            }
-        });
-        eventSource.addEventListener('error', (event) => {
-            // console.log("SSE 'done' event received, raw data:", event.data);
-            console.log("SSE 'error' event received, raw data:", event.data);
-            controller.error(new Error("Stream reported ERROR for ${requestId}"));
-        });
-        eventSource.onerror = (err) => {
-            var _b;
-            const message = ((_b = err === null || err === void 0 ? void 0 : err.error) === null || _b === void 0 ? void 0 : _b.message) || (err === null || err === void 0 ? void 0 : err.message) || '';
-            const isIdleTimeout = typeof message === 'string' && message.includes('No activity within') && message.includes('Reconnecting');
-            if (isIdleTimeout) {
-                console.warn("SSE idle timeout; letting EventSource auto-reconnect.", err);
-                return;
+            catch (error) {
+                controller.error(error instanceof Error
+                    ? error
+                    : new Error(`Fallback polling failed for ${requestId}: ${String((error === null || error === void 0 ? void 0 : error.message) || error)}`));
             }
-            console.warn("SSE Connection Error (onerror) - will allow auto-reconnect:", err);
         };
-        // Handle if API immediately returns a terminal status in initialApiResponse (e.g. already completed/failed)
         if (initialApiResponse.status === "COMPLETED") {
             controller.push(initialApiResponse);
+            const finalResponse = await client.getResponse({ url: responseUrl });
+            controller.done(finalResponse);
         }
         else if (initialApiResponse.status === "ERROR") {
             controller.push(initialApiResponse);
+            controller.error(new Error(`Stream reported ERROR for ${requestId}`));
+        }
+        else if (initialApiResponse.status === "CANCELLED") {
+            controller.push(initialApiResponse);
+            controller.cancel();
+        }
+        else {
+            if (options.disableSse) {
+                void startPollingFallback("SSE disabled by stream options.");
+            }
+            else {
+                let consecutiveSseTransportErrors = 0;
+                try {
+                    eventSource = new EventSourcePolyfill(sseStreamUrl, {
+                        headers: { Authorization: this.apiKey },
+                        heartbeatTimeout: STREAM_HEARTBEAT_TIMEOUT_MS,
+                    });
+                }
+                catch (error) {
+                    console.warn("Failed to initialize SSE transport; switching to polling.", error);
+                    void startPollingFallback(`SSE initialization failed: ${String((error === null || error === void 0 ? void 0 : error.message) || error)}`);
+                }
+                if (eventSource) {
+                    eventSource.onopen = (event) => {
+                        console.log("SSE Connection Opened:", event);
+                    };
+                    eventSource.addEventListener("data", (event) => {
+                        try {
+                            consecutiveSseTransportErrors = 0;
+                            const statusData = JSON.parse(event.data);
+                            controller.push(statusData);
+                        }
+                        catch (e) {
+                            console.error("Error parsing SSE 'data' event:", e, "Raw data:", event.data);
+                            controller.error(new Error(`Error parsing SSE 'data' event: ${e.message}`));
+                        }
+                    });
+                    eventSource.addEventListener("done", async (event) => {
+                        try {
+                            try {
+                                eventSource === null || eventSource === void 0 ? void 0 : eventSource.close();
+                            }
+                            catch { }
+                            if (controller.currentStatus === "COMPLETED") {
+                                const response = await client.getResponse({ url: responseUrl });
+                                controller.done(response);
+                                return;
+                            }
+                            if (controller.currentStatus === "CANCELLED") {
+                                controller.cancel();
+                                return;
+                            }
+                            if (controller.currentStatus === "ERROR") {
+                                controller.error(new Error(`Stream reported ERROR for ${requestId}`));
+                                return;
+                            }
+                            const latestStatus = await client.getStatus({ url: statusUrl });
+                            controller.push(latestStatus);
+                            if (latestStatus.status === "COMPLETED") {
+                                const response = await client.getResponse({ url: responseUrl });
+                                controller.done(response);
+                            }
+                            else if (latestStatus.status === "CANCELLED") {
+                                controller.cancel();
+                            }
+                            else if (latestStatus.status === "ERROR") {
+                                controller.error(new Error(`Stream reported ERROR for ${requestId}`));
+                            }
+                            else {
+                                void startPollingFallback("SSE stream ended without terminal status.");
+                            }
+                        }
+                        catch (e) {
+                            console.error("Error parsing SSE 'done' event:", e, "Raw data:", event.data);
+                            controller.error(new Error(`Error parsing SSE 'done' event: ${e.message}`));
+                        }
+                    });
+                    eventSource.addEventListener("error", (event) => {
+                        const rawData = event === null || event === void 0 ? void 0 : event.data;
+                        if (!rawData) {
+                            console.warn("SSE transport error event; waiting for reconnect.");
+                            return;
+                        }
+                        console.log("SSE application 'error' event received, raw data:", rawData);
+                        controller.error(new Error(`Stream reported ERROR for ${requestId}: ${rawData}`));
+                    });
+                    eventSource.onerror = (err) => {
+                        var _b;
+                        const message = ((_b = err === null || err === void 0 ? void 0 : err.error) === null || _b === void 0 ? void 0 : _b.message) || (err === null || err === void 0 ? void 0 : err.message) || "";
+                        const isIdleTimeout = typeof message === "string" &&
+                            message.includes("No activity within") &&
+                            message.includes("Reconnecting");
+                        if (isIdleTimeout) {
+                            console.warn("SSE idle timeout; letting EventSource auto-reconnect.", err);
+                            return;
+                        }
+                        consecutiveSseTransportErrors += 1;
+                        console.warn("SSE connection issue (onerror); waiting for auto-reconnect.", err);
+                        if (consecutiveSseTransportErrors >= maxConsecutiveSseErrors) {
+                            try {
+                                eventSource === null || eventSource === void 0 ? void 0 : eventSource.close();
+                            }
+                            catch { }
+                            void startPollingFallback(`SSE transport failed ${consecutiveSseTransportErrors} times.`);
+                        }
+                    };
+                }
+            }
         }
         return {
             async *[Symbol.asyncIterator]() {
@@ -260,56 +436,19 @@ export class yetter {
             getRequestId: () => requestId,
         };
     }
-    /**
-     * Upload a file from the filesystem (Node.js) or File/Blob object (browser)
-     *
-     * @param fileOrPath File path (Node.js) or File/Blob object (browser)
-     * @param options Upload configuration options
-     * @returns Promise resolving to upload result with public URL
-     *
-     * @example
-     * ```typescript
-     * // Node.js
-     * const result = await yetter.uploadFile("/path/to/image.jpg", {
-     *   onProgress: (pct) => console.log(`Upload: ${pct}%`)
-     * });
-     *
-     * // Browser
-     * const fileInput = document.querySelector('input[type="file"]');
-     * const file = fileInput.files[0];
-     * const result = await yetter.uploadFile(file, {
-     *   onProgress: (pct) => updateProgressBar(pct)
-     * });
-     * ```
-     */
-    static async uploadFile(fileOrPath, options = {}) {
-        if (!_a.apiKey) {
-            throw new Error("API key is not configured. Call yetter.configure()");
-        }
-        if (typeof fileOrPath === 'string') {
-            // Node.js path
-            return _a._uploadFromPath(fileOrPath, options);
-        }
-        else {
-            // Browser File/Blob
-            return _a._uploadFromBlob(fileOrPath, options);
+    async uploadFile(fileOrPath, options = {}) {
+        this.assertApiKeyConfigured();
+        if (typeof fileOrPath === "string") {
+            return this._uploadFromPath(fileOrPath, options);
         }
+        return this._uploadFromBlob(fileOrPath, options);
     }
-    /**
-     * Upload a file from browser (File or Blob object)
-     * This is an alias for uploadFile for better clarity in browser contexts
-     */
-    static async uploadBlob(file, options = {}) {
-        return _a.uploadFile(file, options);
+    async uploadBlob(file, options = {}) {
+        return this.uploadFile(file, options);
     }
-    /**
-     * Upload file from filesystem path (Node.js only)
-     */
-    static async _uploadFromPath(filePath, options) {
-        // Dynamic import for Node.js modules
-        const fs = await import('fs');
-        const mime = await import('mime-types');
-        // Validate file exists
+    async _uploadFromPath(filePath, options) {
+        const fs = await import("fs");
+        const mime = await import("mime-types");
         if (!fs.existsSync(filePath)) {
             throw new Error(`File not found: ${filePath}`);
         }
@@ -317,24 +456,19 @@ export class yetter {
         const fileSize = stats.size;
         const fileName = filePath.split(/[\\/]/).pop() || "upload";
         const mimeType = mime.default.lookup(filePath) || "application/octet-stream";
-        const client = new YetterImageClient({
-            apiKey: _a.apiKey,
-            endpoint: _a.endpoint,
-        });
-        // Step 1: Request presigned URL(s)
+        const uploadTimeoutMs = this.getUploadTimeoutMs(options);
+        const client = this.createApiClient();
         const uploadUrlResponse = await client.getUploadUrl({
             file_name: fileName,
             content_type: mimeType,
             size: fileSize,
         });
-        // Step 2: Upload file content
         if (uploadUrlResponse.mode === "single") {
-            await _a._uploadFileSingle(filePath, uploadUrlResponse.put_url, mimeType, fileSize, options, fs);
+            await this._uploadFileSingle(filePath, uploadUrlResponse.put_url, mimeType, fileSize, options, fs, uploadTimeoutMs);
         }
         else {
-            await _a._uploadFileMultipart(filePath, uploadUrlResponse.part_urls, uploadUrlResponse.part_size, fileSize, options, fs);
+            await this._uploadFileMultipart(filePath, uploadUrlResponse.part_urls, uploadUrlResponse.part_size, fileSize, options, fs, uploadTimeoutMs);
         }
-        // Step 3: Notify completion
         const result = await client.uploadComplete({
             key: uploadUrlResponse.key,
         });
@@ -343,32 +477,23 @@ export class yetter {
         }
         return result;
     }
-    /**
-     * Upload file from Blob/File object (browser)
-     */
-    static async _uploadFromBlob(file, options) {
+    async _uploadFromBlob(file, options) {
         const fileSize = file.size;
-        const fileName = options.filename ||
-            (file instanceof File ? file.name : "blob-upload");
+        const fileName = options.filename || (file instanceof File ? file.name : "blob-upload");
         const mimeType = file.type || "application/octet-stream";
-        const client = new YetterImageClient({
-            apiKey: _a.apiKey,
-            endpoint: _a.endpoint,
-        });
-        // Step 1: Request presigned URL(s)
+        const uploadTimeoutMs = this.getUploadTimeoutMs(options);
+        const client = this.createApiClient();
         const uploadUrlResponse = await client.getUploadUrl({
             file_name: fileName,
             content_type: mimeType,
             size: fileSize,
         });
-        // Step 2: Upload file content
         if (uploadUrlResponse.mode === "single") {
-            await _a._uploadBlobSingle(file, uploadUrlResponse.put_url, mimeType, fileSize, options);
+            await this._uploadBlobSingle(file, uploadUrlResponse.put_url, mimeType, fileSize, options, uploadTimeoutMs);
         }
         else {
-            await _a._uploadBlobMultipart(file, uploadUrlResponse.part_urls, uploadUrlResponse.part_size, fileSize, options);
+            await this._uploadBlobMultipart(file, uploadUrlResponse.part_urls, uploadUrlResponse.part_size, fileSize, options, uploadTimeoutMs);
         }
-        // Step 3: Notify completion
         const result = await client.uploadComplete({
             key: uploadUrlResponse.key,
         });
@@ -377,19 +502,12 @@ export class yetter {
         }
         return result;
     }
-    /**
-     * Upload file using single PUT request (Node.js, private helper)
-     */
-    static async _uploadFileSingle(filePath, presignedUrl, contentType, totalSize, options, fs) {
+    async _uploadFileSingle(filePath, presignedUrl, contentType, totalSize, options, fs, timeoutMs) {
         const fileBuffer = fs.readFileSync(filePath);
-        const response = await fetch(presignedUrl, {
-            method: "PUT",
-            headers: {
-                "Content-Type": contentType,
-                "Content-Length": String(totalSize),
-            },
-            body: fileBuffer,
-        });
+        const response = await this.putWithTimeout(presignedUrl, fileBuffer, {
+            "Content-Type": contentType,
+            "Content-Length": String(totalSize),
+        }, timeoutMs);
         if (!response.ok) {
             const errorText = await response.text();
             throw new Error(`Single-part upload failed (${response.status}): ${errorText}`);
@@ -398,10 +516,7 @@ export class yetter {
             options.onProgress(90);
         }
     }
-    /**
-     * Upload file using multipart upload (Node.js, private helper)
-     */
-    static async _uploadFileMultipart(filePath, partUrls, partSize, totalSize, options, fs) {
+    async _uploadFileMultipart(filePath, partUrls, partSize, totalSize, options, fs, timeoutMs) {
         const sortedParts = [...partUrls].sort((a, b) => a.part_number - b.part_number);
         const fileHandle = fs.openSync(filePath, "r");
         try {
@@ -414,17 +529,12 @@ export class yetter {
                 if (chunk.length === 0) {
                     break;
                 }
-                const response = await fetch(part.url, {
-                    method: "PUT",
-                    headers: {
-                        "Content-Length": String(chunk.length),
-                    },
-                    body: chunk,
-                });
+                const response = await this.putWithTimeout(part.url, chunk, {
+                    "Content-Length": String(chunk.length),
+                }, timeoutMs);
                 if (!response.ok) {
                     const errorText = await response.text();
-                    throw new Error(`Multipart upload failed at part ${part.part_number} ` +
-                        `(${response.status}): ${errorText}`);
+                    throw new Error(`Multipart upload failed at part ${part.part_number} (${response.status}): ${errorText}`);
                 }
                 if (options.onProgress) {
                     const progress = Math.min(90, Math.floor(((i + 1) / sortedParts.length) * 90));
@@ -436,18 +546,10 @@ export class yetter {
             fs.closeSync(fileHandle);
         }
     }
-    /**
-     * Upload blob using single PUT request (browser, private helper)
-     */
-    static async _uploadBlobSingle(blob, presignedUrl, contentType, totalSize, options) {
-        const response = await fetch(presignedUrl, {
-            method: "PUT",
-            headers: {
-                "Content-Type": contentType,
-                "Content-Length": String(totalSize),
-            },
-            body: blob,
-        });
+    async _uploadBlobSingle(blob, presignedUrl, contentType, _totalSize, options, timeoutMs) {
+        const response = await this.putWithTimeout(presignedUrl, blob, {
+            "Content-Type": contentType,
+        }, timeoutMs);
         if (!response.ok) {
             const errorText = await response.text();
             throw new Error(`Single-part upload failed (${response.status}): ${errorText}`);
@@ -456,10 +558,7 @@ export class yetter {
             options.onProgress(90);
         }
     }
-    /**
-     * Upload blob using multipart upload (browser, private helper)
-     */
-    static async _uploadBlobMultipart(blob, partUrls, partSize, totalSize, options) {
+    async _uploadBlobMultipart(blob, partUrls, partSize, totalSize, options, timeoutMs) {
         const sortedParts = [...partUrls].sort((a, b) => a.part_number - b.part_number);
         for (let i = 0; i < sortedParts.length; i++) {
             const part = sortedParts[i];
@@ -469,17 +568,10 @@ export class yetter {
             if (chunk.size === 0) {
                 break;
             }
-            const response = await fetch(part.url, {
-                method: "PUT",
-                headers: {
-                    "Content-Length": String(chunk.size),
-                },
-                body: chunk,
-            });
+            const response = await this.putWithTimeout(part.url, chunk, {}, timeoutMs);
             if (!response.ok) {
                 const errorText = await response.text();
-                throw new Error(`Multipart upload failed at part ${part.part_number} ` +
-                    `(${response.status}): ${errorText}`);
+                throw new Error(`Multipart upload failed at part ${part.part_number} (${response.status}): ${errorText}`);
             }
             if (options.onProgress) {
                 const progress = Math.min(90, Math.floor(((i + 1) / sortedParts.length) * 90));
@@ -488,54 +580,33 @@ export class yetter {
         }
     }
 }
+export class yetter {
+    static configure(options) {
+        this.client.configure(options);
+    }
+    static subscribe(model, options) {
+        return this.client.subscribe(model, options);
+    }
+    static stream(model, options) {
+        return this.client.stream(model, options);
+    }
+    static uploadFile(fileOrPath, options = {}) {
+        return this.client.uploadFile(fileOrPath, options);
+    }
+    static uploadBlob(file, options = {}) {
+        return this.client.uploadBlob(file, options);
+    }
+}
 _a = yetter;
-yetter.apiKey = 'Key ' + (process.env.YTR_API_KEY || process.env.REACT_APP_YTR_API_KEY || "");
-yetter.endpoint = "https://api.yetter.ai";
+yetter.client = new YetterClient();
 yetter.queue = {
     submit: async (model, options) => {
-        if (!_a.apiKey) {
-            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
-        }
-        const client = new YetterImageClient({
-            apiKey: _a.apiKey,
-            endpoint: _a.endpoint
-        });
-        const generateResponse = await client.generate({
-            model: model,
-            ...options.input,
-        });
-        return generateResponse;
+        return _a.client.queue.submit(model, options);
     },
     status: async (model, options) => {
-        if (!_a.apiKey) {
-            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
-        }
-        const client = new YetterImageClient({
-            apiKey: _a.apiKey,
-            endpoint: _a.endpoint
-        });
-        const endpoint = client.getApiEndpoint();
-        const statusUrl = `${endpoint}/${model}/requests/${options.requestId}/status`;
-        const statusData = await client.getStatus({ url: statusUrl });
-        return {
-            data: statusData,
-            requestId: options.requestId,
-        };
+        return _a.client.queue.status(model, options);
     },
     result: async (model, options) => {
-        if (!_a.apiKey) {
-            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
-        }
-        const client = new YetterImageClient({
-            apiKey: _a.apiKey,
-            endpoint: _a.endpoint
-        });
-        const endpoint = client.getApiEndpoint();
-        const responseUrl = `${endpoint}/${model}/requests/${options.requestId}`;
-        const responseData = await client.getResponse({ url: responseUrl });
-        return {
-            data: responseData,
-            requestId: options.requestId,
-        };
-    }
+        return _a.client.queue.result(model, options);
+    },
 };