@langgraph-js/pure-graph 3.2.0 → 3.2.2

package/dist/adapter/fetch/index.js

@@ -1,5 +1,5 @@
-import { s as serialiseAsDict, a as streamState, g as getGraph, L as LangGraphGlobal } from '../../stream-pZfO6Y-p.js';
-import { c as createEndpoint } from '../../createEndpoint-C2KsYHDx.js';
+import { s as serialiseAsDict, a as streamState, g as getGraph, L as LangGraphGlobal } from '../../stream-jYlUzTZO.js';
+import { c as createEndpoint } from '../../createEndpoint-vMmFiMSz.js';
 import z from 'zod';
 import camelcaseKeys from 'camelcase-keys';
 
@@ -284,13 +284,15 @@ function errorResponse(error, status = 500) {
 function createSSEStream(streamFn) {
   let controller;
   let isClosed = false;
+  const abortController = new AbortController();
   const stream = new ReadableStream({
     async start(ctrl) {
       controller = ctrl;
       const encoder = new TextEncoder();
       const writer = {
+        signal: abortController.signal,
         writeSSE: async ({ data, event, id }) => {
-          if (isClosed) {
+          if (isClosed || abortController.signal.aborted) {
             return;
           }
           try {
@@ -308,7 +310,7 @@ function createSSEStream(streamFn) {
 `;
             controller.enqueue(encoder.encode(message));
           } catch (error) {
-            if (!isClosed) {
+            if (!isClosed && !abortController.signal.aborted) {
               throw error;
             }
           }
@@ -326,7 +328,9 @@ function createSSEStream(streamFn) {
       try {
         await streamFn(writer);
       } catch (error) {
-        console.error("SSE stream error:", error);
+        if (!abortController.signal.aborted) {
+          console.error("SSE stream error:", error);
+        }
       } finally {
         if (!isClosed) {
           isClosed = true;
@@ -339,6 +343,9 @@ function createSSEStream(streamFn) {
     },
     cancel() {
       isClosed = true;
+      if (!abortController.signal.aborted) {
+        abortController.abort("Client disconnected");
+      }
     }
   });
   return new Response(stream, {
@@ -352,32 +359,42 @@ function createSSEStream(streamFn) {
 function withHeartbeat(streamFn, heartbeatInterval = process.env.HEARTBEAT_INTERVAL ? parseInt(process.env.HEARTBEAT_INTERVAL) : 1500) {
   return async (writer) => {
     let heartbeatTimer = null;
-    const startHeartbeat = () => {
+    let isCleaningUp = false;
+    const stopHeartbeat = () => {
       if (heartbeatTimer) {
         clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
       }
+    };
+    const startHeartbeat = () => {
+      stopHeartbeat();
       heartbeatTimer = setInterval(async () => {
+        if (writer.signal.aborted || isCleaningUp) {
+          stopHeartbeat();
+          return;
+        }
         try {
           await writer.writeSSE({ event: "ping", data: "{}" });
         } catch (error) {
-          if (heartbeatTimer) {
-            clearInterval(heartbeatTimer);
-            heartbeatTimer = null;
-          }
+          stopHeartbeat();
         }
       }, heartbeatInterval);
     };
-    const stopHeartbeat = () => {
-      if (heartbeatTimer) {
-        clearInterval(heartbeatTimer);
-        heartbeatTimer = null;
-      }
+    const abortHandler = () => {
+      stopHeartbeat();
     };
+    writer.signal.addEventListener("abort", abortHandler);
     const proxiedWriter = {
+      signal: writer.signal,
       writeSSE: async (data) => {
+        if (writer.signal.aborted) {
+          return;
+        }
         stopHeartbeat();
         await writer.writeSSE(data);
-        startHeartbeat();
+        if (!writer.signal.aborted) {
+          startHeartbeat();
+        }
       },
       close: () => {
         stopHeartbeat();
@@ -388,7 +405,9 @@ function withHeartbeat(streamFn, heartbeatInterval = process.env.HEARTBEAT_INTER
     try {
       await streamFn(proxiedWriter);
     } finally {
+      isCleaningUp = true;
       stopHeartbeat();
+      writer.signal.removeEventListener("abort", abortHandler);
     }
   };
 }
@@ -715,12 +734,37 @@ async function streamRun(req, context) {
         if (langgraphContext) {
           Object.assign(payload.config.configurable, langgraphContext);
         }
-        for await (const { event, data } of client.runs.stream(
-          thread_id,
-          payload.assistant_id,
-          camelcaseKeys(payload)
-        )) {
-          await writer.writeSSE({ data: serialiseAsDict(data) ?? "", event });
+        let generator = null;
+        let isCleaningUp = false;
+        const abortHandler = () => {
+          isCleaningUp = true;
+        };
+        writer.signal.addEventListener("abort", abortHandler);
+        try {
+          generator = client.runs.stream(
+            thread_id,
+            payload.assistant_id,
+            camelcaseKeys(payload)
+          );
+          for await (const { event, data } of generator) {
+            if (isCleaningUp || writer.signal.aborted) {
+              break;
+            }
+            await writer.writeSSE({ data: serialiseAsDict(data) ?? "", event });
+          }
+        } catch (error) {
+          if (!writer.signal.aborted && !isCleaningUp) {
+            throw error;
+          }
+        } finally {
+          writer.signal.removeEventListener("abort", abortHandler);
+          if (generator) {
+            try {
+              await generator.return(void 0);
+            } catch (e) {
+            }
+            generator = null;
+          }
         }
       })
     );
@@ -737,19 +781,33 @@ async function joinRunStream(req, context) {
     return createSSEStream(
       withHeartbeat(async (writer) => {
         const controller = new AbortController();
-        if (cancel_on_disconnect) {
-          const cleanup = () => {
-            controller.abort("Client disconnected");
-          };
-          req.signal?.addEventListener("abort", cleanup);
+        let generator = null;
+        let isCleaningUp = false;
+        const abortHandlers = [];
+        const cleanup = () => {
+          controller.abort("Client disconnected");
+        };
+        if (req.signal) {
+          req.signal.addEventListener("abort", cleanup);
+          abortHandlers.push({ signal: req.signal, handler: cleanup });
         }
+        const writerAbortHandler = () => {
+          isCleaningUp = true;
+          controller.abort("SSE stream closed");
+        };
+        writer.signal.addEventListener("abort", writerAbortHandler);
+        abortHandlers.push({ signal: writer.signal, handler: writerAbortHandler });
         try {
-          for await (const { event, data, id } of client.runs.joinStream(thread_id, run_id, {
+          generator = client.runs.joinStream(thread_id, run_id, {
             signal: controller.signal,
             cancelOnDisconnect: cancel_on_disconnect,
             lastEventId: last_event_id,
             streamMode: stream_mode ? [stream_mode] : void 0
-          })) {
+          });
+          for await (const { event, data, id } of generator) {
+            if (isCleaningUp || writer.signal.aborted || controller.signal.aborted) {
+              break;
+            }
             await writer.writeSSE({
               data: serialiseAsDict(data) ?? "",
               event,
@@ -757,7 +815,8 @@ async function joinRunStream(req, context) {
             });
           }
         } catch (error) {
-          if (!(error instanceof Error) || !error.message.includes("user cancel")) {
+          const isAbortError = controller.signal.aborted || writer.signal.aborted;
+          if (!isAbortError && !(error instanceof Error && error.message.includes("user cancel"))) {
             console.error("Join stream error:", error);
             await writer.writeSSE({
               event: "error",
@@ -766,6 +825,20 @@ async function joinRunStream(req, context) {
               })
             });
           }
+        } finally {
+          for (const { signal, handler } of abortHandlers) {
+            try {
+              signal.removeEventListener("abort", handler);
+            } catch (e) {
+            }
+          }
+          if (generator) {
+            try {
+              await generator.return(void 0);
+            } catch (e) {
+            }
+            generator = null;
+          }
         }
       })
     );
@@ -819,6 +892,7 @@ async function createRun(req, context) {
     const threads = client.threads;
     const run = await threads.createRun(thread_id, payload.assistant_id, camelPayload);
     (async () => {
+      let queueCleared = false;
       try {
         for await (const _ of streamState(threads, run, camelPayload, {
           attempt: 0,
@@ -827,6 +901,14 @@ async function createRun(req, context) {
         }
       } catch (error) {
         console.error("Background run error:", error);
+      } finally {
+        if (!queueCleared) {
+          queueCleared = true;
+          try {
+            await LangGraphGlobal.globalMessageQueue.removeQueue(run.run_id);
+          } catch (e) {
+          }
+        }
       }
     })();
     return jsonResponse(run, 200, {
@@ -955,6 +1037,7 @@ async function createStatelessRun(req, context) {
     camelPayload.temporary = true;
     const run = await threads.createRun(thread.thread_id, payload.assistant_id, camelPayload);
     (async () => {
+      let queueCleared = false;
       try {
         for await (const _ of streamState(threads, run, camelPayload, {
           attempt: 0,
@@ -969,6 +1052,13 @@ async function createStatelessRun(req, context) {
         } catch (e) {
           console.error("Error cleaning up temporary thread:", e);
         }
+        if (!queueCleared) {
+          queueCleared = true;
+          try {
+            await LangGraphGlobal.globalMessageQueue.removeQueue(run.run_id);
+          } catch (e) {
+          }
+        }
       }
     })();
     return jsonResponse(run, 200, {
@@ -1092,6 +1182,7 @@ async function createBatchRuns(req, context) {
         camelPayload.temporary = true;
         const run = await threads.createRun(thread.thread_id, payload.assistant_id, camelPayload);
         (async () => {
+          let queueCleared = false;
           try {
             for await (const _ of streamState(threads, run, camelPayload, {
               attempt: 0,
@@ -1106,6 +1197,13 @@ async function createBatchRuns(req, context) {
             } catch (e) {
               console.error("Error cleaning up temporary thread:", e);
             }
+            if (!queueCleared) {
+              queueCleared = true;
+              try {
+                await LangGraphGlobal.globalMessageQueue.removeQueue(run.run_id);
+              } catch (e) {
+              }
+            }
           }
         })();
         return { thread_id: thread.thread_id, run_id: run.run_id };