@langchain/langgraph-sdk 0.1.10 → 1.0.0

package/dist/react/stream.custom.js

@@ -1,142 +1,127 @@
-/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */
 "use client";
-import { useEffect, useRef, useState, useSyncExternalStore } from "react";
-import { StreamManager } from "../ui/manager.js";
-import { MessageTupleManager } from "../ui/messages.js";
+
+
 import { BytesLineDecoder, SSEDecoder } from "../utils/sse.js";
 import { IterableReadableStream } from "../utils/stream.js";
+import { MessageTupleManager } from "../ui/messages.js";
+import { StreamManager } from "../ui/manager.js";
 import { useControllableThreadId } from "./thread.js";
-export class FetchStreamTransport {
-    constructor(options) {
-        Object.defineProperty(this, "options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: options
-        });
-    }
-    async stream(payload) {
-        const { signal, ...body } = payload;
-        let requestInit = {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...this.options.defaultHeaders,
-            },
-            body: JSON.stringify(body),
-            signal,
-        };
-        if (this.options.onRequest) {
-            requestInit = await this.options.onRequest(this.options.apiUrl, requestInit);
-        }
-        const fetchFn = this.options.fetch ?? fetch;
-        const response = await fetchFn(this.options.apiUrl, requestInit);
-        if (!response.ok) {
-            throw new Error(`Failed to stream: ${response.statusText}`);
-        }
-        const stream = (response.body || new ReadableStream({ start: (ctrl) => ctrl.close() }))
-            .pipeThrough(BytesLineDecoder())
-            .pipeThrough(SSEDecoder());
-        return IterableReadableStream.fromReadableStream(stream);
-    }
-}
-export function useStreamCustom(options) {
-    const [messageManager] = useState(() => new MessageTupleManager());
-    const [stream] = useState(() => new StreamManager(messageManager));
-    useSyncExternalStore(stream.subscribe, stream.getSnapshot, stream.getSnapshot);
-    const [threadId, onThreadId] = useControllableThreadId(options);
-    const threadIdRef = useRef(threadId);
-    // Cancel the stream if thread ID has changed
-    useEffect(() => {
-        if (threadIdRef.current !== threadId) {
-            threadIdRef.current = threadId;
-            stream.clear();
-        }
-    }, [threadId, stream]);
-    const getMessages = (value) => {
-        const messagesKey = options.messagesKey ?? "messages";
-        return Array.isArray(value[messagesKey]) ? value[messagesKey] : [];
-    };
-    const setMessages = (current, messages) => {
-        const messagesKey = options.messagesKey ?? "messages";
-        return { ...current, [messagesKey]: messages };
-    };
-    const historyValues = options.initialValues ?? {};
-    const stop = () => stream.stop(historyValues, { onStop: options.onStop });
-    const submit = async (values, submitOptions) => {
-        let callbackMeta;
-        let usableThreadId = threadId;
-        stream.setStreamValues(() => {
-            if (submitOptions?.optimisticValues != null) {
-                return {
-                    ...historyValues,
-                    ...(typeof submitOptions.optimisticValues === "function"
-                        ? submitOptions.optimisticValues(historyValues)
-                        : submitOptions.optimisticValues),
-                };
-            }
-            return { ...historyValues };
-        });
-        await stream.start(async (signal) => {
-            if (!usableThreadId) {
-                // generate random thread id
-                usableThreadId = crypto.randomUUID();
-                threadIdRef.current = usableThreadId;
-                onThreadId(usableThreadId);
-            }
-            if (!usableThreadId) {
-                throw new Error("Failed to obtain valid thread ID.");
-            }
-            return options.transport.stream({
-                input: values,
-                context: submitOptions?.context,
-                command: submitOptions?.command,
-                signal,
-                config: {
-                    ...submitOptions?.config,
-                    configurable: {
-                        thread_id: usableThreadId,
-                        ...submitOptions?.config?.configurable,
-                    },
-                },
-            });
-        }, {
-            getMessages,
-            setMessages,
-            initialValues: {},
-            callbacks: options,
-            onSuccess: () => undefined,
-            onError(error) {
-                options.onError?.(error, callbackMeta);
-            },
-        });
-    };
-    return {
-        get values() {
-            return stream.values ?? {};
-        },
-        error: stream.error,
-        isLoading: stream.isLoading,
-        stop,
-        submit,
-        get interrupt() {
-            if (stream.values != null &&
-                "__interrupt__" in stream.values &&
-                Array.isArray(stream.values.__interrupt__)) {
-                const valueInterrupts = stream.values.__interrupt__;
-                if (valueInterrupts.length === 0)
-                    return { when: "breakpoint" };
-                if (valueInterrupts.length === 1)
-                    return valueInterrupts[0];
-                // TODO: fix the typing of interrupts if multiple interrupts are returned
-                return valueInterrupts;
-            }
-            return undefined;
-        },
-        get messages() {
-            if (!stream.values)
-                return [];
-            return getMessages(stream.values);
-        },
-    };
+import { useEffect, useRef, useState, useSyncExternalStore } from "react";
+
+//#region src/react/stream.custom.tsx
+var FetchStreamTransport = class {
+	constructor(options) {
+		this.options = options;
+	}
+	async stream(payload) {
+		const { signal,...body } = payload;
+		let requestInit = {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...this.options.defaultHeaders
+			},
+			body: JSON.stringify(body),
+			signal
+		};
+		if (this.options.onRequest) requestInit = await this.options.onRequest(this.options.apiUrl, requestInit);
+		const fetchFn = this.options.fetch ?? fetch;
+		const response = await fetchFn(this.options.apiUrl, requestInit);
+		if (!response.ok) throw new Error(`Failed to stream: ${response.statusText}`);
+		const stream = (response.body || new ReadableStream({ start: (ctrl) => ctrl.close() })).pipeThrough(BytesLineDecoder()).pipeThrough(SSEDecoder());
+		return IterableReadableStream.fromReadableStream(stream);
+	}
+};
+function useStreamCustom(options) {
+	const [messageManager] = useState(() => new MessageTupleManager());
+	const [stream] = useState(() => new StreamManager(messageManager));
+	useSyncExternalStore(stream.subscribe, stream.getSnapshot, stream.getSnapshot);
+	const [threadId, onThreadId] = useControllableThreadId(options);
+	const threadIdRef = useRef(threadId);
+	useEffect(() => {
+		if (threadIdRef.current !== threadId) {
+			threadIdRef.current = threadId;
+			stream.clear();
+		}
+	}, [threadId, stream]);
+	const getMessages = (value) => {
+		const messagesKey = options.messagesKey ?? "messages";
+		return Array.isArray(value[messagesKey]) ? value[messagesKey] : [];
+	};
+	const setMessages = (current, messages) => {
+		const messagesKey = options.messagesKey ?? "messages";
+		return {
+			...current,
+			[messagesKey]: messages
+		};
+	};
+	const historyValues = options.initialValues ?? {};
+	const stop = () => stream.stop(historyValues, { onStop: options.onStop });
+	const submit = async (values, submitOptions) => {
+		let callbackMeta;
+		let usableThreadId = threadId;
+		stream.setStreamValues(() => {
+			if (submitOptions?.optimisticValues != null) return {
+				...historyValues,
+				...typeof submitOptions.optimisticValues === "function" ? submitOptions.optimisticValues(historyValues) : submitOptions.optimisticValues
+			};
+			return { ...historyValues };
+		});
+		await stream.start(async (signal) => {
+			if (!usableThreadId) {
+				usableThreadId = crypto.randomUUID();
+				threadIdRef.current = usableThreadId;
+				onThreadId(usableThreadId);
+			}
+			if (!usableThreadId) throw new Error("Failed to obtain valid thread ID.");
+			return options.transport.stream({
+				input: values,
+				context: submitOptions?.context,
+				command: submitOptions?.command,
+				signal,
+				config: {
+					...submitOptions?.config,
+					configurable: {
+						thread_id: usableThreadId,
+						...submitOptions?.config?.configurable
+					}
+				}
+			});
+		}, {
+			getMessages,
+			setMessages,
+			initialValues: {},
+			callbacks: options,
+			onSuccess: () => void 0,
+			onError(error) {
+				options.onError?.(error, callbackMeta);
+			}
+		});
+	};
+	return {
+		get values() {
+			return stream.values ?? {};
+		},
+		error: stream.error,
+		isLoading: stream.isLoading,
+		stop,
+		submit,
+		get interrupt() {
+			if (stream.values != null && "__interrupt__" in stream.values && Array.isArray(stream.values.__interrupt__)) {
+				const valueInterrupts = stream.values.__interrupt__;
+				if (valueInterrupts.length === 0) return { when: "breakpoint" };
+				if (valueInterrupts.length === 1) return valueInterrupts[0];
+				return valueInterrupts;
+			}
+			return void 0;
+		},
+		get messages() {
+			if (!stream.values) return [];
+			return getMessages(stream.values);
+		}
+	};
 }
