@langchain/langgraph-sdk 1.4.4 → 1.4.6

package/dist/react/types.d.cts

@@ -0,0 +1,152 @@
+import { Interrupt, ThreadState } from "../schema.cjs";
+import { AIMessage, Message, ToolCallWithResult } from "../types.messages.cjs";
+import { StreamMode } from "../types.stream.cjs";
+import { Client } from "../client.cjs";
+import { BagTemplate } from "../types.template.cjs";
+import { Sequence } from "../ui/branching.cjs";
+import { CustomSubmitOptions, GetConfigurableType, GetInterruptType, GetToolCallsType, GetUpdateType, MessageMetadata, RunCallbackMeta, SubmitOptions, UseStreamCustomOptions, UseStreamOptions, UseStreamThread, UseStreamTransport } from "../ui/types.cjs";
+
+//#region src/react/types.d.ts
+interface UseStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> {
+  /**
+   * The current values of the thread.
+   */
+  values: StateType;
+  /**
+   * Last seen error from the thread or during streaming.
+   */
+  error: unknown;
+  /**
+   * Whether the stream is currently running.
+   */
+  isLoading: boolean;
+  /**
+   * Whether the thread is currently being loaded.
+   */
+  isThreadLoading: boolean;
+  /**
+   * Stops the stream.
+   */
+  stop: () => Promise<void>;
+  /**
+   * Create and stream a run to the thread.
+   */
+  submit: (values: GetUpdateType<Bag, StateType> | null | undefined, options?: SubmitOptions<StateType, GetConfigurableType<Bag>>) => Promise<void>;
+  /**
+   * The current branch of the thread.
+   */
+  branch: string;
+  /**
+   * Set the branch of the thread.
+   */
+  setBranch: (branch: string) => void;
+  /**
+   * Flattened history of thread states of a thread.
+   */
+  history: ThreadState<StateType>[];
+  /**
+   * Tree of all branches for the thread.
+   * @experimental
+   */
+  experimental_branchTree: Sequence<StateType>;
+  /**
+   * Get the interrupt value for the stream if interrupted.
+   */
+  interrupt: Interrupt<GetInterruptType<Bag>> | undefined;
+  /**
+   * Messages inferred from the thread.
+   * Will automatically update with incoming message chunks.
+   * Includes all message types including ToolMessage.
+   */
+  messages: Message<GetToolCallsType<StateType>>[];
+  /**
+   * Tool calls paired with their results.
+   * Useful for rendering tool invocations and their outputs together.
+   *
+   * Each item contains the tool call from an AI message paired with its
+   * corresponding ToolMessage result (if available), along with lifecycle state.
+   *
+   * @example
+   * ```tsx
+   * // With type-safe tool calls - embed the type in your messages
+   * type MyToolCalls =
+   *   | { name: "get_weather"; args: { location: string }; id?: string }
+   *   | { name: "search"; args: { query: string }; id?: string };
+   *
+   * interface MyState {
+   *   messages: Message<MyToolCalls>[];
+   * }
+   *
+   * const stream = useStream<MyState>({ ... });
+   *
+   * {stream.toolCalls.map(({ id, call, result, state }) => {
+   *   if (call.name === "get_weather") {
+   *     // call.args is { location: string }
+   *     return (
+   *       <WeatherCard
+   *         key={id}
+   *         location={call.args.location}
+   *         result={result?.content}
+   *         isLoading={state === "pending"}
+   *       />
+   *     );
+   *   }
+   * })}
+   * ```
+   */
+  toolCalls: ToolCallWithResult<GetToolCallsType<StateType>>[];
+  /**
+   * Get tool calls for a specific AI message.
+   * Useful when rendering messages and their associated tool calls together.
+   *
+   * @param message - The AI message to get tool calls for.
+   * @returns Array of tool calls initiated by the message.
+   *
+   * @example
+   * ```tsx
+   * {stream.uiMessages.map((message) => {
+   *   if (message.type === "ai") {
+   *     const toolCalls = stream.getToolCalls(message);
+   *     if (toolCalls.length > 0) {
+   *       return (
+   *         <div key={message.id}>
+   *           {toolCalls.map(tc => <ToolCard key={tc.id} toolCall={tc} />)}
+   *         </div>
+   *       );
+   *     }
+   *   }
+   *   return <MessageBubble key={message.id} message={message} />;
+   * })}
+   * ```
+   */
+  getToolCalls: (message: AIMessage<GetToolCallsType<StateType>>) => ToolCallWithResult<GetToolCallsType<StateType>>[];
+  /**
+   * Get the metadata for a message, such as first thread state the message
+   * was seen in and branch information.
+   *
+   * @param message - The message to get the metadata for.
+   * @param index - The index of the message in the thread.
+   * @returns The metadata for the message.
+   */
+  getMessagesMetadata: (message: Message<GetToolCallsType<StateType>>, index?: number) => MessageMetadata<StateType> | undefined;
+  /**
+   * LangGraph SDK client used to send request and receive responses.
+   */
+  client: Client;
+  /**
+   * The ID of the assistant to use.
+   */
+  assistantId: string;
+  /**
+   * Join an active stream.
+   */
+  joinStream: (runId: string, lastEventId?: string, options?: {
+    streamMode?: StreamMode | StreamMode[];
+  }) => Promise<void>;
+}
+type UseStreamCustom<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> = Pick<UseStream<StateType, Bag>, "values" | "error" | "isLoading" | "stop" | "interrupt" | "messages" | "toolCalls" | "getToolCalls"> & {
+  submit: (values: GetUpdateType<Bag, StateType> | null | undefined, options?: CustomSubmitOptions<StateType, GetConfigurableType<Bag>>) => Promise<void>;
+};
+//#endregion
+export { UseStream, UseStreamCustom };
+//# sourceMappingURL=types.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":["Client","ThreadState","Interrupt","Message","AIMessage","ToolCallWithResult","StreamMode","Sequence","GetUpdateType","GetConfigurableType","GetInterruptType","GetToolCallsType","MessageMetadata","UseStreamThread","UseStreamOptions","UseStreamTransport","UseStreamCustomOptions","SubmitOptions","CustomSubmitOptions","RunCallbackMeta","BagTemplate","UseStream","Record","StateType","Promise","Bag","UseStreamCustom","Pick"],"sources":["../../src/react/types.d.ts"],"sourcesContent":["import type { Client } from \"../client.js\";\nimport type { ThreadState, Interrupt } from \"../schema.js\";\nimport type { Message, AIMessage, ToolCallWithResult } from \"../types.messages.js\";\nimport type { StreamMode } from \"../types.stream.js\";\nimport type { Sequence } from \"../ui/branching.js\";\nimport type { GetUpdateType, GetConfigurableType, GetInterruptType, GetToolCallsType, MessageMetadata, UseStreamThread, UseStreamOptions, UseStreamTransport, UseStreamCustomOptions, SubmitOptions, CustomSubmitOptions, RunCallbackMeta } from \"../ui/types.js\";\nimport type { BagTemplate } from \"../types.template.js\";\nexport type { GetUpdateType, GetConfigurableType, GetInterruptType, GetToolCallsType, MessageMetadata, UseStreamThread, UseStreamOptions, UseStreamTransport, UseStreamCustomOptions, SubmitOptions, CustomSubmitOptions, RunCallbackMeta, };\nexport interface UseStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> {\n    /**\n     * The current values of the thread.\n     */\n    values: StateType;\n    /**\n     * Last seen error from the thread or during streaming.\n     */\n    error: unknown;\n    /**\n     * Whether the stream is currently running.\n     */\n    isLoading: boolean;\n    /**\n     * Whether the thread is currently being loaded.\n     */\n    isThreadLoading: boolean;\n    /**\n     * Stops the stream.\n     */\n    stop: () => Promise<void>;\n    /**\n     * Create and stream a run to the thread.\n     */\n    submit: (values: GetUpdateType<Bag, StateType> | null | undefined, options?: SubmitOptions<StateType, GetConfigurableType<Bag>>) => Promise<void>;\n    /**\n     * The current branch of the thread.\n     */\n    branch: string;\n    /**\n     * Set the branch of the thread.\n     */\n    setBranch: (branch: string) => void;\n    /**\n     * Flattened history of thread states of a thread.\n     */\n    history: ThreadState<StateType>[];\n    /**\n     * Tree of all branches for the thread.\n     * @experimental\n     */\n    experimental_branchTree: Sequence<StateType>;\n    /**\n     * Get the interrupt value for the stream if interrupted.\n     */\n    interrupt: Interrupt<GetInterruptType<Bag>> | undefined;\n    /**\n     * Messages inferred from the thread.\n     * Will automatically update with incoming message chunks.\n     * Includes all message types including ToolMessage.\n     */\n    messages: Message<GetToolCallsType<StateType>>[];\n    /**\n     * Tool calls paired with their results.\n     * Useful for rendering tool invocations and their outputs together.\n     *\n     * Each item contains the tool call from an AI message paired with its\n     * corresponding ToolMessage result (if available), along with lifecycle state.\n     *\n     * @example\n     * ```tsx\n     * // With type-safe tool calls - embed the type in your messages\n     * type MyToolCalls =\n     *   | { name: \"get_weather\"; args: { location: string }; id?: string }\n     *   | { name: \"search\"; args: { query: string }; id?: string };\n     *\n     * interface MyState {\n     *   messages: Message<MyToolCalls>[];\n     * }\n     *\n     * const stream = useStream<MyState>({ ... });\n     *\n     * {stream.toolCalls.map(({ id, call, result, state }) => {\n     *   if (call.name === \"get_weather\") {\n     *     // call.args is { location: string }\n     *     return (\n     *       <WeatherCard\n     *         key={id}\n     *         location={call.args.location}\n     *         result={result?.content}\n     *         isLoading={state === \"pending\"}\n     *       />\n     *     );\n     *   }\n     * })}\n     * ```\n     */\n    toolCalls: ToolCallWithResult<GetToolCallsType<StateType>>[];\n    /**\n     * Get tool calls for a specific AI message.\n     * Useful when rendering messages and their associated tool calls together.\n     *\n     * @param message - The AI message to get tool calls for.\n     * @returns Array of tool calls initiated by the message.\n     *\n     * @example\n     * ```tsx\n     * {stream.uiMessages.map((message) => {\n     *   if (message.type === \"ai\") {\n     *     const toolCalls = stream.getToolCalls(message);\n     *     if (toolCalls.length > 0) {\n     *       return (\n     *         <div key={message.id}>\n     *           {toolCalls.map(tc => <ToolCard key={tc.id} toolCall={tc} />)}\n     *         </div>\n     *       );\n     *     }\n     *   }\n     *   return <MessageBubble key={message.id} message={message} />;\n     * })}\n     * ```\n     */\n    getToolCalls: (message: AIMessage<GetToolCallsType<StateType>>) => ToolCallWithResult<GetToolCallsType<StateType>>[];\n    /**\n     * Get the metadata for a message, such as first thread state the message\n     * was seen in and branch information.\n     *\n     * @param message - The message to get the metadata for.\n     * @param index - The index of the message in the thread.\n     * @returns The metadata for the message.\n     */\n    getMessagesMetadata: (message: Message<GetToolCallsType<StateType>>, index?: number) => MessageMetadata<StateType> | undefined;\n    /**\n     * LangGraph SDK client used to send request and receive responses.\n     */\n    client: Client;\n    /**\n     * The ID of the assistant to use.\n     */\n    assistantId: string;\n    /**\n     * Join an active stream.\n     */\n    joinStream: (runId: string, lastEventId?: string, options?: {\n        streamMode?: StreamMode | StreamMode[];\n    }) => Promise<void>;\n}\nexport type UseStreamCustom<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> = Pick<UseStream<StateType, Bag>, \"values\" | \"error\" | \"isLoading\" | \"stop\" | \"interrupt\" | \"messages\" | \"toolCalls\" | \"getToolCalls\"> & {\n    submit: (values: GetUpdateType<Bag, StateType> | null | undefined, options?: CustomSubmitOptions<StateType, GetConfigurableType<Bag>>) => Promise<void>;\n};\n"],"mappings":";;;;;;;;;UAQiBqB,4BAA4BC,0BAA0BA,qCAAqCF,cAAcA;EAAzGC;;;QAAsDC,EAI3DC,SAJ2DD;;;;OAoBvDE,EAAAA,OAAAA;;;;WAI+ED,EAAAA,OAAAA;;;;iBAAyCC,EAAAA,OAAAA;;;;MAiB3GjB,EAAAA,GAAAA,GArBbiB,OAqBajB,CAAAA,IAAAA,CAAAA;;;;QAUUgB,EAAAA,CAAAA,MAAAA,EA3BlBf,aA2BkBe,CA3BJE,GA2BIF,EA3BCA,SA2BDA,CAAAA,GAAAA,IAAAA,GAAAA,SAAAA,EAAAA,OAAAA,CAAAA,EA3B0CN,aA2B1CM,CA3BwDA,SA2BxDA,EA3BmEd,mBA2BnEc,CA3BuFE,GA2BvFF,CAAAA,CAAAA,EAAAA,GA3BiGC,OA2BjGD,CAAAA,IAAAA,CAAAA;;;;QAoCLZ,EAAAA,MAAAA;;;;WAyBNP,EAAAA,CAAAA,MAAAA,EAAAA,MAAAA,EAAAA,GAAAA,IAAAA;;;;SASgCmB,EArF/CtB,WAqF+CsB,CArFnCA,SAqFmCA,CAAAA,EAAAA;;;;;yBAIhDvB,EApFiBO,QAoFjBP,CApF0BuB,SAoF1BvB,CAAAA;;;;EAUK,SAAA,EA1FFE,SA0FE,CA1FQQ,gBA0FR,CA1FyBe,GA0FzB,CAAA,CAAA,GAAA,SAAA;EAELC;;;;;UAA+GN,EAtF7GjB,OAsF6GiB,CAtFrGT,gBAsFqGS,CAtFpFG,SAsFoFH,CAAAA,CAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAlD5Gf,mBAAmBM,iBAAiBY;;;;;;;;;;;;;;;;;;;;;;;;;0BAyBvBnB,UAAUO,iBAAiBY,gBAAgBlB,mBAAmBM,iBAAiBY;;;;;;;;;iCASxEpB,QAAQQ,iBAAiBY,gCAAgCX,gBAAgBW;;;;UAIhGvB;;;;;;;;;iBASSM,aAAaA;QACxBkB;;KAEEE,kCAAkCJ,0BAA0BA,qCAAqCF,cAAcA,eAAeO,KAAKN,UAAUE,WAAWE;mBAC/IjB,cAAciB,KAAKF,yCAAyCL,oBAAoBK,WAAWd,oBAAoBgB,UAAUD"}

