@bagelink/sdk 1.12.53 → 1.12.57

package/dist/index.cjs

@@ -1265,29 +1265,50 @@ class StreamController {
 }
 
 function createSSEStream(url, options = {}) {
-  const { headers = {}, withCredentials = true } = options;
+  const {
+    headers = {},
+    withCredentials = true,
+    lastEventId: initialLastEventId,
+    maxReconnects = 5,
+    reconnectDelayMs = 1e3
+  } = options;
   const controller = new AbortController();
   const stream = new StreamController(() => {
     controller.abort();
   });
-  fetch(url, {
-    method: "GET",
-    headers: {
+  let lastEventId = initialLastEventId;
+  let reconnectAttempts = 0;
+  async function connect() {
+    const requestHeaders = {
       "Accept": "text/event-stream",
       "Cache-Control": "no-cache",
       ...headers
-    },
-    credentials: withCredentials ? "include" : "same-origin",
-    signal: controller.signal,
-    // Disable keepalive for streaming
-    keepalive: false
-  }).then(async (response) => {
+    };
+    if (lastEventId !== void 0) {
+      requestHeaders["Last-Event-ID"] = lastEventId;
+    }
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "GET",
+        headers: requestHeaders,
+        credentials: withCredentials ? "include" : "same-origin",
+        signal: controller.signal,
+        keepalive: false
+      });
+    } catch (error) {
+      if (error?.name === "AbortError") return;
+      return handleDisconnect(error);
+    }
     if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      stream.emit("error", new Error(`HTTP ${response.status}: ${response.statusText}`));
+      return;
     }
     if (!response.body) {
-      throw new Error("Response body is null");
+      stream.emit("error", new Error("Response body is null"));
+      return;
     }
