@langchain/react 0.1.2 → 0.2.0

package/dist/suspense-stream.cjs

@@ -0,0 +1,187 @@
+"use client";
+const require_stream_lgp = require("./stream.lgp.cjs");
+let react = require("react");
+let _langchain_langgraph_sdk_client = require("@langchain/langgraph-sdk/client");
+//#region src/suspense-stream.tsx
+const threadCache = /* @__PURE__ */ new Map();
+function getCacheKey(client, threadId, limit) {
+	return `suspense:${(0, _langchain_langgraph_sdk_client.getClientConfigHash)(client)}:${threadId}:${limit}`;
+}
+function fetchThreadHistory(client, threadId, options) {
+	if (options?.limit === false) return client.threads.getState(threadId).then((state) => {
+		if (state.checkpoint == null) return [];
+		return [state];
+	});
+	const limit = typeof options?.limit === "number" ? options.limit : 10;
+	return client.threads.getHistory(threadId, { limit });
+}
+function getOrCreateCacheEntry(client, threadId, limit) {
+	const key = getCacheKey(client, threadId, limit);
+	let entry = threadCache.get(key);
+	if (!entry) {
+		entry = {
+			status: "pending",
+			promise: fetchThreadHistory(client, threadId, { limit }).then((data) => {
+				threadCache.set(key, {
+					status: "resolved",
+					data
+				});
+			}).catch((error) => {
+				threadCache.set(key, {
+					status: "rejected",
+					error
+				});
+			})
+		};
+		threadCache.set(key, entry);
+	}
+	return entry;
+}
+/**
+* Clear the internal Suspense cache used by {@link useSuspenseStream}.
+*
+* Call this from an Error Boundary's `onReset` callback so that a retry
+* triggers a fresh thread-history fetch rather than re-throwing the
+* cached error.
+*
+* @example
+* ```tsx
+* <ErrorBoundary
+*   onReset={() => invalidateSuspenseCache()}
+*   fallbackRender={({ resetErrorBoundary }) => (
+*     <button onClick={resetErrorBoundary}>Retry</button>
+*   )}
+* >
+*   <Suspense fallback={<Spinner />}>
+*     <Chat />
+*   </Suspense>
+* </ErrorBoundary>
+* ```
+*/
+function invalidateSuspenseCache() {
+	threadCache.clear();
+}
+function useSuspenseStream(options) {
+	const client = (0, react.useMemo)(() => options.client ?? new _langchain_langgraph_sdk_client.Client({
+		apiUrl: options.apiUrl,
+		apiKey: options.apiKey,
+		callerOptions: options.callerOptions,
+		defaultHeaders: options.defaultHeaders
+	}), [
+		options.client,
+		options.apiKey,
+		options.apiUrl,
+		options.callerOptions,
+		options.defaultHeaders
+	]);
+	const { threadId } = options;
+	const historyLimit = typeof options.fetchStateHistory === "object" && options.fetchStateHistory != null ? options.fetchStateHistory.limit ?? false : options.fetchStateHistory ?? false;
+	const needsHistoryFetch = threadId != null && options.thread == null;
+	let cacheEntry;
+	if (needsHistoryFetch) cacheEntry = getOrCreateCacheEntry(client, threadId, historyLimit);
+	const cachedData = cacheEntry?.status === "resolved" ? cacheEntry.data : void 0;
+	const cachedDataRef = (0, react.useRef)(cachedData);
+	if (cachedData != null) cachedDataRef.current = cachedData;
+	const [, setMutateVersion] = (0, react.useState)(0);
+	const mutate = (0, react.useCallback)(async (mutateId) => {
+		const fetchId = mutateId ?? threadId;
+		if (!fetchId) return void 0;
+		try {
+			const data = await fetchThreadHistory(client, fetchId, { limit: historyLimit });
+			const key = getCacheKey(client, fetchId, historyLimit);
+			threadCache.set(key, {
+				status: "resolved",
+				data
+			});
+			cachedDataRef.current = data;
+			setMutateVersion((v) => v + 1);
+			return data;
+		} catch {
+			return;
+		}
+	}, [
+		client,
+		threadId,
+		historyLimit
+	]);
+	const thread = (0, react.useMemo)(() => {
+		if (!needsHistoryFetch) return options.thread;
+		return {
+			data: cachedDataRef.current,
+			error: void 0,
+			isLoading: false,
+			mutate
+		};
+	}, [
+		needsHistoryFetch,
+		options.thread,
+		cachedData,
+		mutate
+	]);
+	const stream = require_stream_lgp.useStreamLGP({
+		...options,
+		client,
+		thread
+	});
+	if (needsHistoryFetch && cacheEntry && !stream.isLoading) {
+		if (cacheEntry.status === "pending") throw cacheEntry.promise;
+		if (cacheEntry.status === "rejected") {
+			const key = getCacheKey(client, threadId, historyLimit);
+			threadCache.delete(key);
+			throw cacheEntry.error instanceof Error ? cacheEntry.error : new Error(String(cacheEntry.error));
+		}
+	}
+	if (stream.error != null && !stream.isLoading) throw stream.error instanceof Error ? stream.error : new Error(String(stream.error));
+	return {
+		get values() {
+			return stream.values;
+		},
+		get messages() {
+			return stream.messages;
+		},
+		get toolCalls() {
+			return stream.toolCalls;
+		},
+		get toolProgress() {
+			return stream.toolProgress;
+		},
+		getToolCalls: stream.getToolCalls.bind(stream),
+		get interrupt() {
+			return stream.interrupt;
+		},
+		get interrupts() {
+			return stream.interrupts;
+		},
+		get subagents() {
+			return stream.subagents;
+		},
+		get activeSubagents() {
+			return stream.activeSubagents;
+		},
+		getSubagent: stream.getSubagent.bind(stream),
+		getSubagentsByType: stream.getSubagentsByType.bind(stream),
+		getSubagentsByMessage: stream.getSubagentsByMessage.bind(stream),
+		getMessagesMetadata: stream.getMessagesMetadata.bind(stream),
+		get history() {
+			return stream.history;
+		},
+		get experimental_branchTree() {
+			return stream.experimental_branchTree;
+		},
+		stop: stream.stop,
+		submit: stream.submit,
+		switchThread: stream.switchThread,
+		joinStream: stream.joinStream,
+		branch: stream.branch,
+		setBranch: stream.setBranch,
+		client: stream.client,
+		assistantId: stream.assistantId,
+		queue: stream.queue,
+		isStreaming: stream.isLoading
+	};
+}
+//#endregion
+exports.invalidateSuspenseCache = invalidateSuspenseCache;
+exports.useSuspenseStream = useSuspenseStream;
+
+//# sourceMappingURL=suspense-stream.cjs.map

