@langchain/langgraph-sdk 1.6.5 → 1.7.0

package/dist/react/stream.custom.js

@@ -1,162 +0,0 @@
-"use client";
-
-import { BytesLineDecoder, SSEDecoder } from "../utils/sse.js";
-import { IterableReadableStream } from "../utils/stream.js";
-import { MessageTupleManager } from "../ui/messages.js";
-import { getToolCallsWithResults } from "../utils/tools.js";
-import { StreamManager } from "../ui/manager.js";
-import { useControllableThreadId } from "./thread.js";
-import { useEffect, useRef, useState, useSyncExternalStore } from "react";
-
-//#region src/react/stream.custom.tsx
-var FetchStreamTransport = class {
-	constructor(options) {
-		this.options = options;
-	}
-	async stream(payload) {
-		const { signal, ...body } = payload;
-		let requestInit = {
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				...this.options.defaultHeaders
-			},
-			body: JSON.stringify(body),
-			signal
-		};
-		if (this.options.onRequest) requestInit = await this.options.onRequest(this.options.apiUrl, requestInit);
-		const response = await (this.options.fetch ?? fetch)(this.options.apiUrl, requestInit);
-		if (!response.ok) throw new Error(`Failed to stream: ${response.statusText}`);
-		const stream = (response.body || new ReadableStream({ start: (ctrl) => ctrl.close() })).pipeThrough(BytesLineDecoder()).pipeThrough(SSEDecoder());
-		return IterableReadableStream.fromReadableStream(stream);
-	}
-};
-function useStreamCustom(options) {
-	const [messageManager] = useState(() => new MessageTupleManager());
-	const [stream] = useState(() => new StreamManager(messageManager, {
-		throttle: options.throttle ?? false,
-		subagentToolNames: options.subagentToolNames,
-		filterSubagentMessages: options.filterSubagentMessages
-	}));
-	useSyncExternalStore(stream.subscribe, stream.getSnapshot, stream.getSnapshot);
-	const [threadId, onThreadId] = useControllableThreadId(options);
-	const threadIdRef = useRef(threadId);
-	useEffect(() => {
-		if (threadIdRef.current !== threadId) {
-			threadIdRef.current = threadId;
-			stream.clear();
-		}
-	}, [threadId, stream]);
-	const getMessages = (value) => {
-		const messagesKey = options.messagesKey ?? "messages";
-		return Array.isArray(value[messagesKey]) ? value[messagesKey] : [];
-	};
-	const setMessages = (current, messages) => {
-		const messagesKey = options.messagesKey ?? "messages";
-		return {
-			...current,
-			[messagesKey]: messages
-		};
-	};
-	const historyValues = options.initialValues ?? {};
-	const historyMessages = getMessages(historyValues);
-	const shouldReconstructSubagents = options.filterSubagentMessages && !stream.isLoading && historyMessages.length > 0;
-	useEffect(() => {
-		if (shouldReconstructSubagents) stream.reconstructSubagents(historyMessages, { skipIfPopulated: true });
-	}, [shouldReconstructSubagents, historyMessages.length]);
-	const stop = () => stream.stop(historyValues, { onStop: options.onStop });
-	const submit = async (values, submitOptions) => {
-		let usableThreadId = threadId;
-		stream.setStreamValues(() => {
-			if (submitOptions?.optimisticValues != null) return {
-				...historyValues,
-				...typeof submitOptions.optimisticValues === "function" ? submitOptions.optimisticValues(historyValues) : submitOptions.optimisticValues
-			};
-			return { ...historyValues };
-		});
-		await stream.start(async (signal) => {
-			if (!usableThreadId) {
-				usableThreadId = crypto.randomUUID();
-				threadIdRef.current = usableThreadId;
-				onThreadId(usableThreadId);
-			}
-			if (!usableThreadId) throw new Error("Failed to obtain valid thread ID.");
-			return options.transport.stream({
-				input: values,
-				context: submitOptions?.context,
-				command: submitOptions?.command,
-				signal,
-				config: {
-					...submitOptions?.config,
-					configurable: {
-						thread_id: usableThreadId,
-						...submitOptions?.config?.configurable
-					}
-				}
-			});
-		}, {
-			getMessages,
-			setMessages,
-			initialValues: {},
-			callbacks: options,
-			onSuccess: () => void 0,
-			onError(error) {
-				options.onError?.(error, void 0);
-			}
-		});
-	};
-	return {
-		get values() {
-			return stream.values ?? {};
-		},
-		error: stream.error,
-		isLoading: stream.isLoading,
-		stop,
-		submit,
-		get interrupts() {
-			if (stream.values != null && "__interrupt__" in stream.values && Array.isArray(stream.values.__interrupt__)) {
-				const valueInterrupts = stream.values.__interrupt__;
-				if (valueInterrupts.length === 0) return [{ when: "breakpoint" }];
-				return valueInterrupts;
-			}
-			return [];
-		},
-		get interrupt() {
-			const all = this.interrupts;
-			if (all.length === 0) return void 0;
-			if (all.length === 1) return all[0];
-			return all;
-		},
-		get messages() {
-			if (!stream.values) return [];
-			return getMessages(stream.values);
-		},
-		get toolCalls() {
-			if (!stream.values) return [];
-			return getToolCallsWithResults(getMessages(stream.values));
-		},
-		getToolCalls(message) {
-			if (!stream.values) return [];
-			return getToolCallsWithResults(getMessages(stream.values)).filter((tc) => tc.aiMessage.id === message.id);
-		},
-		get subagents() {
-			return stream.getSubagents();
-		},
-		get activeSubagents() {
-			return stream.getActiveSubagents();
-		},
-		getSubagent(toolCallId) {
-			return stream.getSubagent(toolCallId);
-		},
-		getSubagentsByType(type) {
-			return stream.getSubagentsByType(type);
-		},
-		getSubagentsByMessage(messageId) {
-			return stream.getSubagentsByMessage(messageId);
-		}
-	};
-}
-
-//#endregion
-export { FetchStreamTransport, useStreamCustom };
-//# sourceMappingURL=stream.custom.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"stream.custom.js","names":[],"sources":["../../src/react/stream.custom.tsx"],"sourcesContent":["/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */\n\n\"use client\";\n\nimport { useEffect, useRef, useState, useSyncExternalStore } from \"react\";\nimport { EventStreamEvent, StreamManager } from \"../ui/manager.js\";\nimport type {\n  GetUpdateType,\n  GetCustomEventType,\n  GetInterruptType,\n  GetToolCallsType,\n  GetConfigurableType,\n  UseStreamTransport,\n  AnyStreamCustomOptions,\n  CustomSubmitOptions,\n} from \"../ui/types.js\";\nimport type { UseStreamCustom } from \"./types.js\";\nimport { type Message } from \"../types.messages.js\";\nimport { getToolCallsWithResults } from \"../utils/tools.js\";\nimport { MessageTupleManager } from \"../ui/messages.js\";\nimport { Interrupt } from \"../schema.js\";\nimport { BytesLineDecoder, SSEDecoder } from \"../utils/sse.js\";\nimport { IterableReadableStream } from \"../utils/stream.js\";\nimport { useControllableThreadId } from \"./thread.js\";\nimport { Command } from \"../types.js\";\nimport type { BagTemplate } from \"../types.template.js\";\n\ninterface FetchStreamTransportOptions {\n  /**\n   * The URL of the API to use.\n   */\n  apiUrl: string;\n\n  /**\n   * Default headers to send with requests.\n   */\n  defaultHeaders?: HeadersInit;\n\n  /**\n   * Specify a custom fetch implementation.\n   */\n  fetch?: typeof fetch | ((...args: any[]) => any); // eslint-disable-line @typescript-eslint/no-explicit-any\n\n  /**\n   * Callback that is called before the request is made.\n   */\n  onRequest?: (\n    url: string,\n    init: RequestInit\n  ) => Promise<RequestInit> | RequestInit;\n}\n\nexport class FetchStreamTransport<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate\n> implements UseStreamTransport<StateType, Bag>\n{\n  constructor(private readonly options: FetchStreamTransportOptions) {}\n\n  async stream(payload: {\n    input: GetUpdateType<Bag, StateType> | null | undefined;\n    context: GetConfigurableType<Bag> | undefined;\n    command: Command | undefined;\n    signal: AbortSignal;\n  }): Promise<AsyncGenerator<{ id?: string; event: string; data: unknown }>> {\n    const { signal, ...body } = payload;\n\n    let requestInit: RequestInit = {\n      method: \"POST\",\n      headers: {\n        \"Content-Type\": \"application/json\",\n        ...this.options.defaultHeaders,\n      },\n      body: JSON.stringify(body),\n      signal,\n    };\n\n    if (this.options.onRequest) {\n      requestInit = await this.options.onRequest(\n        this.options.apiUrl,\n        requestInit\n      );\n    }\n    const fetchFn = this.options.fetch ?? fetch;\n\n    const response = await fetchFn(this.options.apiUrl, requestInit);\n    if (!response.ok) {\n      throw new Error(`Failed to stream: ${response.statusText}`);\n    }\n\n    const stream = (\n      response.body || new ReadableStream({ start: (ctrl) => ctrl.close() })\n    )\n      .pipeThrough(BytesLineDecoder())\n      .pipeThrough(SSEDecoder());\n\n    return IterableReadableStream.fromReadableStream(stream);\n  }\n}\n\nexport function useStreamCustom<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate\n>(\n  options: AnyStreamCustomOptions<StateType, Bag>\n): UseStreamCustom<StateType, Bag> {\n  type UpdateType = GetUpdateType<Bag, StateType>;\n  type CustomType = GetCustomEventType<Bag>;\n  type InterruptType = GetInterruptType<Bag>;\n  type ConfigurableType = GetConfigurableType<Bag>;\n  type ToolCallType = GetToolCallsType<StateType>;\n\n  const [messageManager] = useState(() => new MessageTupleManager());\n  const [stream] = useState(\n    () =>\n      new StreamManager<StateType, Bag>(messageManager, {\n        throttle: options.throttle ?? false,\n        subagentToolNames: options.subagentToolNames,\n        filterSubagentMessages: options.filterSubagentMessages,\n      })\n  );\n\n  useSyncExternalStore(\n    stream.subscribe,\n    stream.getSnapshot,\n    stream.getSnapshot\n  );\n\n  const [threadId, onThreadId] = useControllableThreadId(options);\n  const threadIdRef = useRef<string | null>(threadId);\n\n  // Cancel the stream if thread ID has changed\n  useEffect(() => {\n    if (threadIdRef.current !== threadId) {\n      threadIdRef.current = threadId;\n      stream.clear();\n    }\n  }, [threadId, stream]);\n\n  const getMessages = (value: StateType): Message[] => {\n    const messagesKey = options.messagesKey ?? \"messages\";\n    return Array.isArray(value[messagesKey])\n      ? (value[messagesKey] as Message[])\n      : [];\n  };\n\n  const setMessages = (current: StateType, messages: Message[]): StateType => {\n    const messagesKey = options.messagesKey ?? \"messages\";\n    return { ...current, [messagesKey]: messages };\n  };\n\n  const historyValues = options.initialValues ?? ({} as StateType);\n\n  // Reconstruct subagents from initialValues when:\n  // 1. Subagent filtering is enabled\n  // 2. Not currently streaming\n  // 3. initialValues has messages\n  // This ensures subagent visualization works with cached/persisted state\n  const historyMessages = getMessages(historyValues);\n  const shouldReconstructSubagents =\n    options.filterSubagentMessages &&\n    !stream.isLoading &&\n    historyMessages.length > 0;\n\n  useEffect(() => {\n    if (shouldReconstructSubagents) {\n      // skipIfPopulated: true ensures we don't overwrite subagents from active streaming\n      stream.reconstructSubagents(historyMessages, { skipIfPopulated: true });\n    }\n    // We intentionally only run this when shouldReconstructSubagents changes\n    // to avoid unnecessary reconstructions during streaming\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [shouldReconstructSubagents, historyMessages.length]);\n\n  const stop = () => stream.stop(historyValues, { onStop: options.onStop });\n\n  const submit = async (\n    values: UpdateType | null | undefined,\n    submitOptions?: CustomSubmitOptions<StateType, ConfigurableType>\n  ) => {\n    let usableThreadId = threadId;\n\n    stream.setStreamValues(() => {\n      if (submitOptions?.optimisticValues != null) {\n        return {\n          ...historyValues,\n          ...(typeof submitOptions.optimisticValues === \"function\"\n            ? submitOptions.optimisticValues(historyValues)\n            : submitOptions.optimisticValues),\n        };\n      }\n\n      return { ...historyValues };\n    });\n\n    await stream.start(\n      async (signal: AbortSignal) => {\n        if (!usableThreadId) {\n          // generate random thread id\n          usableThreadId = crypto.randomUUID();\n          threadIdRef.current = usableThreadId;\n          onThreadId(usableThreadId);\n        }\n\n        if (!usableThreadId) {\n          throw new Error(\"Failed to obtain valid thread ID.\");\n        }\n\n        return options.transport.stream({\n          input: values,\n          context: submitOptions?.context,\n          command: submitOptions?.command,\n          signal,\n          config: {\n            ...submitOptions?.config,\n            configurable: {\n              thread_id: usableThreadId,\n              ...submitOptions?.config?.configurable,\n            } as unknown as GetConfigurableType<Bag>,\n          },\n        }) as Promise<\n          AsyncGenerator<EventStreamEvent<StateType, UpdateType, CustomType>>\n        >;\n      },\n      {\n        getMessages,\n        setMessages,\n\n        initialValues: {} as StateType,\n        callbacks: options,\n\n        onSuccess: () => undefined,\n        onError(error) {\n          options.onError?.(error, undefined);\n        },\n      }\n    );\n  };\n\n  return {\n    get values() {\n      return stream.values ?? ({} as StateType);\n    },\n\n    error: stream.error,\n    isLoading: stream.isLoading,\n\n    stop,\n    submit,\n\n    get interrupts(): Interrupt<InterruptType>[] {\n      if (\n        stream.values != null &&\n        \"__interrupt__\" in stream.values &&\n        Array.isArray(stream.values.__interrupt__)\n      ) {\n        const valueInterrupts = stream.values.__interrupt__;\n        if (valueInterrupts.length === 0) return [{ when: \"breakpoint\" }];\n        return valueInterrupts;\n      }\n\n      return [];\n    },\n\n    get interrupt(): Interrupt<InterruptType> | undefined {\n      const all = this.interrupts;\n      if (all.length === 0) return undefined;\n      if (all.length === 1) return all[0];\n\n      // Multiple interrupts: return the array for backward compat\n      return all as Interrupt<InterruptType>;\n    },\n\n    get messages(): Message<ToolCallType>[] {\n      if (!stream.values) return [];\n      return getMessages(stream.values);\n    },\n\n    get toolCalls() {\n      if (!stream.values) return [];\n      const msgs = getMessages(stream.values);\n      return getToolCallsWithResults<ToolCallType>(msgs);\n    },\n\n    getToolCalls(message) {\n      if (!stream.values) return [];\n      const msgs = getMessages(stream.values);\n      const allToolCalls = getToolCallsWithResults<ToolCallType>(msgs);\n      return allToolCalls.filter((tc) => tc.aiMessage.id === message.id);\n    },\n\n    get subagents() {\n      return stream.getSubagents();\n    },\n\n    get activeSubagents() {\n      return stream.getActiveSubagents();\n    },\n\n    getSubagent(toolCallId: string) {\n      return stream.getSubagent(toolCallId);\n    },\n\n    getSubagentsByType(type: string) {\n      return stream.getSubagentsByType(type);\n    },\n\n    getSubagentsByMessage(messageId: string) {\n      return stream.getSubagentsByMessage(messageId);\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/react/stream.d.cts

