@langchain/langgraph-sdk 0.0.86 → 0.0.88

package/dist/client.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Client = exports.StoreClient = exports.RunsClient = exports.ThreadsClient = exports.AssistantsClient = exports.CronsClient = exports.getApiKey = void 0;
+exports.getClientConfigHash = exports.Client = exports.StoreClient = exports.RunsClient = exports.ThreadsClient = exports.AssistantsClient = exports.CronsClient = exports.getApiKey = void 0;
 const async_caller_js_1 = require("./utils/async_caller.cjs");
 const env_js_1 = require("./utils/env.cjs");
 const signals_js_1 = require("./utils/signals.cjs");
@@ -651,8 +651,8 @@ class RunsClient extends BaseClient {
         if (runMetadata)
             payload?.onRunCreated?.(runMetadata);
         const stream = (response.body || new ReadableStream({ start: (ctrl) => ctrl.close() }))
-            .pipeThrough(new sse_js_1.BytesLineDecoder())
-            .pipeThrough(new sse_js_1.SSEDecoder());
+            .pipeThrough((0, sse_js_1.BytesLineDecoder)())
+            .pipeThrough((0, sse_js_1.SSEDecoder)());
         yield* stream_js_1.IterableReadableStream.fromReadableStream(stream);
     }
     /**
@@ -864,8 +864,8 @@ class RunsClient extends BaseClient {
             },
         }));
         const stream = (response.body || new ReadableStream({ start: (ctrl) => ctrl.close() }))
-            .pipeThrough(new sse_js_1.BytesLineDecoder())
-            .pipeThrough(new sse_js_1.SSEDecoder());
+            .pipeThrough((0, sse_js_1.BytesLineDecoder)())
+            .pipeThrough((0, sse_js_1.SSEDecoder)());
         yield* stream_js_1.IterableReadableStream.fromReadableStream(stream);
     }
     /**
@@ -1156,6 +1156,28 @@ class Client {
             writable: true,
             value: void 0
         });
+        /**
+         * @internal Used to obtain a stable key representing the client.
+         */
+        Object.defineProperty(this, "~configHash", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this["~configHash"] = (() => JSON.stringify({
+            apiUrl: config?.apiUrl,
+            apiKey: config?.apiKey,
+            timeoutMs: config?.timeoutMs,
+            defaultHeaders: config?.defaultHeaders,
+            maxConcurrency: config?.callerOptions?.maxConcurrency,
+            maxRetries: config?.callerOptions?.maxRetries,
+            callbacks: {
+                onFailedResponseHook: config?.callerOptions?.onFailedResponseHook != null,
+                onRequest: config?.onRequest != null,
+                fetch: config?.callerOptions?.fetch != null,
+            },
+        }))();
         this.assistants = new AssistantsClient(config);
         this.threads = new ThreadsClient(config);
         this.runs = new RunsClient(config);
@@ -1165,3 +1187,10 @@ class Client {
     }
 }
 exports.Client = Client;
+/**
+ * @internal Used to obtain a stable key representing the client.
+ */
+function getClientConfigHash(client) {
+    return client["~configHash"];
+}
+exports.getClientConfigHash = getClientConfigHash;

package/dist/client.d.ts

@@ -596,6 +596,14 @@ export declare class Client<TStateType = DefaultValues, TUpdateType = TStateType
      * @internal Used by LoadExternalComponent and the API might change in the future.
      */
     "~ui": UiClient;
+    /**
+     * @internal Used to obtain a stable key representing the client.
+     */
+    private "~configHash";
     constructor(config?: ClientConfig);
 }
+/**
+ * @internal Used to obtain a stable key representing the client.
+ */
+export declare function getClientConfigHash(client: Client): string | undefined;
 export {};

package/dist/client.js

@@ -644,8 +644,8 @@ export class RunsClient extends BaseClient {
         if (runMetadata)
             payload?.onRunCreated?.(runMetadata);
         const stream = (response.body || new ReadableStream({ start: (ctrl) => ctrl.close() }))
-            .pipeThrough(new BytesLineDecoder())
-            .pipeThrough(new SSEDecoder());
+            .pipeThrough(BytesLineDecoder())
+            .pipeThrough(SSEDecoder());
         yield* IterableReadableStream.fromReadableStream(stream);
     }
     /**
@@ -857,8 +857,8 @@ export class RunsClient extends BaseClient {
             },
         }));
         const stream = (response.body || new ReadableStream({ start: (ctrl) => ctrl.close() }))
-            .pipeThrough(new BytesLineDecoder())
-            .pipeThrough(new SSEDecoder());
+            .pipeThrough(BytesLineDecoder())
+            .pipeThrough(SSEDecoder());
         yield* IterableReadableStream.fromReadableStream(stream);
     }
     /**
@@ -1147,6 +1147,28 @@ export class Client {
             writable: true,
             value: void 0
         });
+        /**
+         * @internal Used to obtain a stable key representing the client.
+         */
+        Object.defineProperty(this, "~configHash", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this["~configHash"] = (() => JSON.stringify({
+            apiUrl: config?.apiUrl,
+            apiKey: config?.apiKey,
+            timeoutMs: config?.timeoutMs,
+            defaultHeaders: config?.defaultHeaders,
+            maxConcurrency: config?.callerOptions?.maxConcurrency,
+            maxRetries: config?.callerOptions?.maxRetries,
+            callbacks: {
+                onFailedResponseHook: config?.callerOptions?.onFailedResponseHook != null,
+                onRequest: config?.onRequest != null,
+                fetch: config?.callerOptions?.fetch != null,
+            },
+        }))();
         this.assistants = new AssistantsClient(config);
         this.threads = new ThreadsClient(config);
         this.runs = new RunsClient(config);
@@ -1155,3 +1177,9 @@ export class Client {
         this["~ui"] = new UiClient(config);
     }
 }