package/dist/react/types.d.ts

@@ -0,0 +1,152 @@
+import { Interrupt, ThreadState } from "../schema.js";
+import { AIMessage, Message, ToolCallWithResult } from "../types.messages.js";
+import { StreamMode } from "../types.stream.js";
+import { Client } from "../client.js";
+import { BagTemplate } from "../types.template.js";
+import { Sequence } from "../ui/branching.js";
+import { CustomSubmitOptions, GetConfigurableType, GetInterruptType, GetToolCallsType, GetUpdateType, MessageMetadata, RunCallbackMeta, SubmitOptions, UseStreamCustomOptions, UseStreamOptions, UseStreamThread, UseStreamTransport } from "../ui/types.js";
+
+//#region src/react/types.d.ts
+interface UseStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> {
+  /**
+   * The current values of the thread.
+   */
+  values: StateType;
+  /**
+   * Last seen error from the thread or during streaming.
+   */
+  error: unknown;
+  /**
+   * Whether the stream is currently running.
+   */
+  isLoading: boolean;
+  /**
+   * Whether the thread is currently being loaded.
+   */
+  isThreadLoading: boolean;
+  /**
+   * Stops the stream.
+   */
+  stop: () => Promise<void>;
+  /**
+   * Create and stream a run to the thread.
+   */
+  submit: (values: GetUpdateType<Bag, StateType> | null | undefined, options?: SubmitOptions<StateType, GetConfigurableType<Bag>>) => Promise<void>;
+  /**
+   * The current branch of the thread.
+   */
+  branch: string;
+  /**
+   * Set the branch of the thread.
+   */
+  setBranch: (branch: string) => void;
+  /**
+   * Flattened history of thread states of a thread.
+   */
+  history: ThreadState<StateType>[];
+  /**
+   * Tree of all branches for the thread.
+   * @experimental
+   */
+  experimental_branchTree: Sequence<StateType>;
+  /**
+   * Get the interrupt value for the stream if interrupted.
+   */
+  interrupt: Interrupt<GetInterruptType<Bag>> | undefined;
+  /**
+   * Messages inferred from the thread.
+   * Will automatically update with incoming message chunks.
+   * Includes all message types including ToolMessage.
+   */
+  messages: Message<GetToolCallsType<StateType>>[];
+  /**
+   * Tool calls paired with their results.
+   * Useful for rendering tool invocations and their outputs together.
+   *
+   * Each item contains the tool call from an AI message paired with its
+   * corresponding ToolMessage result (if available), along with lifecycle state.
+   *
+   * @example
+   * ```tsx
+   * // With type-safe tool calls - embed the type in your messages
+   * type MyToolCalls =
+   *   | { name: "get_weather"; args: { location: string }; id?: string }
+   *   | { name: "search"; args: { query: string }; id?: string };
+   *
+   * interface MyState {
+   *   messages: Message<MyToolCalls>[];
+   * }
+   *
+   * const stream = useStream<MyState>({ ... });
+   *
+   * {stream.toolCalls.map(({ id, call, result, state }) => {
+   *   if (call.name === "get_weather") {
+   *     // call.args is { location: string }
+   *     return (
+   *       <WeatherCard
+   *         key={id}
+   *         location={call.args.location}
+   *         result={result?.content}
+   *         isLoading={state === "pending"}
+   *       />
+   *     );
+   *   }
+   * })}
+   * ```
+   */
+  toolCalls: ToolCallWithResult<GetToolCallsType<StateType>>[];
+  /**
+   * Get tool calls for a specific AI message.
+   * Useful when rendering messages and their associated tool calls together.
+   *
+   * @param message - The AI message to get tool calls for.
+   * @returns Array of tool calls initiated by the message.
+   *
+   * @example
+   * ```tsx
+   * {stream.uiMessages.map((message) => {
+   *   if (message.type === "ai") {
+   *     const toolCalls = stream.getToolCalls(message);
+   *     if (toolCalls.length > 0) {
+   *       return (
+   *         <div key={message.id}>
+   *           {toolCalls.map(tc => <ToolCard key={tc.id} toolCall={tc} />)}
+   *         </div>
+   *       );
+   *     }
+   *   }
+   *   return <MessageBubble key={message.id} message={message} />;
+   * })}
+   * ```
+   */
+  getToolCalls: (message: AIMessage<GetToolCallsType<StateType>>) => ToolCallWithResult<GetToolCallsType<StateType>>[];
+  /**
+   * Get the metadata for a message, such as first thread state the message
+   * was seen in and branch information.
+   *
+   * @param message - The message to get the metadata for.
+   * @param index - The index of the message in the thread.
+   * @returns The metadata for the message.
+   */
+  getMessagesMetadata: (message: Message<GetToolCallsType<StateType>>, index?: number) => MessageMetadata<StateType> | undefined;
+  /**
+   * LangGraph SDK client used to send request and receive responses.
+   */
+  client: Client;
+  /**
+   * The ID of the assistant to use.
+   */
+  assistantId: string;
+  /**
+   * Join an active stream.
+   */
+  joinStream: (runId: string, lastEventId?: string, options?: {
+    streamMode?: StreamMode | StreamMode[];
+  }) => Promise<void>;
+}
+type UseStreamCustom<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> = Pick<UseStream<StateType, Bag>, "values" | "error" | "isLoading" | "stop" | "interrupt" | "messages" | "toolCalls" | "getToolCalls"> & {
+  submit: (values: GetUpdateType<Bag, StateType> | null | undefined, options?: CustomSubmitOptions<StateType, GetConfigurableType<Bag>>) => Promise<void>;
+};
+//#endregion
+export { UseStream, UseStreamCustom };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":["Client","ThreadState","Interrupt","Message","AIMessage","ToolCallWithResult","StreamMode","Sequence","GetUpdateType","GetConfigurableType","GetInterruptType","GetToolCallsType","MessageMetadata","UseStreamThread","UseStreamOptions","UseStreamTransport","UseStreamCustomOptions","SubmitOptions","CustomSubmitOptions","RunCallbackMeta","BagTemplate","UseStream","Record","StateType","Promise","Bag","UseStreamCustom","Pick"],"sources":["../../src/react/types.d.ts"],"sourcesContent":["import type { Client } from \"../client.js\";\nimport type { ThreadState, Interrupt } from \"../schema.js\";\nimport type { Message, AIMessage, ToolCallWithResult } from \"../types.messages.js\";\nimport type { StreamMode } from \"../types.stream.js\";\nimport type { Sequence } from \"../ui/branching.js\";\nimport type { GetUpdateType, GetConfigurableType, GetInterruptType, GetToolCallsType, MessageMetadata, UseStreamThread, UseStreamOptions, UseStreamTransport, UseStreamCustomOptions, SubmitOptions, CustomSubmitOptions, RunCallbackMeta } from \"../ui/types.js\";\nimport type { BagTemplate } from \"../types.template.js\";\nexport type { GetUpdateType, GetConfigurableType, GetInterruptType, GetToolCallsType, MessageMetadata, UseStreamThread, UseStreamOptions, UseStreamTransport, UseStreamCustomOptions, SubmitOptions, CustomSubmitOptions, RunCallbackMeta, };\nexport interface UseStream<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> {\n    /**\n     * The current values of the thread.\n     */\n    values: StateType;\n    /**\n     * Last seen error from the thread or during streaming.\n     */\n    error: unknown;\n    /**\n     * Whether the stream is currently running.\n     */\n    isLoading: boolean;\n    /**\n     * Whether the thread is currently being loaded.\n     */\n    isThreadLoading: boolean;\n    /**\n     * Stops the stream.\n     */\n    stop: () => Promise<void>;\n    /**\n     * Create and stream a run to the thread.\n     */\n    submit: (values: GetUpdateType<Bag, StateType> | null | undefined, options?: SubmitOptions<StateType, GetConfigurableType<Bag>>) => Promise<void>;\n    /**\n     * The current branch of the thread.\n     */\n    branch: string;\n    /**\n     * Set the branch of the thread.\n     */\n    setBranch: (branch: string) => void;\n    /**\n     * Flattened history of thread states of a thread.\n     */\n    history: ThreadState<StateType>[];\n    /**\n     * Tree of all branches for the thread.\n     * @experimental\n     */\n    experimental_branchTree: Sequence<StateType>;\n    /**\n     * Get the interrupt value for the stream if interrupted.\n     */\n    interrupt: Interrupt<GetInterruptType<Bag>> | undefined;\n    /**\n     * Messages inferred from the thread.\n     * Will automatically update with incoming message chunks.\n     * Includes all message types including ToolMessage.\n     */\n    messages: Message<GetToolCallsType<StateType>>[];\n    /**\n     * Tool calls paired with their results.\n     * Useful for rendering tool invocations and their outputs together.\n     *\n     * Each item contains the tool call from an AI message paired with its\n     * corresponding ToolMessage result (if available), along with lifecycle state.\n     *\n     * @example\n     * ```tsx\n     * // With type-safe tool calls - embed the type in your messages\n     * type MyToolCalls =\n     *   | { name: \"get_weather\"; args: { location: string }; id?: string }\n     *   | { name: \"search\"; args: { query: string }; id?: string };\n     *\n     * interface MyState {\n     *   messages: Message<MyToolCalls>[];\n     * }\n     *\n     * const stream = useStream<MyState>({ ... });\n     *\n     * {stream.toolCalls.map(({ id, call, result, state }) => {\n     *   if (call.name === \"get_weather\") {\n     *     // call.args is { location: string }\n     *     return (\n     *       <WeatherCard\n     *         key={id}\n     *         location={call.args.location}\n     *         result={result?.content}\n     *         isLoading={state === \"pending\"}\n     *       />\n     *     );\n     *   }\n     * })}\n     * ```\n     */\n    toolCalls: ToolCallWithResult<GetToolCallsType<StateType>>[];\n    /**\n     * Get tool calls for a specific AI message.\n     * Useful when rendering messages and their associated tool calls together.\n     *\n     * @param message - The AI message to get tool calls for.\n     * @returns Array of tool calls initiated by the message.\n     *\n     * @example\n     * ```tsx\n     * {stream.uiMessages.map((message) => {\n     *   if (message.type === \"ai\") {\n     *     const toolCalls = stream.getToolCalls(message);\n     *     if (toolCalls.length > 0) {\n     *       return (\n     *         <div key={message.id}>\n     *           {toolCalls.map(tc => <ToolCard key={tc.id} toolCall={tc} />)}\n     *         </div>\n     *       );\n     *     }\n     *   }\n     *   return <MessageBubble key={message.id} message={message} />;\n     * })}\n     * ```\n     */\n    getToolCalls: (message: AIMessage<GetToolCallsType<StateType>>) => ToolCallWithResult<GetToolCallsType<StateType>>[];\n    /**\n     * Get the metadata for a message, such as first thread state the message\n     * was seen in and branch information.\n     *\n     * @param message - The message to get the metadata for.\n     * @param index - The index of the message in the thread.\n     * @returns The metadata for the message.\n     */\n    getMessagesMetadata: (message: Message<GetToolCallsType<StateType>>, index?: number) => MessageMetadata<StateType> | undefined;\n    /**\n     * LangGraph SDK client used to send request and receive responses.\n     */\n    client: Client;\n    /**\n     * The ID of the assistant to use.\n     */\n    assistantId: string;\n    /**\n     * Join an active stream.\n     */\n    joinStream: (runId: string, lastEventId?: string, options?: {\n        streamMode?: StreamMode | StreamMode[];\n    }) => Promise<void>;\n}\nexport type UseStreamCustom<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> = Pick<UseStream<StateType, Bag>, \"values\" | \"error\" | \"isLoading\" | \"stop\" | \"interrupt\" | \"messages\" | \"toolCalls\" | \"getToolCalls\"> & {\n    submit: (values: GetUpdateType<Bag, StateType> | null | undefined, options?: CustomSubmitOptions<StateType, GetConfigurableType<Bag>>) => Promise<void>;\n};\n"],"mappings":";;;;;;;;;UAQiBqB,4BAA4BC,0BAA0BA,qCAAqCF,cAAcA;EAAzGC;;;QAAsDC,EAI3DC,SAJ2DD;;;;OAoBvDE,EAAAA,OAAAA;;;;WAI+ED,EAAAA,OAAAA;;;;iBAAyCC,EAAAA,OAAAA;;;;MAiB3GjB,EAAAA,GAAAA,GArBbiB,OAqBajB,CAAAA,IAAAA,CAAAA;;;;QAUUgB,EAAAA,CAAAA,MAAAA,EA3BlBf,aA2BkBe,CA3BJE,GA2BIF,EA3BCA,SA2BDA,CAAAA,GAAAA,IAAAA,GAAAA,SAAAA,EAAAA,OAAAA,CAAAA,EA3B0CN,aA2B1CM,CA3BwDA,SA2BxDA,EA3BmEd,mBA2BnEc,CA3BuFE,GA2BvFF,CAAAA,CAAAA,EAAAA,GA3BiGC,OA2BjGD,CAAAA,IAAAA,CAAAA;;;;QAoCLZ,EAAAA,MAAAA;;;;WAyBNP,EAAAA,CAAAA,MAAAA,EAAAA,MAAAA,EAAAA,GAAAA,IAAAA;;;;SASgCmB,EArF/CtB,WAqF+CsB,CArFnCA,SAqFmCA,CAAAA,EAAAA;;;;;yBAIhDvB,EApFiBO,QAoFjBP,CApF0BuB,SAoF1BvB,CAAAA;;;;EAUK,SAAA,EA1FFE,SA0FE,CA1FQQ,gBA0FR,CA1FyBe,GA0FzB,CAAA,CAAA,GAAA,SAAA;EAELC;;;;;UAA+GN,EAtF7GjB,OAsF6GiB,CAtFrGT,gBAsFqGS,CAtFpFG,SAsFoFH,CAAAA,CAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAlD5Gf,mBAAmBM,iBAAiBY;;;;;;;;;;;;;;;;;;;;;;;;;0BAyBvBnB,UAAUO,iBAAiBY,gBAAgBlB,mBAAmBM,iBAAiBY;;;;;;;;;iCASxEpB,QAAQQ,iBAAiBY,gCAAgCX,gBAAgBW;;;;UAIhGvB;;;;;;;;;iBASSM,aAAaA;QACxBkB;;KAEEE,kCAAkCJ,0BAA0BA,qCAAqCF,cAAcA,eAAeO,KAAKN,UAAUE,WAAWE;mBAC/IjB,cAAciB,KAAKF,yCAAyCL,oBAAoBK,WAAWd,oBAAoBgB,UAAUD"}