@@ -1,174 +0,0 @@
-import { BagTemplate } from "../types.template.cjs";
-import { UseStreamCustomOptions } from "../ui/types.cjs";
-import { InferBag, InferStateType, ResolveStreamInterface, ResolveStreamOptions } from "../ui/stream/index.cjs";
-
-//#region src/react/stream.d.ts
-/**
- * A React hook that provides seamless integration with LangGraph streaming capabilities.
- *
- * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,
- * letting you focus on building great chat experiences. It provides automatic state management for
- * messages, interrupts, loading states, subagent streams, and errors.
- *
- * ## Usage with ReactAgent (recommended for createAgent users)
- *
- * When using `createAgent` from `@langchain/langgraph`, you can pass `typeof agent` as the
- * type parameter to automatically infer tool call types:
- *
- * @example
- * ```typescript
- * // In your agent file (e.g., agent.ts)
- * import { createAgent, tool } from "langchain";
- * import { z } from "zod";
- *
- * const getWeather = tool(
- *   async ({ location }) => `Weather in ${location}`,
- *   { name: "get_weather", schema: z.object({ location: z.string() }) }
- * );
- *
- * export const agent = createAgent({
- *   model: "openai:gpt-4o",
- *   tools: [getWeather],
- * });
- *
- * // In your React component
- * import { agent } from "./agent";
- *
- * function Chat() {
- *   // Tool calls are automatically typed from the agent's tools!
- *   const stream = useStream<typeof agent>({
- *     assistantId: "agent",
- *     apiUrl: "http://localhost:2024",
- *   });
- *
- *   // stream.toolCalls[0].call.name is typed as "get_weather"
- *   // stream.toolCalls[0].call.args is typed as { location: string }
- * }
- * ```
- *
- * ## Usage with StateGraph (for custom LangGraph applications)
- *
- * When building custom graphs with `StateGraph`, embed your tool call types directly
- * in your state's messages property using `Message<MyToolCalls>`:
- *
- * @example
- * ```typescript
- * import { Message } from "@langchain/langgraph-sdk";
- *
- * // Define your tool call types as a discriminated union
- * type MyToolCalls =
- *   | { name: "search"; args: { query: string }; id?: string }
- *   | { name: "calculate"; args: { expression: string }; id?: string };
- *
- * // Embed tool call types in your state's messages
- * interface MyGraphState {
- *   messages: Message<MyToolCalls>[];
- *   context?: string;
- * }
- *
- * function Chat() {
- *   const stream = useStream<MyGraphState>({
- *     assistantId: "my-graph",
- *     apiUrl: "http://localhost:2024",
- *   });
- *
- *   // stream.values is typed as MyGraphState
- *   // stream.toolCalls[0].call.name is typed as "search" | "calculate"
- * }
- * ```
- *
- * @example
- * ```typescript
- * // With additional type configuration (interrupts, configurable)
- * interface MyGraphState {
- *   messages: Message<MyToolCalls>[];
- * }
- *
- * function Chat() {
- *   const stream = useStream<MyGraphState, {
- *     InterruptType: { question: string };
- *     ConfigurableType: { userId: string };
- *   }>({
- *     assistantId: "my-graph",
- *     apiUrl: "http://localhost:2024",
- *   });
- *
- *   // stream.interrupt is typed as { question: string } | undefined
- * }
- * ```
- *
- * ## Usage with Deep Agents (subagent streaming, experimental)
- *
- * For agents that spawn subagents (nested graphs), use `filterSubagentMessages`
- * to keep the main message stream clean while tracking subagent activity separately:
- *
- * @example
- * ```typescript
- * import { useStream, SubagentStream } from "@langchain/langgraph-sdk/react";
- * import type { agent } from "./agent";
- *
- * function DeepAgentChat() {
- *   const stream = useStream<typeof agent>({
- *     assistantId: "deepagent",
- *     apiUrl: "http://localhost:2024",
- *     // Filter subagent messages from main stream
- *     filterSubagentMessages: true,
- *   });
- *
- *   const handleSubmit = (content: string) => {
- *     stream.submit(
- *       { messages: [{ content, type: "human" }] },
- *       { streamSubgraphs: true } // Enable subgraph streaming
- *     );
- *   };
- *
- *   // Access subagent streams via stream.subagents (Map<string, SubagentStream>)
- *   const subagentList = [...stream.subagents.values()];
- *
- *   return (
- *     <div>
- *       {stream.messages.map((msg) => <Message key={msg.id} message={msg} />)}
- *
- *       {subagentList.map((subagent) => (
- *         <SubagentCard
- *           key={subagent.id}
- *           status={subagent.status} // "pending" | "running" | "complete" | "error"
- *           messages={subagent.messages}
- *           toolCalls={subagent.toolCalls}
- *         />
- *       ))}
- *     </div>
- *   );
- * }
- * ```
- *
- * @template T Either a ReactAgent type (with `~agentTypes`) or a state type (`Record<string, unknown>`)
- * @template Bag Type configuration bag containing:
- *   - `ConfigurableType`: Type for the `config.configurable` property
- *   - `InterruptType`: Type for interrupt values
- *   - `CustomEventType`: Type for custom events
- *   - `UpdateType`: Type for the submit function updates
- *
- * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}
- */
-declare function useStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: ResolveStreamOptions<T, InferBag<T, Bag>>): ResolveStreamInterface<T, InferBag<T, Bag>>;
-/**
- * A React hook that provides seamless integration with LangGraph streaming capabilities.
- *
- * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,
- * letting you focus on building great chat experiences. It provides automatic state management for
- * messages, interrupts, loading states, and errors.
- *
- * @template T Either a ReactAgent type (with `~agentTypes`) or a state type (`Record<string, unknown>`)
- * @template Bag Type configuration bag containing:
- *   - `ConfigurableType`: Type for the `config.configurable` property
- *   - `InterruptType`: Type for interrupt values
- *   - `CustomEventType`: Type for custom events
- *   - `UpdateType`: Type for the submit function updates
- *
- * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}
- */
-declare function useStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>): ResolveStreamInterface<T, InferBag<T, Bag>>;
-//#endregion
-export { useStream };
-//# sourceMappingURL=stream.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"stream.d.cts","names":[],"sources":["../../src/react/stream.tsx"],"mappings":";;;;;;;AA4KA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAvBgB,SAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EAAS,oBAAA,CAAqB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA,KAC5C,sBAAA,CAAuB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA;;;;;;;;;;;;;;;;;iBAkBzB,SAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EAAS,sBAAA,CAAuB,cAAA,CAAe,CAAA,GAAI,QAAA,CAAS,CAAA,EAAG,GAAA,KAC9D,sBAAA,CAAuB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA"}

