@yetter/client 0.0.13 → 0.0.14

package/README.md

@@ -146,11 +146,18 @@ This function submits an image generation request and returns an async iterable
 **Features:**
 
 * Initiates a request and establishes an SSE connection.
+* Automatically falls back to status polling if SSE transport repeatedly fails.
 * Provides an `AsyncIterator` (`Symbol.asyncIterator`) to loop through status events (`StreamEvent`).
 * A `done()` method: Returns a Promise that resolves with the final `GetResponseResponse` **after the server emits `event: done`** (successful completion), or rejects if the server emits `event: error` or the final response cannot be fetched.
 * A `cancel()` method: Requests cancellation on the backend; the stream naturally ends when the server emits `data` (with `status: "CANCELLED"`) followed by `event: done`.
 * A `getRequestId()` method: Returns the request ID for the stream.
 
+**Transport options (`StreamOptions`):**
+
+* `disableSse?: boolean` - skip SSE and use polling only.
+* `pollIntervalMs?: number` - polling interval for fallback/forced polling (default: `2000`).
+* `sseMaxConsecutiveErrors?: number` - number of transport errors tolerated before fallback (default: `3`).
+
 **Events (`StreamEvent`):**
 Each event pushed by the stream is an object typically including:
 

package/dist/client.js

@@ -4,6 +4,7 @@ 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));
@@ -173,6 +174,14 @@ export class YetterClient {
         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;
         let resolveDonePromise;
         let rejectDonePromise;
@@ -255,6 +264,40 @@ export class YetterClient {
                 return new Promise((resolve) => this.resolvers.push(resolve));
             },
         };
+        let hasStartedFallbackPolling = false;
+        const terminalStatuses = new Set(["COMPLETED", "ERROR", "CANCELLED"]);
+        const startPollingFallback = async (reason) => {
+            if (controller.isClosed || hasStartedFallbackPolling) {
+                return;
+            }
+            hasStartedFallbackPolling = true;
+            try {
+                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;
+                    }
+                    await sleep(streamPollIntervalMs);
+                }
+            }
+            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)}`));
+            }
+        };
         if (initialApiResponse.status === "COMPLETED") {
             controller.push(initialApiResponse);
             const finalResponse = await client.getResponse({ url: responseUrl });
@@ -269,81 +312,107 @@ export class YetterClient {
             controller.cancel();
         }
         else {
-            eventSource = new EventSourcePolyfill(sseStreamUrl, {
-                headers: { Authorization: this.apiKey },
-                heartbeatTimeout: STREAM_HEARTBEAT_TIMEOUT_MS,
-            });
-            eventSource.onopen = (event) => {
-                console.log("SSE Connection Opened:", event);
-            };
-            eventSource.addEventListener("data", (event) => {
+            if (options.disableSse) {
+                void startPollingFallback("SSE disabled by stream options.");
+            }
+            else {
+                let consecutiveSseTransportErrors = 0;
                 try {
-                    const statusData = JSON.parse(event.data);
-                    controller.push(statusData);
+                    eventSource = new EventSourcePolyfill(sseStreamUrl, {
+                        headers: { Authorization: this.apiKey },
+                        heartbeatTimeout: STREAM_HEARTBEAT_TIMEOUT_MS,
+                    });
                 }
-                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}`));
+                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)}`);
                 }
-            });
-            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 {
-                        controller.error(new Error(`Stream ended without terminal status for ${requestId}`));
-                    }
+                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.`);
+                        }
+                    };
                 }
-                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;
-                }
-                console.warn("SSE connection issue (onerror); waiting for auto-reconnect.", err);
-            };
+            }
         }
         return {
             async *[Symbol.asyncIterator]() {

package/dist/types.d.ts

@@ -79,6 +79,21 @@ export interface StatusResponse {
 }
 export interface StreamOptions {
     input: Omit<GenerateRequest, 'model'>;
+    /**
+     * Disable SSE transport and use status polling only.
+     * Useful when running behind proxies/CDNs that break long-lived SSE over HTTP/2.
+     */
+    disableSse?: boolean;
+    /**
+     * Poll interval used by fallback polling (or when disableSse=true).
+     * Default: 2000ms
+     */
+    pollIntervalMs?: number;
+    /**
+     * Number of consecutive SSE transport errors tolerated before switching to polling.
+     * Default: 3
+     */
+    sseMaxConsecutiveErrors?: number;
 }
 /**
  * Represents an event received from the SSE stream.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yetter/client",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "type": "module",
   "scripts": {
     "build": "tsc",