+    reconnectAttempts = 0;
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
@@ -1295,8 +1316,10 @@ function createSSEStream(url, options = {}) {
       while (true) {
         const { done, value } = await reader.read();
         if (done) {
-          stream.emit("done", {});
-          stream.emit("complete", {});
+          if (!controller.signal.aborted) {
+            stream.emit("done", {});
+            stream.emit("complete", {});
+          }
           break;
         }
         buffer += decoder.decode(value, { stream: true });
@@ -1304,27 +1327,35 @@ function createSSEStream(url, options = {}) {
         buffer = lines.pop() || "";
         let currentEvent = "message";
         let currentData = "";
+        let currentId;
         for (const line of lines) {
-          if (line.startsWith("event:")) {
+          if (line.startsWith("id:")) {
+            currentId = line.slice(3).trim();
+          } else if (line.startsWith("event:")) {
             currentEvent = line.slice(6).trim();
           } else if (line.startsWith("data:")) {
             currentData = line.slice(5).trim();
           } else if (line === "" && currentData) {
+            if (currentId !== void 0) lastEventId = currentId;
             try {
               const parsed = JSON.parse(currentData);
               stream.emit(currentEvent, parsed);
+              if (currentEvent === "done" || currentEvent === "error") {
+                stream.emit("complete", {});
+                return;
+              }
             } catch {
               stream.emit(currentEvent, currentData);
             }
             currentEvent = "message";
             currentData = "";
+            currentId = void 0;
           }
         }
       }
     } catch (error) {
       if (error?.name !== "AbortError") {
-        const errorMessage = error?.message || "Stream connection error";
-        stream.emit("error", new Error(errorMessage));
+        return handleDisconnect(error);
       }
     } finally {
       try {
@@ -1332,11 +1363,20 @@ function createSSEStream(url, options = {}) {
       } catch {
       }
     }
-  }).catch((error) => {
-    if (error?.name !== "AbortError") {
-      const errorMessage = error?.message || "Failed to establish stream connection";
-      stream.emit("error", new Error(errorMessage));
+  }
+  async function handleDisconnect(error) {
+    if (controller.signal.aborted) return;
+    if (reconnectAttempts >= maxReconnects) {
+      const msg = error?.message || "Stream connection lost";
+      stream.emit("error", new Error(`${msg} (gave up after ${maxReconnects} reconnects)`));
+      return;
     }
+    reconnectAttempts++;
+    const delay = reconnectDelayMs * Math.pow(2, reconnectAttempts - 1);
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    if (!controller.signal.aborted) await connect();
+  }
+  connect().catch(() => {
   });
   return stream;
 }

package/dist/index.d.cts

@@ -55,6 +55,20 @@ interface SSEStreamOptions {
     headers?: Record<string, string>;
     /** Whether to include credentials (cookies) with the request */
     withCredentials?: boolean;
+    /**
+     * Last-Event-ID to resume from on reconnect.
+     * The server uses this to replay buffered events from that sequence number.
+     */
+    lastEventId?: string;
+    /**
+     * Maximum number of automatic reconnect attempts (GET streams only).
+     * Set to 0 to disable auto-reconnect. Defaults to 5.
+     */
+    maxReconnects?: number;
+    /**
+     * Base delay in ms between reconnect attempts (exponential backoff). Defaults to 1000.
+     */
+    reconnectDelayMs?: number;
 }
 /**
  * Creates an SSE stream consumer with elegant event-based API

package/dist/index.d.mts

@@ -55,6 +55,20 @@ interface SSEStreamOptions {
     headers?: Record<string, string>;
     /** Whether to include credentials (cookies) with the request */
     withCredentials?: boolean;
+    /**
+     * Last-Event-ID to resume from on reconnect.
+     * The server uses this to replay buffered events from that sequence number.
+     */
+    lastEventId?: string;
+    /**
+     * Maximum number of automatic reconnect attempts (GET streams only).
+     * Set to 0 to disable auto-reconnect. Defaults to 5.
+     */
+    maxReconnects?: number;
+    /**
+     * Base delay in ms between reconnect attempts (exponential backoff). Defaults to 1000.
+     */
+    reconnectDelayMs?: number;
 }
 /**
  * Creates an SSE stream consumer with elegant event-based API

package/dist/index.d.ts

@@ -55,6 +55,20 @@ interface SSEStreamOptions {
     headers?: Record<string, string>;
     /** Whether to include credentials (cookies) with the request */
     withCredentials?: boolean;
+    /**
+     * Last-Event-ID to resume from on reconnect.
+     * The server uses this to replay buffered events from that sequence number.
+     */
+    lastEventId?: string;
+    /**
+     * Maximum number of automatic reconnect attempts (GET streams only).
+     * Set to 0 to disable auto-reconnect. Defaults to 5.
+     */
+    maxReconnects?: number;
+    /**
+     * Base delay in ms between reconnect attempts (exponential backoff). Defaults to 1000.
+     */
+    reconnectDelayMs?: number;
 }
 /**
  * Creates an SSE stream consumer with elegant event-based API

package/dist/index.mjs

@@ -1259,29 +1259,50 @@ class StreamController {
 }
 
 function createSSEStream(url, options = {}) {
-  const { headers = {}, withCredentials = true } = options;
+  const {
+    headers = {},
+    withCredentials = true,
+    lastEventId: initialLastEventId,
+    maxReconnects = 5,
+    reconnectDelayMs = 1e3
+  } = options;
   const controller = new AbortController();
   const stream = new StreamController(() => {
     controller.abort();
   });
-  fetch(url, {
-    method: "GET",
-    headers: {
+  let lastEventId = initialLastEventId;
+  let reconnectAttempts = 0;
+  async function connect() {
+    const requestHeaders = {
       "Accept": "text/event-stream",
       "Cache-Control": "no-cache",
       ...headers
-    },
-    credentials: withCredentials ? "include" : "same-origin",
-    signal: controller.signal,
-    // Disable keepalive for streaming
-    keepalive: false
-  }).then(async (response) => {
+    };
+    if (lastEventId !== void 0) {
+      requestHeaders["Last-Event-ID"] = lastEventId;
+    }
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "GET",
+        headers: requestHeaders,
+        credentials: withCredentials ? "include" : "same-origin",
+        signal: controller.signal,
+        keepalive: false
+      });
+    } catch (error) {
+      if (error?.name === "AbortError") return;
+      return handleDisconnect(error);
+    }
     if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      stream.emit("error", new Error(`HTTP ${response.status}: ${response.statusText}`));
+      return;
     }
     if (!response.body) {
-      throw new Error("Response body is null");
+      stream.emit("error", new Error("Response body is null"));
+      return;
     }
+    reconnectAttempts = 0;
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
@@ -1289,8 +1310,10 @@ function createSSEStream(url, options = {}) {
       while (true) {
         const { done, value } = await reader.read();
         if (done) {
-          stream.emit("done", {});
-          stream.emit("complete", {});
+          if (!controller.signal.aborted) {
+            stream.emit("done", {});
+            stream.emit("complete", {});
+          }
           break;
         }
         buffer += decoder.decode(value, { stream: true });
@@ -1298,27 +1321,35 @@ function createSSEStream(url, options = {}) {
         buffer = lines.pop() || "";
         let currentEvent = "message";
         let currentData = "";
+        let currentId;
         for (const line of lines) {
-          if (line.startsWith("event:")) {
+          if (line.startsWith("id:")) {
+            currentId = line.slice(3).trim();
+          } else if (line.startsWith("event:")) {
             currentEvent = line.slice(6).trim();
           } else if (line.startsWith("data:")) {
             currentData = line.slice(5).trim();
           } else if (line === "" && currentData) {
+            if (currentId !== void 0) lastEventId = currentId;
             try {
               const parsed = JSON.parse(currentData);
               stream.emit(currentEvent, parsed);
+              if (currentEvent === "done" || currentEvent === "error") {
+                stream.emit("complete", {});
+                return;
+              }
             } catch {
               stream.emit(currentEvent, currentData);
             }
             currentEvent = "message";
             currentData = "";
+            currentId = void 0;
           }
         }
       }
     } catch (error) {
       if (error?.name !== "AbortError") {
-        const errorMessage = error?.message || "Stream connection error";
-        stream.emit("error", new Error(errorMessage));
+        return handleDisconnect(error);
       }
     } finally {
       try {
@@ -1326,11 +1357,20 @@ function createSSEStream(url, options = {}) {
       } catch {
       }
     }
-  }).catch((error) => {
-    if (error?.name !== "AbortError") {
-      const errorMessage = error?.message || "Failed to establish stream connection";
-      stream.emit("error", new Error(errorMessage));
+  }
+  async function handleDisconnect(error) {
+    if (controller.signal.aborted) return;
+    if (reconnectAttempts >= maxReconnects) {
+      const msg = error?.message || "Stream connection lost";
+      stream.emit("error", new Error(`${msg} (gave up after ${maxReconnects} reconnects)`));
+      return;
     }
+    reconnectAttempts++;
+    const delay = reconnectDelayMs * Math.pow(2, reconnectAttempts - 1);
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    if (!controller.signal.aborted) await connect();
+  }
+  connect().catch(() => {
   });
   return stream;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bagelink/sdk",
   "type": "module",
-  "version": "1.12.53",
+  "version": "1.12.57",
   "description": "Bagel core sdk packages",
   "author": {
     "name": "Bagel Studio",

package/src/openAPITools/streamClient.ts

@@ -1,7 +1,4 @@
-/* eslint-disable ts/no-unnecessary-condition */
-/* eslint-disable no-await-in-loop */
-/* eslint-disable ts/strict-boolean-expressions */
-/* eslint-disable ts/use-unknown-in-catch-callback-variable */
+ 
 /**
  * SSE (Server-Sent Events) Client Utilities
  * Simple, reliable SSE streaming without event loss
@@ -17,6 +14,20 @@ export interface SSEStreamOptions {
 	headers?: Record<string, string>
 	/** Whether to include credentials (cookies) with the request */
 	withCredentials?: boolean
