@agentuity/core 3.0.0-alpha.5 → 3.0.0-alpha.7

package/dist/services/coder/sse.js

@@ -45,7 +45,7 @@
  * })) {
  *   console.log('Event:', event.event, event.data);
  *
- *   if (event.event === 'broadcast' && event.data.event === 'session_complete') {
+ *   if (event.data.type === 'broadcast' && event.data.event === 'session_complete') {
  *     controller.abort(); // Stop the stream
  *   }
  * }
@@ -189,12 +189,124 @@ async function buildSSEUrl(sessionId, options) {
     const queryString = params.toString();
     return queryString ? `${baseUrl}${path}?${queryString}` : `${baseUrl}${path}`;
 }
-function getSSEData(event) {
-    const msgEvent = event;
-    if (typeof msgEvent.data === 'string') {
-        return msgEvent.data;
+const TYPED_TRANSPORT_EVENTS = new Set(['snapshot', 'hydration', 'presence', 'broadcast']);
+function isAbortError(err) {
+    return err instanceof Error && err.name === 'AbortError';
+}
+function parseSSEFrame(block) {
+    let event = 'message';
+    const dataLines = [];
+    for (const line of block.split('\n')) {
+        if (!line || line.startsWith(':'))
+            continue;
+        const separatorIndex = line.indexOf(':');
+        const field = separatorIndex === -1 ? line : line.slice(0, separatorIndex);
+        let value = separatorIndex === -1 ? '' : line.slice(separatorIndex + 1);
+        if (value.startsWith(' ')) {
+            value = value.slice(1);
+        }
+        if (field === 'event') {
+            event = value || 'message';
+        }
+        else if (field === 'data') {
+            dataLines.push(value);
+        }
+    }
+    if (dataLines.length === 0) {
+        return null;
+    }
+    return {
+        event,
+        data: dataLines.join('\n'),
+    };
+}
+function consumeSSEBuffer(rawBuffer, onFrame) {
+    const normalized = rawBuffer.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    let cursor = 0;
+    while (true) {
+        const boundary = normalized.indexOf('\n\n', cursor);
+        if (boundary === -1)
+            break;
+        const block = normalized.slice(cursor, boundary);
+        cursor = boundary + 2;
+        if (!block.trim())
+            continue;
+        const frame = parseSSEFrame(block);
+        if (frame) {
+            onFrame(frame);
+        }
+    }
+    return normalized.slice(cursor);
+}
+function decodeCoderSSEEvent(frame, sessionId) {
+    let parsed;
+    try {
+        parsed = JSON.parse(frame.data);
+    }
+    catch (err) {
+        throw new CoderSSEError({
+            message: `Failed to parse SSE ${frame.event} event: ${err instanceof Error ? err.message : String(err)}`,
+            code: 'parse_error',
+            sessionId,
+        });
+    }
+    const payload = TYPED_TRANSPORT_EVENTS.has(frame.event) && parsed && typeof parsed === 'object'
+        ? { type: frame.event, ...parsed }
+        : parsed;
+    const result = ObserverSseMessageSchema.safeParse(payload);
+    if (!result.success) {
+        throw new CoderSSEError({
+            message: `Invalid SSE ${frame.event} event format`,
+            code: 'parse_error',
+            sessionId,
+        });
+    }
+    const event = frame.event === 'message' ? result.data.type : frame.event;
+    return { event, data: result.data };
+}
+async function readSSEStream(response, signal, onEvent, sessionId) {
+    if (!response.body) {
+        throw new CoderSSEError({
+            message: 'SSE response did not include a readable body',
+            code: 'connection_failed',
+            sessionId,
+        });
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        while (!signal.aborted) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            buffer = consumeSSEBuffer(buffer, (frame) => {
+                onEvent(decodeCoderSSEEvent(frame, sessionId));
+            });
+        }
+    }
+    finally {
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // Some runtimes throw if the reader is already released after abort.
+        }
+    }
+}
+function buildConnectionError(response, sessionId) {
+    return new CoderSSEError({
+        message: `SSE connection failed: ${response.status} ${response.statusText || 'HTTP error'}`,
+        code: response.status === 401 || response.status === 403 ? 'auth_failed' : 'connection_failed',
+        sessionId,
+    });
+}
+function isRetryableStreamError(error) {
+    if (error instanceof CoderSSEError) {
+        return error.code === 'connection_failed';
     }
-    return null;
+    return true;
 }
 /**
  * Class-based SSE client for observing Coder Hub sessions.
@@ -225,7 +337,7 @@ function getSSEData(event) {
 export class CoderSSEClient {
     #options;
     #state = 'closed';
-    #eventSource = null;
+    #abortController = null;
     #reconnectAttempts = 0;
     #reconnectTimer = null;
     #intentionallyClosed = false;
@@ -267,7 +379,7 @@ export class CoderSSEClient {
      * Whether the client is currently connected and receiving events.
      */
     get isConnected() {
-        return this.#state === 'connected' && this.#eventSource?.readyState === 1;
+        return this.#state === 'connected' && this.#abortController !== null;
     }
     /**
      * Establish the SSE connection and start receiving events.
@@ -298,9 +410,9 @@ export class CoderSSEClient {
             clearTimeout(this.#reconnectTimer);
             this.#reconnectTimer = null;
         }
-        if (this.#eventSource) {
-            this.#eventSource.close();
-            this.#eventSource = null;
+        if (this.#abortController) {
+            this.#abortController.abort();
+            this.#abortController = null;
         }
         this.#state = 'closed';
         this.#options.onClose?.();
@@ -308,50 +420,20 @@ export class CoderSSEClient {
     #setState(state) {
         this.#state = state;
     }
-    #handleEvent(eventName, typeOverride) {
-        this.#eventSource.addEventListener(eventName, (event) => {
-            const data = getSSEData(event);
-            if (!data)
-                return;
-            try {
-                const parsed = JSON.parse(data);
-                const payload = typeOverride ? { type: typeOverride, ...parsed } : parsed;
-                const result = ObserverSseMessageSchema.safeParse(payload);
-                if (result.success) {
-                    const semanticEvent = typeOverride || result.data.type;
-                    const sseEvent = { event: semanticEvent, data: result.data };
-                    this.#options.onEvent?.(sseEvent);
-                    if (result.data.type === 'snapshot') {
-                        this.#options.onSnapshot?.(result.data);
-                    }
-                    else if (result.data.type === 'hydration') {
-                        this.#options.onHydration?.(result.data);
-                    }
-                    else if (result.data.type === 'presence') {
-                        this.#options.onPresence?.(result.data);
-                    }
-                    else if (result.data.type === 'broadcast') {
-                        this.#options.onBroadcast?.(result.data);
-                    }
-                }
-                else {
-                    const parseError = new CoderSSEError({
-                        message: `Invalid SSE ${eventName} event format`,
-                        code: 'parse_error',
-                        sessionId: this.#options.sessionId,
-                    });
-                    this.#options.onError?.(parseError);
-                }
-            }
-            catch (err) {
-                const parseError = new CoderSSEError({
-                    message: `Failed to parse SSE ${eventName} event: ${err instanceof Error ? err.message : String(err)}`,
-                    code: 'parse_error',
-                    sessionId: this.#options.sessionId,
-                });
-                this.#options.onError?.(parseError);
-            }
-        });
+    #dispatchEvent(event) {
+        this.#options.onEvent?.(event);
+        if (event.data.type === 'snapshot') {
+            this.#options.onSnapshot?.(event.data);
+        }
+        else if (event.data.type === 'hydration') {
+            this.#options.onHydration?.(event.data);
+        }
+        else if (event.data.type === 'presence') {
+            this.#options.onPresence?.(event.data);
+        }
+        else if (event.data.type === 'broadcast') {
+            this.#options.onBroadcast?.(event.data);
+        }
     }
     async #connectInternal() {
         if (this.#intentionallyClosed) {
@@ -370,46 +452,60 @@ export class CoderSSEClient {
         if (this.#intentionallyClosed || this.#state === 'closed') {
             return;
         }
-        // Workaround for bun-types EventSource constructor typing issue.
-        // The type definitions don't match the runtime signature, so we use
-        // a double type assertion to construct EventSource with a URL parameter.
+        const controller = new AbortController();
+        this.#abortController = controller;
+        let response;
         try {
-            const EventSourceCtor = EventSource;
-            this.#eventSource = new EventSourceCtor(url);
+            response = await fetch(url, {
+                headers: {
+                    accept: 'text/event-stream',
+                },
+                signal: controller.signal,
+            });
         }
         catch (err) {
+            this.#abortController = null;
+            if (this.#intentionallyClosed || isAbortError(err)) {
+                this.#setState('closed');
+                return;
+            }
             this.#setState('closed');
             this.#options.onError?.(new CoderSSEError({
-                message: `Failed to create EventSource: ${err instanceof Error ? err.message : String(err)}`,
+                message: `Failed to connect SSE stream: ${err instanceof Error ? err.message : String(err)}`,
                 code: 'connection_failed',
                 sessionId: this.#options.sessionId,
             }));
             this.#scheduleReconnect();
             return;
         }
-        this.#eventSource.onerror = () => {
-            // Notify caller of transient error before reconnecting
-            this.#options.onError?.(new Error('EventSource transient error'));
-            if (this.#eventSource) {
-                this.#eventSource.close();
-                this.#eventSource = null;
-            }
-            if (this.#intentionallyClosed) {
-                return;
-            }
+        if (!response.ok) {
+            this.#abortController = null;
+            this.#setState('closed');
+            this.#options.onError?.(buildConnectionError(response, this.#options.sessionId));
             this.#scheduleReconnect();
-        };
-        this.#eventSource.onopen = () => {
+            return;
+        }
+        try {
             this.#reconnectAttempts = 0;
             this.#setState('connected');
             this.#options.logger.debug('SSE connection established for session %s', this.#options.sessionId);
             this.#options.onOpen?.();
-        };
-        this.#handleEvent('snapshot', 'snapshot');
-        this.#handleEvent('hydration', 'hydration');
-        this.#handleEvent('presence', 'presence');
-        this.#handleEvent('broadcast', 'broadcast');
-        this.#handleEvent('message');
+            await readSSEStream(response, controller.signal, (event) => this.#dispatchEvent(event), this.#options.sessionId);
+        }
+        catch (err) {
+            if (this.#intentionallyClosed || isAbortError(err)) {
+                return;
+            }
+            this.#options.onError?.(err instanceof Error ? err : new Error(String(err)));
+        }
+        finally {
+            if (this.#abortController === controller) {
+                this.#abortController = null;
+            }
+        }
+        if (!this.#intentionallyClosed) {
+            this.#scheduleReconnect();
+        }
     }
     #scheduleReconnect() {
         if (this.#intentionallyClosed || !this.#options.reconnect) {
@@ -498,13 +594,14 @@ export async function* streamCoderSessionSSE(options) {
     if (signal?.aborted) {
         return;
     }
-    let eventSource = null;
+    let activeController = null;
     let reconnectAttempts = 0;
     const buffer = [];
     const MAX_BUFFER = 1000;
     let resolve = null;
     let done = false;
     let terminalError = null;
+    let reconnectTimer = null;
     const wake = () => {
         if (resolve) {
             resolve();
@@ -512,51 +609,55 @@ export async function* streamCoderSessionSSE(options) {
         }
     };
     const cleanup = () => {
-        if (eventSource) {
-            eventSource.close();
-            eventSource = null;
+        if (reconnectTimer !== null) {
+            clearTimeout(reconnectTimer);
+            reconnectTimer = null;
+        }
+        if (activeController) {
+            activeController.abort();
+            activeController = null;
         }
     };
-    const handleSSEEvent = (eventName, typeOverride) => {
-        eventSource.addEventListener(eventName, (event) => {
-            const data = getSSEData(event);
-            if (!data)
-                return;
-            try {
-                const parsed = JSON.parse(data);
-                const payload = typeOverride ? { type: typeOverride, ...parsed } : parsed;
-                const result = ObserverSseMessageSchema.safeParse(payload);
-                if (result.success) {
-                    if (buffer.length >= MAX_BUFFER) {
-                        buffer.shift();
-                        logger.debug('SSE buffer full, dropped oldest event');
-                    }
-                    const semanticEvent = typeOverride || result.data.type;
-                    buffer.push({ event: semanticEvent, data: result.data });
-                    wake();
-                }
-                else {
-                    terminalError = new CoderSSEError({
-                        message: `Invalid SSE ${eventName} event format`,
-                        code: 'parse_error',
-                        sessionId: options.sessionId,
-                    });
-                    done = true;
-                    wake();
-                    return;
-                }
-            }
-            catch (err) {
-                terminalError = new CoderSSEError({
-                    message: `Failed to parse SSE ${eventName} event: ${err instanceof Error ? err.message : String(err)}`,
-                    code: 'parse_error',
-                    sessionId: options.sessionId,
-                });
-                done = true;
-                wake();
-                return;
-            }
-        });
+    const finish = (error) => {
+        if (error) {
+            terminalError = error;
+        }
+        done = true;
+        wake();
+    };
+    const scheduleReconnect = (error) => {
+        if (done) {
+            return;
+        }
+        if (signal?.aborted || (error && isAbortError(error))) {
+            finish();
+            return;
+        }
+        if (error && !isRetryableStreamError(error)) {
+            finish(error);
+            return;
+        }
+        if (!reconnect) {
+            finish(error);
+            return;
+        }
+        if (reconnectAttempts >= maxReconnectAttempts) {
+            finish(new CoderSSEError({
+                message: `Exceeded maximum reconnection attempts (${maxReconnectAttempts})`,
+                code: 'max_reconnects_exceeded',
+                sessionId: options.sessionId,
+            }));
+            return;
+        }
+        const baseDelay = reconnectDelayMs * 2 ** reconnectAttempts;
+        const jitter = 0.5 + Math.random() * 0.5;
+        const delay = Math.min(Math.floor(baseDelay * jitter), maxReconnectDelayMs);
+        reconnectAttempts++;
+        logger.debug('SSE connection lost, reconnecting in %dms (attempt %d)', delay, reconnectAttempts);
+        reconnectTimer = setTimeout(() => {
+            reconnectTimer = null;
+            void connect();
+        }, delay);
     };
     const connect = async () => {
         if (done || signal?.aborted) {
@@ -570,82 +671,92 @@ export async function* streamCoderSessionSSE(options) {
             });
         }
         catch (err) {
-            terminalError = err;
-            done = true;
-            wake();
+            finish(err instanceof Error ? err : new Error(String(err)));
             return;
         }
         if (signal?.aborted) {
-            done = true;
-            wake();
+            finish();
             return;
         }
-        // Workaround for bun-types EventSource constructor typing issue (see above).
+        const controller = new AbortController();
+        activeController = controller;
+        const abortFromCaller = () => controller.abort();
+        signal?.addEventListener('abort', abortFromCaller, { once: true });
+        let response;
         try {
-            const EventSourceCtor = EventSource;
-            eventSource = new EventSourceCtor(url);
+            response = await fetch(url, {
+                headers: {
+                    accept: 'text/event-stream',
+                },
+                signal: controller.signal,
+            });
         }
         catch (err) {
-            terminalError = new CoderSSEError({
-                message: `Failed to create EventSource: ${err instanceof Error ? err.message : String(err)}`,
-                code: 'connection_failed',
-                sessionId: options.sessionId,
-            });
-            done = true;
-            wake();
+            signal?.removeEventListener('abort', abortFromCaller);
+            if (activeController === controller) {
+                activeController = null;
+            }
+            if (signal?.aborted || isAbortError(err)) {
+                finish();
+                return;
+            }
+            const error = err instanceof CoderSSEError
+                ? err
+                : new CoderSSEError({
+                    message: `Failed to connect SSE stream: ${err instanceof Error ? err.message : String(err)}`,
+                    code: 'connection_failed',
+                    sessionId: options.sessionId,
+                });
+            scheduleReconnect(error);
             return;
         }
         if (signal?.aborted) {
+            signal?.removeEventListener('abort', abortFromCaller);
             cleanup();
-            done = true;
-            wake();
+            finish();
             return;
         }
-        eventSource.onerror = () => {
-            cleanup();
-            if (signal?.aborted) {
-                done = true;
-                wake();
-                return;
+        if (!response.ok) {
+            signal?.removeEventListener('abort', abortFromCaller);
+            if (activeController === controller) {
+                activeController = null;
             }
-            if (reconnect && reconnectAttempts < maxReconnectAttempts) {
-                const baseDelay = reconnectDelayMs * 2 ** reconnectAttempts;
-                const jitter = 0.5 + Math.random() * 0.5;
-                const delay = Math.min(Math.floor(baseDelay * jitter), maxReconnectDelayMs);
-                reconnectAttempts++;
-                logger.debug('SSE connection lost, reconnecting in %dms (attempt %d)', delay, reconnectAttempts);
-                setTimeout(() => {
-                    connect();
-                }, delay);
+            scheduleReconnect(buildConnectionError(response, options.sessionId));
+            return;
+        }
+        reconnectAttempts = 0;
+        logger.debug('SSE connection established for session %s', options.sessionId);
+        let readFailed = false;
+        void readSSEStream(response, controller.signal, (event) => {
+            if (buffer.length >= MAX_BUFFER) {
+                buffer.shift();
+                logger.debug('SSE buffer full, dropped oldest event');
             }
-            else if (reconnect) {
-                terminalError = new CoderSSEError({
-                    message: `Exceeded maximum reconnection attempts (${maxReconnectAttempts})`,
-                    code: 'max_reconnects_exceeded',
-                    sessionId: options.sessionId,
-                });
-                done = true;
-                wake();
+            buffer.push(event);
+            wake();
+        }, options.sessionId)
+            .catch((err) => {
+            readFailed = true;
+            scheduleReconnect(err instanceof Error ? err : new Error(String(err)));
+        })
+            .finally(() => {
+            signal?.removeEventListener('abort', abortFromCaller);
+            if (activeController === controller) {
+                activeController = null;
             }
-            else {
-                done = true;
-                wake();
+            if (done || signal?.aborted) {
+                finish();
+                return;
             }
-        };
-        eventSource.onopen = () => {
-            reconnectAttempts = 0;
-            logger.debug('SSE connection established for session %s', options.sessionId);
-        };
-        handleSSEEvent('snapshot', 'snapshot');
-        handleSSEEvent('hydration', 'hydration');
-        handleSSEEvent('presence', 'presence');
-        handleSSEEvent('broadcast', 'broadcast');
-        handleSSEEvent('message');
+            if (readFailed) {
+                return;
+            }
+            scheduleReconnect();
+        });
     };
     const onAbort = () => {
-        done = true;
         cleanup();
-        wake();
+        finish();
     };
     signal?.addEventListener('abort', onAbort, { once: true });
     await connect();
@@ -670,6 +781,7 @@ export async function* streamCoderSessionSSE(options) {
     }
     finally {
         signal?.removeEventListener('abort', onAbort);
+        done = true;
         cleanup();
     }
 }