package/dist/suspense-stream.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"suspense-stream.cjs","names":["Client","useStreamLGP"],"sources":["../src/suspense-stream.tsx"],"sourcesContent":["/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */\n\n\"use client\";\n\nimport { useCallback, useMemo, useRef, useState } from \"react\";\nimport type { ThreadState, BagTemplate } from \"@langchain/langgraph-sdk\";\nimport { Client, getClientConfigHash } from \"@langchain/langgraph-sdk/client\";\nimport type {\n  UseStreamThread,\n  ResolveStreamOptions,\n  ResolveStreamInterface,\n  InferBag,\n} from \"@langchain/langgraph-sdk/ui\";\nimport { useStreamLGP } from \"./stream.lgp.js\";\nimport type { WithClassMessages } from \"./stream.js\";\n\n// ---------------------------------------------------------------------------\n// Suspense cache\n// ---------------------------------------------------------------------------\n\ntype SuspenseCacheEntry<T> =\n  | { status: \"pending\"; promise: Promise<void> }\n  | { status: \"resolved\"; data: T }\n  | { status: \"rejected\"; error: unknown };\n\nconst threadCache = new Map<string, SuspenseCacheEntry<unknown>>();\n\nfunction getCacheKey(\n  client: Client,\n  threadId: string,\n  limit: boolean | number,\n): string {\n  return `suspense:${getClientConfigHash(client)}:${threadId}:${limit}`;\n}\n\nfunction fetchThreadHistory<StateType extends Record<string, unknown>>(\n  client: Client,\n  threadId: string,\n  options?: { limit?: boolean | number },\n): Promise<ThreadState<StateType>[]> {\n  if (options?.limit === false) {\n    return client.threads.getState<StateType>(threadId).then((state) => {\n      if (state.checkpoint == null) return [];\n      return [state];\n    });\n  }\n\n  const limit = typeof options?.limit === \"number\" ? options.limit : 10;\n  return client.threads.getHistory<StateType>(threadId, { limit });\n}\n\nfunction getOrCreateCacheEntry<StateType extends Record<string, unknown>>(\n  client: Client,\n  threadId: string,\n  limit: boolean | number,\n): SuspenseCacheEntry<ThreadState<StateType>[]> {\n  const key = getCacheKey(client, threadId, limit);\n  let entry = threadCache.get(key) as\n    | SuspenseCacheEntry<ThreadState<StateType>[]>\n    | undefined;\n\n  if (!entry) {\n    // Start fetch. The promise always resolves (never rejects) so React\n    // Suspense correctly waits for it and then retries the render.\n    const promise = fetchThreadHistory<StateType>(client, threadId, { limit })\n      .then((data) => {\n        threadCache.set(key, { status: \"resolved\", data });\n      })\n      .catch((error: unknown) => {\n        threadCache.set(key, { status: \"rejected\", error });\n      });\n\n    entry = { status: \"pending\", promise };\n    threadCache.set(key, entry);\n  }\n\n  return entry;\n}\n\n/**\n * Clear the internal Suspense cache used by {@link useSuspenseStream}.\n *\n * Call this from an Error Boundary's `onReset` callback so that a retry\n * triggers a fresh thread-history fetch rather than re-throwing the\n * cached error.\n *\n * @example\n * ```tsx\n * <ErrorBoundary\n *   onReset={() => invalidateSuspenseCache()}\n *   fallbackRender={({ resetErrorBoundary }) => (\n *     <button onClick={resetErrorBoundary}>Retry</button>\n *   )}\n * >\n *   <Suspense fallback={<Spinner />}>\n *     <Chat />\n *   </Suspense>\n * </ErrorBoundary>\n * ```\n */\nexport function invalidateSuspenseCache(): void {\n  threadCache.clear();\n}\n\n// ---------------------------------------------------------------------------\n// Return-type helper\n// ---------------------------------------------------------------------------\n\ntype WithSuspense<T> = Omit<T, \"isLoading\" | \"error\" | \"isThreadLoading\"> & {\n  isStreaming: boolean;\n};\n\n// ---------------------------------------------------------------------------\n// Hook\n// ---------------------------------------------------------------------------\n\n/**\n * A Suspense-compatible variant of {@link useStream} for LangGraph Platform.\n *\n * `useSuspenseStream` suspends the component while the initial thread\n * history is being fetched and throws errors to the nearest React Error\n * Boundary.  During active streaming the component stays rendered and\n * `isStreaming` indicates whether tokens are arriving.\n *\n * @example\n * ```tsx\n * <ErrorBoundary fallback={<ErrorDisplay />}>\n *   <Suspense fallback={<Spinner />}>\n *     <Chat />\n *   </Suspense>\n * </ErrorBoundary>\n *\n * function Chat() {\n *   const { messages, submit, isStreaming } = useSuspenseStream({\n *     assistantId: \"agent\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *   return <MessageList messages={messages} />;\n * }\n * ```\n *\n * @template T - Either a ReactAgent / DeepAgent type or a state record type.\n * @template Bag - Type configuration bag (ConfigurableType, InterruptType, …).\n */\nexport function useSuspenseStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(\n  options: ResolveStreamOptions<T, InferBag<T, Bag>>,\n): WithClassMessages<WithSuspense<ResolveStreamInterface<T, InferBag<T, Bag>>>>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useSuspenseStream(options: any): any {\n  type StateType = Record<string, unknown>;\n\n  // ---- client (needed before useStreamLGP for cache key derivation) ----\n  const client = useMemo(\n    () =>\n      options.client ??\n      new Client({\n        apiUrl: options.apiUrl,\n        apiKey: options.apiKey,\n        callerOptions: options.callerOptions,\n        defaultHeaders: options.defaultHeaders,\n      }),\n    [\n      options.client,\n      options.apiKey,\n      options.apiUrl,\n      options.callerOptions,\n      options.defaultHeaders,\n    ],\n  );\n\n  const { threadId } = options;\n\n  const historyLimit: boolean | number =\n    typeof options.fetchStateHistory === \"object\" &&\n    options.fetchStateHistory != null\n      ? (options.fetchStateHistory.limit ?? false)\n      : (options.fetchStateHistory ?? false);\n\n  // Only manage history via the suspense cache when the caller hasn't\n  // supplied an external `thread` and there's a threadId to load.\n  const needsHistoryFetch = threadId != null && options.thread == null;\n\n  // ---- suspense cache lookup (synchronous, may create fetch) ----\n  let cacheEntry: SuspenseCacheEntry<ThreadState<StateType>[]> | undefined;\n\n  if (needsHistoryFetch) {\n    cacheEntry = getOrCreateCacheEntry<StateType>(\n      client,\n      threadId,\n      historyLimit,\n    );\n  }\n\n  const cachedData =\n    cacheEntry?.status === \"resolved\" ? cacheEntry.data : undefined;\n\n  // ---- mutable ref so `mutate` always writes the freshest data ----\n  const cachedDataRef = useRef(cachedData);\n  if (cachedData != null) {\n    cachedDataRef.current = cachedData;\n  }\n\n  // Re-render trigger after external mutate calls.\n  const [, setMutateVersion] = useState(0);\n\n  const mutate = useCallback(\n    async (\n      mutateId?: string,\n    ): Promise<ThreadState<StateType>[] | null | undefined> => {\n      const fetchId = mutateId ?? threadId;\n      if (!fetchId) return undefined;\n      try {\n        const data = await fetchThreadHistory<StateType>(client, fetchId, {\n          limit: historyLimit,\n        });\n        const key = getCacheKey(client, fetchId, historyLimit);\n        threadCache.set(key, { status: \"resolved\", data });\n        cachedDataRef.current = data;\n        setMutateVersion((v) => v + 1);\n        return data;\n      } catch {\n        return undefined;\n      }\n    },\n    [client, threadId, historyLimit],\n  );\n\n  // ---- build thread override for useStreamLGP ----\n  const thread: UseStreamThread<StateType> | undefined = useMemo(() => {\n    if (!needsHistoryFetch) return options.thread;\n    return {\n      data: cachedDataRef.current,\n      error: undefined,\n      isLoading: false,\n      mutate,\n    };\n    // `cachedData` is included so the memo recomputes when the cache\n    // transitions from pending → resolved across suspend/retry cycles.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [needsHistoryFetch, options.thread, cachedData, mutate]);\n\n  // ---- delegate to useStreamLGP (must always run – Rules of Hooks) ----\n  const stream = useStreamLGP({\n    ...options,\n    client,\n    thread,\n  });\n\n  // ---- post-hook: suspend or throw ----\n\n  // Suspend while thread history is loading, but only when the stream\n  // itself is idle. If an active stream is running (e.g. the thread was\n  // just created during submit), suspending would discard the stream\n  // state, so we skip it.\n  if (needsHistoryFetch && cacheEntry && !stream.isLoading) {\n    if (cacheEntry.status === \"pending\") {\n      // eslint-disable-next-line @typescript-eslint/no-throw-literal\n      throw cacheEntry.promise;\n    }\n    if (cacheEntry.status === \"rejected\") {\n      // Clear cache so a subsequent retry (ErrorBoundary reset) starts\n      // a fresh fetch instead of re-throwing the stale error.\n      const key = getCacheKey(client, threadId!, historyLimit);\n      threadCache.delete(key);\n      // eslint-disable-next-line no-instanceof/no-instanceof\n      throw cacheEntry.error instanceof Error\n        ? cacheEntry.error\n        : new Error(String(cacheEntry.error));\n    }\n  }\n\n  // Throw non-streaming errors to the nearest Error Boundary.\n  if (stream.error != null && !stream.isLoading) {\n    // eslint-disable-next-line no-instanceof/no-instanceof\n    throw stream.error instanceof Error\n      ? stream.error\n      : new Error(String(stream.error));\n  }\n\n  // Build return object explicitly to avoid triggering throwing getters\n  // (e.g. `history` throws when `fetchStateHistory` is not set).\n  return {\n    get values() {\n      return stream.values;\n    },\n    get messages() {\n      return stream.messages;\n    },\n    get toolCalls() {\n      return stream.toolCalls;\n    },\n    get toolProgress() {\n      return stream.toolProgress;\n    },\n    getToolCalls: stream.getToolCalls.bind(stream),\n    get interrupt() {\n      return stream.interrupt;\n    },\n    get interrupts() {\n      return stream.interrupts;\n    },\n    get subagents() {\n      return stream.subagents;\n    },\n    get activeSubagents() {\n      return stream.activeSubagents;\n    },\n    getSubagent: stream.getSubagent.bind(stream),\n    getSubagentsByType: stream.getSubagentsByType.bind(stream),\n    getSubagentsByMessage: stream.getSubagentsByMessage.bind(stream),\n    getMessagesMetadata: stream.getMessagesMetadata.bind(stream),\n    get history() {\n      return stream.history;\n    },\n    get experimental_branchTree() {\n      return stream.experimental_branchTree;\n    },\n    stop: stream.stop,\n    submit: stream.submit,\n    switchThread: stream.switchThread,\n    joinStream: stream.joinStream,\n    branch: stream.branch,\n    setBranch: stream.setBranch,\n    client: stream.client,\n    assistantId: stream.assistantId,\n    queue: stream.queue,\n    isStreaming: stream.isLoading,\n  };\n}\n"],"mappings":"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"}