+/**
+ * @internal Used to obtain a stable key representing the client.
+ */
+export function getClientConfigHash(client) {
+    return client["~configHash"];
+}

package/dist/react/stream.cjs

@@ -174,8 +174,12 @@ function fetchHistory(client, threadId) {
 }
 function useThreadHistory(threadId, client, clearCallbackRef, submittingRef) {
     const [history, setHistory] = (0, react_1.useState)([]);
+    const clientHash = (0, client_js_1.getClientConfigHash)(client);
+    const clientRef = (0, react_1.useRef)(client);
+    clientRef.current = client;
     const fetcher = (0, react_1.useCallback)((threadId) => {
         if (threadId != null) {
+            const client = clientRef.current;
             return fetchHistory(client, threadId).then((history) => {
                 setHistory(history);
                 return history;
@@ -189,7 +193,7 @@ function useThreadHistory(threadId, client, clearCallbackRef, submittingRef) {
         if (submittingRef.current)
             return;
         fetcher(threadId);
-    }, [fetcher, submittingRef, threadId]);
+    }, [fetcher, clientHash, submittingRef, threadId]);
     return {
         data: history,
         mutate: (mutateId) => fetcher(mutateId ?? threadId),
@@ -208,6 +212,32 @@ const useControllableThreadId = (options) => {
     }
     return [options.threadId ?? null, onThreadId];
 };
+function useStreamValuesState() {
+    const [values, setValues] = (0, react_1.useState)(null);
+    const setStreamValues = (0, react_1.useCallback)((values, kind = "stream") => {
+        if (typeof values === "function") {
+            setValues((prevTuple) => {
+                const [prevValues, prevKind] = prevTuple ?? [null, "stream"];
+                const next = values(prevValues, prevKind);
+                if (next == null)
+                    return null;
+                return [next, kind];
+            });
+            return;
+        }
+        if (values == null)
+            setValues(null);
+        setValues([values, kind]);
+    }, []);
+    const mutate = (0, react_1.useCallback)((kind, serverValues) => (update) => {
+        setStreamValues((clientValues) => {
+            const prev = { ...serverValues, ...clientValues };
+            const next = typeof update === "function" ? update(prev) : update;
+            return { ...prev, ...next };
+        }, kind);
+    }, [setStreamValues]);
+    return [values?.[0] ?? null, setStreamValues, mutate];
+}
 function useStream(options) {
     let { assistantId, messagesKey, onCreated, onError, onFinish } = options;
     const reconnectOnMountRef = (0, react_1.useRef)(options.reconnectOnMount);
@@ -239,7 +269,7 @@ function useStream(options) {
     const [branch, setBranch] = (0, react_1.useState)("");
     const [isLoading, setIsLoading] = (0, react_1.useState)(false);
     const [streamError, setStreamError] = (0, react_1.useState)(undefined);
-    const [streamValues, setStreamValues] = (0, react_1.useState)(null);
+    const [streamValues, setStreamValues, getMutateFn] = useStreamValuesState();
     const messageManagerRef = (0, react_1.useRef)(new MessageTupleManager());
     const submittingRef = (0, react_1.useRef)(false);
     const abortRef = (0, react_1.useRef)(null);
@@ -289,7 +319,7 @@ function useStream(options) {
     const { rootSequence, paths } = getBranchSequence(history.data);
     const { history: flatHistory, branchByCheckpoint } = getBranchView(rootSequence, paths, branch);
     const threadHead = flatHistory.at(-1);
-    const historyValues = threadHead?.values ?? {};
+    const historyValues = threadHead?.values ?? options.initialValues ?? {};
     const historyError = (() => {
         const error = threadHead?.tasks?.at(-1)?.error;
         if (error == null)
@@ -344,6 +374,7 @@ function useStream(options) {
                 client.runs.cancel(threadId, runId);
             runMetadataStorage.removeItem(`lg:stream:${threadId}`);
         }
+        options?.onStop?.({ mutate: getMutateFn("stop", historyValues) });
     };
     async function consumeStream(action) {
         let getCallbackMeta;
@@ -364,15 +395,7 @@ function useStream(options) {
                     options.onUpdateEvent?.(data);
                 if (event === "custom")
                     options.onCustomEvent?.(data, {
-                        mutate: (update) => setStreamValues((prev) => {
-                            // should not happen
-                            if (prev == null)
-                                return prev;
-                            return {
-                                ...prev,
-                                ...(typeof update === "function" ? update(prev) : update),
-                            };
-                        }),
+                        mutate: getMutateFn("stream", historyValues),
                     });
                 if (event === "metadata")
                     options.onMetadataEvent?.(data);
@@ -408,7 +431,12 @@ function useStream(options) {
             }
             // TODO: stream created checkpoints to avoid an unnecessary network request
             const result = await run.onSuccess();
-            setStreamValues(null);
+            setStreamValues((values, kind) => {
+                // Do not clear out the user values set on `stop`.
+                if (kind === "stop")
+                    return values;
+                return null;
+            });
             if (streamError != null)
                 throw streamError;
             const lastHead = result.at(0);
@@ -431,7 +459,7 @@ function useStream(options) {
             abortRef.current = null;
         }
     }
-    const joinStream = async (runId, lastEventId) => {
+    const joinStream = async (runId, lastEventId, options) => {
         lastEventId ??= "-1";
         if (!threadId)
             return;
@@ -439,6 +467,7 @@ function useStream(options) {
             const stream = client.runs.joinStream(threadId, runId, {
                 signal,
                 lastEventId,
+                streamMode: options?.streamMode,
             });
             return {
                 onSuccess: () => {
@@ -458,23 +487,22 @@ function useStream(options) {
                 : undefined;
             if (newPath != null)
                 setBranch(newPath ?? "");
-            // Assumption: we're setting the initial value
-            // Used for instant feedback
             setStreamValues(() => {
-                const values = { ...historyValues };
                 if (submitOptions?.optimisticValues != null) {
                     return {
-                        ...values,
+                        ...historyValues,
                         ...(typeof submitOptions.optimisticValues === "function"
-                            ? submitOptions.optimisticValues(values)
+                            ? submitOptions.optimisticValues(historyValues)
                             : submitOptions.optimisticValues),
                     };
                 }
-                return values;
+                return { ...historyValues };
             });
             let usableThreadId = threadId;
             if (!usableThreadId) {
-                const thread = await client.threads.create();
+                const thread = await client.threads.create({
+                    threadId: submitOptions?.threadId,
+                });
                 onThreadId(thread.thread_id);
                 usableThreadId = thread.thread_id;
             }

package/dist/react/stream.d.ts

@@ -125,6 +125,28 @@ export interface UseStreamOptions<StateType extends Record<string, unknown> = Re
      * @internal This API is experimental and subject to change.
      */
     onDebugEvent?: (data: DebugStreamEvent["data"]) => void;
+    /**
+     * Callback that is called when the stream is stopped by the user.
+     * Provides a mutate function to update the stream state immediately
+     * without requiring a server roundtrip.
+     *
+     * @example
+     * ```typescript
+     * onStop: ({ mutate }) => {
+     *   mutate((prev) => ({
+     *     ...prev,
+     *     ui: prev.ui?.map(component =>
+     *       component.props.isLoading
+     *         ? { ...component, props: { ...component.props, stopped: true, isLoading: false }}
+     *         : component
+     *     )
+     *   }));
+     * }
+     * ```
+     */
+    onStop?: (options: {
+        mutate: (update: Partial<StateType> | ((prev: StateType) => Partial<StateType>)) => void;
+    }) => void;
     /**
      * The ID of the thread to fetch history and current values from.
      */
@@ -135,6 +157,16 @@ export interface UseStreamOptions<StateType extends Record<string, unknown> = Re
     onThreadId?: (threadId: string) => void;
     /** Will reconnect the stream on mount */
     reconnectOnMount?: boolean | (() => RunMetadataStorage);
+    /**
+     * Initial values to display immediately when loading a thread.
+     * Useful for displaying cached thread data while official history loads.
+     * These values will be replaced when official thread data is fetched.
+     *
+     * Note: UI components from initialValues will render immediately if they're
+     * predefined in LoadExternalComponent's components prop, providing instant
+     * cached UI display without server fetches.
+     */
+    initialValues?: StateType | null;
 }
 interface RunMetadataStorage {
     getItem(key: `lg:stream:${string}`): string | null;
@@ -208,7 +240,9 @@ export interface UseStream<StateType extends Record<string, unknown> = Record<st
     /**
      * Join an active stream.
      */
-    joinStream: (runId: string) => Promise<void>;
+    joinStream: (runId: string, lastEventId?: string, options?: {
+        streamMode?: StreamMode | StreamMode[];
+    }) => Promise<void>;
 }
 type ConfigWithConfigurable<ConfigurableType extends Record<string, unknown>> = Config & {
     configurable?: ConfigurableType;
@@ -233,6 +267,13 @@ interface SubmitOptions<StateType extends Record<string, unknown> = Record<strin
      */
     streamSubgraphs?: boolean;
     streamResumable?: boolean;
+    /**
+     * The ID to use when creating a new thread. When provided, this ID will be used
+     * for thread creation when threadId is `null` or `undefined`.
+     * This enables optimistic UI updates where you know the thread ID
+     * before the thread is actually created.
+     */
+    threadId?: string;
 }
 export declare function useStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends {
     ConfigurableType?: Record<string, unknown>;

package/dist/react/stream.js

@@ -1,6 +1,6 @@
 /* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */
 "use client";
-import { Client } from "../client.js";
+import { Client, getClientConfigHash } from "../client.js";
 import { useCallback, useEffect, useMemo, useRef, useState, } from "react";
 import { coerceMessageLikeToMessage, convertToChunk, isBaseMessageChunk, } from "@langchain/core/messages";
 class StreamError extends Error {
@@ -171,8 +171,12 @@ function fetchHistory(client, threadId) {
 }
 function useThreadHistory(threadId, client, clearCallbackRef, submittingRef) {
     const [history, setHistory] = useState([]);
+    const clientHash = getClientConfigHash(client);
+    const clientRef = useRef(client);
+    clientRef.current = client;
     const fetcher = useCallback((threadId) => {
         if (threadId != null) {
+            const client = clientRef.current;
             return fetchHistory(client, threadId).then((history) => {
                 setHistory(history);
                 return history;
@@ -186,7 +190,7 @@ function useThreadHistory(threadId, client, clearCallbackRef, submittingRef) {
         if (submittingRef.current)
             return;
         fetcher(threadId);
-    }, [fetcher, submittingRef, threadId]);
+    }, [fetcher, clientHash, submittingRef, threadId]);
     return {
         data: history,
         mutate: (mutateId) => fetcher(mutateId ?? threadId),
@@ -205,6 +209,32 @@ const useControllableThreadId = (options) => {
     }
     return [options.threadId ?? null, onThreadId];
 };
+function useStreamValuesState() {
+    const [values, setValues] = useState(null);
+    const setStreamValues = useCallback((values, kind = "stream") => {
+        if (typeof values === "function") {
+            setValues((prevTuple) => {
+                const [prevValues, prevKind] = prevTuple ?? [null, "stream"];
+                const next = values(prevValues, prevKind);
+                if (next == null)
+                    return null;
+                return [next, kind];
+            });
+            return;
+        }
+        if (values == null)
+            setValues(null);
+        setValues([values, kind]);
+    }, []);
+    const mutate = useCallback((kind, serverValues) => (update) => {
+        setStreamValues((clientValues) => {
+            const prev = { ...serverValues, ...clientValues };
+            const next = typeof update === "function" ? update(prev) : update;
+            return { ...prev, ...next };
+        }, kind);
+    }, [setStreamValues]);
+    return [values?.[0] ?? null, setStreamValues, mutate];
+}
 export function useStream(options) {
     let { assistantId, messagesKey, onCreated, onError, onFinish } = options;
     const reconnectOnMountRef = useRef(options.reconnectOnMount);
@@ -236,7 +266,7 @@ export function useStream(options) {
     const [branch, setBranch] = useState("");
     const [isLoading, setIsLoading] = useState(false);
     const [streamError, setStreamError] = useState(undefined);
-    const [streamValues, setStreamValues] = useState(null);
+    const [streamValues, setStreamValues, getMutateFn] = useStreamValuesState();
     const messageManagerRef = useRef(new MessageTupleManager());
     const submittingRef = useRef(false);
     const abortRef = useRef(null);
@@ -286,7 +316,7 @@ export function useStream(options) {
     const { rootSequence, paths } = getBranchSequence(history.data);
     const { history: flatHistory, branchByCheckpoint } = getBranchView(rootSequence, paths, branch);
     const threadHead = flatHistory.at(-1);
-    const historyValues = threadHead?.values ?? {};
+    const historyValues = threadHead?.values ?? options.initialValues ?? {};
     const historyError = (() => {
         const error = threadHead?.tasks?.at(-1)?.error;
         if (error == null)
@@ -341,6 +371,7 @@ export function useStream(options) {
                 client.runs.cancel(threadId, runId);
             runMetadataStorage.removeItem(`lg:stream:${threadId}`);
         }
+        options?.onStop?.({ mutate: getMutateFn("stop", historyValues) });
     };
     async function consumeStream(action) {
         let getCallbackMeta;
@@ -361,15 +392,7 @@ export function useStream(options) {
                     options.onUpdateEvent?.(data);
                 if (event === "custom")
                     options.onCustomEvent?.(data, {
-                        mutate: (update) => setStreamValues((prev) => {
-                            // should not happen
-                            if (prev == null)
-                                return prev;
-                            return {
-                                ...prev,
-                                ...(typeof update === "function" ? update(prev) : update),
-                            };
-                        }),
+                        mutate: getMutateFn("stream", historyValues),
                     });
                 if (event === "metadata")
                     options.onMetadataEvent?.(data);
@@ -405,7 +428,12 @@ export function useStream(options) {
             }
             // TODO: stream created checkpoints to avoid an unnecessary network request
             const result = await run.onSuccess();
-            setStreamValues(null);
+            setStreamValues((values, kind) => {
+                // Do not clear out the user values set on `stop`.
+                if (kind === "stop")
+                    return values;
+                return null;
+            });
             if (streamError != null)
                 throw streamError;
             const lastHead = result.at(0);
@@ -428,7 +456,7 @@ export function useStream(options) {
             abortRef.current = null;
         }
     }
-    const joinStream = async (runId, lastEventId) => {
+    const joinStream = async (runId, lastEventId, options) => {
         lastEventId ??= "-1";
         if (!threadId)
             return;
@@ -436,6 +464,7 @@ export function useStream(options) {
             const stream = client.runs.joinStream(threadId, runId, {
                 signal,
                 lastEventId,
+                streamMode: options?.streamMode,
             });
             return {
                 onSuccess: () => {
@@ -455,23 +484,22 @@ export function useStream(options) {
                 : undefined;
             if (newPath != null)
                 setBranch(newPath ?? "");
-            // Assumption: we're setting the initial value
-            // Used for instant feedback
             setStreamValues(() => {
-                const values = { ...historyValues };
                 if (submitOptions?.optimisticValues != null) {
                     return {
-                        ...values,
+                        ...historyValues,
                         ...(typeof submitOptions.optimisticValues === "function"
-                            ? submitOptions.optimisticValues(values)
+                            ? submitOptions.optimisticValues(historyValues)
                             : submitOptions.optimisticValues),
                     };
                 }
-                return values;
+                return { ...historyValues };
             });
             let usableThreadId = threadId;
             if (!usableThreadId) {
-                const thread = await client.threads.create();
+                const thread = await client.threads.create({
+                    threadId: submitOptions?.threadId,
+                });
                 onThreadId(thread.thread_id);
                 usableThreadId = thread.thread_id;
             }

package/dist/utils/sse.cjs

@@ -7,141 +7,137 @@ const NULL = "\0".charCodeAt(0);
 const COLON = ":".charCodeAt(0);
 const SPACE = " ".charCodeAt(0);
 const TRAILING_NEWLINE = [CR, LF];
-class BytesLineDecoder extends TransformStream {
-    constructor() {
-        let buffer = [];
-        let trailingCr = false;
-        super({
-            start() {
-                buffer = [];
+function BytesLineDecoder() {
+    let buffer = [];
+    let trailingCr = false;
+    return new TransformStream({
+        start() {
+            buffer = [];
+            trailingCr = false;
+        },
+        transform(chunk, controller) {
+            // See https://docs.python.org/3/glossary.html#term-universal-newlines
+            let text = chunk;
+            // Handle trailing CR from previous chunk
+            if (trailingCr) {
+                text = joinArrays([[CR], text]);
                 trailingCr = false;
-            },
-            transform(chunk, controller) {
-                // See https://docs.python.org/3/glossary.html#term-universal-newlines
-                let text = chunk;
-                // Handle trailing CR from previous chunk
-                if (trailingCr) {
-                    text = joinArrays([[CR], text]);
-                    trailingCr = false;
-                }
-                // Check for trailing CR in current chunk
-                if (text.length > 0 && text.at(-1) === CR) {
-                    trailingCr = true;
-                    text = text.subarray(0, -1);
-                }
-                if (!text.length)
-                    return;
-                const trailingNewline = TRAILING_NEWLINE.includes(text.at(-1));
-                const lastIdx = text.length - 1;
-                const { lines } = text.reduce((acc, cur, idx) => {
-                    if (acc.from > idx)
-                        return acc;
-                    if (cur === CR || cur === LF) {
-                        acc.lines.push(text.subarray(acc.from, idx));
-                        if (cur === CR && text[idx + 1] === LF) {
-                            acc.from = idx + 2;
-                        }
-                        else {
-                            acc.from = idx + 1;
-                        }
+            }
+            // Check for trailing CR in current chunk
+            if (text.length > 0 && text.at(-1) === CR) {
+                trailingCr = true;
+                text = text.subarray(0, -1);
+            }
+            if (!text.length)
+                return;
+            const trailingNewline = TRAILING_NEWLINE.includes(text.at(-1));
+            const lastIdx = text.length - 1;
+            const { lines } = text.reduce((acc, cur, idx) => {
+                if (acc.from > idx)
+                    return acc;
+                if (cur === CR || cur === LF) {
+                    acc.lines.push(text.subarray(acc.from, idx));
+                    if (cur === CR && text[idx + 1] === LF) {
+                        acc.from = idx + 2;
                     }
-                    if (idx === lastIdx && acc.from <= lastIdx) {
-                        acc.lines.push(text.subarray(acc.from));
+                    else {
+                        acc.from = idx + 1;
                     }
-                    return acc;
-                }, { lines: [], from: 0 });
-                if (lines.length === 1 && !trailingNewline) {
-                    buffer.push(lines[0]);
-                    return;
-                }
-                if (buffer.length) {
-                    // Include existing buffer in first line
-                    buffer.push(lines[0]);
-                    lines[0] = joinArrays(buffer);
-                    buffer = [];
-                }
-                if (!trailingNewline) {
-                    // If the last segment is not newline terminated,
-                    // buffer it for the next chunk
-                    if (lines.length)
-                        buffer = [lines.pop()];
                 }
-                // Enqueue complete lines
-                for (const line of lines) {
-                    controller.enqueue(line);
+                if (idx === lastIdx && acc.from <= lastIdx) {
+                    acc.lines.push(text.subarray(acc.from));
                 }
-            },
-            flush(controller) {
-                if (buffer.length) {
-                    controller.enqueue(joinArrays(buffer));
-                }
-            },
-        });
-    }
+                return acc;
+            }, { lines: [], from: 0 });
+            if (lines.length === 1 && !trailingNewline) {
+                buffer.push(lines[0]);
+                return;
+            }
+            if (buffer.length) {
+                // Include existing buffer in first line
+                buffer.push(lines[0]);
+                lines[0] = joinArrays(buffer);
+                buffer = [];
+            }
+            if (!trailingNewline) {
+                // If the last segment is not newline terminated,
+                // buffer it for the next chunk
+                if (lines.length)
+                    buffer = [lines.pop()];
+            }
+            // Enqueue complete lines
+            for (const line of lines) {
+                controller.enqueue(line);
+            }
+        },
+        flush(controller) {
+            if (buffer.length) {
+                controller.enqueue(joinArrays(buffer));
+            }
+        },
+    });
 }
 exports.BytesLineDecoder = BytesLineDecoder;
-class SSEDecoder extends TransformStream {
-    constructor() {
-        let event = "";
-        let data = [];
-        let lastEventId = "";
-        let retry = null;
-        const decoder = new TextDecoder();
-        super({
-            transform(chunk, controller) {
-                // Handle empty line case
-                if (!chunk.length) {
-                    if (!event && !data.length && !lastEventId && retry == null)
-                        return;
-                    const sse = {
-                        id: lastEventId || undefined,
-                        event,
-                        data: data.length ? decodeArraysToJson(decoder, data) : null,
-                    };
-                    // NOTE: as per the SSE spec, do not reset lastEventId
-                    event = "";
-                    data = [];
-                    retry = null;
-                    controller.enqueue(sse);
-                    return;
-                }
-                // Ignore comments
-                if (chunk[0] === COLON)
+function SSEDecoder() {
+    let event = "";
+    let data = [];
+    let lastEventId = "";
+    let retry = null;
+    const decoder = new TextDecoder();
+    return new TransformStream({
+        transform(chunk, controller) {
+            // Handle empty line case
+            if (!chunk.length) {
+                if (!event && !data.length && !lastEventId && retry == null)
                     return;
-                const sepIdx = chunk.indexOf(COLON);
-                if (sepIdx === -1)
-                    return;
-                const fieldName = decoder.decode(chunk.subarray(0, sepIdx));
-                let value = chunk.subarray(sepIdx + 1);
-                if (value[0] === SPACE)
-                    value = value.subarray(1);
-                if (fieldName === "event") {
-                    event = decoder.decode(value);
-                }
-                else if (fieldName === "data") {
-                    data.push(value);
-                }
-                else if (fieldName === "id") {
-                    if (value.indexOf(NULL) === -1)
-                        lastEventId = decoder.decode(value);
-                }
-                else if (fieldName === "retry") {
-                    const retryNum = Number.parseInt(decoder.decode(value));
-                    if (!Number.isNaN(retryNum))
-                        retry = retryNum;
-                }
-            },
-            flush(controller) {
-                if (event) {
-                    controller.enqueue({
-                        id: lastEventId || undefined,
-                        event,
-                        data: data.length ? decodeArraysToJson(decoder, data) : null,
-                    });
-                }
-            },
-        });
-    }
+                const sse = {
+                    id: lastEventId || undefined,
+                    event,
+                    data: data.length ? decodeArraysToJson(decoder, data) : null,
+                };
+                // NOTE: as per the SSE spec, do not reset lastEventId
+                event = "";
+                data = [];
+                retry = null;
+                controller.enqueue(sse);
+                return;
+            }
+            // Ignore comments
+            if (chunk[0] === COLON)
+                return;
+            const sepIdx = chunk.indexOf(COLON);
+            if (sepIdx === -1)
+                return;
+            const fieldName = decoder.decode(chunk.subarray(0, sepIdx));
+            let value = chunk.subarray(sepIdx + 1);
+            if (value[0] === SPACE)
+                value = value.subarray(1);
+            if (fieldName === "event") {
+                event = decoder.decode(value);
+            }
+            else if (fieldName === "data") {
+                data.push(value);
+            }
+            else if (fieldName === "id") {
+                if (value.indexOf(NULL) === -1)
+                    lastEventId = decoder.decode(value);
+            }
+            else if (fieldName === "retry") {
+                const retryNum = Number.parseInt(decoder.decode(value));
+                if (!Number.isNaN(retryNum))
+                    retry = retryNum;
+            }
+        },
+        flush(controller) {
+            if (event) {
+                controller.enqueue({
+                    id: lastEventId || undefined,
+                    event,
+                    data: data.length ? decodeArraysToJson(decoder, data) : null,
+                });
+            }
+        },
+    });
 }
 exports.SSEDecoder = SSEDecoder;
 function joinArrays(data) {

package/dist/utils/sse.d.ts

@@ -1,12 +1,8 @@
-export declare class BytesLineDecoder extends TransformStream<Uint8Array, Uint8Array> {
-    constructor();
-}
+export declare function BytesLineDecoder(): TransformStream<Uint8Array, Uint8Array>;
 interface StreamPart {
     id: string | undefined;
     event: string;
     data: unknown;
 }
-export declare class SSEDecoder extends TransformStream<Uint8Array, StreamPart> {
-    constructor();
-}
+export declare function SSEDecoder(): TransformStream<Uint8Array, StreamPart>;
 export {};

package/dist/utils/sse.js

@@ -4,140 +4,136 @@ const NULL = "\0".charCodeAt(0);
 const COLON = ":".charCodeAt(0);
 const SPACE = " ".charCodeAt(0);
 const TRAILING_NEWLINE = [CR, LF];
-export class BytesLineDecoder extends TransformStream {
-    constructor() {
-        let buffer = [];
-        let trailingCr = false;
-        super({
-            start() {
-                buffer = [];
+export function BytesLineDecoder() {
+    let buffer = [];
+    let trailingCr = false;
+    return new TransformStream({
+        start() {
+            buffer = [];
+            trailingCr = false;
+        },
+        transform(chunk, controller) {
+            // See https://docs.python.org/3/glossary.html#term-universal-newlines
+            let text = chunk;
+            // Handle trailing CR from previous chunk
+            if (trailingCr) {
+                text = joinArrays([[CR], text]);
                 trailingCr = false;
-            },
-            transform(chunk, controller) {
-                // See https://docs.python.org/3/glossary.html#term-universal-newlines
-                let text = chunk;
-                // Handle trailing CR from previous chunk
-                if (trailingCr) {
-                    text = joinArrays([[CR], text]);
-                    trailingCr = false;
-                }
-                // Check for trailing CR in current chunk
-                if (text.length > 0 && text.at(-1) === CR) {
-                    trailingCr = true;
-                    text = text.subarray(0, -1);
-                }
-                if (!text.length)
-                    return;
-                const trailingNewline = TRAILING_NEWLINE.includes(text.at(-1));
-                const lastIdx = text.length - 1;
-                const { lines } = text.reduce((acc, cur, idx) => {
-                    if (acc.from > idx)
-                        return acc;
-                    if (cur === CR || cur === LF) {
-                        acc.lines.push(text.subarray(acc.from, idx));
-                        if (cur === CR && text[idx + 1] === LF) {
-                            acc.from = idx + 2;
-                        }
-                        else {
-                            acc.from = idx + 1;
-                        }
+            }
+            // Check for trailing CR in current chunk
+            if (text.length > 0 && text.at(-1) === CR) {
+                trailingCr = true;
+                text = text.subarray(0, -1);
+            }
+            if (!text.length)
+                return;
+            const trailingNewline = TRAILING_NEWLINE.includes(text.at(-1));
+            const lastIdx = text.length - 1;
+            const { lines } = text.reduce((acc, cur, idx) => {
+                if (acc.from > idx)
+                    return acc;
+                if (cur === CR || cur === LF) {
+                    acc.lines.push(text.subarray(acc.from, idx));
+                    if (cur === CR && text[idx + 1] === LF) {
+                        acc.from = idx + 2;
                     }
-                    if (idx === lastIdx && acc.from <= lastIdx) {
-                        acc.lines.push(text.subarray(acc.from));
+                    else {
+                        acc.from = idx + 1;
                     }
-                    return acc;
-                }, { lines: [], from: 0 });
-                if (lines.length === 1 && !trailingNewline) {
-                    buffer.push(lines[0]);
-                    return;
-                }
-                if (buffer.length) {
-                    // Include existing buffer in first line
-                    buffer.push(lines[0]);
-                    lines[0] = joinArrays(buffer);
-                    buffer = [];
-                }
-                if (!trailingNewline) {
-                    // If the last segment is not newline terminated,
-                    // buffer it for the next chunk
-                    if (lines.length)
-                        buffer = [lines.pop()];
                 }
-                // Enqueue complete lines
-                for (const line of lines) {
-                    controller.enqueue(line);
+                if (idx === lastIdx && acc.from <= lastIdx) {
+                    acc.lines.push(text.subarray(acc.from));
                 }
-            },
-            flush(controller) {
-                if (buffer.length) {
-                    controller.enqueue(joinArrays(buffer));
-                }
-            },
-        });
-    }
+                return acc;
+            }, { lines: [], from: 0 });
+            if (lines.length === 1 && !trailingNewline) {
+                buffer.push(lines[0]);
+                return;
+            }
+            if (buffer.length) {
+                // Include existing buffer in first line
+                buffer.push(lines[0]);
+                lines[0] = joinArrays(buffer);
+                buffer = [];
+            }
+            if (!trailingNewline) {
+                // If the last segment is not newline terminated,
+                // buffer it for the next chunk
+                if (lines.length)
+                    buffer = [lines.pop()];
+            }
+            // Enqueue complete lines
+            for (const line of lines) {
+                controller.enqueue(line);
+            }
+        },
+        flush(controller) {
+            if (buffer.length) {
+                controller.enqueue(joinArrays(buffer));
+            }
+        },
+    });
 }
-export class SSEDecoder extends TransformStream {
-    constructor() {
-        let event = "";
-        let data = [];
-        let lastEventId = "";
-        let retry = null;
-        const decoder = new TextDecoder();
-        super({
-            transform(chunk, controller) {
-                // Handle empty line case
-                if (!chunk.length) {
-                    if (!event && !data.length && !lastEventId && retry == null)
-                        return;
-                    const sse = {
-                        id: lastEventId || undefined,
-                        event,
-                        data: data.length ? decodeArraysToJson(decoder, data) : null,
-                    };
-                    // NOTE: as per the SSE spec, do not reset lastEventId
-                    event = "";
-                    data = [];
-                    retry = null;
-                    controller.enqueue(sse);
-                    return;
-                }
-                // Ignore comments
-                if (chunk[0] === COLON)
+export function SSEDecoder() {
+    let event = "";
+    let data = [];
+    let lastEventId = "";
+    let retry = null;
+    const decoder = new TextDecoder();
+    return new TransformStream({
+        transform(chunk, controller) {
+            // Handle empty line case
+            if (!chunk.length) {
+                if (!event && !data.length && !lastEventId && retry == null)
                     return;
-                const sepIdx = chunk.indexOf(COLON);
-                if (sepIdx === -1)
-                    return;
-                const fieldName = decoder.decode(chunk.subarray(0, sepIdx));
-                let value = chunk.subarray(sepIdx + 1);
-                if (value[0] === SPACE)
-                    value = value.subarray(1);
-                if (fieldName === "event") {
-                    event = decoder.decode(value);
-                }
-                else if (fieldName === "data") {
-                    data.push(value);
-                }
-                else if (fieldName === "id") {
-                    if (value.indexOf(NULL) === -1)
-                        lastEventId = decoder.decode(value);
-                }
-                else if (fieldName === "retry") {
-                    const retryNum = Number.parseInt(decoder.decode(value));
-                    if (!Number.isNaN(retryNum))
-                        retry = retryNum;
-                }
-            },
-            flush(controller) {
-                if (event) {
-                    controller.enqueue({
-                        id: lastEventId || undefined,
-                        event,
-                        data: data.length ? decodeArraysToJson(decoder, data) : null,
-                    });
-                }
-            },
-        });
-    }
+                const sse = {
+                    id: lastEventId || undefined,
+                    event,
+                    data: data.length ? decodeArraysToJson(decoder, data) : null,
+                };
+                // NOTE: as per the SSE spec, do not reset lastEventId
+                event = "";
+                data = [];
+                retry = null;
+                controller.enqueue(sse);
+                return;
+            }
+            // Ignore comments
+            if (chunk[0] === COLON)
+                return;
+            const sepIdx = chunk.indexOf(COLON);
+            if (sepIdx === -1)
+                return;
+            const fieldName = decoder.decode(chunk.subarray(0, sepIdx));
+            let value = chunk.subarray(sepIdx + 1);
+            if (value[0] === SPACE)
+                value = value.subarray(1);
+            if (fieldName === "event") {
+                event = decoder.decode(value);
+            }
+            else if (fieldName === "data") {
+                data.push(value);
+            }
+            else if (fieldName === "id") {
+                if (value.indexOf(NULL) === -1)
+                    lastEventId = decoder.decode(value);
+            }
+            else if (fieldName === "retry") {
+                const retryNum = Number.parseInt(decoder.decode(value));
+                if (!Number.isNaN(retryNum))
+                    retry = retryNum;
+            }
+        },
+        flush(controller) {
+            if (event) {
+                controller.enqueue({
+                    id: lastEventId || undefined,
+                    event,
+                    data: data.length ? decodeArraysToJson(decoder, data) : null,
+                });
+            }
+        },
+    });
 }
 function joinArrays(data) {
     const totalLength = data.reduce((acc, curr) => acc + curr.length, 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-sdk",
-  "version": "0.0.86",
+  "version": "0.0.88",
   "description": "Client library for interacting with the LangGraph API",
   "type": "module",
   "packageManager": "yarn@1.22.19",
@@ -22,7 +22,9 @@
     "uuid": "^9.0.0"
   },
   "devDependencies": {
-    "@langchain/core": "^0.3.31",
+    "@langchain/langgraph-api": "~0.0.41",
+    "@langchain/core": "^0.3.61",
+    "@langchain/langgraph": "^0.3.5",
     "@langchain/scripts": "^0.1.4",
     "@testing-library/dom": "^10.4.0",
     "@testing-library/jest-dom": "^6.6.3",
@@ -35,6 +37,7 @@
     "@types/uuid": "^9.0.1",
     "@vitejs/plugin-react": "^4.4.1",
     "concat-md": "^0.5.1",
+    "hono": "^4.8.2",
     "jsdom": "^26.1.0",
     "msw": "^2.8.2",
     "prettier": "^3.2.5",