package/dist/react-ui/client.cjs

@@ -0,0 +1,138 @@
+"use client";
+
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_stream = require('../react/stream.cjs');
+require('../react/index.cjs');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+let react_dom = require("react-dom");
+react_dom = require_rolldown_runtime.__toESM(react_dom);
+let react_jsx_runtime = require("react/jsx-runtime");
+react_jsx_runtime = require_rolldown_runtime.__toESM(react_jsx_runtime);
+
+//#region src/react-ui/client.tsx
+const UseStreamContext = react.createContext(null);
+function useStreamContext() {
+	const ctx = react.useContext(UseStreamContext);
+	if (!ctx) throw new Error("useStreamContext must be used within a LoadExternalComponent");
+	return new Proxy(ctx, { get(target, prop) {
+		if (prop === "meta") return target.meta;
+		return target.stream[prop];
+	} });
+}
+var ComponentStore = class {
+	cache = {};
+	boundCache = {};
+	callbacks = {};
+	respond(shadowRootId, comp, targetElement) {
+		this.cache[shadowRootId] = {
+			comp,
+			target: targetElement
+		};
+		this.callbacks[shadowRootId]?.forEach((c) => c(comp, targetElement));
+	}
+	getBoundStore(shadowRootId) {
+		this.boundCache[shadowRootId] ??= {
+			subscribe: (onStoreChange) => {
+				this.callbacks[shadowRootId] ??= [];
+				this.callbacks[shadowRootId].push(onStoreChange);
+				return () => {
+					this.callbacks[shadowRootId] = this.callbacks[shadowRootId].filter((c) => c !== onStoreChange);
+				};
+			},
+			getSnapshot: () => this.cache[shadowRootId]
+		};
+		return this.boundCache[shadowRootId];
+	}
+};
+const COMPONENT_STORE = new ComponentStore();
+const EXT_STORE_SYMBOL = Symbol.for("LGUI_EXT_STORE");
+const REQUIRE_SYMBOL = Symbol.for("LGUI_REQUIRE");
+const REQUIRE_EXTRA_SYMBOL = Symbol.for("LGUI_REQUIRE_EXTRA");
+const isIterable = (value) => value != null && typeof value === "object" && Symbol.iterator in value;
+const isPromise = (value) => value != null && typeof value === "object" && "then" in value && typeof value.then === "function";
+const isReactNode = (value) => {
+	if (react.isValidElement(value)) return true;
+	if (value == null) return true;
+	if (typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") return true;
+	if (isIterable(value)) return true;
+	if (isPromise(value)) return true;
+	return false;
+};
+function LoadExternalComponent({ stream, namespace, message, meta, fallback, components, ...props }) {
+	const ref = react.useRef(null);
+	const shadowRootId = `child-shadow-${react.useId()}`;
+	const store = react.useMemo(() => COMPONENT_STORE.getBoundStore(shadowRootId), [shadowRootId]);
+	const state = react.useSyncExternalStore(store.subscribe, store.getSnapshot);
+	const clientComponent = components?.[message.name];
+	const hasClientComponent = clientComponent != null;
+	let fallbackComponent = null;
+	if (isReactNode(fallback)) fallbackComponent = fallback;
+	else if (typeof fallback === "object" && fallback != null) fallbackComponent = fallback?.[message.name];
+	const uiNamespace = namespace ?? stream.assistantId;
+	const uiClient = stream.client["~ui"];
+	react.useEffect(() => {
+		if (hasClientComponent) return;
+		uiClient.getComponent(uiNamespace, message.name).then((html) => {
+			const dom = ref.current;
+			if (!dom) return;
+			const root = dom.shadowRoot ?? dom.attachShadow({ mode: "open" });
+			const fragment = document.createRange().createContextualFragment(html.replace("{{shadowRootId}}", shadowRootId));
+			root.appendChild(fragment);
+		});
+	}, [
+		uiClient,
+		uiNamespace,
+		message.name,
+		shadowRootId,
+		hasClientComponent
+	]);
+	if (hasClientComponent) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(UseStreamContext.Provider, {
+		value: {
+			stream,
+			meta
+		},
+		children: react.createElement(clientComponent, message.props)
+	});
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		id: shadowRootId,
+		ref,
+		...props
+	}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(UseStreamContext.Provider, {
+		value: {
+			stream,
+			meta
+		},
+		children: state?.target != null ? react_dom.createPortal(react.createElement(state.comp, message.props), state.target) : fallbackComponent
+	})] });
+}
+function experimental_loadShare(name, module$1) {
+	if (typeof window === "undefined") return;
+	window[REQUIRE_EXTRA_SYMBOL] ??= {};
+	window[REQUIRE_EXTRA_SYMBOL][name] = module$1;
+}
+function bootstrapUiContext() {
+	if (typeof window === "undefined") return;
+	window[EXT_STORE_SYMBOL] = COMPONENT_STORE;
+	window[REQUIRE_SYMBOL] = (name) => {
+		if (name === "react") return react;
+		if (name === "react-dom") return react_dom;
+		if (name === "react/jsx-runtime") return react_jsx_runtime;
+		if (name === "@langchain/langgraph-sdk/react") return { useStream: require_stream.useStream };
+		if (name === "@langchain/langgraph-sdk/react-ui") return {
+			useStreamContext,
+			LoadExternalComponent: () => {
+				throw new Error("Nesting LoadExternalComponent is not supported");
+			}
+		};
+		if (window[REQUIRE_EXTRA_SYMBOL] != null && typeof window[REQUIRE_EXTRA_SYMBOL] === "object" && name in window[REQUIRE_EXTRA_SYMBOL]) return window[REQUIRE_EXTRA_SYMBOL][name];
+		throw new Error(`Unknown module...: ${name}`);
+	};
+}
+
+//#endregion
+exports.LoadExternalComponent = LoadExternalComponent;
+exports.bootstrapUiContext = bootstrapUiContext;
+exports.experimental_loadShare = experimental_loadShare;
+exports.useStreamContext = useStreamContext;
+//# sourceMappingURL=client.cjs.map