package/dist/react/stream.d.ts

@@ -1,174 +0,0 @@
-import { BagTemplate } from "../types.template.js";
-import { UseStreamCustomOptions } from "../ui/types.js";
-import { InferBag, InferStateType, ResolveStreamInterface, ResolveStreamOptions } from "../ui/stream/index.js";
-
-//#region src/react/stream.d.ts
-/**
- * A React hook that provides seamless integration with LangGraph streaming capabilities.
- *
- * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,
- * letting you focus on building great chat experiences. It provides automatic state management for
- * messages, interrupts, loading states, subagent streams, and errors.
- *
- * ## Usage with ReactAgent (recommended for createAgent users)
- *
- * When using `createAgent` from `@langchain/langgraph`, you can pass `typeof agent` as the
- * type parameter to automatically infer tool call types:
- *
- * @example
- * ```typescript
- * // In your agent file (e.g., agent.ts)
- * import { createAgent, tool } from "langchain";
- * import { z } from "zod";
- *
- * const getWeather = tool(
- *   async ({ location }) => `Weather in ${location}`,
- *   { name: "get_weather", schema: z.object({ location: z.string() }) }
- * );
- *
- * export const agent = createAgent({
- *   model: "openai:gpt-4o",
- *   tools: [getWeather],
- * });
- *
- * // In your React component
- * import { agent } from "./agent";
- *
- * function Chat() {
- *   // Tool calls are automatically typed from the agent's tools!
- *   const stream = useStream<typeof agent>({
- *     assistantId: "agent",
- *     apiUrl: "http://localhost:2024",
- *   });
- *
- *   // stream.toolCalls[0].call.name is typed as "get_weather"
- *   // stream.toolCalls[0].call.args is typed as { location: string }
- * }
- * ```
- *
- * ## Usage with StateGraph (for custom LangGraph applications)
- *
- * When building custom graphs with `StateGraph`, embed your tool call types directly
- * in your state's messages property using `Message<MyToolCalls>`:
- *
- * @example
- * ```typescript
- * import { Message } from "@langchain/langgraph-sdk";
- *
- * // Define your tool call types as a discriminated union
- * type MyToolCalls =
- *   | { name: "search"; args: { query: string }; id?: string }
- *   | { name: "calculate"; args: { expression: string }; id?: string };
- *
- * // Embed tool call types in your state's messages
- * interface MyGraphState {
- *   messages: Message<MyToolCalls>[];
- *   context?: string;
- * }
- *
- * function Chat() {
- *   const stream = useStream<MyGraphState>({
- *     assistantId: "my-graph",
- *     apiUrl: "http://localhost:2024",
- *   });
- *
- *   // stream.values is typed as MyGraphState
- *   // stream.toolCalls[0].call.name is typed as "search" | "calculate"
- * }
- * ```
- *
- * @example
- * ```typescript
- * // With additional type configuration (interrupts, configurable)
- * interface MyGraphState {
- *   messages: Message<MyToolCalls>[];
- * }
- *
- * function Chat() {
- *   const stream = useStream<MyGraphState, {
- *     InterruptType: { question: string };
- *     ConfigurableType: { userId: string };
- *   }>({
- *     assistantId: "my-graph",
- *     apiUrl: "http://localhost:2024",
- *   });
- *
- *   // stream.interrupt is typed as { question: string } | undefined
- * }
- * ```
- *
- * ## Usage with Deep Agents (subagent streaming, experimental)
- *
- * For agents that spawn subagents (nested graphs), use `filterSubagentMessages`
- * to keep the main message stream clean while tracking subagent activity separately:
- *
- * @example
- * ```typescript
- * import { useStream, SubagentStream } from "@langchain/langgraph-sdk/react";
- * import type { agent } from "./agent";
- *
- * function DeepAgentChat() {
- *   const stream = useStream<typeof agent>({
- *     assistantId: "deepagent",
- *     apiUrl: "http://localhost:2024",
- *     // Filter subagent messages from main stream
- *     filterSubagentMessages: true,
- *   });
- *
- *   const handleSubmit = (content: string) => {
- *     stream.submit(
- *       { messages: [{ content, type: "human" }] },
- *       { streamSubgraphs: true } // Enable subgraph streaming
- *     );
- *   };
- *
- *   // Access subagent streams via stream.subagents (Map<string, SubagentStream>)
- *   const subagentList = [...stream.subagents.values()];
- *
- *   return (
- *     <div>
- *       {stream.messages.map((msg) => <Message key={msg.id} message={msg} />)}
- *
- *       {subagentList.map((subagent) => (
- *         <SubagentCard
- *           key={subagent.id}
- *           status={subagent.status} // "pending" | "running" | "complete" | "error"
- *           messages={subagent.messages}
- *           toolCalls={subagent.toolCalls}
- *         />
- *       ))}
- *     </div>
- *   );
- * }
- * ```
- *
- * @template T Either a ReactAgent type (with `~agentTypes`) or a state type (`Record<string, unknown>`)
- * @template Bag Type configuration bag containing:
- *   - `ConfigurableType`: Type for the `config.configurable` property
- *   - `InterruptType`: Type for interrupt values
- *   - `CustomEventType`: Type for custom events
- *   - `UpdateType`: Type for the submit function updates
- *
- * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}
- */
-declare function useStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: ResolveStreamOptions<T, InferBag<T, Bag>>): ResolveStreamInterface<T, InferBag<T, Bag>>;
-/**
- * A React hook that provides seamless integration with LangGraph streaming capabilities.
- *
- * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,
- * letting you focus on building great chat experiences. It provides automatic state management for
- * messages, interrupts, loading states, and errors.
- *
- * @template T Either a ReactAgent type (with `~agentTypes`) or a state type (`Record<string, unknown>`)
- * @template Bag Type configuration bag containing:
- *   - `ConfigurableType`: Type for the `config.configurable` property
- *   - `InterruptType`: Type for interrupt values
- *   - `CustomEventType`: Type for custom events
- *   - `UpdateType`: Type for the submit function updates
- *
- * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}
- */
-declare function useStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>): ResolveStreamInterface<T, InferBag<T, Bag>>;
-//#endregion
-export { useStream };
-//# sourceMappingURL=stream.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"stream.d.ts","names":[],"sources":["../../src/react/stream.tsx"],"mappings":";;;;;;;AA4KA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAvBgB,SAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EAAS,oBAAA,CAAqB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA,KAC5C,sBAAA,CAAuB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA;;;;;;;;;;;;;;;;;iBAkBzB,SAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EAAS,sBAAA,CAAuB,cAAA,CAAe,CAAA,GAAI,QAAA,CAAS,CAAA,EAAG,GAAA,KAC9D,sBAAA,CAAuB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA"}