+	/**
+	 * Last-Event-ID to resume from on reconnect.
+	 * The server uses this to replay buffered events from that sequence number.
+	 */
+	lastEventId?: string
+	/**
+	 * Maximum number of automatic reconnect attempts (GET streams only).
+	 * Set to 0 to disable auto-reconnect. Defaults to 5.
+	 */
+	maxReconnects?: number
+	/**
+	 * Base delay in ms between reconnect attempts (exponential backoff). Defaults to 1000.
+	 */
+	reconnectDelayMs?: number
 }
 
 /**
@@ -40,98 +51,133 @@ export function createSSEStream<TEventMap extends StreamEventMap = StreamEventMa
 	url: string,
 	options: SSEStreamOptions = {}
 ): StreamController<TEventMap> {
-	const { headers = {}, withCredentials = true } = options
-	const controller = new AbortController()
+	const {
+		headers = {},
+		withCredentials = true,
+		lastEventId: initialLastEventId,
+		maxReconnects = 5,
+		reconnectDelayMs = 1000,
+	} = options
 
+	const controller = new AbortController()
 	const stream = new StreamController<TEventMap>(() => { controller.abort() })
 
-	// Start the fetch request
-	fetch(url, {
-		method: 'GET',
-		headers: {
+	let lastEventId = initialLastEventId
+	let reconnectAttempts = 0
+
+	async function connect(): Promise<void> {
+		const requestHeaders: Record<string, string> = {
 			'Accept': 'text/event-stream',
 			'Cache-Control': 'no-cache',
 			...headers,
-		},
-		credentials: withCredentials ? 'include' : 'same-origin',
-		signal: controller.signal,
-		// Disable keepalive for streaming
-		keepalive: false,
-	})
-		.then(async (response) => {
-			if (!response.ok) {
-				throw new Error(`HTTP ${response.status}: ${response.statusText}`)
-			}
+		}
+		if (lastEventId !== undefined) {
+			requestHeaders['Last-Event-ID'] = lastEventId
+		}
 
-			if (!response.body) {
-				throw new Error('Response body is null')
-			}
+		let response: Response
+		try {
+			response = await fetch(url, {
+				method: 'GET',
+				headers: requestHeaders,
+				credentials: withCredentials ? 'include' : 'same-origin',
+				signal: controller.signal,
+				keepalive: false,
+			})
+		} catch (error: any) {
+			if (error?.name === 'AbortError') return
+			return handleDisconnect(error)
+		}
 
-			const reader = response.body.getReader()
-			const decoder = new TextDecoder()
-			let buffer = ''
+		if (!response.ok) {
+			stream.emit('error', new Error(`HTTP ${response.status}: ${response.statusText}`))
+			return
+		}
+		if (!response.body) {
+			stream.emit('error', new Error('Response body is null'))
+			return
+		}
 
-			try {
-				while (true) {
-					const { done, value } = await reader.read()
+		// Successful connection — reset reconnect counter
+		reconnectAttempts = 0
 
-					if (done) {
+		const reader = response.body.getReader()
+		const decoder = new TextDecoder()
+		let buffer = ''
+
+		try {
+			while (true) {
+				const { done, value } = await reader.read()
+
+				if (done) {
+					// Server closed the connection — emit done only if not aborted
+					if (!controller.signal.aborted) {
 						stream.emit('done', {})
 						stream.emit('complete', {})
-						break
 					}
+					break
+				}
 
-					// Decode the chunk and add to buffer
-					buffer += decoder.decode(value, { stream: true })
+				buffer += decoder.decode(value, { stream: true })
+				const lines = buffer.split('\n')
+				buffer = lines.pop() || ''
 
-					// Process complete events in the buffer
-					const lines = buffer.split('\n')
-					buffer = lines.pop() || '' // Keep incomplete line in buffer
+				let currentEvent = 'message'
+				let currentData = ''
+				let currentId: string | undefined
 
-					let currentEvent = 'message'
-					let currentData = ''
+				for (const line of lines) {
+					if (line.startsWith('id:')) {
+						currentId = line.slice(3).trim()
+					} else if (line.startsWith('event:')) {
+						currentEvent = line.slice(6).trim()
+					} else if (line.startsWith('data:')) {
+						currentData = line.slice(5).trim()
+					} else if (line === '' && currentData) {
+						// Track last seen ID for reconnect
+						if (currentId !== undefined) lastEventId = currentId
 
-					for (const line of lines) {
-						if (line.startsWith('event:')) {
-							currentEvent = line.slice(6).trim()
-						} else if (line.startsWith('data:')) {
-							currentData = line.slice(5).trim()
-						} else if (line === '' && currentData) {
-							// Empty line indicates end of event - emit immediately
-							try {
-								const parsed = JSON.parse(currentData)
-								stream.emit(currentEvent, parsed)
-							} catch {
-								// If not valid JSON, emit as string
-								stream.emit(currentEvent, currentData)
+						try {
+							const parsed = JSON.parse(currentData)
+							stream.emit(currentEvent, parsed)
+
+							// Auto-close stream on terminal events
+							if (currentEvent === 'done' || currentEvent === 'error') {
+								stream.emit('complete', {})
+								return
 							}
-							// Reset for next event
-							currentEvent = 'message'
-							currentData = ''
+						} catch {
+							stream.emit(currentEvent, currentData)
 						}
+						currentEvent = 'message'
+						currentData = ''
+						currentId = undefined
 					}
 				}
-			} catch (error: any) {
-				// Handle all stream errors (network errors, protocol errors, etc.)
-				if (error?.name !== 'AbortError') {
-					const errorMessage = error?.message || 'Stream connection error'
-					stream.emit('error', new Error(errorMessage))
-				}
-			} finally {
-				// Clean up reader
-				try {
-					reader.releaseLock()
-				} catch {
-					// Ignore cleanup errors
-				}
 			}
-		})
-		.catch((error: any) => {
+		} catch (error: any) {
 			if (error?.name !== 'AbortError') {
-				const errorMessage = error?.message || 'Failed to establish stream connection'
-				stream.emit('error', new Error(errorMessage))
+				return handleDisconnect(error)
 			}
-		})
+		} finally {
+			try { reader.releaseLock() } catch { /* ignore */ }
+		}
+	}
+
+	async function handleDisconnect(error?: any): Promise<void> {
+		if (controller.signal.aborted) return
+		if (reconnectAttempts >= maxReconnects) {
+			const msg = error?.message || 'Stream connection lost'
+			stream.emit('error', new Error(`${msg} (gave up after ${maxReconnects} reconnects)`))
+			return
+		}
+		reconnectAttempts++
+		const delay = reconnectDelayMs * Math.pow(2, reconnectAttempts - 1) // exponential backoff
+		await new Promise(resolve => setTimeout(resolve, delay))
+		if (!controller.signal.aborted) await connect()
+	}
+
+	connect().catch(() => { /* errors handled inside connect() */ })
 
 	return stream
 }