package/dist/react-ui/client.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.cjs","names":["React","ReactDOM","module","JsxRuntime"],"sources":["../../src/react-ui/client.tsx"],"sourcesContent":["\"use client\";\n\nimport * as React from \"react\";\nimport * as ReactDOM from \"react-dom\";\nimport * as JsxRuntime from \"react/jsx-runtime\";\nimport type { UIMessage } from \"./types.js\";\nimport { useStream } from \"../react/index.js\";\nimport type { UseStream } from \"../react/types.js\";\nimport type { BagTemplate } from \"../types.template.js\";\n\nconst UseStreamContext = React.createContext<{\n  stream: ReturnType<typeof useStream>;\n  meta: unknown;\n}>(null!);\n\ntype GetMetaType<Bag extends BagTemplate> = Bag extends { MetaType: unknown }\n  ? Bag[\"MetaType\"]\n  : unknown;\n\ninterface UseStreamContext<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate\n> extends UseStream<StateType, Bag> {\n  meta?: GetMetaType<Bag>;\n}\n\nexport function useStreamContext<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate\n>(): UseStreamContext<StateType, Bag> {\n  const ctx = React.useContext(UseStreamContext);\n  if (!ctx) {\n    throw new Error(\n      \"useStreamContext must be used within a LoadExternalComponent\"\n    );\n  }\n\n  return new Proxy(ctx, {\n    get(target, prop: keyof UseStreamContext<StateType, Bag>) {\n      if (prop === \"meta\") return target.meta;\n      return target.stream[prop];\n    },\n  }) as unknown as UseStreamContext<StateType, Bag>;\n}\n\ninterface ComponentTarget {\n  comp: React.FunctionComponent | React.ComponentClass;\n  target: HTMLElement;\n}\n\nclass ComponentStore {\n  private cache: Record<string, ComponentTarget> = {};\n\n  private boundCache: Record<\n    string,\n    {\n      subscribe: (onStoreChange: () => void) => () => void;\n      getSnapshot: () => ComponentTarget | undefined;\n    }\n  > = {};\n\n  private callbacks: Record<\n    string,\n    ((\n      comp: React.FunctionComponent | React.ComponentClass,\n      el: HTMLElement\n    ) => void)[]\n  > = {};\n\n  respond(\n    shadowRootId: string,\n    comp: React.FunctionComponent | React.ComponentClass,\n    targetElement: HTMLElement\n  ) {\n    this.cache[shadowRootId] = { comp, target: targetElement };\n    this.callbacks[shadowRootId]?.forEach((c) => c(comp, targetElement));\n  }\n\n  getBoundStore(shadowRootId: string) {\n    this.boundCache[shadowRootId] ??= {\n      subscribe: (onStoreChange: () => void) => {\n        this.callbacks[shadowRootId] ??= [];\n        this.callbacks[shadowRootId].push(onStoreChange);\n        return () => {\n          this.callbacks[shadowRootId] = this.callbacks[shadowRootId].filter(\n            (c) => c !== onStoreChange\n          );\n        };\n      },\n      getSnapshot: () => this.cache[shadowRootId],\n    };\n\n    return this.boundCache[shadowRootId];\n  }\n}\n\nconst COMPONENT_STORE = new ComponentStore();\nconst EXT_STORE_SYMBOL = Symbol.for(\"LGUI_EXT_STORE\");\nconst REQUIRE_SYMBOL = Symbol.for(\"LGUI_REQUIRE\");\nconst REQUIRE_EXTRA_SYMBOL = Symbol.for(\"LGUI_REQUIRE_EXTRA\");\n\ninterface LoadExternalComponentProps\n  extends Pick<React.HTMLAttributes<HTMLDivElement>, \"style\" | \"className\"> {\n  /** Stream of the assistant */\n  stream: ReturnType<typeof useStream>;\n\n  /** Namespace of UI components. Defaults to assistant ID. */\n  namespace?: string;\n\n  /** UI message to be rendered */\n  message: UIMessage;\n\n  /** Additional context to be passed to the child component */\n  meta?: unknown;\n\n  /** Fallback to be rendered when the component is loading */\n  fallback?: React.ReactNode | Record<string, React.ReactNode>;\n\n  /**\n   * Map of components that can be rendered directly without fetching the UI code\n   * from the server.\n   */\n  components?: Record<string, React.FunctionComponent | React.ComponentClass>;\n}\n\nconst isIterable = (value: unknown): value is Iterable<unknown> =>\n  value != null && typeof value === \"object\" && Symbol.iterator in value;\n\nconst isPromise = (value: unknown): value is Promise<unknown> =>\n  value != null &&\n  typeof value === \"object\" &&\n  \"then\" in value &&\n  typeof value.then === \"function\";\n\nconst isReactNode = (value: unknown): value is React.ReactNode => {\n  if (React.isValidElement(value)) return true;\n  if (value == null) return true;\n  if (\n    typeof value === \"string\" ||\n    typeof value === \"number\" ||\n    typeof value === \"bigint\" ||\n    typeof value === \"boolean\"\n  ) {\n    return true;\n  }\n\n  if (isIterable(value)) return true;\n  if (isPromise(value)) return true;\n\n  return false;\n};\n\nexport function LoadExternalComponent({\n  stream,\n  namespace,\n  message,\n  meta,\n  fallback,\n  components,\n  ...props\n}: LoadExternalComponentProps) {\n  const ref = React.useRef<HTMLDivElement>(null);\n  const id = React.useId();\n  const shadowRootId = `child-shadow-${id}`;\n\n  const store = React.useMemo(\n    () => COMPONENT_STORE.getBoundStore(shadowRootId),\n    [shadowRootId]\n  );\n  const state = React.useSyncExternalStore(store.subscribe, store.getSnapshot);\n\n  const clientComponent = components?.[message.name];\n  const hasClientComponent = clientComponent != null;\n\n  let fallbackComponent = null;\n  if (isReactNode(fallback)) {\n    fallbackComponent = fallback;\n  } else if (typeof fallback === \"object\" && fallback != null) {\n    fallbackComponent = fallback?.[message.name];\n  }\n\n  const uiNamespace = namespace ?? stream.assistantId;\n  const uiClient = stream.client[\"~ui\"];\n  React.useEffect(() => {\n    if (hasClientComponent) return;\n    void uiClient.getComponent(uiNamespace, message.name).then((html) => {\n      const dom = ref.current;\n      if (!dom) return;\n      const root = dom.shadowRoot ?? dom.attachShadow({ mode: \"open\" });\n      const fragment = document\n        .createRange()\n        .createContextualFragment(\n          html.replace(\"{{shadowRootId}}\", shadowRootId)\n        );\n      root.appendChild(fragment);\n    });\n  }, [uiClient, uiNamespace, message.name, shadowRootId, hasClientComponent]);\n\n  if (hasClientComponent) {\n    return (\n      <UseStreamContext.Provider value={{ stream, meta }}>\n        {React.createElement(clientComponent, message.props)}\n      </UseStreamContext.Provider>\n    );\n  }\n\n  return (\n    <>\n      <div id={shadowRootId} ref={ref} {...props} />\n\n      <UseStreamContext.Provider value={{ stream, meta }}>\n        {state?.target != null\n          ? ReactDOM.createPortal(\n              React.createElement(state.comp, message.props),\n              state.target\n            )\n          : fallbackComponent}\n      </UseStreamContext.Provider>\n    </>\n  );\n}\n\ndeclare global {\n  interface Window {\n    [EXT_STORE_SYMBOL]: ComponentStore;\n    [REQUIRE_SYMBOL]: (name: string) => unknown;\n    [REQUIRE_EXTRA_SYMBOL]: Record<string, unknown>;\n  }\n}\n\nexport function experimental_loadShare(name: string, module: unknown) {\n  if (typeof window === \"undefined\") return;\n\n  window[REQUIRE_EXTRA_SYMBOL] ??= {};\n  window[REQUIRE_EXTRA_SYMBOL][name] = module;\n}\n\nexport function bootstrapUiContext() {\n  if (typeof window === \"undefined\") {\n    return;\n  }\n\n  window[EXT_STORE_SYMBOL] = COMPONENT_STORE;\n  window[REQUIRE_SYMBOL] = (name: string) => {\n    if (name === \"react\") return React;\n    if (name === \"react-dom\") return ReactDOM;\n    if (name === \"react/jsx-runtime\") return JsxRuntime;\n    if (name === \"@langchain/langgraph-sdk/react\") return { useStream };\n    if (name === \"@langchain/langgraph-sdk/react-ui\") {\n      return {\n        useStreamContext,\n        LoadExternalComponent: () => {\n          throw new Error(\"Nesting LoadExternalComponent is not supported\");\n        },\n      };\n    }\n\n    if (\n      window[REQUIRE_EXTRA_SYMBOL] != null &&\n      typeof window[REQUIRE_EXTRA_SYMBOL] === \"object\" &&\n      name in window[REQUIRE_EXTRA_SYMBOL]\n    ) {\n      return window[REQUIRE_EXTRA_SYMBOL][name];\n    }\n\n    throw new Error(`Unknown module...: ${name}`);\n  };\n}\n"],"mappings":"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"}