+
+//#endregion
+export { FetchStreamTransport, useStreamCustom };
+//# sourceMappingURL=stream.custom.js.map

package/dist/react/stream.custom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.custom.js","names":["options: FetchStreamTransportOptions","requestInit: RequestInit","callbackMeta: RunCallbackMeta | undefined"],"sources":["../../src/react/stream.custom.tsx"],"sourcesContent":["/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */\n\n\"use client\";\n\nimport { useEffect, useRef, useState, useSyncExternalStore } from \"react\";\nimport { EventStreamEvent, StreamManager } from \"../ui/manager.js\";\nimport type {\n  BagTemplate,\n  GetUpdateType,\n  GetCustomEventType,\n  GetInterruptType,\n  RunCallbackMeta,\n  GetConfigurableType,\n  UseStreamCustomOptions,\n  UseStreamCustom,\n  UseStreamTransport,\n  CustomSubmitOptions,\n} from \"./types.js\";\nimport type { Message } from \"../types.messages.js\";\nimport { MessageTupleManager } from \"../ui/messages.js\";\nimport { Interrupt } from \"../schema.js\";\nimport { BytesLineDecoder, SSEDecoder } from \"../utils/sse.js\";\nimport { IterableReadableStream } from \"../utils/stream.js\";\nimport { useControllableThreadId } from \"./thread.js\";\nimport { Command } from \"../types.js\";\n\ninterface FetchStreamTransportOptions {\n  /**\n   * The URL of the API to use.\n   */\n  apiUrl: string;\n\n  /**\n   * Default headers to send with requests.\n   */\n  defaultHeaders?: HeadersInit;\n\n  /**\n   * Specify a custom fetch implementation.\n   */\n  fetch?: typeof fetch | ((...args: any[]) => any); // eslint-disable-line @typescript-eslint/no-explicit-any\n\n  /**\n   * Callback that is called before the request is made.\n   */\n  onRequest?: (\n    url: string,\n    init: RequestInit\n  ) => Promise<RequestInit> | RequestInit;\n}\n\nexport class FetchStreamTransport<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate\n> implements UseStreamTransport<StateType, Bag>\n{\n  constructor(private readonly options: FetchStreamTransportOptions) {}\n\n  async stream(payload: {\n    input: GetUpdateType<Bag, StateType> | null | undefined;\n    context: GetConfigurableType<Bag> | undefined;\n    command: Command | undefined;\n    signal: AbortSignal;\n  }): Promise<AsyncGenerator<{ id?: string; event: string; data: unknown }>> {\n    const { signal, ...body } = payload;\n\n    let requestInit: RequestInit = {\n      method: \"POST\",\n      headers: {\n        \"Content-Type\": \"application/json\",\n        ...this.options.defaultHeaders,\n      },\n      body: JSON.stringify(body),\n      signal,\n    };\n\n    if (this.options.onRequest) {\n      requestInit = await this.options.onRequest(\n        this.options.apiUrl,\n        requestInit\n      );\n    }\n    const fetchFn = this.options.fetch ?? fetch;\n\n    const response = await fetchFn(this.options.apiUrl, requestInit);\n    if (!response.ok) {\n      throw new Error(`Failed to stream: ${response.statusText}`);\n    }\n\n    const stream = (\n      response.body || new ReadableStream({ start: (ctrl) => ctrl.close() })\n    )\n      .pipeThrough(BytesLineDecoder())\n      .pipeThrough(SSEDecoder());\n\n    return IterableReadableStream.fromReadableStream(stream);\n  }\n}\n\nexport function useStreamCustom<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends {\n    ConfigurableType?: Record<string, unknown>;\n    InterruptType?: unknown;\n    CustomEventType?: unknown;\n    UpdateType?: unknown;\n  } = BagTemplate\n>(\n  options: UseStreamCustomOptions<StateType, Bag>\n): UseStreamCustom<StateType, Bag> {\n  type UpdateType = GetUpdateType<Bag, StateType>;\n  type CustomType = GetCustomEventType<Bag>;\n  type InterruptType = GetInterruptType<Bag>;\n  type ConfigurableType = GetConfigurableType<Bag>;\n\n  const [messageManager] = useState(() => new MessageTupleManager());\n  const [stream] = useState(\n    () => new StreamManager<StateType, Bag>(messageManager)\n  );\n\n  useSyncExternalStore(\n    stream.subscribe,\n    stream.getSnapshot,\n    stream.getSnapshot\n  );\n\n  const [threadId, onThreadId] = useControllableThreadId(options);\n  const threadIdRef = useRef<string | null>(threadId);\n\n  // Cancel the stream if thread ID has changed\n  useEffect(() => {\n    if (threadIdRef.current !== threadId) {\n      threadIdRef.current = threadId;\n      stream.clear();\n    }\n  }, [threadId, stream]);\n\n  const getMessages = (value: StateType): Message[] => {\n    const messagesKey = options.messagesKey ?? \"messages\";\n    return Array.isArray(value[messagesKey]) ? value[messagesKey] : [];\n  };\n\n  const setMessages = (current: StateType, messages: Message[]): StateType => {\n    const messagesKey = options.messagesKey ?? \"messages\";\n    return { ...current, [messagesKey]: messages };\n  };\n\n  const historyValues = options.initialValues ?? ({} as StateType);\n\n  const stop = () => stream.stop(historyValues, { onStop: options.onStop });\n\n  const submit = async (\n    values: UpdateType | null | undefined,\n    submitOptions?: CustomSubmitOptions<StateType, ConfigurableType>\n  ) => {\n    let callbackMeta: RunCallbackMeta | undefined;\n    let usableThreadId = threadId;\n\n    stream.setStreamValues(() => {\n      if (submitOptions?.optimisticValues != null) {\n        return {\n          ...historyValues,\n          ...(typeof submitOptions.optimisticValues === \"function\"\n            ? submitOptions.optimisticValues(historyValues)\n            : submitOptions.optimisticValues),\n        };\n      }\n\n      return { ...historyValues };\n    });\n\n    await stream.start(\n      async (signal: AbortSignal) => {\n        if (!usableThreadId) {\n          // generate random thread id\n          usableThreadId = crypto.randomUUID();\n          threadIdRef.current = usableThreadId;\n          onThreadId(usableThreadId);\n        }\n\n        if (!usableThreadId) {\n          throw new Error(\"Failed to obtain valid thread ID.\");\n        }\n\n        return options.transport.stream({\n          input: values,\n          context: submitOptions?.context,\n          command: submitOptions?.command,\n          signal,\n          config: {\n            ...submitOptions?.config,\n            configurable: {\n              thread_id: usableThreadId,\n              ...submitOptions?.config?.configurable,\n            } as unknown as GetConfigurableType<Bag>,\n          },\n        }) as Promise<\n          AsyncGenerator<EventStreamEvent<StateType, UpdateType, CustomType>>\n        >;\n      },\n      {\n        getMessages,\n        setMessages,\n\n        initialValues: {} as StateType,\n        callbacks: options,\n\n        onSuccess: () => undefined,\n        onError(error) {\n          options.onError?.(error, callbackMeta);\n        },\n      }\n    );\n  };\n\n  return {\n    get values() {\n      return stream.values ?? ({} as StateType);\n    },\n\n    error: stream.error,\n    isLoading: stream.isLoading,\n\n    stop,\n    submit,\n\n    get interrupt(): Interrupt<InterruptType> | undefined {\n      if (\n        stream.values != null &&\n        \"__interrupt__\" in stream.values &&\n        Array.isArray(stream.values.__interrupt__)\n      ) {\n        const valueInterrupts = stream.values.__interrupt__;\n        if (valueInterrupts.length === 0) return { when: \"breakpoint\" };\n        if (valueInterrupts.length === 1) return valueInterrupts[0];\n\n        // TODO: fix the typing of interrupts if multiple interrupts are returned\n        return valueInterrupts as Interrupt<InterruptType>;\n      }\n\n      return undefined;\n    },\n\n    get messages() {\n      if (!stream.values) return [];\n      return getMessages(stream.values);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;AAmDA,IAAa,uBAAb,MAIA;CACE,YAAY,AAAiBA,SAAsC;EAAtC;;CAE7B,MAAM,OAAO,SAK8D;EACzE,MAAM,EAAE,OAAQ,GAAG,SAAS;EAE5B,IAAIC,cAA2B;GAC7B,QAAQ;GACR,SAAS;IACP,gBAAgB;IAChB,GAAG,KAAK,QAAQ;;GAElB,MAAM,KAAK,UAAU;GACrB;;AAGF,MAAI,KAAK,QAAQ,UACf,eAAc,MAAM,KAAK,QAAQ,UAC/B,KAAK,QAAQ,QACb;EAGJ,MAAM,UAAU,KAAK,QAAQ,SAAS;EAEtC,MAAM,WAAW,MAAM,QAAQ,KAAK,QAAQ,QAAQ;AACpD,MAAI,CAAC,SAAS,GACZ,OAAM,IAAI,MAAM,qBAAqB,SAAS;EAGhD,MAAM,UACJ,SAAS,QAAQ,IAAI,eAAe,EAAE,QAAQ,SAAS,KAAK,YAE3D,YAAY,oBACZ,YAAY;AAEf,SAAO,uBAAuB,mBAAmB;;;AAIrD,SAAgB,gBASd,SACiC;CAMjC,MAAM,CAAC,kBAAkB,eAAe,IAAI;CAC5C,MAAM,CAAC,UAAU,eACT,IAAI,cAA8B;AAG1C,sBACE,OAAO,WACP,OAAO,aACP,OAAO;CAGT,MAAM,CAAC,UAAU,cAAc,wBAAwB;CACvD,MAAM,cAAc,OAAsB;AAG1C,iBAAgB;AACd,MAAI,YAAY,YAAY,UAAU;AACpC,eAAY,UAAU;AACtB,UAAO;;IAER,CAAC,UAAU;CAEd,MAAM,eAAe,UAAgC;EACnD,MAAM,cAAc,QAAQ,eAAe;AAC3C,SAAO,MAAM,QAAQ,MAAM,gBAAgB,MAAM,eAAe;;CAGlE,MAAM,eAAe,SAAoB,aAAmC;EAC1E,MAAM,cAAc,QAAQ,eAAe;AAC3C,SAAO;GAAE,GAAG;IAAU,cAAc;;;CAGtC,MAAM,gBAAgB,QAAQ,iBAAkB;CAEhD,MAAM,aAAa,OAAO,KAAK,eAAe,EAAE,QAAQ,QAAQ;CAEhE,MAAM,SAAS,OACb,QACA,kBACG;EACH,IAAIC;EACJ,IAAI,iBAAiB;AAErB,SAAO,sBAAsB;AAC3B,OAAI,eAAe,oBAAoB,KACrC,QAAO;IACL,GAAG;IACH,GAAI,OAAO,cAAc,qBAAqB,aAC1C,cAAc,iBAAiB,iBAC/B,cAAc;;AAItB,UAAO,EAAE,GAAG;;AAGd,QAAM,OAAO,MACX,OAAO,WAAwB;AAC7B,OAAI,CAAC,gBAAgB;AAEnB,qBAAiB,OAAO;AACxB,gBAAY,UAAU;AACtB,eAAW;;AAGb,OAAI,CAAC,eACH,OAAM,IAAI,MAAM;AAGlB,UAAO,QAAQ,UAAU,OAAO;IAC9B,OAAO;IACP,SAAS,eAAe;IACxB,SAAS,eAAe;IACxB;IACA,QAAQ;KACN,GAAG,eAAe;KAClB,cAAc;MACZ,WAAW;MACX,GAAG,eAAe,QAAQ;;;;KAOlC;GACE;GACA;GAEA,eAAe;GACf,WAAW;GAEX,iBAAiB;GACjB,QAAQ,OAAO;AACb,YAAQ,UAAU,OAAO;;;;AAMjC,QAAO;EACL,IAAI,SAAS;AACX,UAAO,OAAO,UAAW;;EAG3B,OAAO,OAAO;EACd,WAAW,OAAO;EAElB;EACA;EAEA,IAAI,YAAkD;AACpD,OACE,OAAO,UAAU,QACjB,mBAAmB,OAAO,UAC1B,MAAM,QAAQ,OAAO,OAAO,gBAC5B;IACA,MAAM,kBAAkB,OAAO,OAAO;AACtC,QAAI,gBAAgB,WAAW,EAAG,QAAO,EAAE,MAAM;AACjD,QAAI,gBAAgB,WAAW,EAAG,QAAO,gBAAgB;AAGzD,WAAO;;AAGT,UAAO;;EAGT,IAAI,WAAW;AACb,OAAI,CAAC,OAAO,OAAQ,QAAO;AAC3B,UAAO,YAAY,OAAO"}