package/dist/suspense-stream.d.cts

@@ -0,0 +1,62 @@
+import { WithClassMessages } from "./stream.cjs";
+import { BagTemplate } from "@langchain/langgraph-sdk";
+import { InferBag, ResolveStreamInterface, ResolveStreamOptions } from "@langchain/langgraph-sdk/ui";
+
+//#region src/suspense-stream.d.ts
+/**
+ * Clear the internal Suspense cache used by {@link useSuspenseStream}.
+ *
+ * Call this from an Error Boundary's `onReset` callback so that a retry
+ * triggers a fresh thread-history fetch rather than re-throwing the
+ * cached error.
+ *
+ * @example
+ * ```tsx
+ * <ErrorBoundary
+ *   onReset={() => invalidateSuspenseCache()}
+ *   fallbackRender={({ resetErrorBoundary }) => (
+ *     <button onClick={resetErrorBoundary}>Retry</button>
+ *   )}
+ * >
+ *   <Suspense fallback={<Spinner />}>
+ *     <Chat />
+ *   </Suspense>
+ * </ErrorBoundary>
+ * ```
+ */
+declare function invalidateSuspenseCache(): void;
+type WithSuspense<T> = Omit<T, "isLoading" | "error" | "isThreadLoading"> & {
+  isStreaming: boolean;
+};
+/**
+ * A Suspense-compatible variant of {@link useStream} for LangGraph Platform.
+ *
+ * `useSuspenseStream` suspends the component while the initial thread
+ * history is being fetched and throws errors to the nearest React Error
+ * Boundary.  During active streaming the component stays rendered and
+ * `isStreaming` indicates whether tokens are arriving.
+ *
+ * @example
+ * ```tsx
+ * <ErrorBoundary fallback={<ErrorDisplay />}>
+ *   <Suspense fallback={<Spinner />}>
+ *     <Chat />
+ *   </Suspense>
+ * </ErrorBoundary>
+ *
+ * function Chat() {
+ *   const { messages, submit, isStreaming } = useSuspenseStream({
+ *     assistantId: "agent",
+ *     apiUrl: "http://localhost:2024",
+ *   });
+ *   return <MessageList messages={messages} />;
+ * }
+ * ```
+ *
+ * @template T - Either a ReactAgent / DeepAgent type or a state record type.
+ * @template Bag - Type configuration bag (ConfigurableType, InterruptType, …).
+ */
+declare function useSuspenseStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: ResolveStreamOptions<T, InferBag<T, Bag>>): WithClassMessages<WithSuspense<ResolveStreamInterface<T, InferBag<T, Bag>>>>;
+//#endregion
+export { invalidateSuspenseCache, useSuspenseStream };
+//# sourceMappingURL=suspense-stream.d.cts.map

package/dist/suspense-stream.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suspense-stream.d.cts","names":[],"sources":["../src/suspense-stream.tsx"],"mappings":";;;;;;;AAoGA;;;;;AAEC;;;;;;;;;;AA0CD;;;;iBA5CgB,uBAAA,CAAA;AAAA,KAQX,YAAA,MAAkB,IAAA,CAAK,CAAA;EAC1B,WAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCc,iBAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EAAS,oBAAA,CAAqB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA,KAC5C,iBAAA,CAAkB,YAAA,CAAa,sBAAA,CAAuB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA"}

package/dist/suspense-stream.d.ts

