langchain.js
    Preparing search index...

    Interface UseAgentStream<StateType, ToolCall, Bag>Experimental

    Stream interface for ReactAgent instances created with createAgent.

    Extends UseGraphStream with tool calling capabilities. Tool calls are automatically typed based on the agent's tools configuration.

    Use this interface when streaming from an agent created with createAgent. For subagent streaming capabilities, use UseDeepAgentStream with createDeepAgent.

    This interface is subject to change.

    import { createAgent, tool } from "@langchain/langgraph";
    import { useStream } from "@langchain/langgraph-sdk/react";
    import { z } from "zod";

    // Define tools with typed schemas
    const searchTool = tool(
      async ({ query }) => `Results for: ${query}`,
      { name: "search", schema: z.object({ query: z.string() }) }
    );

    const calculatorTool = tool(
      async ({ expression }) => eval(expression).toString(),
      { name: "calculator", schema: z.object({ expression: z.string() }) }
    );

    // Create the agent
    const agent = createAgent({
      model: "gpt-4",
      tools: [searchTool, calculatorTool],
    });

    // In React component:
    function Chat() {
      const stream = useStream<typeof agent>({
        assistantId: "my-agent",
        apiUrl: "http://localhost:2024",
      });

      // Tool calls are typed!
      stream.toolCalls.forEach(tc => {
        if (tc.call.name === "search") {
          // tc.call.args is typed as { query: string }
          console.log("Searching for:", tc.call.args.query);
        } else if (tc.call.name === "calculator") {
          // tc.call.args is typed as { expression: string }
          console.log("Calculating:", tc.call.args.expression);
        }
      });
    }

    This interface adds tool calling on top of UseGraphStream:

    • toolCalls - Array of tool calls paired with their results
    • getToolCalls(message) - Get tool calls for a specific AI message

    It does NOT include subagent streaming features. For those, use UseDeepAgentStream with createDeepAgent.

    interface UseAgentStream<
        StateType extends Record<string, unknown> = Record<string, unknown>,
        ToolCall = DefaultToolCall,
        Bag extends BagTemplate = BagTemplate,
    > {
        assistantId: string;
        branch: string;
        client: Client;
        error: unknown;
        experimental_branchTree: Sequence<StateType>;
        getMessagesMetadata: (
            message: Message<ToolCall>,
            index?: number,
        ) => undefined | MessageMetadata<StateType>;
        getToolCalls: (
            message: AIMessage<ToolCall>,
        ) => ToolCallWithResult<ToolCall>[];
        history: ThreadState<StateType>[];
        interrupt: undefined | Interrupt<GetInterruptType<Bag>>;
        interrupts: Interrupt<GetInterruptType<Bag>>[];
        isLoading: boolean;
        isThreadLoading: boolean;
        joinStream: (
            runId: string,
            lastEventId?: string,
            options?: {
                filter?: (
                    event: { data: unknown; event: StreamEvent; id?: string },
                ) => boolean;
                streamMode?: StreamMode | StreamMode[];
            },
        ) => Promise<void>;
        messages: Message<ToolCall>[];
        setBranch: (branch: string) => void;
        stop: () => Promise<void>;
        submit: (
            values: undefined | null | GetUpdateType<Bag, StateType>,
            options?: SubmitOptions<StateType, GetConfigurableType<Bag>>,
        ) => Promise<void>;
        toolCalls: ToolCallWithResult<ToolCall>[];
        values: StateType;
    }

    Type Parameters

    • StateType extends Record<string, unknown> = Record<string, unknown>

      The agent's state type (base + middleware states)

    • ToolCall = DefaultToolCall

      Tool call type inferred from agent's tools

    • Bag extends BagTemplate = BagTemplate

      Type configuration bag

    Hierarchy (View Summary)

    Index

    Properties

    assistantId branch client error experimental_branchTree getMessagesMetadata getToolCalls history interrupt interrupts isLoading isThreadLoading joinStream messages setBranch stop submit toolCalls values

    Properties

    assistantId: string

    The ID of the assistant to use.

    branch: string

    The current branch of the thread. Used for navigating between different conversation branches.

    client: Client

    LangGraph SDK client used to send requests and receive responses.

    error: unknown

    Last seen error from the stream, if any. Reset to undefined when a new stream starts.

    experimental_branchTree: Sequence<StateType>

    Tree of all branches for the thread. This API is experimental and subject to change.

    getMessagesMetadata: (
        message: Message<ToolCall>,
        index?: number,
    ) => undefined | MessageMetadata<StateType>

    Get the metadata for a message, such as first thread state the message was seen in and branch information.

    Type Declaration

    getToolCalls: (message: AIMessage<ToolCall>) => ToolCallWithResult<ToolCall>[]

    Get tool calls for a specific AI message.

    Use this to find which tool calls were initiated by a particular assistant message, useful for rendering tool calls inline with messages.

    Type Declaration

    messages.map(message => {
      if (message.type === "ai") {
        const calls = stream.getToolCalls(message);
        return (
          <>
            <MessageBubble message={message} />
            {calls.map(tc => <ToolCallCard key={tc.call.id} {...tc} />)}
          </>
        );
      }
      return <MessageBubble message={message} />;
    });
    history: ThreadState<StateType>[]

    Flattened history of thread states of a thread. Contains all states in the current branch's history.

    interrupt: undefined | Interrupt<GetInterruptType<Bag>>

    Current interrupt, if the stream is interrupted. Convenience alias for interrupts[0]. For workflows with multiple concurrent interrupts, use interrupts instead.

    interrupts: Interrupt<GetInterruptType<Bag>>[]

    All current interrupts from the stream. When using Send() fan-out with per-task interrupt() calls, multiple interrupts may be pending simultaneously.

    isLoading: boolean

    Whether the stream is currently running. true while streaming, false when idle or completed.

    isThreadLoading: boolean

    Whether the thread is currently being loaded. true during initial thread data fetch.

    joinStream: (
        runId: string,
        lastEventId?: string,
        options?: {
            filter?: (
                event: { data: unknown; event: StreamEvent; id?: string },
            ) => boolean;
            streamMode?: StreamMode | StreamMode[];
        },
    ) => Promise<void>

    Join an active stream that's already running.

    Type Declaration

      • (
            runId: string,
            lastEventId?: string,
            options?: {
                filter?: (
                    event: { data: unknown; event: StreamEvent; id?: string },
                ) => boolean;
                streamMode?: StreamMode | StreamMode[];
            },
        ): Promise<void>

      • Parameters

        • runId: string

          The ID of the run to join

        • OptionallastEventId: string

          Optional last event ID for resuming from a specific point

        • Optionaloptions: {
              filter?: (
                  event: { data: unknown; event: StreamEvent; id?: string },
              ) => boolean;
              streamMode?: StreamMode | StreamMode[];
          }

          Optional configuration for the stream

        Returns Promise<void>

    messages: Message<ToolCall>[]

    Messages accumulated during the stream. Includes both human and AI messages. AI messages include typed tool calls based on the agent's tools.

    setBranch: (branch: string) => void

    Set the branch of the thread.

    Type Declaration

      • (branch: string): void

      • Parameters

        • branch: string

          The branch identifier to switch to

        Returns void

    stop: () => Promise<void>

    Stops the currently running stream.

    Type Declaration

      • (): Promise<void>

      • Returns Promise<void>

        A promise that resolves when the stream is stopped.

    submit: (
        values: undefined | null | GetUpdateType<Bag, StateType>,
        options?: SubmitOptions<StateType, GetConfigurableType<Bag>>,
    ) => Promise<void>

    Create and stream a run to the thread.

    Type Declaration

      • (
            values: undefined | null | GetUpdateType<Bag, StateType>,
            options?: SubmitOptions<StateType, GetConfigurableType<Bag>>,
        ): Promise<void>

      • Parameters

        • values: undefined | null | GetUpdateType<Bag, StateType>

          The input values to send, or null/undefined for empty input

        • Optionaloptions: SubmitOptions<StateType, GetConfigurableType<Bag>>

          Optional configuration for the submission

        Returns Promise<void>

        A promise that resolves when the stream completes

    toolCalls: ToolCallWithResult<ToolCall>[]

    Tool calls paired with their results.

    Each entry contains the tool call request and its corresponding result. Useful for rendering tool invocations and their outputs together.

    stream.toolCalls.map(({ call, result }) => (
      <ToolCallCard
        name={call.name}
        args={call.args}
        result={result}
      />
    ));
    values: StateType

    The current state values of the stream. Updated as streaming events are received.

    Settings

    Member Visibility

    On This Page

    Properties