package/dist/react/stream.d.cts

@@ -0,0 +1,73 @@
+import { BagTemplate, UseStream, UseStreamCustom, UseStreamCustomOptions, UseStreamOptions } from "./types.cjs";
+
+//#region src/react/stream.d.ts
+
+/**
+ * A React hook that provides seamless integration with LangGraph streaming capabilities.
+ *
+ * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,
+ * letting you focus on building great chat experiences. It provides automatic state management for
+ * messages, interrupts, loading states, and errors.
+ *
+ * @template StateType The type of the thread state (default: `Record<string, unknown>`)
+ * @template Bag Type configuration bag containing:
+ *   - `ConfigurableType`: Type for the `config.configurable` property
+ *   - `InterruptType`: Type for interrupt values
+ *   - `CustomEventType`: Type for custom events
+ *   - `UpdateType`: Type for the submit function updates
+ *
+ * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}
+ */
+declare function useStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends {
+  ConfigurableType?: Record<string, unknown>;
+  InterruptType?: unknown;
+  CustomEventType?: unknown;
+  UpdateType?: unknown;
+} = BagTemplate>(options: UseStreamOptions<StateType, Bag>): UseStream<StateType, Bag>;
+/**
+ * A React hook that provides seamless integration with LangGraph streaming capabilities.
+ *
+ * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,
+ * letting you focus on building great chat experiences. It provides automatic state management for
+ * messages, interrupts, loading states, and errors.
+ *
+ * @template StateType The type of the thread state (default: `Record<string, unknown>`)
+ * @template Bag Type configuration bag containing:
+ *   - `ConfigurableType`: Type for the `config.configurable` property
+ *   - `InterruptType`: Type for interrupt values
+ *   - `CustomEventType`: Type for custom events
+ *   - `UpdateType`: Type for the submit function updates
+ *
+ * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}
+ */
+declare function useStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends {
+  ConfigurableType?: Record<string, unknown>;
+  InterruptType?: unknown;
+  CustomEventType?: unknown;
+  UpdateType?: unknown;
+} = BagTemplate>(options: UseStreamCustomOptions<StateType, Bag>): UseStreamCustom<StateType, Bag>;
+/**
+ * A React hook that provides seamless integration with LangGraph streaming capabilities.
+ *
+ * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,
+ * letting you focus on building great chat experiences. It provides automatic state management for
+ * messages, interrupts, loading states, and errors.
+ *
+ * @template StateType The type of the thread state (default: `Record<string, unknown>`)
+ * @template Bag Type configuration bag containing:
+ *   - `ConfigurableType`: Type for the `config.configurable` property
+ *   - `InterruptType`: Type for interrupt values
+ *   - `CustomEventType`: Type for custom events
+ *   - `UpdateType`: Type for the submit function updates
+ *
+ * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}
+ */
+declare function useStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends {
+  ConfigurableType?: Record<string, unknown>;
+  InterruptType?: unknown;
+  CustomEventType?: unknown;
+  UpdateType?: unknown;
+} = BagTemplate>(options: UseStreamOptions<StateType, Bag>): UseStream<StateType, Bag>;
+//#endregion
+export { useStream };
+//# sourceMappingURL=stream.d.cts.map