package/dist/react/stream.js

@@ -1,17 +0,0 @@
-import { useStreamLGP } from "./stream.lgp.js";
-import { useStreamCustom } from "./stream.custom.js";
-import { useState } from "react";
-
-//#region src/react/stream.tsx
-function isCustomOptions(options) {
-	return "transport" in options;
-}
-function useStream(options) {
-	const [isCustom] = useState(isCustomOptions(options));
-	if (isCustom) return useStreamCustom(options);
-	return useStreamLGP(options);
-}
-
-//#endregion
-export { useStream };
-//# sourceMappingURL=stream.js.map

package/dist/react/stream.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream.js","names":[],"sources":["../../src/react/stream.tsx"],"sourcesContent":["import { useState } from \"react\";\nimport { useStreamLGP } from \"./stream.lgp.js\";\nimport { useStreamCustom } from \"./stream.custom.js\";\nimport type { UseStreamOptions } from \"../ui/types.js\";\nimport type { BagTemplate } from \"../types.template.js\";\nimport type { UseStreamCustomOptions } from \"./types.js\";\nimport type {\n  ResolveStreamInterface,\n  ResolveStreamOptions,\n  InferBag,\n  InferStateType,\n} from \"../ui/stream/index.js\";\n\nfunction isCustomOptions<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate\n>(\n  options:\n    | UseStreamOptions<StateType, Bag>\n    | UseStreamCustomOptions<StateType, Bag>\n): options is UseStreamCustomOptions<StateType, Bag> {\n  return \"transport\" in options;\n}\n\n/**\n * A React hook that provides seamless integration with LangGraph streaming capabilities.\n *\n * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,\n * letting you focus on building great chat experiences. It provides automatic state management for\n * messages, interrupts, loading states, subagent streams, and errors.\n *\n * ## Usage with ReactAgent (recommended for createAgent users)\n *\n * When using `createAgent` from `@langchain/langgraph`, you can pass `typeof agent` as the\n * type parameter to automatically infer tool call types:\n *\n * @example\n * ```typescript\n * // In your agent file (e.g., agent.ts)\n * import { createAgent, tool } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool(\n *   async ({ location }) => `Weather in ${location}`,\n *   { name: \"get_weather\", schema: z.object({ location: z.string() }) }\n * );\n *\n * export const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [getWeather],\n * });\n *\n * // In your React component\n * import { agent } from \"./agent\";\n *\n * function Chat() {\n *   // Tool calls are automatically typed from the agent's tools!\n *   const stream = useStream<typeof agent>({\n *     assistantId: \"agent\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *\n *   // stream.toolCalls[0].call.name is typed as \"get_weather\"\n *   // stream.toolCalls[0].call.args is typed as { location: string }\n * }\n * ```\n *\n * ## Usage with StateGraph (for custom LangGraph applications)\n *\n * When building custom graphs with `StateGraph`, embed your tool call types directly\n * in your state's messages property using `Message<MyToolCalls>`:\n *\n * @example\n * ```typescript\n * import { Message } from \"@langchain/langgraph-sdk\";\n *\n * // Define your tool call types as a discriminated union\n * type MyToolCalls =\n *   | { name: \"search\"; args: { query: string }; id?: string }\n *   | { name: \"calculate\"; args: { expression: string }; id?: string };\n *\n * // Embed tool call types in your state's messages\n * interface MyGraphState {\n *   messages: Message<MyToolCalls>[];\n *   context?: string;\n * }\n *\n * function Chat() {\n *   const stream = useStream<MyGraphState>({\n *     assistantId: \"my-graph\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *\n *   // stream.values is typed as MyGraphState\n *   // stream.toolCalls[0].call.name is typed as \"search\" | \"calculate\"\n * }\n * ```\n *\n * @example\n * ```typescript\n * // With additional type configuration (interrupts, configurable)\n * interface MyGraphState {\n *   messages: Message<MyToolCalls>[];\n * }\n *\n * function Chat() {\n *   const stream = useStream<MyGraphState, {\n *     InterruptType: { question: string };\n *     ConfigurableType: { userId: string };\n *   }>({\n *     assistantId: \"my-graph\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *\n *   // stream.interrupt is typed as { question: string } | undefined\n * }\n * ```\n *\n * ## Usage with Deep Agents (subagent streaming, experimental)\n *\n * For agents that spawn subagents (nested graphs), use `filterSubagentMessages`\n * to keep the main message stream clean while tracking subagent activity separately:\n *\n * @example\n * ```typescript\n * import { useStream, SubagentStream } from \"@langchain/langgraph-sdk/react\";\n * import type { agent } from \"./agent\";\n *\n * function DeepAgentChat() {\n *   const stream = useStream<typeof agent>({\n *     assistantId: \"deepagent\",\n *     apiUrl: \"http://localhost:2024\",\n *     // Filter subagent messages from main stream\n *     filterSubagentMessages: true,\n *   });\n *\n *   const handleSubmit = (content: string) => {\n *     stream.submit(\n *       { messages: [{ content, type: \"human\" }] },\n *       { streamSubgraphs: true } // Enable subgraph streaming\n *     );\n *   };\n *\n *   // Access subagent streams via stream.subagents (Map<string, SubagentStream>)\n *   const subagentList = [...stream.subagents.values()];\n *\n *   return (\n *     <div>\n *       {stream.messages.map((msg) => <Message key={msg.id} message={msg} />)}\n *\n *       {subagentList.map((subagent) => (\n *         <SubagentCard\n *           key={subagent.id}\n *           status={subagent.status} // \"pending\" | \"running\" | \"complete\" | \"error\"\n *           messages={subagent.messages}\n *           toolCalls={subagent.toolCalls}\n *         />\n *       ))}\n *     </div>\n *   );\n * }\n * ```\n *\n * @template T Either a ReactAgent type (with `~agentTypes`) or a state type (`Record<string, unknown>`)\n * @template Bag Type configuration bag containing:\n *   - `ConfigurableType`: Type for the `config.configurable` property\n *   - `InterruptType`: Type for interrupt values\n *   - `CustomEventType`: Type for custom events\n *   - `UpdateType`: Type for the submit function updates\n *\n * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}\n */\nexport function useStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate\n>(\n  options: ResolveStreamOptions<T, InferBag<T, Bag>>\n): ResolveStreamInterface<T, InferBag<T, Bag>>;\n\n/**\n * A React hook that provides seamless integration with LangGraph streaming capabilities.\n *\n * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,\n * letting you focus on building great chat experiences. It provides automatic state management for\n * messages, interrupts, loading states, and errors.\n *\n * @template T Either a ReactAgent type (with `~agentTypes`) or a state type (`Record<string, unknown>`)\n * @template Bag Type configuration bag containing:\n *   - `ConfigurableType`: Type for the `config.configurable` property\n *   - `InterruptType`: Type for interrupt values\n *   - `CustomEventType`: Type for custom events\n *   - `UpdateType`: Type for the submit function updates\n *\n * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}\n */\nexport function useStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate\n>(\n  options: UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>\n): ResolveStreamInterface<T, InferBag<T, Bag>>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useStream(options: any): any {\n  // Store this in useState to make sure we're not changing the implementation in re-renders\n  const [isCustom] = useState(isCustomOptions(options));\n\n  if (isCustom) {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    return useStreamCustom(options);\n  }\n\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  return useStreamLGP(options);\n}\n"],"mappings":";;;;;AAaA,SAAS,gBAIP,SAGmD;AACnD,QAAO,eAAe;;AAsLxB,SAAgB,UAAU,SAAmB;CAE3C,MAAM,CAAC,YAAY,SAAS,gBAAgB,QAAQ,CAAC;AAErD,KAAI,SAEF,QAAO,gBAAgB,QAAQ;AAIjC,QAAO,aAAa,QAAQ"}