@@ -0,0 +1,62 @@
+import { WithClassMessages } from "./stream.js";
+import { InferBag, ResolveStreamInterface, ResolveStreamOptions } from "@langchain/langgraph-sdk/ui";
+import { BagTemplate } from "@langchain/langgraph-sdk";
+
+//#region src/suspense-stream.d.ts
+/**
+ * Clear the internal Suspense cache used by {@link useSuspenseStream}.
+ *
+ * Call this from an Error Boundary's `onReset` callback so that a retry
+ * triggers a fresh thread-history fetch rather than re-throwing the
+ * cached error.
+ *
+ * @example
+ * ```tsx
+ * <ErrorBoundary
+ *   onReset={() => invalidateSuspenseCache()}
+ *   fallbackRender={({ resetErrorBoundary }) => (
+ *     <button onClick={resetErrorBoundary}>Retry</button>
+ *   )}
+ * >
+ *   <Suspense fallback={<Spinner />}>
+ *     <Chat />
+ *   </Suspense>
+ * </ErrorBoundary>
+ * ```
+ */
+declare function invalidateSuspenseCache(): void;
+type WithSuspense<T> = Omit<T, "isLoading" | "error" | "isThreadLoading"> & {
+  isStreaming: boolean;
+};
+/**
+ * A Suspense-compatible variant of {@link useStream} for LangGraph Platform.
+ *
+ * `useSuspenseStream` suspends the component while the initial thread
+ * history is being fetched and throws errors to the nearest React Error
+ * Boundary.  During active streaming the component stays rendered and
+ * `isStreaming` indicates whether tokens are arriving.
+ *
+ * @example
+ * ```tsx
+ * <ErrorBoundary fallback={<ErrorDisplay />}>
+ *   <Suspense fallback={<Spinner />}>
+ *     <Chat />
+ *   </Suspense>
+ * </ErrorBoundary>
+ *
+ * function Chat() {
+ *   const { messages, submit, isStreaming } = useSuspenseStream({
+ *     assistantId: "agent",
+ *     apiUrl: "http://localhost:2024",
+ *   });
+ *   return <MessageList messages={messages} />;
+ * }
+ * ```
+ *
+ * @template T - Either a ReactAgent / DeepAgent type or a state record type.
+ * @template Bag - Type configuration bag (ConfigurableType, InterruptType, …).
+ */
+declare function useSuspenseStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: ResolveStreamOptions<T, InferBag<T, Bag>>): WithClassMessages<WithSuspense<ResolveStreamInterface<T, InferBag<T, Bag>>>>;
+//#endregion
+export { invalidateSuspenseCache, useSuspenseStream };
+//# sourceMappingURL=suspense-stream.d.ts.map

package/dist/suspense-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suspense-stream.d.ts","names":[],"sources":["../src/suspense-stream.tsx"],"mappings":";;;;;;;AAoGA;;;;;AAEC;;;;;;;;;;AA0CD;;;;iBA5CgB,uBAAA,CAAA;AAAA,KAQX,YAAA,MAAkB,IAAA,CAAK,CAAA;EAC1B,WAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCc,iBAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EAAS,oBAAA,CAAqB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA,KAC5C,iBAAA,CAAkB,YAAA,CAAa,sBAAA,CAAuB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA"}

package/dist/suspense-stream.js

@@ -0,0 +1,186 @@
+"use client";
+import { useStreamLGP } from "./stream.lgp.js";
+import { useCallback, useMemo, useRef, useState } from "react";
+import { Client, getClientConfigHash } from "@langchain/langgraph-sdk/client";
+//#region src/suspense-stream.tsx
+const threadCache = /* @__PURE__ */ new Map();
+function getCacheKey(client, threadId, limit) {
+	return `suspense:${getClientConfigHash(client)}:${threadId}:${limit}`;
+}
+function fetchThreadHistory(client, threadId, options) {
+	if (options?.limit === false) return client.threads.getState(threadId).then((state) => {
+		if (state.checkpoint == null) return [];
+		return [state];
+	});
+	const limit = typeof options?.limit === "number" ? options.limit : 10;
+	return client.threads.getHistory(threadId, { limit });
+}
+function getOrCreateCacheEntry(client, threadId, limit) {
+	const key = getCacheKey(client, threadId, limit);
+	let entry = threadCache.get(key);
+	if (!entry) {
+		entry = {
+			status: "pending",
+			promise: fetchThreadHistory(client, threadId, { limit }).then((data) => {
+				threadCache.set(key, {
+					status: "resolved",
+					data
+				});
+			}).catch((error) => {
+				threadCache.set(key, {
+					status: "rejected",
+					error
+				});
+			})
+		};
+		threadCache.set(key, entry);
+	}
+	return entry;
+}
+/**
+* Clear the internal Suspense cache used by {@link useSuspenseStream}.
+*
+* Call this from an Error Boundary's `onReset` callback so that a retry
+* triggers a fresh thread-history fetch rather than re-throwing the
+* cached error.
+*
+* @example
+* ```tsx
+* <ErrorBoundary
+*   onReset={() => invalidateSuspenseCache()}
+*   fallbackRender={({ resetErrorBoundary }) => (
+*     <button onClick={resetErrorBoundary}>Retry</button>
+*   )}
+* >
+*   <Suspense fallback={<Spinner />}>
+*     <Chat />
+*   </Suspense>
+* </ErrorBoundary>
+* ```
+*/
+function invalidateSuspenseCache() {
+	threadCache.clear();
+}
+function useSuspenseStream(options) {
+	const client = useMemo(() => options.client ?? new Client({
+		apiUrl: options.apiUrl,
+		apiKey: options.apiKey,
+		callerOptions: options.callerOptions,
+		defaultHeaders: options.defaultHeaders
+	}), [
+		options.client,
+		options.apiKey,
+		options.apiUrl,
+		options.callerOptions,
+		options.defaultHeaders
+	]);
+	const { threadId } = options;
+	const historyLimit = typeof options.fetchStateHistory === "object" && options.fetchStateHistory != null ? options.fetchStateHistory.limit ?? false : options.fetchStateHistory ?? false;
+	const needsHistoryFetch = threadId != null && options.thread == null;
+	let cacheEntry;
+	if (needsHistoryFetch) cacheEntry = getOrCreateCacheEntry(client, threadId, historyLimit);
+	const cachedData = cacheEntry?.status === "resolved" ? cacheEntry.data : void 0;
+	const cachedDataRef = useRef(cachedData);
+	if (cachedData != null) cachedDataRef.current = cachedData;
+	const [, setMutateVersion] = useState(0);
+	const mutate = useCallback(async (mutateId) => {
+		const fetchId = mutateId ?? threadId;
+		if (!fetchId) return void 0;
+		try {
+			const data = await fetchThreadHistory(client, fetchId, { limit: historyLimit });
+			const key = getCacheKey(client, fetchId, historyLimit);
+			threadCache.set(key, {
+				status: "resolved",
+				data
+			});
+			cachedDataRef.current = data;
+			setMutateVersion((v) => v + 1);
+			return data;
+		} catch {
+			return;
+		}
+	}, [
+		client,
+		threadId,
+		historyLimit
+	]);
+	const thread = useMemo(() => {
+		if (!needsHistoryFetch) return options.thread;
+		return {
+			data: cachedDataRef.current,
+			error: void 0,
+			isLoading: false,
+			mutate
+		};
+	}, [
+		needsHistoryFetch,
+		options.thread,
+		cachedData,
+		mutate
+	]);
+	const stream = useStreamLGP({
+		...options,
+		client,
+		thread
+	});
+	if (needsHistoryFetch && cacheEntry && !stream.isLoading) {
+		if (cacheEntry.status === "pending") throw cacheEntry.promise;
+		if (cacheEntry.status === "rejected") {
+			const key = getCacheKey(client, threadId, historyLimit);
+			threadCache.delete(key);
+			throw cacheEntry.error instanceof Error ? cacheEntry.error : new Error(String(cacheEntry.error));
+		}
+	}
+	if (stream.error != null && !stream.isLoading) throw stream.error instanceof Error ? stream.error : new Error(String(stream.error));
+	return {
+		get values() {
+			return stream.values;
+		},
+		get messages() {
+			return stream.messages;
+		},
+		get toolCalls() {
+			return stream.toolCalls;
+		},
+		get toolProgress() {
+			return stream.toolProgress;
+		},
+		getToolCalls: stream.getToolCalls.bind(stream),
+		get interrupt() {
+			return stream.interrupt;
+		},
+		get interrupts() {
+			return stream.interrupts;
+		},
+		get subagents() {
+			return stream.subagents;
+		},
+		get activeSubagents() {
+			return stream.activeSubagents;
+		},
+		getSubagent: stream.getSubagent.bind(stream),
+		getSubagentsByType: stream.getSubagentsByType.bind(stream),
+		getSubagentsByMessage: stream.getSubagentsByMessage.bind(stream),
+		getMessagesMetadata: stream.getMessagesMetadata.bind(stream),
+		get history() {
+			return stream.history;
+		},
+		get experimental_branchTree() {
+			return stream.experimental_branchTree;
+		},
+		stop: stream.stop,
+		submit: stream.submit,
+		switchThread: stream.switchThread,
+		joinStream: stream.joinStream,
+		branch: stream.branch,
+		setBranch: stream.setBranch,
+		client: stream.client,
+		assistantId: stream.assistantId,
+		queue: stream.queue,
+		isStreaming: stream.isLoading
+	};
+}
+//#endregion
+export { invalidateSuspenseCache, useSuspenseStream };
+
+//# sourceMappingURL=suspense-stream.js.map