package/dist/react/stream.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.cts","names":["BagTemplate","UseStream","UseStreamCustom","UseStreamCustomOptions","UseStreamOptions","useStream","Record","StateType","Bag"],"sources":["../../src/react/stream.d.ts"],"sourcesContent":["import { BagTemplate, UseStream, UseStreamCustom, UseStreamCustomOptions, UseStreamOptions } from \"./types.js\";\n/**\n * A React hook that provides seamless integration with LangGraph streaming capabilities.\n *\n * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,\n * letting you focus on building great chat experiences. It provides automatic state management for\n * messages, interrupts, loading states, and errors.\n *\n * @template StateType The type of the thread state (default: `Record<string, unknown>`)\n * @template Bag Type configuration bag containing:\n *   - `ConfigurableType`: Type for the `config.configurable` property\n *   - `InterruptType`: Type for interrupt values\n *   - `CustomEventType`: Type for custom events\n *   - `UpdateType`: Type for the submit function updates\n *\n * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}\n */\nexport declare function useStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends {\n    ConfigurableType?: Record<string, unknown>;\n    InterruptType?: unknown;\n    CustomEventType?: unknown;\n    UpdateType?: unknown;\n} = BagTemplate>(options: UseStreamOptions<StateType, Bag>): UseStream<StateType, Bag>;\n/**\n * A React hook that provides seamless integration with LangGraph streaming capabilities.\n *\n * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,\n * letting you focus on building great chat experiences. It provides automatic state management for\n * messages, interrupts, loading states, and errors.\n *\n * @template StateType The type of the thread state (default: `Record<string, unknown>`)\n * @template Bag Type configuration bag containing:\n *   - `ConfigurableType`: Type for the `config.configurable` property\n *   - `InterruptType`: Type for interrupt values\n *   - `CustomEventType`: Type for custom events\n *   - `UpdateType`: Type for the submit function updates\n *\n * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}\n */\nexport declare function useStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends {\n    ConfigurableType?: Record<string, unknown>;\n    InterruptType?: unknown;\n    CustomEventType?: unknown;\n    UpdateType?: unknown;\n} = BagTemplate>(options: UseStreamCustomOptions<StateType, Bag>): UseStreamCustom<StateType, Bag>;\n/**\n * A React hook that provides seamless integration with LangGraph streaming capabilities.\n *\n * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,\n * letting you focus on building great chat experiences. It provides automatic state management for\n * messages, interrupts, loading states, and errors.\n *\n * @template StateType The type of the thread state (default: `Record<string, unknown>`)\n * @template Bag Type configuration bag containing:\n *   - `ConfigurableType`: Type for the `config.configurable` property\n *   - `InterruptType`: Type for interrupt values\n *   - `CustomEventType`: Type for custom events\n *   - `UpdateType`: Type for the submit function updates\n *\n * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}\n */\nexport declare function useStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends {\n    ConfigurableType?: Record<string, unknown>;\n    InterruptType?: unknown;\n    CustomEventType?: unknown;\n    UpdateType?: unknown;\n} = BagTemplate>(options: UseStreamOptions<StateType, Bag>): UseStream<StateType, Bag>;\n"],"mappings":";;;;;;AAiBA;;;;;;;;;;;;;AAsBA;AAAiC,iBAtBTK,SAsBS,CAAA,kBAtBmBC,MAsBnB,CAAA,MAAA,EAAA,OAAA,CAAA,GAtB6CA,MAsB7C,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,YAAA;kBAAmBA,CAAAA,EArB7BA,MAqB6BA,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;eAA0BA,CAAAA,EAAAA,OAAAA;iBACvDA,CAAAA,EAAAA,OAAAA;YAInBN,CAAAA,EAAAA,OAAAA;IAtBAA,WAsB6CO,CAAAA,CAAAA,OAAAA,EAtBvBH,gBAsBuBG,CAtBNA,SAsBMA,EAtBKC,GAsBLD,CAAAA,CAAAA,EAtBYN,SAsBZM,CAtBsBA,SAsBtBA,EAtBiCC,GAsBjCD,CAAAA;;;;;;;AAiBjD;;;;;;;;;;AAKkFC,iBA3B1DH,SA2B0DG,CAAAA,kBA3B9BF,MA2B8BE,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GA3BJF,MA2BIE,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,YAAAA;kBAArBP,CAAAA,EA1BtCK,MA0BsCL,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;;;;IAtBzDD,sBAAsBG,uBAAuBI,WAAWC,OAAON,gBAAgBK,WAAWC;;;;;;;;;;;;;;;;;iBAiBtEH,4BAA4BC,0BAA0BA;qBACvDA;;;;IAInBN,sBAAsBI,iBAAiBG,WAAWC,OAAOP,UAAUM,WAAWC"}