package/dist/react-ui/client.d.cts

@@ -0,0 +1,73 @@
+import { BagTemplate } from "../types.template.cjs";
+import { UseStream, UseStreamCustom } from "../react/types.cjs";
+import { UIMessage } from "./types.cjs";
+import { useStream } from "../react/stream.cjs";
+import * as React from "react";
+import * as JsxRuntime from "react/jsx-runtime";
+
+//#region src/react-ui/client.d.ts
+declare const UseStreamContext: React.Context<{
+  stream: UseStreamCustom<Record<string, unknown>, BagTemplate>;
+  meta: unknown;
+}>;
+type GetMetaType<Bag extends BagTemplate> = Bag extends {
+  MetaType: unknown;
+} ? Bag["MetaType"] : unknown;
+interface UseStreamContext<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> extends UseStream<StateType, Bag> {
+  meta?: GetMetaType<Bag>;
+}
+declare function useStreamContext<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(): UseStreamContext<StateType, Bag>;
+interface ComponentTarget {
+  comp: React.FunctionComponent | React.ComponentClass;
+  target: HTMLElement;
+}
+declare class ComponentStore {
+  private cache;
+  private boundCache;
+  private callbacks;
+  respond(shadowRootId: string, comp: React.FunctionComponent | React.ComponentClass, targetElement: HTMLElement): void;
+  getBoundStore(shadowRootId: string): {
+    subscribe: (onStoreChange: () => void) => () => void;
+    getSnapshot: () => ComponentTarget | undefined;
+  };
+}
+declare const EXT_STORE_SYMBOL: unique symbol;
+declare const REQUIRE_SYMBOL: unique symbol;
+declare const REQUIRE_EXTRA_SYMBOL: unique symbol;
+interface LoadExternalComponentProps extends Pick<React.HTMLAttributes<HTMLDivElement>, "style" | "className"> {
+  /** Stream of the assistant */
+  stream: ReturnType<typeof useStream>;
+  /** Namespace of UI components. Defaults to assistant ID. */
+  namespace?: string;
+  /** UI message to be rendered */
+  message: UIMessage;
+  /** Additional context to be passed to the child component */
+  meta?: unknown;
+  /** Fallback to be rendered when the component is loading */
+  fallback?: React.ReactNode | Record<string, React.ReactNode>;
+  /**
+   * Map of components that can be rendered directly without fetching the UI code
+   * from the server.
+   */
+  components?: Record<string, React.FunctionComponent | React.ComponentClass>;
+}
+declare function LoadExternalComponent({
+  stream,
+  namespace,
+  message,
+  meta,
+  fallback,
+  components,
+  ...props
+}: LoadExternalComponentProps): JsxRuntime.JSX.Element;
+declare global {
+  interface Window {
+    [EXT_STORE_SYMBOL]: ComponentStore;
+    [REQUIRE_SYMBOL]: (name: string) => unknown;
+    [REQUIRE_EXTRA_SYMBOL]: Record<string, unknown>;
+  }
+}
+declare function experimental_loadShare(name: string, module: unknown): void;
+//#endregion
+export { LoadExternalComponent, experimental_loadShare, useStreamContext };
+//# sourceMappingURL=client.d.cts.map