package/dist/suspense-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"suspense-stream.js","names":[],"sources":["../src/suspense-stream.tsx"],"sourcesContent":["/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */\n\n\"use client\";\n\nimport { useCallback, useMemo, useRef, useState } from \"react\";\nimport type { ThreadState, BagTemplate } from \"@langchain/langgraph-sdk\";\nimport { Client, getClientConfigHash } from \"@langchain/langgraph-sdk/client\";\nimport type {\n  UseStreamThread,\n  ResolveStreamOptions,\n  ResolveStreamInterface,\n  InferBag,\n} from \"@langchain/langgraph-sdk/ui\";\nimport { useStreamLGP } from \"./stream.lgp.js\";\nimport type { WithClassMessages } from \"./stream.js\";\n\n// ---------------------------------------------------------------------------\n// Suspense cache\n// ---------------------------------------------------------------------------\n\ntype SuspenseCacheEntry<T> =\n  | { status: \"pending\"; promise: Promise<void> }\n  | { status: \"resolved\"; data: T }\n  | { status: \"rejected\"; error: unknown };\n\nconst threadCache = new Map<string, SuspenseCacheEntry<unknown>>();\n\nfunction getCacheKey(\n  client: Client,\n  threadId: string,\n  limit: boolean | number,\n): string {\n  return `suspense:${getClientConfigHash(client)}:${threadId}:${limit}`;\n}\n\nfunction fetchThreadHistory<StateType extends Record<string, unknown>>(\n  client: Client,\n  threadId: string,\n  options?: { limit?: boolean | number },\n): Promise<ThreadState<StateType>[]> {\n  if (options?.limit === false) {\n    return client.threads.getState<StateType>(threadId).then((state) => {\n      if (state.checkpoint == null) return [];\n      return [state];\n    });\n  }\n\n  const limit = typeof options?.limit === \"number\" ? options.limit : 10;\n  return client.threads.getHistory<StateType>(threadId, { limit });\n}\n\nfunction getOrCreateCacheEntry<StateType extends Record<string, unknown>>(\n  client: Client,\n  threadId: string,\n  limit: boolean | number,\n): SuspenseCacheEntry<ThreadState<StateType>[]> {\n  const key = getCacheKey(client, threadId, limit);\n  let entry = threadCache.get(key) as\n    | SuspenseCacheEntry<ThreadState<StateType>[]>\n    | undefined;\n\n  if (!entry) {\n    // Start fetch. The promise always resolves (never rejects) so React\n    // Suspense correctly waits for it and then retries the render.\n    const promise = fetchThreadHistory<StateType>(client, threadId, { limit })\n      .then((data) => {\n        threadCache.set(key, { status: \"resolved\", data });\n      })\n      .catch((error: unknown) => {\n        threadCache.set(key, { status: \"rejected\", error });\n      });\n\n    entry = { status: \"pending\", promise };\n    threadCache.set(key, entry);\n  }\n\n  return entry;\n}\n\n/**\n * Clear the internal Suspense cache used by {@link useSuspenseStream}.\n *\n * Call this from an Error Boundary's `onReset` callback so that a retry\n * triggers a fresh thread-history fetch rather than re-throwing the\n * cached error.\n *\n * @example\n * ```tsx\n * <ErrorBoundary\n *   onReset={() => invalidateSuspenseCache()}\n *   fallbackRender={({ resetErrorBoundary }) => (\n *     <button onClick={resetErrorBoundary}>Retry</button>\n *   )}\n * >\n *   <Suspense fallback={<Spinner />}>\n *     <Chat />\n *   </Suspense>\n * </ErrorBoundary>\n * ```\n */\nexport function invalidateSuspenseCache(): void {\n  threadCache.clear();\n}\n\n// ---------------------------------------------------------------------------\n// Return-type helper\n// ---------------------------------------------------------------------------\n\ntype WithSuspense<T> = Omit<T, \"isLoading\" | \"error\" | \"isThreadLoading\"> & {\n  isStreaming: boolean;\n};\n\n// ---------------------------------------------------------------------------\n// Hook\n// ---------------------------------------------------------------------------\n\n/**\n * A Suspense-compatible variant of {@link useStream} for LangGraph Platform.\n *\n * `useSuspenseStream` suspends the component while the initial thread\n * history is being fetched and throws errors to the nearest React Error\n * Boundary.  During active streaming the component stays rendered and\n * `isStreaming` indicates whether tokens are arriving.\n *\n * @example\n * ```tsx\n * <ErrorBoundary fallback={<ErrorDisplay />}>\n *   <Suspense fallback={<Spinner />}>\n *     <Chat />\n *   </Suspense>\n * </ErrorBoundary>\n *\n * function Chat() {\n *   const { messages, submit, isStreaming } = useSuspenseStream({\n *     assistantId: \"agent\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *   return <MessageList messages={messages} />;\n * }\n * ```\n *\n * @template T - Either a ReactAgent / DeepAgent type or a state record type.\n * @template Bag - Type configuration bag (ConfigurableType, InterruptType, …).\n */\nexport function useSuspenseStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(\n  options: ResolveStreamOptions<T, InferBag<T, Bag>>,\n): WithClassMessages<WithSuspense<ResolveStreamInterface<T, InferBag<T, Bag>>>>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useSuspenseStream(options: any): any {\n  type StateType = Record<string, unknown>;\n\n  // ---- client (needed before useStreamLGP for cache key derivation) ----\n  const client = useMemo(\n    () =>\n      options.client ??\n      new Client({\n        apiUrl: options.apiUrl,\n        apiKey: options.apiKey,\n        callerOptions: options.callerOptions,\n        defaultHeaders: options.defaultHeaders,\n      }),\n    [\n      options.client,\n      options.apiKey,\n      options.apiUrl,\n      options.callerOptions,\n      options.defaultHeaders,\n    ],\n  );\n\n  const { threadId } = options;\n\n  const historyLimit: boolean | number =\n    typeof options.fetchStateHistory === \"object\" &&\n    options.fetchStateHistory != null\n      ? (options.fetchStateHistory.limit ?? false)\n      : (options.fetchStateHistory ?? false);\n\n  // Only manage history via the suspense cache when the caller hasn't\n  // supplied an external `thread` and there's a threadId to load.\n  const needsHistoryFetch = threadId != null && options.thread == null;\n\n  // ---- suspense cache lookup (synchronous, may create fetch) ----\n  let cacheEntry: SuspenseCacheEntry<ThreadState<StateType>[]> | undefined;\n\n  if (needsHistoryFetch) {\n    cacheEntry = getOrCreateCacheEntry<StateType>(\n      client,\n      threadId,\n      historyLimit,\n    );\n  }\n\n  const cachedData =\n    cacheEntry?.status === \"resolved\" ? cacheEntry.data : undefined;\n\n  // ---- mutable ref so `mutate` always writes the freshest data ----\n  const cachedDataRef = useRef(cachedData);\n  if (cachedData != null) {\n    cachedDataRef.current = cachedData;\n  }\n\n  // Re-render trigger after external mutate calls.\n  const [, setMutateVersion] = useState(0);\n\n  const mutate = useCallback(\n    async (\n      mutateId?: string,\n    ): Promise<ThreadState<StateType>[] | null | undefined> => {\n      const fetchId = mutateId ?? threadId;\n      if (!fetchId) return undefined;\n      try {\n        const data = await fetchThreadHistory<StateType>(client, fetchId, {\n          limit: historyLimit,\n        });\n        const key = getCacheKey(client, fetchId, historyLimit);\n        threadCache.set(key, { status: \"resolved\", data });\n        cachedDataRef.current = data;\n        setMutateVersion((v) => v + 1);\n        return data;\n      } catch {\n        return undefined;\n      }\n    },\n    [client, threadId, historyLimit],\n  );\n\n  // ---- build thread override for useStreamLGP ----\n  const thread: UseStreamThread<StateType> | undefined = useMemo(() => {\n    if (!needsHistoryFetch) return options.thread;\n    return {\n      data: cachedDataRef.current,\n      error: undefined,\n      isLoading: false,\n      mutate,\n    };\n    // `cachedData` is included so the memo recomputes when the cache\n    // transitions from pending → resolved across suspend/retry cycles.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [needsHistoryFetch, options.thread, cachedData, mutate]);\n\n  // ---- delegate to useStreamLGP (must always run – Rules of Hooks) ----\n  const stream = useStreamLGP({\n    ...options,\n    client,\n    thread,\n  });\n\n  // ---- post-hook: suspend or throw ----\n\n  // Suspend while thread history is loading, but only when the stream\n  // itself is idle. If an active stream is running (e.g. the thread was\n  // just created during submit), suspending would discard the stream\n  // state, so we skip it.\n  if (needsHistoryFetch && cacheEntry && !stream.isLoading) {\n    if (cacheEntry.status === \"pending\") {\n      // eslint-disable-next-line @typescript-eslint/no-throw-literal\n      throw cacheEntry.promise;\n    }\n    if (cacheEntry.status === \"rejected\") {\n      // Clear cache so a subsequent retry (ErrorBoundary reset) starts\n      // a fresh fetch instead of re-throwing the stale error.\n      const key = getCacheKey(client, threadId!, historyLimit);\n      threadCache.delete(key);\n      // eslint-disable-next-line no-instanceof/no-instanceof\n      throw cacheEntry.error instanceof Error\n        ? cacheEntry.error\n        : new Error(String(cacheEntry.error));\n    }\n  }\n\n  // Throw non-streaming errors to the nearest Error Boundary.\n  if (stream.error != null && !stream.isLoading) {\n    // eslint-disable-next-line no-instanceof/no-instanceof\n    throw stream.error instanceof Error\n      ? stream.error\n      : new Error(String(stream.error));\n  }\n\n  // Build return object explicitly to avoid triggering throwing getters\n  // (e.g. `history` throws when `fetchStateHistory` is not set).\n  return {\n    get values() {\n      return stream.values;\n    },\n    get messages() {\n      return stream.messages;\n    },\n    get toolCalls() {\n      return stream.toolCalls;\n    },\n    get toolProgress() {\n      return stream.toolProgress;\n    },\n    getToolCalls: stream.getToolCalls.bind(stream),\n    get interrupt() {\n      return stream.interrupt;\n    },\n    get interrupts() {\n      return stream.interrupts;\n    },\n    get subagents() {\n      return stream.subagents;\n    },\n    get activeSubagents() {\n      return stream.activeSubagents;\n    },\n    getSubagent: stream.getSubagent.bind(stream),\n    getSubagentsByType: stream.getSubagentsByType.bind(stream),\n    getSubagentsByMessage: stream.getSubagentsByMessage.bind(stream),\n    getMessagesMetadata: stream.getMessagesMetadata.bind(stream),\n    get history() {\n      return stream.history;\n    },\n    get experimental_branchTree() {\n      return stream.experimental_branchTree;\n    },\n    stop: stream.stop,\n    submit: stream.submit,\n    switchThread: stream.switchThread,\n    joinStream: stream.joinStream,\n    branch: stream.branch,\n    setBranch: stream.setBranch,\n    client: stream.client,\n    assistantId: stream.assistantId,\n    queue: stream.queue,\n    isStreaming: stream.isLoading,\n  };\n}\n"],"mappings":"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"}