package/dist/react/stream.d.ts

@@ -1,4 +1,7 @@
 import { BagTemplate, UseStream, UseStreamCustom, UseStreamCustomOptions, UseStreamOptions } from "./types.js";
+
+//#region src/react/stream.d.ts
+
 /**
  * A React hook that provides seamless integration with LangGraph streaming capabilities.
  *
@@ -15,11 +18,11 @@ import { BagTemplate, UseStream, UseStreamCustom, UseStreamCustomOptions, UseStr
  *
  * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}
  */
-export declare function useStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends {
-    ConfigurableType?: Record<string, unknown>;
-    InterruptType?: unknown;
-    CustomEventType?: unknown;
-    UpdateType?: unknown;
+declare function useStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends {
+  ConfigurableType?: Record<string, unknown>;
+  InterruptType?: unknown;
+  CustomEventType?: unknown;
+  UpdateType?: unknown;
 } = BagTemplate>(options: UseStreamOptions<StateType, Bag>): UseStream<StateType, Bag>;
 /**
  * A React hook that provides seamless integration with LangGraph streaming capabilities.
@@ -37,11 +40,11 @@ export declare function useStream<StateType extends Record<string, unknown> = Re
  *
  * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}
  */
-export declare function useStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends {
-    ConfigurableType?: Record<string, unknown>;
-    InterruptType?: unknown;
-    CustomEventType?: unknown;
-    UpdateType?: unknown;
+declare function useStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends {
+  ConfigurableType?: Record<string, unknown>;
+  InterruptType?: unknown;
+  CustomEventType?: unknown;
+  UpdateType?: unknown;
 } = BagTemplate>(options: UseStreamCustomOptions<StateType, Bag>): UseStreamCustom<StateType, Bag>;
 /**
  * A React hook that provides seamless integration with LangGraph streaming capabilities.
@@ -59,9 +62,12 @@ export declare function useStream<StateType extends Record<string, unknown> = Re
  *
  * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}
  */
-export declare function useStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends {
-    ConfigurableType?: Record<string, unknown>;
-    InterruptType?: unknown;
-    CustomEventType?: unknown;
-    UpdateType?: unknown;
+declare function useStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends {
+  ConfigurableType?: Record<string, unknown>;
+  InterruptType?: unknown;
+  CustomEventType?: unknown;
+  UpdateType?: unknown;
 } = BagTemplate>(options: UseStreamOptions<StateType, Bag>): UseStream<StateType, Bag>;
+//#endregion
+export { useStream };
+//# sourceMappingURL=stream.d.ts.map

package/dist/react/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","names":["BagTemplate","UseStream","UseStreamCustom","UseStreamCustomOptions","UseStreamOptions","useStream","Record","StateType","Bag"],"sources":["../../src/react/stream.d.ts"],"sourcesContent":["import { BagTemplate, UseStream, UseStreamCustom, UseStreamCustomOptions, UseStreamOptions } from \"./types.js\";\n/**\n * A React hook that provides seamless integration with LangGraph streaming capabilities.\n *\n * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,\n * letting you focus on building great chat experiences. It provides automatic state management for\n * messages, interrupts, loading states, and errors.\n *\n * @template StateType The type of the thread state (default: `Record<string, unknown>`)\n * @template Bag Type configuration bag containing:\n *   - `ConfigurableType`: Type for the `config.configurable` property\n *   - `InterruptType`: Type for interrupt values\n *   - `CustomEventType`: Type for custom events\n *   - `UpdateType`: Type for the submit function updates\n *\n * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}\n */\nexport declare function useStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends {\n    ConfigurableType?: Record<string, unknown>;\n    InterruptType?: unknown;\n    CustomEventType?: unknown;\n    UpdateType?: unknown;\n} = BagTemplate>(options: UseStreamOptions<StateType, Bag>): UseStream<StateType, Bag>;\n/**\n * A React hook that provides seamless integration with LangGraph streaming capabilities.\n *\n * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,\n * letting you focus on building great chat experiences. It provides automatic state management for\n * messages, interrupts, loading states, and errors.\n *\n * @template StateType The type of the thread state (default: `Record<string, unknown>`)\n * @template Bag Type configuration bag containing:\n *   - `ConfigurableType`: Type for the `config.configurable` property\n *   - `InterruptType`: Type for interrupt values\n *   - `CustomEventType`: Type for custom events\n *   - `UpdateType`: Type for the submit function updates\n *\n * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}\n */\nexport declare function useStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends {\n    ConfigurableType?: Record<string, unknown>;\n    InterruptType?: unknown;\n    CustomEventType?: unknown;\n    UpdateType?: unknown;\n} = BagTemplate>(options: UseStreamCustomOptions<StateType, Bag>): UseStreamCustom<StateType, Bag>;\n/**\n * A React hook that provides seamless integration with LangGraph streaming capabilities.\n *\n * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,\n * letting you focus on building great chat experiences. It provides automatic state management for\n * messages, interrupts, loading states, and errors.\n *\n * @template StateType The type of the thread state (default: `Record<string, unknown>`)\n * @template Bag Type configuration bag containing:\n *   - `ConfigurableType`: Type for the `config.configurable` property\n *   - `InterruptType`: Type for interrupt values\n *   - `CustomEventType`: Type for custom events\n *   - `UpdateType`: Type for the submit function updates\n *\n * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}\n */\nexport declare function useStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends {\n    ConfigurableType?: Record<string, unknown>;\n    InterruptType?: unknown;\n    CustomEventType?: unknown;\n    UpdateType?: unknown;\n} = BagTemplate>(options: UseStreamOptions<StateType, Bag>): UseStream<StateType, Bag>;\n"],"mappings":";;;;;;AAiBA;;;;;;;;;;;;;AAsBA;AAAiC,iBAtBTK,SAsBS,CAAA,kBAtBmBC,MAsBnB,CAAA,MAAA,EAAA,OAAA,CAAA,GAtB6CA,MAsB7C,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,YAAA;kBAAmBA,CAAAA,EArB7BA,MAqB6BA,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;eAA0BA,CAAAA,EAAAA,OAAAA;iBACvDA,CAAAA,EAAAA,OAAAA;YAInBN,CAAAA,EAAAA,OAAAA;IAtBAA,WAsB6CO,CAAAA,CAAAA,OAAAA,EAtBvBH,gBAsBuBG,CAtBNA,SAsBMA,EAtBKC,GAsBLD,CAAAA,CAAAA,EAtBYN,SAsBZM,CAtBsBA,SAsBtBA,EAtBiCC,GAsBjCD,CAAAA;;;;;;;AAiBjD;;;;;;;;;;AAKkFC,iBA3B1DH,SA2B0DG,CAAAA,kBA3B9BF,MA2B8BE,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GA3BJF,MA2BIE,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,YAAAA;kBAArBP,CAAAA,EA1BtCK,MA0BsCL,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;;;;IAtBzDD,sBAAsBG,uBAAuBI,WAAWC,OAAON,gBAAgBK,WAAWC;;;;;;;;;;;;;;;;;iBAiBtEH,4BAA4BC,0BAA0BA;qBACvDA;;;;IAInBN,sBAAsBI,iBAAiBG,WAAWC,OAAOP,UAAUM,WAAWC"}

package/dist/react/stream.js

@@ -1,16 +1,17 @@
-import { useState } from "react";
 import { useStreamLGP } from "./stream.lgp.js";
 import { useStreamCustom } from "./stream.custom.js";
+import { useState } from "react";
+
+//#region src/react/stream.tsx
 function isCustomOptions(options) {
-    return "transport" in options;
+	return "transport" in options;
 }
-export function useStream(options) {
-    // Store this in useState to make sure we're not changing the implementation in re-renders
-    const [isCustom] = useState(isCustomOptions(options));
-    if (isCustom) {
-        // eslint-disable-next-line react-hooks/rules-of-hooks
-        return useStreamCustom(options);
-    }
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    return useStreamLGP(options);
+function useStream(options) {
+	const [isCustom] = useState(isCustomOptions(options));
+	if (isCustom) return useStreamCustom(options);
+	return useStreamLGP(options);
 }
+
+//#endregion
+export { useStream };
+//# sourceMappingURL=stream.js.map

package/dist/react/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","names":[],"sources":["../../src/react/stream.tsx"],"sourcesContent":["import { useState } from \"react\";\nimport { useStreamLGP } from \"./stream.lgp.js\";\nimport { useStreamCustom } from \"./stream.custom.js\";\nimport {\n  BagTemplate,\n  UseStream,\n  UseStreamCustom,\n  UseStreamCustomOptions,\n  UseStreamOptions,\n} from \"./types.js\";\n\nfunction isCustomOptions<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends {\n    ConfigurableType?: Record<string, unknown>;\n    InterruptType?: unknown;\n    CustomEventType?: unknown;\n    UpdateType?: unknown;\n  } = BagTemplate\n>(\n  options:\n    | UseStreamOptions<StateType, Bag>\n    | UseStreamCustomOptions<StateType, Bag>\n): options is UseStreamCustomOptions<StateType, Bag> {\n  return \"transport\" in options;\n}\n\n/**\n * A React hook that provides seamless integration with LangGraph streaming capabilities.\n *\n * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,\n * letting you focus on building great chat experiences. It provides automatic state management for\n * messages, interrupts, loading states, and errors.\n *\n * @template StateType The type of the thread state (default: `Record<string, unknown>`)\n * @template Bag Type configuration bag containing:\n *   - `ConfigurableType`: Type for the `config.configurable` property\n *   - `InterruptType`: Type for interrupt values\n *   - `CustomEventType`: Type for custom events\n *   - `UpdateType`: Type for the submit function updates\n *\n * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}\n */\nexport function useStream<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends {\n    ConfigurableType?: Record<string, unknown>;\n    InterruptType?: unknown;\n    CustomEventType?: unknown;\n    UpdateType?: unknown;\n  } = BagTemplate\n>(options: UseStreamOptions<StateType, Bag>): UseStream<StateType, Bag>;\n\n/**\n * A React hook that provides seamless integration with LangGraph streaming capabilities.\n *\n * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,\n * letting you focus on building great chat experiences. It provides automatic state management for\n * messages, interrupts, loading states, and errors.\n *\n * @template StateType The type of the thread state (default: `Record<string, unknown>`)\n * @template Bag Type configuration bag containing:\n *   - `ConfigurableType`: Type for the `config.configurable` property\n *   - `InterruptType`: Type for interrupt values\n *   - `CustomEventType`: Type for custom events\n *   - `UpdateType`: Type for the submit function updates\n *\n * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}\n */\nexport function useStream<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends {\n    ConfigurableType?: Record<string, unknown>;\n    InterruptType?: unknown;\n    CustomEventType?: unknown;\n    UpdateType?: unknown;\n  } = BagTemplate\n>(\n  options: UseStreamCustomOptions<StateType, Bag>\n): UseStreamCustom<StateType, Bag>;\n\n/**\n * A React hook that provides seamless integration with LangGraph streaming capabilities.\n *\n * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,\n * letting you focus on building great chat experiences. It provides automatic state management for\n * messages, interrupts, loading states, and errors.\n *\n * @template StateType The type of the thread state (default: `Record<string, unknown>`)\n * @template Bag Type configuration bag containing:\n *   - `ConfigurableType`: Type for the `config.configurable` property\n *   - `InterruptType`: Type for interrupt values\n *   - `CustomEventType`: Type for custom events\n *   - `UpdateType`: Type for the submit function updates\n *\n * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}\n */\nexport function useStream<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends {\n    ConfigurableType?: Record<string, unknown>;\n    InterruptType?: unknown;\n    CustomEventType?: unknown;\n    UpdateType?: unknown;\n  } = BagTemplate\n>(options: UseStreamOptions<StateType, Bag>): UseStream<StateType, Bag>;\n\nexport function useStream<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends {\n    ConfigurableType?: Record<string, unknown>;\n    InterruptType?: unknown;\n    CustomEventType?: unknown;\n    UpdateType?: unknown;\n  } = BagTemplate\n>(\n  options:\n    | UseStreamOptions<StateType, Bag>\n    | UseStreamCustomOptions<StateType, Bag>\n): UseStream<StateType, Bag> | UseStreamCustom<StateType, Bag> {\n  // Store this in useState to make sure we're not changing the implementation in re-renders\n  const [isCustom] = useState(isCustomOptions(options));\n\n  if (isCustom) {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    return useStreamCustom(options as UseStreamCustomOptions<StateType, Bag>);\n  }\n\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  return useStreamLGP(options as UseStreamOptions<StateType, Bag>);\n}\n"],"mappings":";;;;;AAWA,SAAS,gBASP,SAGmD;AACnD,QAAO,eAAe;;AAmFxB,SAAgB,UASd,SAG6D;CAE7D,MAAM,CAAC,YAAY,SAAS,gBAAgB;AAE5C,KAAI,SAEF,QAAO,gBAAgB;AAIzB,QAAO,aAAa"}