package/dist/react-ui/client.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.cts","names":["React","JsxRuntime","UIMessage","useStream","UseStream","BagTemplate","UseStreamContext","Record","___react_types_js0","UseStreamCustom","Context","GetMetaType","Bag","StateType","useStreamContext","ComponentTarget","FunctionComponent","ComponentClass","HTMLElement","ComponentStore","EXT_STORE_SYMBOL","REQUIRE_SYMBOL","REQUIRE_EXTRA_SYMBOL","LoadExternalComponentProps","HTMLDivElement","HTMLAttributes","ReturnType","ReactNode","Pick","LoadExternalComponent","stream","namespace","message","meta","fallback","components","JSX","Element","_0","sideEffect","experimental_loadShare","bootstrapUiContext"],"sources":["../../src/react-ui/client.d.ts"],"sourcesContent":["import * as React from \"react\";\nimport * as JsxRuntime from \"react/jsx-runtime\";\nimport type { UIMessage } from \"./types.js\";\nimport { useStream } from \"../react/index.js\";\nimport type { UseStream } from \"../react/types.js\";\nimport type { BagTemplate } from \"../types.template.js\";\ndeclare const UseStreamContext: React.Context<{\n    stream: import(\"../react/types.js\").UseStreamCustom<Record<string, unknown>, BagTemplate>;\n    meta: unknown;\n}>;\ntype GetMetaType<Bag extends BagTemplate> = Bag extends {\n    MetaType: unknown;\n} ? Bag[\"MetaType\"] : unknown;\ninterface UseStreamContext<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> extends UseStream<StateType, Bag> {\n    meta?: GetMetaType<Bag>;\n}\nexport declare function useStreamContext<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(): UseStreamContext<StateType, Bag>;\ninterface ComponentTarget {\n    comp: React.FunctionComponent | React.ComponentClass;\n    target: HTMLElement;\n}\ndeclare class ComponentStore {\n    private cache;\n    private boundCache;\n    private callbacks;\n    respond(shadowRootId: string, comp: React.FunctionComponent | React.ComponentClass, targetElement: HTMLElement): void;\n    getBoundStore(shadowRootId: string): {\n        subscribe: (onStoreChange: () => void) => () => void;\n        getSnapshot: () => ComponentTarget | undefined;\n    };\n}\ndeclare const EXT_STORE_SYMBOL: unique symbol;\ndeclare const REQUIRE_SYMBOL: unique symbol;\ndeclare const REQUIRE_EXTRA_SYMBOL: unique symbol;\ninterface LoadExternalComponentProps extends Pick<React.HTMLAttributes<HTMLDivElement>, \"style\" | \"className\"> {\n    /** Stream of the assistant */\n    stream: ReturnType<typeof useStream>;\n    /** Namespace of UI components. Defaults to assistant ID. */\n    namespace?: string;\n    /** UI message to be rendered */\n    message: UIMessage;\n    /** Additional context to be passed to the child component */\n    meta?: unknown;\n    /** Fallback to be rendered when the component is loading */\n    fallback?: React.ReactNode | Record<string, React.ReactNode>;\n    /**\n     * Map of components that can be rendered directly without fetching the UI code\n     * from the server.\n     */\n    components?: Record<string, React.FunctionComponent | React.ComponentClass>;\n}\nexport declare function LoadExternalComponent({ stream, namespace, message, meta, fallback, components, ...props }: LoadExternalComponentProps): JsxRuntime.JSX.Element;\ndeclare global {\n    interface Window {\n        [EXT_STORE_SYMBOL]: ComponentStore;\n        [REQUIRE_SYMBOL]: (name: string) => unknown;\n        [REQUIRE_EXTRA_SYMBOL]: Record<string, unknown>;\n    }\n}\nexport declare function experimental_loadShare(name: string, module: unknown): void;\nexport declare function bootstrapUiContext(): void;\nexport {};\n"],"mappings":";;;;;;;;cAMcM,kBAAkBN,KAAAA,CAAMU;UACsDF,gBAApCD,yBAAyBF;EADnEC,IAAAA,EAAAA,OAAAA;CAGZ,CAAA;KACGK,WAHmDJ,CAAAA,YAG3BF,WAH2BE,CAAAA,GAGZK,GAHYL,SAAAA;UAAyBF,EAAAA,OAAAA;IAK7EO,GALwFJ,CAAAA,UAAAA,CAAAA,GAAAA,OAAAA;UAMlFF,gBAP4BI,CAAAA,kBAOOH,MAPPG,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GAOiCH,MAPjCG,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,YAOsEL,WAPtEK,GAOoFL,WAPpFK,CAAAA,SAOyGN,SAPzGM,CAOmHG,SAPnHH,EAO8HE,GAP9HF,CAAAA,CAAAA;EAAO,IAAA,CAAA,EAQlCC,WARkC,CAQtBC,GARsB,CAAA;AAAA;AAI7B,iBAMQE,gBANR,CAAA,kBAM2CP,MAN3C,CAAA,MAAA,EAAA,OAAA,CAAA,GAMqEA,MANrE,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,YAM0GF,WAN1G,GAMwHA,WANxH,CAAA,CAAA,CAAA,EAMwIC,gBANxI,CAMyJO,SANzJ,EAMoKD,GANpK,CAAA;UAONG,eAAAA,CAPmBV;MAAeO,EAQlCZ,KAAAA,CAAMgB,iBAR4BJ,GAQRZ,KAAAA,CAAMiB,cAREL;QAExCA,EAOQM,WAPRN;;AAAG,cASOO,cAAAA,CARY;EAAA,QAAA,KAAA;UAAmBZ,UAAAA;UAA0BA,SAAAA;SAAqCF,CAAAA,YAAAA,EAAAA,MAAAA,EAAAA,IAAAA,EAYpEL,KAAAA,CAAMgB,iBAZ8DX,GAY1CL,KAAAA,CAAMiB,cAZoCZ,EAAAA,aAAAA,EAYLa,WAZKb,CAAAA,EAAAA,IAAAA;eAAcA,CAAAA,YAAAA,EAAAA,MAAAA,CAAAA,EAAAA;IAA+BQ,SAAAA,EAAAA,CAAAA,aAAAA,EAAAA,GAAAA,GAAAA,IAAAA,EAAAA,GAAAA,GAAAA,GAAAA,IAAAA;IAAWD,WAAAA,EAAAA,GAAAA,GAezIG,eAfyIH,GAAAA,SAAAA;;;cAkBtJQ,gBAlBiIhB,EAAAA,OAAAA,MAAAA;cAmBjIiB,cAnB0I,EAAA,OAAA,MAAA;AAGxJ,cAiBcC,oBAjB0B,EAAA,OAAA,MAAA;UAkB9BC,0BAAAA,SAAmCK,IAlBL,CAkBU5B,KAAAA,CAAMyB,cAlBhB,CAkB+BD,cAlB/B,CAAA,EAAA,OAAA,GAAA,WAAA,CAAA,CAAA;;QAA6CjB,EAoBzEmB,UApByEnB,CAAAA,OAoBvDJ,SApBuDI,CAAAA;;WAAmDF,CAAAA,EAAAA,MAAAA;;SAA4CO,EAwBvKV,SAxBuKU;;EAAZ,IAAA,CAAA,EAAA,OAAA;EAC9JG;EAAe,QAAA,CAAA,EA2BVf,KAAAA,CAAM2B,SA3BI,GA2BQpB,MA3BR,CAAA,MAAA,EA2BuBP,KAAAA,CAAM2B,SA3B7B,CAAA;;;;;EAIXR,UAAAA,CAAAA,EA4BGZ,MA5BW,CAAA,MAAA,EA4BIP,KAAAA,CAAMgB,iBA5BV,GA4B8BhB,KAAAA,CAAMiB,cA5BpC,CAAA;;AAIYjB,iBA0BhB6B,qBAAAA,CA1BsBb;EAAAA,MAAAA;EAAAA,SAAAA;EAAAA,OAAAA;EAAAA,IAAAA;EAAAA,QAAAA;EAAAA,UAAAA;EAAAA,GAAAA;AAAAA,CAAAA,EA0BsEO,0BA1BtEP,CAAAA,EA0BmGf,UAAAA,CAAWmC,GAAAA,CAAIC,OA1BlHrB;QAAoBhB,MAAMiB,CAAAA;YAA+BC,MAAAA,CAAAA;IAG5EH,CA0BlBK,gBAAAA,CA1BkBL,EA0BCI,cA1BDJ;IAAe,CA2BjCM,cAAAA,CA3BiC,EAAA,CAAA,IAAA,EAAA,MAAA,EAAA,GAAA,OAAA;IAG5BD,CAyBLE,oBAAAA,CAzBoC,EAyBbf,MAzBa,CAAA,MAAA,EAAA,OAAA,CAAA;EAC/Bc;AAA6B;AAEjCE,iBAyBciB,sBAAAA,CAzBY,IAAA,EAAA,MAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EAAA,IAAA"}