package/dist/thread.cjs

@@ -1,5 +1,4 @@
 "use client";
-require("./_virtual/_rolldown/runtime.cjs");
 let react = require("react");
 //#region src/thread.tsx
 const useControllableThreadId = (options) => {

package/dist/thread.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"thread.cjs","names":[],"sources":["../src/thread.tsx"],"sourcesContent":["\"use client\";\n\nimport { useState, useRef, useCallback } from \"react\";\n\nexport const useControllableThreadId = (options?: {\n  threadId?: string | null;\n  onThreadId?: (threadId: string) => void;\n}): [string | null, (threadId: string | null) => void] => {\n  const [localThreadId, _setLocalThreadId] = useState<string | null>(\n    options?.threadId ?? null,\n  );\n\n  const onThreadIdRef = useRef(options?.onThreadId);\n  onThreadIdRef.current = options?.onThreadId;\n\n  const setThreadId = useCallback((threadId: string | null) => {\n    _setLocalThreadId(threadId);\n    if (threadId != null) onThreadIdRef.current?.(threadId);\n  }, []);\n\n  if (!options || !(\"threadId\" in options)) {\n    return [localThreadId, setThreadId];\n  }\n\n  return [options.threadId ?? null, setThreadId];\n};\n"],"mappings":";;;;AAIA,MAAa,2BAA2B,YAGkB;CACxD,MAAM,CAAC,eAAe,sBAAA,GAAA,MAAA,UACpB,SAAS,YAAY,KACtB;CAED,MAAM,iBAAA,GAAA,MAAA,QAAuB,SAAS,WAAW;AACjD,eAAc,UAAU,SAAS;CAEjC,MAAM,eAAA,GAAA,MAAA,cAA2B,aAA4B;AAC3D,oBAAkB,SAAS;AAC3B,MAAI,YAAY,KAAM,eAAc,UAAU,SAAS;IACtD,EAAE,CAAC;AAEN,KAAI,CAAC,WAAW,EAAE,cAAc,SAC9B,QAAO,CAAC,eAAe,YAAY;AAGrC,QAAO,CAAC,QAAQ,YAAY,MAAM,YAAY"}
+{"version":3,"file":"thread.cjs","names":[],"sources":["../src/thread.tsx"],"sourcesContent":["\"use client\";\n\nimport { useState, useRef, useCallback } from \"react\";\n\nexport const useControllableThreadId = (options?: {\n  threadId?: string | null;\n  onThreadId?: (threadId: string) => void;\n}): [string | null, (threadId: string | null) => void] => {\n  const [localThreadId, _setLocalThreadId] = useState<string | null>(\n    options?.threadId ?? null,\n  );\n\n  const onThreadIdRef = useRef(options?.onThreadId);\n  onThreadIdRef.current = options?.onThreadId;\n\n  const setThreadId = useCallback((threadId: string | null) => {\n    _setLocalThreadId(threadId);\n    if (threadId != null) onThreadIdRef.current?.(threadId);\n  }, []);\n\n  if (!options || !(\"threadId\" in options)) {\n    return [localThreadId, setThreadId];\n  }\n\n  return [options.threadId ?? null, setThreadId];\n};\n"],"mappings":";;;AAIA,MAAa,2BAA2B,YAGkB;CACxD,MAAM,CAAC,eAAe,sBAAA,GAAA,MAAA,UACpB,SAAS,YAAY,KACtB;CAED,MAAM,iBAAA,GAAA,MAAA,QAAuB,SAAS,WAAW;AACjD,eAAc,UAAU,SAAS;CAEjC,MAAM,eAAA,GAAA,MAAA,cAA2B,aAA4B;AAC3D,oBAAkB,SAAS;AAC3B,MAAI,YAAY,KAAM,eAAc,UAAU,SAAS;IACtD,EAAE,CAAC;AAEN,KAAI,CAAC,WAAW,EAAE,cAAc,SAC9B,QAAO,CAAC,eAAe,YAAY;AAGrC,QAAO,CAAC,QAAQ,YAAY,MAAM,YAAY"}

