@langchain/react 0.2.0 → 0.2.2

package/dist/suspense-stream.cjs.map

@@ -1 +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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"}
+{"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\nexport type SuspenseCacheEntry<T> =\n  | { status: \"pending\"; promise: Promise<void> }\n  | { status: \"resolved\"; data: T }\n  | { status: \"rejected\"; error: unknown };\n\nexport type SuspenseCache = Map<string, SuspenseCacheEntry<unknown>>;\n\nconst defaultSuspenseCache: SuspenseCache = new Map();\n\nexport function createSuspenseCache(): SuspenseCache {\n  return new Map();\n}\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  cache: SuspenseCache,\n  client: Client,\n  threadId: string,\n  limit: boolean | number,\n): SuspenseCacheEntry<ThreadState<StateType>[]> {\n  const key = getCacheKey(client, threadId, limit);\n  let entry = cache.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        cache.set(key, { status: \"resolved\", data });\n      })\n      .catch((error: unknown) => {\n        cache.set(key, { status: \"rejected\", error });\n      });\n\n    entry = { status: \"pending\", promise };\n    cache.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(\n  cache: SuspenseCache = defaultSuspenseCache,\n): void {\n  cache.clear();\n}\n\n// ---------------------------------------------------------------------------\n// Return-type helper\n// ---------------------------------------------------------------------------\n\ntype WithSuspense<T> = Omit<T, \"isLoading\" | \"error\" | \"isThreadLoading\"> & {\n  isStreaming: boolean;\n};\n\ntype UseSuspenseStreamOptions<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n> = ResolveStreamOptions<T, InferBag<T, Bag>> & {\n  /**\n   * Optional cache store used by Suspense history prefetching.\n   * Provide a custom cache in tests to avoid cross-test cache sharing.\n   */\n  suspenseCache?: SuspenseCache;\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: UseSuspenseStreamOptions<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  const cache: SuspenseCache = options.suspenseCache ?? defaultSuspenseCache;\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      cache,\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        cache.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    [cache, 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      cache.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    get branch() {\n      return stream.branch;\n    },\n    setBranch: stream.setBranch,\n    get client() {\n      return stream.client;\n    },\n    get assistantId() {\n      return stream.assistantId;\n    },\n    get queue() {\n      return stream.queue;\n    },\n    get isStreaming() {\n      return stream.isLoading;\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/suspense-stream.d.cts

@@ -1,8 +1,20 @@
-import { WithClassMessages } from "./stream.cjs";
+import { WithClassMessages as WithClassMessages$1 } from "./stream.cjs";
 import { BagTemplate } from "@langchain/langgraph-sdk";
 import { InferBag, ResolveStreamInterface, ResolveStreamOptions } from "@langchain/langgraph-sdk/ui";
 
 //#region src/suspense-stream.d.ts
+type SuspenseCacheEntry<T> = {
+  status: "pending";
+  promise: Promise<void>;
+} | {
+  status: "resolved";
+  data: T;
+} | {
+  status: "rejected";
+  error: unknown;
+};
+type SuspenseCache = Map<string, SuspenseCacheEntry<unknown>>;
+declare function createSuspenseCache(): SuspenseCache;
 /**
  * Clear the internal Suspense cache used by {@link useSuspenseStream}.
  *
@@ -24,10 +36,17 @@ import { InferBag, ResolveStreamInterface, ResolveStreamOptions } from "@langcha
  * </ErrorBoundary>
  * ```
  */
-declare function invalidateSuspenseCache(): void;
+declare function invalidateSuspenseCache(cache?: SuspenseCache): void;
 type WithSuspense<T> = Omit<T, "isLoading" | "error" | "isThreadLoading"> & {
   isStreaming: boolean;
 };
+type UseSuspenseStreamOptions<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> = ResolveStreamOptions<T, InferBag<T, Bag>> & {
+  /**
+   * Optional cache store used by Suspense history prefetching.
+   * Provide a custom cache in tests to avoid cross-test cache sharing.
+   */
+  suspenseCache?: SuspenseCache;
+};
 /**
  * A Suspense-compatible variant of {@link useStream} for LangGraph Platform.
  *
@@ -56,7 +75,7 @@ type WithSuspense<T> = Omit<T, "isLoading" | "error" | "isThreadLoading"> & {
  * @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>>>>;
+declare function useSuspenseStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: UseSuspenseStreamOptions<T, InferBag<T, Bag>>): WithClassMessages$1<WithSuspense<ResolveStreamInterface<T, InferBag<T, Bag>>>>;
 //#endregion
-export { invalidateSuspenseCache, useSuspenseStream };
+export { SuspenseCache, createSuspenseCache, invalidateSuspenseCache, useSuspenseStream };
 //# sourceMappingURL=suspense-stream.d.cts.map

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

@@ -1 +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"}
+{"version":3,"file":"suspense-stream.d.cts","names":[],"sources":["../src/suspense-stream.tsx"],"mappings":";;;;;KAoBY,kBAAA;EACN,MAAA;EAAmB,OAAA,EAAS,OAAA;AAAA;EAC5B,MAAA;EAAoB,IAAA,EAAM,CAAA;AAAA;EAC1B,MAAA;EAAoB,KAAA;AAAA;AAAA,KAEd,aAAA,GAAgB,GAAA,SAAY,kBAAA;AAAA,iBAIxB,mBAAA,CAAA,GAAuB,aAAA;;;;;;AAJvC;;;;;AAIA;;;;;AA8EA;;;;;AAIC;iBAJe,uBAAA,CACd,KAAA,GAAO,aAAA;AAAA,KASJ,YAAA,MAAkB,IAAA,CAAK,CAAA;EAC1B,WAAA;AAAA;AAAA,KAGG,wBAAA,KACC,MAAA,+BACQ,WAAA,GAAc,WAAA,IACxB,oBAAA,CAAqB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA;EAPZ;;;;EAY1B,aAAA,GAAgB,aAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmClB;;iBAAgB,iBAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EAAS,wBAAA,CAAyB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA,KAChD,mBAAA,CAAkB,YAAA,CAAa,sBAAA,CAAuB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA"}

package/dist/suspense-stream.d.ts

@@ -1,8 +1,20 @@
-import { WithClassMessages } from "./stream.js";
+import { WithClassMessages as WithClassMessages$1 } from "./stream.js";
 import { InferBag, ResolveStreamInterface, ResolveStreamOptions } from "@langchain/langgraph-sdk/ui";
 import { BagTemplate } from "@langchain/langgraph-sdk";
 
 //#region src/suspense-stream.d.ts
+type SuspenseCacheEntry<T> = {
+  status: "pending";
+  promise: Promise<void>;
+} | {
+  status: "resolved";
+  data: T;
+} | {
+  status: "rejected";
+  error: unknown;
+};
+type SuspenseCache = Map<string, SuspenseCacheEntry<unknown>>;
+declare function createSuspenseCache(): SuspenseCache;
 /**
  * Clear the internal Suspense cache used by {@link useSuspenseStream}.
  *
@@ -24,10 +36,17 @@ import { BagTemplate } from "@langchain/langgraph-sdk";
  * </ErrorBoundary>
  * ```
  */
-declare function invalidateSuspenseCache(): void;
+declare function invalidateSuspenseCache(cache?: SuspenseCache): void;
 type WithSuspense<T> = Omit<T, "isLoading" | "error" | "isThreadLoading"> & {
   isStreaming: boolean;
 };
+type UseSuspenseStreamOptions<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> = ResolveStreamOptions<T, InferBag<T, Bag>> & {
+  /**
+   * Optional cache store used by Suspense history prefetching.
+   * Provide a custom cache in tests to avoid cross-test cache sharing.
+   */
+  suspenseCache?: SuspenseCache;
+};
 /**
  * A Suspense-compatible variant of {@link useStream} for LangGraph Platform.
  *
@@ -56,7 +75,7 @@ type WithSuspense<T> = Omit<T, "isLoading" | "error" | "isThreadLoading"> & {
  * @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>>>>;
+declare function useSuspenseStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: UseSuspenseStreamOptions<T, InferBag<T, Bag>>): WithClassMessages$1<WithSuspense<ResolveStreamInterface<T, InferBag<T, Bag>>>>;
 //#endregion
-export { invalidateSuspenseCache, useSuspenseStream };
+export { SuspenseCache, createSuspenseCache, invalidateSuspenseCache, useSuspenseStream };
 //# sourceMappingURL=suspense-stream.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"suspense-stream.d.ts","names":[],"sources":["../src/suspense-stream.tsx"],"mappings":";;;;;KAoBY,kBAAA;EACN,MAAA;EAAmB,OAAA,EAAS,OAAA;AAAA;EAC5B,MAAA;EAAoB,IAAA,EAAM,CAAA;AAAA;EAC1B,MAAA;EAAoB,KAAA;AAAA;AAAA,KAEd,aAAA,GAAgB,GAAA,SAAY,kBAAA;AAAA,iBAIxB,mBAAA,CAAA,GAAuB,aAAA;;;;;;AAJvC;;;;;AAIA;;;;;AA8EA;;;;;AAIC;iBAJe,uBAAA,CACd,KAAA,GAAO,aAAA;AAAA,KASJ,YAAA,MAAkB,IAAA,CAAK,CAAA;EAC1B,WAAA;AAAA;AAAA,KAGG,wBAAA,KACC,MAAA,+BACQ,WAAA,GAAc,WAAA,IACxB,oBAAA,CAAqB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA;EAPZ;;;;EAY1B,aAAA,GAAgB,aAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmClB;;iBAAgB,iBAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EAAS,wBAAA,CAAyB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA,KAChD,mBAAA,CAAkB,YAAA,CAAa,sBAAA,CAAuB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA"}

package/dist/suspense-stream.js

@@ -3,7 +3,10 @@ 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();
+const defaultSuspenseCache = /* @__PURE__ */ new Map();
+function createSuspenseCache() {
+	return /* @__PURE__ */ new Map();
+}
 function getCacheKey(client, threadId, limit) {
 	return `suspense:${getClientConfigHash(client)}:${threadId}:${limit}`;
 }
@@ -15,25 +18,25 @@ function fetchThreadHistory(client, threadId, options) {
 	const limit = typeof options?.limit === "number" ? options.limit : 10;
 	return client.threads.getHistory(threadId, { limit });
 }
-function getOrCreateCacheEntry(client, threadId, limit) {
+function getOrCreateCacheEntry(cache, client, threadId, limit) {
 	const key = getCacheKey(client, threadId, limit);
-	let entry = threadCache.get(key);
+	let entry = cache.get(key);
 	if (!entry) {
 		entry = {
 			status: "pending",
 			promise: fetchThreadHistory(client, threadId, { limit }).then((data) => {
-				threadCache.set(key, {
+				cache.set(key, {
 					status: "resolved",
 					data
 				});
 			}).catch((error) => {
-				threadCache.set(key, {
+				cache.set(key, {
 					status: "rejected",
 					error
 				});
 			})
 		};
-		threadCache.set(key, entry);
+		cache.set(key, entry);
 	}
 	return entry;
 }
@@ -58,10 +61,11 @@ function getOrCreateCacheEntry(client, threadId, limit) {
 * </ErrorBoundary>
 * ```
 */
-function invalidateSuspenseCache() {
-	threadCache.clear();
+function invalidateSuspenseCache(cache = defaultSuspenseCache) {
+	cache.clear();
 }
 function useSuspenseStream(options) {
+	const cache = options.suspenseCache ?? defaultSuspenseCache;
 	const client = useMemo(() => options.client ?? new Client({
 		apiUrl: options.apiUrl,
 		apiKey: options.apiKey,
@@ -78,7 +82,7 @@ function useSuspenseStream(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);
+	if (needsHistoryFetch) cacheEntry = getOrCreateCacheEntry(cache, client, threadId, historyLimit);
 	const cachedData = cacheEntry?.status === "resolved" ? cacheEntry.data : void 0;
 	const cachedDataRef = useRef(cachedData);
 	if (cachedData != null) cachedDataRef.current = cachedData;
@@ -89,7 +93,7 @@ function useSuspenseStream(options) {
 		try {
 			const data = await fetchThreadHistory(client, fetchId, { limit: historyLimit });
 			const key = getCacheKey(client, fetchId, historyLimit);
-			threadCache.set(key, {
+			cache.set(key, {
 				status: "resolved",
 				data
 			});
@@ -100,6 +104,7 @@ function useSuspenseStream(options) {
 			return;
 		}
 	}, [
+		cache,
 		client,
 		threadId,
 		historyLimit
@@ -127,7 +132,7 @@ function useSuspenseStream(options) {
 		if (cacheEntry.status === "pending") throw cacheEntry.promise;
 		if (cacheEntry.status === "rejected") {
 			const key = getCacheKey(client, threadId, historyLimit);
-			threadCache.delete(key);
+			cache.delete(key);
 			throw cacheEntry.error instanceof Error ? cacheEntry.error : new Error(String(cacheEntry.error));
 		}
 	}
@@ -172,15 +177,25 @@ function useSuspenseStream(options) {
 		submit: stream.submit,
 		switchThread: stream.switchThread,
 		joinStream: stream.joinStream,
-		branch: stream.branch,
+		get branch() {
+			return stream.branch;
+		},
 		setBranch: stream.setBranch,
-		client: stream.client,
-		assistantId: stream.assistantId,
-		queue: stream.queue,
-		isStreaming: stream.isLoading
+		get client() {
+			return stream.client;
+		},
+		get assistantId() {
+			return stream.assistantId;
+		},
+		get queue() {
+			return stream.queue;
+		},
+		get isStreaming() {
+			return stream.isLoading;
+		}
 	};
 }
 //#endregion
-export { invalidateSuspenseCache, useSuspenseStream };
+export { createSuspenseCache, invalidateSuspenseCache, useSuspenseStream };
 
 //# sourceMappingURL=suspense-stream.js.map

package/dist/suspense-stream.js.map

@@ -1 +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":";;;;;AAyBA,MAAM,8BAAc,IAAI,KAA0C;AAElE,SAAS,YACP,QACA,UACA,OACQ;AACR,QAAO,YAAY,oBAAoB,OAAO,CAAC,GAAG,SAAS,GAAG;;AAGhE,SAAS,mBACP,QACA,UACA,SACmC;AACnC,KAAI,SAAS,UAAU,MACrB,QAAO,OAAO,QAAQ,SAAoB,SAAS,CAAC,MAAM,UAAU;AAClE,MAAI,MAAM,cAAc,KAAM,QAAO,EAAE;AACvC,SAAO,CAAC,MAAM;GACd;CAGJ,MAAM,QAAQ,OAAO,SAAS,UAAU,WAAW,QAAQ,QAAQ;AACnE,QAAO,OAAO,QAAQ,WAAsB,UAAU,EAAE,OAAO,CAAC;;AAGlE,SAAS,sBACP,QACA,UACA,OAC8C;CAC9C,MAAM,MAAM,YAAY,QAAQ,UAAU,MAAM;CAChD,IAAI,QAAQ,YAAY,IAAI,IAAI;AAIhC,KAAI,CAAC,OAAO;AAWV,UAAQ;GAAE,QAAQ;GAAW,SARb,mBAA8B,QAAQ,UAAU,EAAE,OAAO,CAAC,CACvE,MAAM,SAAS;AACd,gBAAY,IAAI,KAAK;KAAE,QAAQ;KAAY;KAAM,CAAC;KAClD,CACD,OAAO,UAAmB;AACzB,gBAAY,IAAI,KAAK;KAAE,QAAQ;KAAY;KAAO,CAAC;KACnD;GAEkC;AACtC,cAAY,IAAI,KAAK,MAAM;;AAG7B,QAAO;;;;;;;;;;;;;;;;;;;;;;;AAwBT,SAAgB,0BAAgC;AAC9C,aAAY,OAAO;;AAmDrB,SAAgB,kBAAkB,SAAmB;CAInD,MAAM,SAAS,cAEX,QAAQ,UACR,IAAI,OAAO;EACT,QAAQ,QAAQ;EAChB,QAAQ,QAAQ;EAChB,eAAe,QAAQ;EACvB,gBAAgB,QAAQ;EACzB,CAAC,EACJ;EACE,QAAQ;EACR,QAAQ;EACR,QAAQ;EACR,QAAQ;EACR,QAAQ;EACT,CACF;CAED,MAAM,EAAE,aAAa;CAErB,MAAM,eACJ,OAAO,QAAQ,sBAAsB,YACrC,QAAQ,qBAAqB,OACxB,QAAQ,kBAAkB,SAAS,QACnC,QAAQ,qBAAqB;CAIpC,MAAM,oBAAoB,YAAY,QAAQ,QAAQ,UAAU;CAGhE,IAAI;AAEJ,KAAI,kBACF,cAAa,sBACX,QACA,UACA,aACD;CAGH,MAAM,aACJ,YAAY,WAAW,aAAa,WAAW,OAAO,KAAA;CAGxD,MAAM,gBAAgB,OAAO,WAAW;AACxC,KAAI,cAAc,KAChB,eAAc,UAAU;CAI1B,MAAM,GAAG,oBAAoB,SAAS,EAAE;CAExC,MAAM,SAAS,YACb,OACE,aACyD;EACzD,MAAM,UAAU,YAAY;AAC5B,MAAI,CAAC,QAAS,QAAO,KAAA;AACrB,MAAI;GACF,MAAM,OAAO,MAAM,mBAA8B,QAAQ,SAAS,EAChE,OAAO,cACR,CAAC;GACF,MAAM,MAAM,YAAY,QAAQ,SAAS,aAAa;AACtD,eAAY,IAAI,KAAK;IAAE,QAAQ;IAAY;IAAM,CAAC;AAClD,iBAAc,UAAU;AACxB,qBAAkB,MAAM,IAAI,EAAE;AAC9B,UAAO;UACD;AACN;;IAGJ;EAAC;EAAQ;EAAU;EAAa,CACjC;CAGD,MAAM,SAAiD,cAAc;AACnE,MAAI,CAAC,kBAAmB,QAAO,QAAQ;AACvC,SAAO;GACL,MAAM,cAAc;GACpB,OAAO,KAAA;GACP,WAAW;GACX;GACD;IAIA;EAAC;EAAmB,QAAQ;EAAQ;EAAY;EAAO,CAAC;CAG3D,MAAM,SAAS,aAAa;EAC1B,GAAG;EACH;EACA;EACD,CAAC;AAQF,KAAI,qBAAqB,cAAc,CAAC,OAAO,WAAW;AACxD,MAAI,WAAW,WAAW,UAExB,OAAM,WAAW;AAEnB,MAAI,WAAW,WAAW,YAAY;GAGpC,MAAM,MAAM,YAAY,QAAQ,UAAW,aAAa;AACxD,eAAY,OAAO,IAAI;AAEvB,SAAM,WAAW,iBAAiB,QAC9B,WAAW,QACX,IAAI,MAAM,OAAO,WAAW,MAAM,CAAC;;;AAK3C,KAAI,OAAO,SAAS,QAAQ,CAAC,OAAO,UAElC,OAAM,OAAO,iBAAiB,QAC1B,OAAO,QACP,IAAI,MAAM,OAAO,OAAO,MAAM,CAAC;AAKrC,QAAO;EACL,IAAI,SAAS;AACX,UAAO,OAAO;;EAEhB,IAAI,WAAW;AACb,UAAO,OAAO;;EAEhB,IAAI,YAAY;AACd,UAAO,OAAO;;EAEhB,IAAI,eAAe;AACjB,UAAO,OAAO;;EAEhB,cAAc,OAAO,aAAa,KAAK,OAAO;EAC9C,IAAI,YAAY;AACd,UAAO,OAAO;;EAEhB,IAAI,aAAa;AACf,UAAO,OAAO;;EAEhB,IAAI,YAAY;AACd,UAAO,OAAO;;EAEhB,IAAI,kBAAkB;AACpB,UAAO,OAAO;;EAEhB,aAAa,OAAO,YAAY,KAAK,OAAO;EAC5C,oBAAoB,OAAO,mBAAmB,KAAK,OAAO;EAC1D,uBAAuB,OAAO,sBAAsB,KAAK,OAAO;EAChE,qBAAqB,OAAO,oBAAoB,KAAK,OAAO;EAC5D,IAAI,UAAU;AACZ,UAAO,OAAO;;EAEhB,IAAI,0BAA0B;AAC5B,UAAO,OAAO;;EAEhB,MAAM,OAAO;EACb,QAAQ,OAAO;EACf,cAAc,OAAO;EACrB,YAAY,OAAO;EACnB,QAAQ,OAAO;EACf,WAAW,OAAO;EAClB,QAAQ,OAAO;EACf,aAAa,OAAO;EACpB,OAAO,OAAO;EACd,aAAa,OAAO;EACrB"}
+{"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\nexport type SuspenseCacheEntry<T> =\n  | { status: \"pending\"; promise: Promise<void> }\n  | { status: \"resolved\"; data: T }\n  | { status: \"rejected\"; error: unknown };\n\nexport type SuspenseCache = Map<string, SuspenseCacheEntry<unknown>>;\n\nconst defaultSuspenseCache: SuspenseCache = new Map();\n\nexport function createSuspenseCache(): SuspenseCache {\n  return new Map();\n}\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  cache: SuspenseCache,\n  client: Client,\n  threadId: string,\n  limit: boolean | number,\n): SuspenseCacheEntry<ThreadState<StateType>[]> {\n  const key = getCacheKey(client, threadId, limit);\n  let entry = cache.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        cache.set(key, { status: \"resolved\", data });\n      })\n      .catch((error: unknown) => {\n        cache.set(key, { status: \"rejected\", error });\n      });\n\n    entry = { status: \"pending\", promise };\n    cache.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(\n  cache: SuspenseCache = defaultSuspenseCache,\n): void {\n  cache.clear();\n}\n\n// ---------------------------------------------------------------------------\n// Return-type helper\n// ---------------------------------------------------------------------------\n\ntype WithSuspense<T> = Omit<T, \"isLoading\" | \"error\" | \"isThreadLoading\"> & {\n  isStreaming: boolean;\n};\n\ntype UseSuspenseStreamOptions<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n> = ResolveStreamOptions<T, InferBag<T, Bag>> & {\n  /**\n   * Optional cache store used by Suspense history prefetching.\n   * Provide a custom cache in tests to avoid cross-test cache sharing.\n   */\n  suspenseCache?: SuspenseCache;\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: UseSuspenseStreamOptions<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  const cache: SuspenseCache = options.suspenseCache ?? defaultSuspenseCache;\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      cache,\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        cache.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    [cache, 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      cache.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    get branch() {\n      return stream.branch;\n    },\n    setBranch: stream.setBranch,\n    get client() {\n      return stream.client;\n    },\n    get assistantId() {\n      return stream.assistantId;\n    },\n    get queue() {\n      return stream.queue;\n    },\n    get isStreaming() {\n      return stream.isLoading;\n    },\n  };\n}\n"],"mappings":"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"}

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 as UseStreamCustomOptions$1 } from "@langchain/langgraph-sdk/ui";
+import { CustomSubmitOptions, DefaultSubagentStates, GetConfigurableType, GetInterruptType, GetToolCallsType, GetUpdateType, MessageMetadata, QueueInterface, Sequence, StreamBase, SubagentStream, SubagentStreamInterface, 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"> {
@@ -45,7 +45,7 @@ interface UseStream<StateType extends Record<string, unknown> = Record<string, u
    * @param index - The index of the message in the thread.
    * @returns The metadata for the message.
    */
-  getMessagesMetadata: (message: BaseMessage, index?: number) => MessageMetadata$1<StateType> | undefined;
+  getMessagesMetadata: (message: BaseMessage, index?: number) => MessageMetadata<StateType> | undefined;
   /**
    * Progress of tool executions during streaming.
    */
@@ -105,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, UseStream, UseStreamCustom, type UseStreamCustomOptions$1 as UseStreamCustomOptions, UseSuspenseStream };
+export { type SubagentStream, type 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;;;;;;;;;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"}
+{"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,eAAA,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"}

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-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";
+import { CustomSubmitOptions, DefaultSubagentStates, GetConfigurableType, GetInterruptType, GetToolCallsType, GetUpdateType, MessageMetadata, QueueInterface, Sequence, StreamBase, SubagentStream, SubagentStreamInterface, SubmitOptions, UseStreamCustomOptions as UseStreamCustomOptions$1 } from "@langchain/langgraph-sdk/ui";
 import { BaseMessage } from "@langchain/core/messages";
 import { BagTemplate, Client, StreamEvent, StreamMode, ThreadState, ToolProgress } from "@langchain/langgraph-sdk";
 
@@ -45,7 +45,7 @@ interface UseStream<StateType extends Record<string, unknown> = Record<string, u
    * @param index - The index of the message in the thread.
    * @returns The metadata for the message.
    */
-  getMessagesMetadata: (message: BaseMessage, index?: number) => MessageMetadata$1<StateType> | undefined;
+  getMessagesMetadata: (message: BaseMessage, index?: number) => MessageMetadata<StateType> | undefined;
   /**
    * Progress of tool executions during streaming.
    */
@@ -105,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, UseStream, UseStreamCustom, type UseStreamCustomOptions$1 as UseStreamCustomOptions, UseSuspenseStream };
+export { type SubagentStream, type SubagentStreamInterface, UseStream, UseStreamCustom, type UseStreamCustomOptions$1 as UseStreamCustomOptions, UseSuspenseStream };
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","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"}
+{"version":3,"file":"types.d.ts","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,eAAA,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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/react",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "React integration for LangGraph & LangChain",
   "type": "module",
   "license": "MIT",
@@ -10,7 +10,7 @@
     "directory": "libs/sdk-react"
   },
   "dependencies": {
-    "@langchain/langgraph-sdk": "^1.7.5"
+    "@langchain/langgraph-sdk": "^1.8.1"
   },
   "devDependencies": {
     "@hono/node-server": "^1.19.11",
@@ -39,7 +39,7 @@
     "vitest-browser-react": "^2.0.5",
     "webdriverio": "^9.25.0",
     "zod": "^4.3.6",
-    "@langchain/langgraph": "^1.2.4",
+    "@langchain/langgraph": "^1.2.6",
     "@langchain/langgraph-api": "^1.1.16",
     "@langchain/langgraph-checkpoint": "^1.0.1"
   },