Interface●Since v1.6

UseAgentStream

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.

interface UseAgentStream

Bases

BaseStream<StateType, ToolCall, Bag>

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.

Example

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);
    }
  });
}

Properties

property

assistantId: string

property

branch: string

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

property

client: Client

LangGraph SDK client used to send requests and receive responses.

property

error: unknown

property

experimental_branchTree: Sequence<StateType>

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

property

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

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

property

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.

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} />;
});

property

history: ThreadState<StateType>[]

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

property

interrupt: Interrupt<GetInterruptType<Bag>> | undefined

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

property

interrupts: Interrupt<GetInterruptType<Bag>>[]

Interrupt payloads collected during the run, if any. Mirrors the in-process run.interrupts.

property

isLoading: boolean

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

property

isThreadLoading: boolean

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

property