package/dist/types.d.cts

@@ -1,6 +1,6 @@
 import { BaseMessage } from "@langchain/core/messages";
 import { BagTemplate, Client, StreamEvent, StreamMode, ThreadState, ToolProgress } from "@langchain/langgraph-sdk";
-import { CustomSubmitOptions, DefaultSubagentStates, GetConfigurableType, GetInterruptType, GetToolCallsType, GetUpdateType, MessageMetadata as MessageMetadata$1, QueueInterface, Sequence, StreamBase, SubagentStream, SubagentStreamInterface as SubagentStreamInterface$1, SubmitOptions, UseStreamCustomOptions } from "@langchain/langgraph-sdk/ui";
+import { CustomSubmitOptions, DefaultSubagentStates, GetConfigurableType, GetInterruptType, GetToolCallsType, GetUpdateType, MessageMetadata as MessageMetadata$1, QueueInterface, Sequence, StreamBase, SubagentStream, SubagentStreamInterface as SubagentStreamInterface$1, SubmitOptions, UseStreamCustomOptions as UseStreamCustomOptions$1 } from "@langchain/langgraph-sdk/ui";
 
 //#region src/types.d.ts
 interface UseStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate, SubagentStates extends Record<string, unknown> = DefaultSubagentStates> extends Omit<StreamBase<StateType, GetToolCallsType<StateType>, GetInterruptType<Bag>, SubagentStates>, "messages"> {
@@ -80,6 +80,22 @@ interface UseStream<StateType extends Record<string, unknown> = Record<string, u
    */
   queue: QueueInterface<StateType, SubmitOptions<StateType, GetConfigurableType<Bag>>>;
 }
+/**
+ * Return type for {@link useSuspenseStream}.
+ *
+ * Identical to {@link UseStream} but without `isLoading`, `error`, and
+ * `isThreadLoading` (those states are handled by Suspense / Error Boundaries).
+ * An `isStreaming` flag is provided instead to indicate whether tokens are
+ * currently being received from the server.
+ */
+type UseSuspenseStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate, SubagentStates extends Record<string, unknown> = DefaultSubagentStates> = Omit<UseStream<StateType, Bag, SubagentStates>, "isLoading" | "error" | "isThreadLoading"> & {
+  /**
+   * Whether the stream is currently receiving data from the server.
+   * Unlike Suspense-based loading, streaming is incremental and the
+   * component stays rendered throughout.
+   */
+  isStreaming: boolean;
+};
 type UseStreamCustom<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate, SubagentStates extends Record<string, unknown> = DefaultSubagentStates> = Pick<UseStream<StateType, Bag, SubagentStates>, "values" | "error" | "isLoading" | "stop" | "interrupt" | "interrupts" | "messages" | "toolCalls" | "getToolCalls" | "getMessagesMetadata" | "branch" | "setBranch" | "subagents" | "activeSubagents" | "getSubagent" | "getSubagentsByType" | "getSubagentsByMessage"> & {
   submit: (values: GetUpdateType<Bag, StateType> | null | undefined, options?: CustomSubmitOptions<StateType, GetConfigurableType<Bag>>) => Promise<void>;
   switchThread: (newThreadId: string | null) => void;
@@ -89,5 +105,5 @@ type UseStreamCustom<StateType extends Record<string, unknown> = Record<string,
   queue: QueueInterface<StateType, CustomSubmitOptions<StateType, GetConfigurableType<Bag>>>;
 };
 //#endregion
-export { type SubagentStream, type SubagentStreamInterface$1 as SubagentStreamInterface, type SubmitOptions, UseStream, UseStreamCustom, type UseStreamCustomOptions };
+export { type SubagentStream, type SubagentStreamInterface$1 as SubagentStreamInterface, UseStream, UseStreamCustom, type UseStreamCustomOptions$1 as UseStreamCustomOptions, UseSuspenseStream };
 //# sourceMappingURL=types.d.cts.map

package/dist/types.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":[],"sources":["../src/types.tsx"],"mappings":";;;;;UAgFiB,SAAA,mBACG,MAAA,oBAA0B,MAAA,+BAChC,WAAA,GAAc,WAAA,yBACH,MAAA,oBAA0B,qBAAA,UACzC,IAAA,CACR,UAAA,CACE,SAAA,EACA,gBAAA,CAAiB,SAAA,GACjB,gBAAA,CAAiB,GAAA,GACjB,cAAA;EATa;;;EAgBf,QAAA,EAAU,WAAA;EAfkC;;;EAoB5C,eAAA;EAlBiD;;;EAuBjD,IAAA,QAAY,OAAA;EAlBO;;;EAuBnB,MAAA,GACE,MAAA,EAAQ,aAAA,CAAc,GAAA,EAAK,SAAA,sBAC3B,OAAA,GAAU,aAAA,CAAc,SAAA,EAAW,mBAAA,CAAoB,GAAA,OACpD,OAAA;EAlBK;;;EAuBV,MAAA;EAPU;;;EAYV,SAAA,GAAY,MAAA;EAXA;;;EAgBZ,OAAA,EAAS,WAAA,CAAY,SAAA;EAMa;;;;EAAlC,uBAAA,EAAyB,QAAA,CAAS,SAAA;EAkBpB;;;;;;;;EARd,mBAAA,GACE,OAAA,EAAS,WAAA,EACT,KAAA,cACG,iBAAA,CAAgB,SAAA;EA6CM;;;EAxC3B,YAAA,EAAc,YAAA;EArEF;;;EA0EZ,MAAA,EAAQ,MAAA;EA7EoC;;;EAkF5C,WAAA;EAhFA;;;EAqFA,UAAA,GACE,KAAA,UACA,WAAA,WACA,OAAA;IACE,UAAA,GAAa,UAAA,GAAa,UAAA;IAC1B,MAAA,IAAU,KAAA;MACR,EAAA;MACA,KAAA,EAAO,WAAA;MACP,IAAA;IAAA;EAAA,MAGD,OAAA;EAnFL;;;;EAyFA,YAAA,GAAe,WAAA;EA1Ef;;;;EAgFA,KAAA,EAAO,cAAA,CACL,SAAA,EACA,aAAA,CAAc,SAAA,EAAW,mBAAA,CAAoB,GAAA;AAAA;AAAA,KAIrC,eAAA,mBACQ,MAAA,oBAA0B,MAAA,+BAChC,WAAA,GAAc,WAAA,yBACH,MAAA,oBAA0B,qBAAA,IAC/C,IAAA,CACF,SAAA,CAAU,SAAA,EAAW,GAAA,EAAK,cAAA;EAmB1B,MAAA,GACE,MAAA,EAAQ,aAAA,CAAc,GAAA,EAAK,SAAA,sBAC3B,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,mBAAA,CAAoB,GAAA,OAC1D,OAAA;EAEL,YAAA,GAAe,WAAA;EAjHb;;;EAsHF,KAAA,EAAO,cAAA,CACL,SAAA,EACA,mBAAA,CAAoB,SAAA,EAAW,mBAAA,CAAoB,GAAA;AAAA"}
+{"version":3,"file":"types.d.cts","names":[],"sources":["../src/types.tsx"],"mappings":";;;;;UAgFiB,SAAA,mBACG,MAAA,oBAA0B,MAAA,+BAChC,WAAA,GAAc,WAAA,yBACH,MAAA,oBAA0B,qBAAA,UACzC,IAAA,CACR,UAAA,CACE,SAAA,EACA,gBAAA,CAAiB,SAAA,GACjB,gBAAA,CAAiB,GAAA,GACjB,cAAA;EATa;;;EAgBf,QAAA,EAAU,WAAA;EAfkC;;;EAoB5C,eAAA;EAlBiD;;;EAuBjD,IAAA,QAAY,OAAA;EAlBO;;;EAuBnB,MAAA,GACE,MAAA,EAAQ,aAAA,CAAc,GAAA,EAAK,SAAA,sBAC3B,OAAA,GAAU,aAAA,CAAc,SAAA,EAAW,mBAAA,CAAoB,GAAA,OACpD,OAAA;EAlBK;;;EAuBV,MAAA;EAPU;;;EAYV,SAAA,GAAY,MAAA;EAXA;;;EAgBZ,OAAA,EAAS,WAAA,CAAY,SAAA;EAMa;;;;EAAlC,uBAAA,EAAyB,QAAA,CAAS,SAAA;EAkBpB;;;;;;;;EARd,mBAAA,GACE,OAAA,EAAS,WAAA,EACT,KAAA,cACG,iBAAA,CAAgB,SAAA;EA6CM;;;EAxC3B,YAAA,EAAc,YAAA;EArEF;;;EA0EZ,MAAA,EAAQ,MAAA;EA7EoC;;;EAkF5C,WAAA;EAhFA;;;EAqFA,UAAA,GACE,KAAA,UACA,WAAA,WACA,OAAA;IACE,UAAA,GAAa,UAAA,GAAa,UAAA;IAC1B,MAAA,IAAU,KAAA;MACR,EAAA;MACA,KAAA,EAAO,WAAA;MACP,IAAA;IAAA;EAAA,MAGD,OAAA;EAnFL;;;;EAyFA,YAAA,GAAe,WAAA;EA1Ef;;;;EAgFA,KAAA,EAAO,cAAA,CACL,SAAA,EACA,aAAA,CAAc,SAAA,EAAW,mBAAA,CAAoB,GAAA;AAAA;;;;;;;;;KAYrC,iBAAA,mBACQ,MAAA,oBAA0B,MAAA,+BAChC,WAAA,GAAc,WAAA,yBACH,MAAA,oBAA0B,qBAAA,IAC/C,IAAA,CACF,SAAA,CAAU,SAAA,EAAW,GAAA,EAAK,cAAA;EAjFjB;;;;;EAyFT,WAAA;AAAA;AAAA,KAGU,eAAA,mBACQ,MAAA,oBAA0B,MAAA,+BAChC,WAAA,GAAc,WAAA,yBACH,MAAA,oBAA0B,qBAAA,IAC/C,IAAA,CACF,SAAA,CAAU,SAAA,EAAW,GAAA,EAAK,cAAA;EAmB1B,MAAA,GACE,MAAA,EAAQ,aAAA,CAAc,GAAA,EAAK,SAAA,sBAC3B,OAAA,GAAU,mBAAA,CAAoB,SAAA,EAAW,mBAAA,CAAoB,GAAA,OAC1D,OAAA;EAEL,YAAA,GAAe,WAAA;EAtGM;;;EA2GrB,KAAA,EAAO,cAAA,CACL,SAAA,EACA,mBAAA,CAAoB,SAAA,EAAW,mBAAA,CAAoB,GAAA;AAAA"}