@langchain/langgraph-sdk 1.5.6 → 1.6.1

package/dist/ui/stream/deep-agent.d.ts

@@ -0,0 +1,277 @@
+import { DefaultToolCall } from "../../types.messages.js";
+import { BagTemplate } from "../../types.template.js";
+import { DefaultSubagentStates, SubagentStream } from "../types.js";
+import { UseAgentStream, UseAgentStreamOptions } from "./agent.js";
+
+//#region src/ui/stream/deep-agent.d.ts
+
+/**
+ * Stream interface for DeepAgent instances created with `createDeepAgent`.
+ *
+ * Extends {@link UseAgentStream} with subagent streaming capabilities. Subagent
+ * streams are automatically typed based on the agent's subagent configuration,
+ * enabling type-safe access to subagent state and messages.
+ *
+ * Use this interface when streaming from an agent created with `createDeepAgent`
+ * that orchestrates multiple specialized subagents.
+ *
+ * @experimental This interface is subject to change.
+ *
+ * @template StateType - The agent's state type
+ * @template ToolCall - Tool call type from agent's tools
+ * @template SubagentStates - Map of subagent names to their state types
+ * @template Bag - Type configuration bag
+ *
+ * @example
+ * ```typescript
+ * import { createDeepAgent } from "deepagents";
+ * import { useStream } from "@langchain/langgraph-sdk/react";
+ *
+ * // Define subagents with typed middleware
+ * const agent = createDeepAgent({
+ *   subagents: [
+ *     {
+ *       name: "researcher",
+ *       description: "Research specialist",
+ *       middleware: [ResearchMiddleware],
+ *     },
+ *     {
+ *       name: "writer",
+ *       description: "Content writer",
+ *       middleware: [WriterMiddleware],
+ *     },
+ *   ] as const, // Important: use 'as const' for type inference
+ * });
+ *
+ * // In React component:
+ * function Chat() {
+ *   const stream = useStream<typeof agent>({
+ *     assistantId: "deep-agent",
+ *     apiUrl: "http://localhost:2024",
+ *     filterSubagentMessages: true, // Only show main agent messages
+ *   });
+ *
+ *   // Subagent streams are typed!
+ *   const researchers = stream.getSubagentsByType("researcher");
+ *   researchers.forEach(subagent => {
+ *     // subagent.values.messages is typed as Message<ToolCall>[]
+ *     // subagent.status is "pending" | "running" | "complete" | "error"
+ *     console.log("Researcher status:", subagent.status);
+ *   });
+ *
+ *   // Track all active subagents
+ *   stream.activeSubagents.forEach(subagent => {
+ *     console.log(`${subagent.toolCall.args.subagent_type} is running...`);
+ *   });
+ * }
+ * ```
+ *
+ * @remarks
+ * This interface adds subagent streaming on top of {@link UseAgentStream}:
+ * - `subagents` - Map of all subagent streams by tool call ID
+ * - `activeSubagents` - Array of currently running subagents
+ * - `getSubagent(id)` - Get a specific subagent by tool call ID
+ * - `getSubagentsByType(type)` - Get all subagents of a specific type with typed state
+ * - `getSubagentsByMessage(messageId)` - Get all subagents triggered by a specific AI message
+ *
+ * It also enables the `filterSubagentMessages` option to exclude subagent
+ * messages from the main `messages` array.
+ */
+interface UseDeepAgentStream<StateType extends Record<string, unknown> = Record<string, unknown>, ToolCall = DefaultToolCall, SubagentStates extends Record<string, unknown> = DefaultSubagentStates, Bag extends BagTemplate = BagTemplate> extends UseAgentStream<StateType, ToolCall, Bag> {
+  /**
+   * All currently active and completed subagent streams.
+   *
+   * Keyed by tool call ID for easy lookup. Includes subagents in all states:
+   * pending, running, complete, and error.
+   *
+   * @example
+   * ```typescript
+   * // Iterate over all subagents
+   * stream.subagents.forEach((subagent, toolCallId) => {
+   *   console.log(`Subagent ${toolCallId}: ${subagent.status}`);
+   * });
+   *
+   * // Get a specific subagent
+   * const specific = stream.subagents.get("call_abc123");
+   * ```
+   */
+  subagents: Map<string, SubagentStream<SubagentStates[keyof SubagentStates], ToolCall>>;
+  /**
+   * Currently active subagents (where status === "running").
+   *
+   * Use this to track and display subagents that are actively executing.
+   * Completed or errored subagents are not included.
+   *
+   * @example
+   * ```typescript
+   * // Show loading indicators for active subagents
+   * stream.activeSubagents.map(subagent => (
+   *   <SubagentCard
+   *     key={subagent.id}
+   *     type={subagent.toolCall.args.subagent_type}
+   *     isLoading={true}
+   *   />
+   * ));
+   * ```
+   */
+  activeSubagents: SubagentStream<SubagentStates[keyof SubagentStates], ToolCall>[];
+  /**
+   * Get subagent stream by tool call ID.
+   *
+   * Use this when you have a specific tool call ID and need to access
+   * its corresponding subagent stream.
+   *
+   * @param toolCallId - The tool call ID that initiated the subagent
+   * @returns The subagent stream, or undefined if not found
+   *
+   * @example
+   * ```typescript
+   * // In a tool call component
+   * const subagent = stream.getSubagent(toolCall.id);
+   * if (subagent) {
+   *   return <SubagentProgress subagent={subagent} />;
+   * }
+   * ```
+   */
+  getSubagent: (toolCallId: string) => SubagentStream<SubagentStates[keyof SubagentStates], ToolCall> | undefined;
+  /**
+   * Get all subagents of a specific type.
+   *
+   * Returns streams with properly inferred state types based on subagent name.
+   * When called with a literal string that matches a subagent name, TypeScript
+   * will infer the correct state type for that subagent.
+   *
+   * @param type - The subagent_type to filter by
+   * @returns Array of matching subagent streams with inferred state types
+   *
+   * @example
+   * ```typescript
+   * // Get all researcher subagents with typed state
+   * const researchers = stream.getSubagentsByType("researcher");
+   *
+   * researchers.forEach(researcher => {
+   *   // researcher.values is typed based on ResearchMiddleware
+   *   console.log("Research messages:", researcher.values.messages.length);
+   *   console.log("Status:", researcher.status);
+   * });
+   *
+   * // Get all writer subagents
+   * const writers = stream.getSubagentsByType("writer");
+   * // writers have different state type based on WriterMiddleware
+   * ```
+   */
+  getSubagentsByType: {
+    /**
+     * Overload for known subagent names - returns typed streams.
+     * TypeScript infers the state type from SubagentStates[TName].
+     */
+    <TName extends keyof SubagentStates & string>(type: TName): SubagentStream<SubagentStates[TName], ToolCall>[];
+    /**
+     * Overload for unknown names - returns untyped streams.
+     * Used when the subagent name is not known at compile time.
+     */
+    (type: string): SubagentStream<Record<string, unknown>, ToolCall>[];
+  };
+  /**
+   * Get all subagents triggered by a specific AI message.
+   *
+   * Useful for rendering subagent activities grouped by conversation turn.
+   * Each AI message that contains subagent tool calls will have its triggered
+   * subagents returned by this method.
+   *
+   * @param messageId - The ID of the AI message that triggered the subagents
+   * @returns Array of subagent streams triggered by that message
+   *
+   * @example
+   * ```tsx
+   * // Render subagents inline after the AI message that triggered them
+   * {stream.messages.map((msg) => (
+   *   <div key={msg.id}>
+   *     <MessageBubble message={msg} />
+   *     {msg.type === "ai" && "tool_calls" in msg && (
+   *       <SubagentPipeline
+   *         subagents={stream.getSubagentsByMessage(msg.id)}
+   *       />
+   *     )}
+   *   </div>
+   * ))}
+   * ```
+   */
+  getSubagentsByMessage: (messageId: string) => SubagentStream<SubagentStates[keyof SubagentStates], ToolCall>[];
+}
+/**
+ * Options for configuring a deep agent stream.
+ *
+ * Use this options interface when calling `useStream` with a DeepAgent
+ * created via `createDeepAgent`. Includes all agent options plus
+ * subagent-specific configuration.
+ *
+ * @template StateType - The agent's state type
+ * @template Bag - Type configuration bag
+ *
+ * @example
+ * ```typescript
+ * const stream = useStream<typeof agent>({
+ *   assistantId: "deep-agent",
+ *   apiUrl: "http://localhost:2024",
+ *
+ *   // DeepAgent-specific options
+ *   subagentToolNames: ["task", "delegate"],
+ *   filterSubagentMessages: true,
+ *
+ *   onError: (error) => console.error(error),
+ * });
+ * ```
+ */
+interface UseDeepAgentStreamOptions<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> extends UseAgentStreamOptions<StateType, Bag> {
+  /**
+   * Tool names that indicate subagent invocation.
+   *
+   * When an AI message contains tool calls with these names, they are
+   * automatically tracked as subagent executions. This enables the
+   * `subagents`, `activeSubagents`, `getSubagent()`, `getSubagentsByType()`, and `getSubagentsByMessage()`
+   * properties on the stream.
+   *
+   * @default ["task"]
+   *
+   * @example
+   * ```typescript
+   * const stream = useStream<typeof agent>({
+   *   assistantId: "deep-agent",
+   *   // Track both "task" and "delegate" as subagent tools
+   *   subagentToolNames: ["task", "delegate", "spawn_agent"],
+   * });
+   *
+   * // Now stream.subagents will include executions from any of these tools
+   * ```
+   */
+  subagentToolNames?: string[];
+  /**
+   * Whether to filter out messages from subagent namespaces.
+   *
+   * When `true`, only messages from the main agent are included in
+   * the `messages` array. Subagent messages are still accessible via
+   * the `subagents` map and individual subagent streams.
+   *
+   * This is useful when you want to display subagent progress separately
+   * from the main conversation, or when subagent messages would be too
+   * verbose in the main message list.
+   *
+   * @default false
+   *
+   * @example
+   * ```typescript
+   * const stream = useStream<typeof agent>({
+   *   assistantId: "deep-agent",
+   *   filterSubagentMessages: true,
+   * });
+   *
+   * // stream.messages only contains main agent messages
+   * // Subagent messages are in stream.getSubagentsByType("researcher")[0].messages
+   * ```
+   */
+  filterSubagentMessages?: boolean;
+}
+//#endregion
+export { UseDeepAgentStream, UseDeepAgentStreamOptions };
+//# sourceMappingURL=deep-agent.d.ts.map

package/dist/ui/stream/deep-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-agent.d.ts","names":["DefaultToolCall","BagTemplate","SubagentStream","DefaultSubagentStates","UseAgentStream","UseAgentStreamOptions","UseDeepAgentStream","Record","StateType","ToolCall","Bag","SubagentStates","Map","TName","UseDeepAgentStreamOptions"],"sources":["../../../src/ui/stream/deep-agent.d.ts"],"sourcesContent":["/**\n * Stream types for DeepAgent instances created with `createDeepAgent`.\n *\n * This module provides the stream interface that adds subagent streaming\n * capabilities on top of agent streaming functionality.\n *\n * @module\n */\nimport type { DefaultToolCall } from \"../../types.messages.js\";\nimport type { BagTemplate } from \"../../types.template.js\";\nimport type { SubagentStream, DefaultSubagentStates } from \"../types.js\";\nimport type { UseAgentStream, UseAgentStreamOptions } from \"./agent.js\";\n/**\n * Stream interface for DeepAgent instances created with `createDeepAgent`.\n *\n * Extends {@link UseAgentStream} with subagent streaming capabilities. Subagent\n * streams are automatically typed based on the agent's subagent configuration,\n * enabling type-safe access to subagent state and messages.\n *\n * Use this interface when streaming from an agent created with `createDeepAgent`\n * that orchestrates multiple specialized subagents.\n *\n * @experimental This interface is subject to change.\n *\n * @template StateType - The agent's state type\n * @template ToolCall - Tool call type from agent's tools\n * @template SubagentStates - Map of subagent names to their state types\n * @template Bag - Type configuration bag\n *\n * @example\n * ```typescript\n * import { createDeepAgent } from \"deepagents\";\n * import { useStream } from \"@langchain/langgraph-sdk/react\";\n *\n * // Define subagents with typed middleware\n * const agent = createDeepAgent({\n *   subagents: [\n *     {\n *       name: \"researcher\",\n *       description: \"Research specialist\",\n *       middleware: [ResearchMiddleware],\n *     },\n *     {\n *       name: \"writer\",\n *       description: \"Content writer\",\n *       middleware: [WriterMiddleware],\n *     },\n *   ] as const, // Important: use 'as const' for type inference\n * });\n *\n * // In React component:\n * function Chat() {\n *   const stream = useStream<typeof agent>({\n *     assistantId: \"deep-agent\",\n *     apiUrl: \"http://localhost:2024\",\n *     filterSubagentMessages: true, // Only show main agent messages\n *   });\n *\n *   // Subagent streams are typed!\n *   const researchers = stream.getSubagentsByType(\"researcher\");\n *   researchers.forEach(subagent => {\n *     // subagent.values.messages is typed as Message<ToolCall>[]\n *     // subagent.status is \"pending\" | \"running\" | \"complete\" | \"error\"\n *     console.log(\"Researcher status:\", subagent.status);\n *   });\n *\n *   // Track all active subagents\n *   stream.activeSubagents.forEach(subagent => {\n *     console.log(`${subagent.toolCall.args.subagent_type} is running...`);\n *   });\n * }\n * ```\n *\n * @remarks\n * This interface adds subagent streaming on top of {@link UseAgentStream}:\n * - `subagents` - Map of all subagent streams by tool call ID\n * - `activeSubagents` - Array of currently running subagents\n * - `getSubagent(id)` - Get a specific subagent by tool call ID\n * - `getSubagentsByType(type)` - Get all subagents of a specific type with typed state\n * - `getSubagentsByMessage(messageId)` - Get all subagents triggered by a specific AI message\n *\n * It also enables the `filterSubagentMessages` option to exclude subagent\n * messages from the main `messages` array.\n */\nexport interface UseDeepAgentStream<StateType extends Record<string, unknown> = Record<string, unknown>, ToolCall = DefaultToolCall, SubagentStates extends Record<string, unknown> = DefaultSubagentStates, Bag extends BagTemplate = BagTemplate> extends UseAgentStream<StateType, ToolCall, Bag> {\n    /**\n     * All currently active and completed subagent streams.\n     *\n     * Keyed by tool call ID for easy lookup. Includes subagents in all states:\n     * pending, running, complete, and error.\n     *\n     * @example\n     * ```typescript\n     * // Iterate over all subagents\n     * stream.subagents.forEach((subagent, toolCallId) => {\n     *   console.log(`Subagent ${toolCallId}: ${subagent.status}`);\n     * });\n     *\n     * // Get a specific subagent\n     * const specific = stream.subagents.get(\"call_abc123\");\n     * ```\n     */\n    subagents: Map<string, SubagentStream<SubagentStates[keyof SubagentStates], ToolCall>>;\n    /**\n     * Currently active subagents (where status === \"running\").\n     *\n     * Use this to track and display subagents that are actively executing.\n     * Completed or errored subagents are not included.\n     *\n     * @example\n     * ```typescript\n     * // Show loading indicators for active subagents\n     * stream.activeSubagents.map(subagent => (\n     *   <SubagentCard\n     *     key={subagent.id}\n     *     type={subagent.toolCall.args.subagent_type}\n     *     isLoading={true}\n     *   />\n     * ));\n     * ```\n     */\n    activeSubagents: SubagentStream<SubagentStates[keyof SubagentStates], ToolCall>[];\n    /**\n     * Get subagent stream by tool call ID.\n     *\n     * Use this when you have a specific tool call ID and need to access\n     * its corresponding subagent stream.\n     *\n     * @param toolCallId - The tool call ID that initiated the subagent\n     * @returns The subagent stream, or undefined if not found\n     *\n     * @example\n     * ```typescript\n     * // In a tool call component\n     * const subagent = stream.getSubagent(toolCall.id);\n     * if (subagent) {\n     *   return <SubagentProgress subagent={subagent} />;\n     * }\n     * ```\n     */\n    getSubagent: (toolCallId: string) => SubagentStream<SubagentStates[keyof SubagentStates], ToolCall> | undefined;\n    /**\n     * Get all subagents of a specific type.\n     *\n     * Returns streams with properly inferred state types based on subagent name.\n     * When called with a literal string that matches a subagent name, TypeScript\n     * will infer the correct state type for that subagent.\n     *\n     * @param type - The subagent_type to filter by\n     * @returns Array of matching subagent streams with inferred state types\n     *\n     * @example\n     * ```typescript\n     * // Get all researcher subagents with typed state\n     * const researchers = stream.getSubagentsByType(\"researcher\");\n     *\n     * researchers.forEach(researcher => {\n     *   // researcher.values is typed based on ResearchMiddleware\n     *   console.log(\"Research messages:\", researcher.values.messages.length);\n     *   console.log(\"Status:\", researcher.status);\n     * });\n     *\n     * // Get all writer subagents\n     * const writers = stream.getSubagentsByType(\"writer\");\n     * // writers have different state type based on WriterMiddleware\n     * ```\n     */\n    getSubagentsByType: {\n        /**\n         * Overload for known subagent names - returns typed streams.\n         * TypeScript infers the state type from SubagentStates[TName].\n         */\n        <TName extends keyof SubagentStates & string>(type: TName): SubagentStream<SubagentStates[TName], ToolCall>[];\n        /**\n         * Overload for unknown names - returns untyped streams.\n         * Used when the subagent name is not known at compile time.\n         */\n        (type: string): SubagentStream<Record<string, unknown>, ToolCall>[];\n    };\n    /**\n     * Get all subagents triggered by a specific AI message.\n     *\n     * Useful for rendering subagent activities grouped by conversation turn.\n     * Each AI message that contains subagent tool calls will have its triggered\n     * subagents returned by this method.\n     *\n     * @param messageId - The ID of the AI message that triggered the subagents\n     * @returns Array of subagent streams triggered by that message\n     *\n     * @example\n     * ```tsx\n     * // Render subagents inline after the AI message that triggered them\n     * {stream.messages.map((msg) => (\n     *   <div key={msg.id}>\n     *     <MessageBubble message={msg} />\n     *     {msg.type === \"ai\" && \"tool_calls\" in msg && (\n     *       <SubagentPipeline\n     *         subagents={stream.getSubagentsByMessage(msg.id)}\n     *       />\n     *     )}\n     *   </div>\n     * ))}\n     * ```\n     */\n    getSubagentsByMessage: (messageId: string) => SubagentStream<SubagentStates[keyof SubagentStates], ToolCall>[];\n}\n/**\n * Options for configuring a deep agent stream.\n *\n * Use this options interface when calling `useStream` with a DeepAgent\n * created via `createDeepAgent`. Includes all agent options plus\n * subagent-specific configuration.\n *\n * @template StateType - The agent's state type\n * @template Bag - Type configuration bag\n *\n * @example\n * ```typescript\n * const stream = useStream<typeof agent>({\n *   assistantId: \"deep-agent\",\n *   apiUrl: \"http://localhost:2024\",\n *\n *   // DeepAgent-specific options\n *   subagentToolNames: [\"task\", \"delegate\"],\n *   filterSubagentMessages: true,\n *\n *   onError: (error) => console.error(error),\n * });\n * ```\n */\nexport interface UseDeepAgentStreamOptions<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> extends UseAgentStreamOptions<StateType, Bag> {\n    /**\n     * Tool names that indicate subagent invocation.\n     *\n     * When an AI message contains tool calls with these names, they are\n     * automatically tracked as subagent executions. This enables the\n     * `subagents`, `activeSubagents`, `getSubagent()`, `getSubagentsByType()`, and `getSubagentsByMessage()`\n     * properties on the stream.\n     *\n     * @default [\"task\"]\n     *\n     * @example\n     * ```typescript\n     * const stream = useStream<typeof agent>({\n     *   assistantId: \"deep-agent\",\n     *   // Track both \"task\" and \"delegate\" as subagent tools\n     *   subagentToolNames: [\"task\", \"delegate\", \"spawn_agent\"],\n     * });\n     *\n     * // Now stream.subagents will include executions from any of these tools\n     * ```\n     */\n    subagentToolNames?: string[];\n    /**\n     * Whether to filter out messages from subagent namespaces.\n     *\n     * When `true`, only messages from the main agent are included in\n     * the `messages` array. Subagent messages are still accessible via\n     * the `subagents` map and individual subagent streams.\n     *\n     * This is useful when you want to display subagent progress separately\n     * from the main conversation, or when subagent messages would be too\n     * verbose in the main message list.\n     *\n     * @default false\n     *\n     * @example\n     * ```typescript\n     * const stream = useStream<typeof agent>({\n     *   assistantId: \"deep-agent\",\n     *   filterSubagentMessages: true,\n     * });\n     *\n     * // stream.messages only contains main agent messages\n     * // Subagent messages are in stream.getSubagentsByType(\"researcher\")[0].messages\n     * ```\n     */\n    filterSubagentMessages?: boolean;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAlJiBM,qCAAqCC,0BAA0BA,oCAAoCP,wCAAwCO,0BAA0BJ,mCAAmCF,cAAcA,qBAAqBG,eAAeI,WAAWC,UAAUC;;;;;;;;;;;;;;;;;;aAkBjRE,YAAYV,eAAeS,qBAAqBA,iBAAiBF;;;;;;;;;;;;;;;;;;;mBAmB3DP,eAAeS,qBAAqBA,iBAAiBF;;;;;;;;;;;;;;;;;;;uCAmBjCP,eAAeS,qBAAqBA,iBAAiBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAgCjEE,+BAA+BE,QAAQX,eAAeS,eAAeE,QAAQJ;;;;;oBAKlFP,eAAeK,yBAAyBE;;;;;;;;;;;;;;;;;;;;;;;;;;;gDA2BdP,eAAeS,qBAAqBA,iBAAiBF;;;;;;;;;;;;;;;;;;;;;;;;;;UA0BtFK,4CAA4CP,0BAA0BA,qCAAqCN,cAAcA,qBAAqBI,sBAAsBG,WAAWE"}

package/dist/ui/stream/index.d.cts

@@ -0,0 +1,172 @@
+import { DefaultToolCall } from "../../types.messages.cjs";
+import { BagTemplate } from "../../types.template.cjs";
+import { AgentTypeConfigLike, DeepAgentTypeConfigLike, DefaultSubagentStates, InferAgentState, InferAgentToolCalls, SubagentStateMap, UseStreamOptions } from "../types.cjs";
+import { BaseStream } from "./base.cjs";
+import { UseAgentStream, UseAgentStreamOptions } from "./agent.cjs";
+import { UseDeepAgentStream, UseDeepAgentStreamOptions } from "./deep-agent.cjs";
+
+//#region src/ui/stream/index.d.ts
+
+/**
+ * Check if a type is a DeepAgent (has `~deepAgentTypes` phantom property).
+ */
+type IsDeepAgent<T> = T extends {
+  "~deepAgentTypes": DeepAgentTypeConfigLike;
+} ? true : false;
+/**
+ * Check if a type is a ReactAgent (has `~agentTypes` but not `~deepAgentTypes`).
+ */
+type IsReactAgent<T> = T extends {
+  "~agentTypes": AgentTypeConfigLike;
+} ? T extends {
+  "~deepAgentTypes": unknown;
+} ? false : true : false;
+/**
+ * Infer the state type from an agent, graph, or direct state type.
+ *
+ * Detection order:
+ * 1. Agent-like (`~agentTypes`) → InferAgentState
+ * 2. CompiledGraph (`~RunOutput`) → Extract RunOutput
+ * 3. Pregel (`~OutputType`) → Extract OutputType
+ * 4. Direct state type → Return as-is
+ */
+type InferStateType<T> = T extends {
+  "~agentTypes": unknown;
+} ? InferAgentState<T> : T extends {
+  "~RunOutput": infer S;
+} ? S extends Record<string, unknown> ? S : Record<string, unknown> : T extends {
+  "~OutputType": infer O;
+} ? O extends Record<string, unknown> ? O : Record<string, unknown> : T extends Record<string, unknown> ? T : Record<string, unknown>;
+/**
+ * Infer the node names from a compiled graph.
+ *
+ * Extracts the `~NodeType` phantom property from CompiledGraph instances,
+ * providing a union of all node names defined in the graph.
+ *
+ * @example
+ * ```typescript
+ * const graph = new StateGraph(StateAnnotation)
+ *   .addNode("agent", agentFn)
+ *   .addNode("tool", toolFn)
+ *   .compile();
+ *
+ * type NodeNames = InferNodeNames<typeof graph>; // "agent" | "tool"
+ * ```
+ */
+type InferNodeNames<T> = T extends {
+  "~NodeType": infer N;
+} ? N extends string ? Exclude<N, "__start__"> : string : string;
+/**
+ * Infer the per-node return types from a compiled graph.
+ *
+ * Extracts the `~NodeReturnType` phantom property from CompiledGraph instances,
+ * which is a mapped type of `{ [nodeName]: ReturnType }` for each node.
+ *
+ * @example
+ * ```typescript
+ * const graph = new StateGraph(StateAnnotation)
+ *   .addNode("dispatcher", async () => ({ topic: "foo" }))
+ *   .addNode("researcher", async () => ({ research: "bar" }))
+ *   .compile();
+ *
+ * type NodeReturns = InferNodeReturnTypes<typeof graph>;
+ * // { dispatcher: { topic: string }; researcher: { research: string } }
+ * ```
+ */
+type InferNodeReturnTypes<T> = T extends {
+  "~NodeReturnType": infer R;
+} ? R extends Record<string, unknown> ? R : Record<string, Record<string, unknown>> : Record<string, Record<string, unknown>>;
+/**
+ * Infer tool call types from an agent.
+ *
+ * For agents, extracts typed tool calls from the agent's tools.
+ * For non-agents, returns DefaultToolCall.
+ */
+type InferToolCalls<T> = T extends {
+  "~agentTypes": unknown;
+} ? InferAgentToolCalls<T> : DefaultToolCall;
+/**
+ * Infer subagent state map from a DeepAgent.
+ *
+ * For DeepAgent, creates a map of subagent names to their state types.
+ * For non-DeepAgent, returns DefaultSubagentStates.
+ */
+type InferSubagentStates<T> = T extends {
+  "~deepAgentTypes": unknown;
+} ? SubagentStateMap<T, InferAgentToolCalls<T>> : DefaultSubagentStates;
+/**
+ * Resolves the appropriate stream interface based on the agent/graph type.
+ *
+ * This type automatically selects the correct stream interface based on
+ * the type of agent or graph passed to `useStream`:
+ *
+ * 1. **DeepAgent** (`~deepAgentTypes`) → {@link UseDeepAgentStream}
+ *    - Includes: values, messages, toolCalls, subagents, getSubagentsByType, getSubagentsByMessage
+ *
+ * 2. **ReactAgent** (`~agentTypes`) → {@link UseAgentStream}
+ *    - Includes: values, messages, toolCalls, getToolCalls
+ *    - Excludes: subagents, getSubagentsByType
+ *
+ * 3. **CompiledGraph** (`~RunOutput`/`~OutputType`) → {@link UseGraphStream}
+ *    - Includes: values, messages, submit, stop, nodes, getNodeStreamsByName
+ *    - Excludes: toolCalls, subagents
+ *    - Node names are inferred from `~NodeType` for type-safe access
+ *
+ * 4. **Default** → {@link UseGraphStream}
+ *
+ * @template T - The agent or graph type (use `typeof agent` or `typeof graph`)
+ * @template Bag - Type configuration bag for interrupts, configurable, etc.
+ *
+ * @example
+ * ```typescript
+ * // Automatic detection based on agent type
+ * type GraphStream = ResolveStreamInterface<typeof compiledGraph, BagTemplate>;
+ * // → UseGraphStream (with typed node names)
+ *
+ * type AgentStream = ResolveStreamInterface<typeof reactAgent, BagTemplate>;
+ * // → UseAgentStream (has toolCalls)
+ *
+ * type DeepStream = ResolveStreamInterface<typeof deepAgent, BagTemplate>;
+ * // → UseDeepAgentStream (has toolCalls AND subagents)
+ * ```
+ */
+type ResolveStreamInterface<T, Bag extends BagTemplate = BagTemplate> = IsDeepAgent<T> extends true ? UseDeepAgentStream<InferStateType<T>, InferToolCalls<T>, InferSubagentStates<T>, Bag> : IsReactAgent<T> extends true ? UseAgentStream<InferStateType<T>, InferToolCalls<T>, Bag> : BaseStream<InferStateType<T>, InferToolCalls<T>, Bag>;
+/**
+ * Resolves the appropriate options interface based on the agent/graph type.
+ *
+ * This type automatically selects the correct options interface based on
+ * the type of agent or graph:
+ *
+ * 1. **DeepAgent** → {@link UseDeepAgentStreamOptions}
+ *    - Includes: `filterSubagentMessages` option
+ *
+ * 2. **ReactAgent** → {@link UseAgentStreamOptions}
+ *
+ * 3. **CompiledGraph** / **Default** → {@link UseGraphStreamOptions}
+ *
+ * @template T - The agent or graph type
+ * @template Bag - Type configuration bag
+ *
+ * @example
+ * ```typescript
+ * // Only DeepAgent options include filterSubagentMessages
+ * type DeepOptions = ResolveStreamOptions<typeof deepAgent, BagTemplate>;
+ * // DeepOptions.filterSubagentMessages exists
+ *
+ * type AgentOptions = ResolveStreamOptions<typeof reactAgent, BagTemplate>;
+ * // AgentOptions.filterSubagentMessages does NOT exist
+ * ```
+ */
+type ResolveStreamOptions<T, Bag extends BagTemplate = BagTemplate> = IsDeepAgent<T> extends true ? UseDeepAgentStreamOptions<InferStateType<T>, Bag> : IsReactAgent<T> extends true ? UseAgentStreamOptions<InferStateType<T>, Bag> : UseStreamOptions<InferStateType<T>, Bag>;
+/**
+ * Infer the Bag type from an agent, defaulting to the provided Bag.
+ *
+ * Currently returns the provided Bag for all types.
+ * Can be extended in the future to extract Bag from agent types.
+ */
+type InferBag<T, B extends BagTemplate = BagTemplate> = T extends {
+  "~agentTypes": unknown;
+} ? BagTemplate : B;
+//#endregion
+export { InferBag, InferNodeNames, InferNodeReturnTypes, InferStateType, InferSubagentStates, InferToolCalls, ResolveStreamInterface, ResolveStreamOptions };
+//# sourceMappingURL=index.d.cts.map

package/dist/ui/stream/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["DefaultToolCall","BagTemplate","InferAgentState","InferAgentToolCalls","SubagentStateMap","DefaultSubagentStates","AgentTypeConfigLike","DeepAgentTypeConfigLike","UseStreamOptions","BaseStream","UseAgentStream","UseAgentStreamOptions","UseDeepAgentStream","UseDeepAgentStreamOptions","IsDeepAgent","T","IsReactAgent","InferStateType","S","Record","O","InferNodeNames","N","Exclude","InferNodeReturnTypes","R","InferToolCalls","InferSubagentStates","ResolveStreamInterface","Bag","ResolveStreamOptions","InferBag","B"],"sources":["../../../src/ui/stream/index.d.ts"],"sourcesContent":["/**\n * Unified stream type system for LangGraph.\n *\n * This module provides the type resolution system that automatically selects\n * the appropriate stream interface based on the agent/graph type:\n *\n * - **CompiledStateGraph** → {@link UseGraphStream}\n * - **ReactAgent** (createAgent) → {@link UseAgentStream}\n * - **DeepAgent** (createDeepAgent) → {@link UseDeepAgentStream}\n *\n * @module\n */\nimport type { DefaultToolCall } from \"../../types.messages.js\";\nimport type { BagTemplate } from \"../../types.template.js\";\nimport type { InferAgentState, InferAgentToolCalls, SubagentStateMap, DefaultSubagentStates, AgentTypeConfigLike, DeepAgentTypeConfigLike, UseStreamOptions } from \"../types.js\";\nimport type { BaseStream } from \"./base.js\";\nimport type { UseAgentStream, UseAgentStreamOptions } from \"./agent.js\";\nimport type { UseDeepAgentStream, UseDeepAgentStreamOptions } from \"./deep-agent.js\";\nexport type { BaseStream } from \"./base.js\";\nexport type { UseAgentStream, UseAgentStreamOptions } from \"./agent.js\";\nexport type { UseDeepAgentStream, UseDeepAgentStreamOptions, } from \"./deep-agent.js\";\n/**\n * Check if a type is a DeepAgent (has `~deepAgentTypes` phantom property).\n */\ntype IsDeepAgent<T> = T extends {\n    \"~deepAgentTypes\": DeepAgentTypeConfigLike;\n} ? true : false;\n/**\n * Check if a type is a ReactAgent (has `~agentTypes` but not `~deepAgentTypes`).\n */\ntype IsReactAgent<T> = T extends {\n    \"~agentTypes\": AgentTypeConfigLike;\n} ? T extends {\n    \"~deepAgentTypes\": unknown;\n} ? false : true : false;\n/**\n * Infer the state type from an agent, graph, or direct state type.\n *\n * Detection order:\n * 1. Agent-like (`~agentTypes`) → InferAgentState\n * 2. CompiledGraph (`~RunOutput`) → Extract RunOutput\n * 3. Pregel (`~OutputType`) → Extract OutputType\n * 4. Direct state type → Return as-is\n */\nexport type InferStateType<T> = T extends {\n    \"~agentTypes\": unknown;\n} ? InferAgentState<T> : T extends {\n    \"~RunOutput\": infer S;\n} ? S extends Record<string, unknown> ? S : Record<string, unknown> : T extends {\n    \"~OutputType\": infer O;\n} ? O extends Record<string, unknown> ? O : Record<string, unknown> : T extends Record<string, unknown> ? T : Record<string, unknown>;\n/**\n * Infer the node names from a compiled graph.\n *\n * Extracts the `~NodeType` phantom property from CompiledGraph instances,\n * providing a union of all node names defined in the graph.\n *\n * @example\n * ```typescript\n * const graph = new StateGraph(StateAnnotation)\n *   .addNode(\"agent\", agentFn)\n *   .addNode(\"tool\", toolFn)\n *   .compile();\n *\n * type NodeNames = InferNodeNames<typeof graph>; // \"agent\" | \"tool\"\n * ```\n */\nexport type InferNodeNames<T> = T extends {\n    \"~NodeType\": infer N;\n} ? N extends string ? Exclude<N, \"__start__\"> : string : string;\n/**\n * Infer the per-node return types from a compiled graph.\n *\n * Extracts the `~NodeReturnType` phantom property from CompiledGraph instances,\n * which is a mapped type of `{ [nodeName]: ReturnType }` for each node.\n *\n * @example\n * ```typescript\n * const graph = new StateGraph(StateAnnotation)\n *   .addNode(\"dispatcher\", async () => ({ topic: \"foo\" }))\n *   .addNode(\"researcher\", async () => ({ research: \"bar\" }))\n *   .compile();\n *\n * type NodeReturns = InferNodeReturnTypes<typeof graph>;\n * // { dispatcher: { topic: string }; researcher: { research: string } }\n * ```\n */\nexport type InferNodeReturnTypes<T> = T extends {\n    \"~NodeReturnType\": infer R;\n} ? R extends Record<string, unknown> ? R : Record<string, Record<string, unknown>> : Record<string, Record<string, unknown>>;\n/**\n * Infer tool call types from an agent.\n *\n * For agents, extracts typed tool calls from the agent's tools.\n * For non-agents, returns DefaultToolCall.\n */\nexport type InferToolCalls<T> = T extends {\n    \"~agentTypes\": unknown;\n} ? InferAgentToolCalls<T> : DefaultToolCall;\n/**\n * Infer subagent state map from a DeepAgent.\n *\n * For DeepAgent, creates a map of subagent names to their state types.\n * For non-DeepAgent, returns DefaultSubagentStates.\n */\nexport type InferSubagentStates<T> = T extends {\n    \"~deepAgentTypes\": unknown;\n} ? SubagentStateMap<T, InferAgentToolCalls<T>> : DefaultSubagentStates;\n/**\n * Resolves the appropriate stream interface based on the agent/graph type.\n *\n * This type automatically selects the correct stream interface based on\n * the type of agent or graph passed to `useStream`:\n *\n * 1. **DeepAgent** (`~deepAgentTypes`) → {@link UseDeepAgentStream}\n *    - Includes: values, messages, toolCalls, subagents, getSubagentsByType, getSubagentsByMessage\n *\n * 2. **ReactAgent** (`~agentTypes`) → {@link UseAgentStream}\n *    - Includes: values, messages, toolCalls, getToolCalls\n *    - Excludes: subagents, getSubagentsByType\n *\n * 3. **CompiledGraph** (`~RunOutput`/`~OutputType`) → {@link UseGraphStream}\n *    - Includes: values, messages, submit, stop, nodes, getNodeStreamsByName\n *    - Excludes: toolCalls, subagents\n *    - Node names are inferred from `~NodeType` for type-safe access\n *\n * 4. **Default** → {@link UseGraphStream}\n *\n * @template T - The agent or graph type (use `typeof agent` or `typeof graph`)\n * @template Bag - Type configuration bag for interrupts, configurable, etc.\n *\n * @example\n * ```typescript\n * // Automatic detection based on agent type\n * type GraphStream = ResolveStreamInterface<typeof compiledGraph, BagTemplate>;\n * // → UseGraphStream (with typed node names)\n *\n * type AgentStream = ResolveStreamInterface<typeof reactAgent, BagTemplate>;\n * // → UseAgentStream (has toolCalls)\n *\n * type DeepStream = ResolveStreamInterface<typeof deepAgent, BagTemplate>;\n * // → UseDeepAgentStream (has toolCalls AND subagents)\n * ```\n */\nexport type ResolveStreamInterface<T, Bag extends BagTemplate = BagTemplate> = IsDeepAgent<T> extends true ? UseDeepAgentStream<InferStateType<T>, InferToolCalls<T>, InferSubagentStates<T>, Bag> : IsReactAgent<T> extends true ? UseAgentStream<InferStateType<T>, InferToolCalls<T>, Bag> : BaseStream<InferStateType<T>, InferToolCalls<T>, Bag>;\n/**\n * Resolves the appropriate options interface based on the agent/graph type.\n *\n * This type automatically selects the correct options interface based on\n * the type of agent or graph:\n *\n * 1. **DeepAgent** → {@link UseDeepAgentStreamOptions}\n *    - Includes: `filterSubagentMessages` option\n *\n * 2. **ReactAgent** → {@link UseAgentStreamOptions}\n *\n * 3. **CompiledGraph** / **Default** → {@link UseGraphStreamOptions}\n *\n * @template T - The agent or graph type\n * @template Bag - Type configuration bag\n *\n * @example\n * ```typescript\n * // Only DeepAgent options include filterSubagentMessages\n * type DeepOptions = ResolveStreamOptions<typeof deepAgent, BagTemplate>;\n * // DeepOptions.filterSubagentMessages exists\n *\n * type AgentOptions = ResolveStreamOptions<typeof reactAgent, BagTemplate>;\n * // AgentOptions.filterSubagentMessages does NOT exist\n * ```\n */\nexport type ResolveStreamOptions<T, Bag extends BagTemplate = BagTemplate> = IsDeepAgent<T> extends true ? UseDeepAgentStreamOptions<InferStateType<T>, Bag> : IsReactAgent<T> extends true ? UseAgentStreamOptions<InferStateType<T>, Bag> : UseStreamOptions<InferStateType<T>, Bag>;\n/**\n * Infer the Bag type from an agent, defaulting to the provided Bag.\n *\n * Currently returns the provided Bag for all types.\n * Can be extended in the future to extract Bag from agent types.\n */\nexport type InferBag<T, B extends BagTemplate = BagTemplate> = T extends {\n    \"~agentTypes\": unknown;\n} ? BagTemplate : B;\n"],"mappings":"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"}

package/dist/ui/stream/index.d.ts

@@ -0,0 +1,172 @@
+import { DefaultToolCall } from "../../types.messages.js";
+import { BagTemplate } from "../../types.template.js";
+import { AgentTypeConfigLike, DeepAgentTypeConfigLike, DefaultSubagentStates, InferAgentState, InferAgentToolCalls, SubagentStateMap, UseStreamOptions } from "../types.js";
+import { BaseStream } from "./base.js";
+import { UseAgentStream, UseAgentStreamOptions } from "./agent.js";
+import { UseDeepAgentStream, UseDeepAgentStreamOptions } from "./deep-agent.js";
+
+//#region src/ui/stream/index.d.ts
+
+/**
+ * Check if a type is a DeepAgent (has `~deepAgentTypes` phantom property).
+ */
+type IsDeepAgent<T> = T extends {
+  "~deepAgentTypes": DeepAgentTypeConfigLike;
+} ? true : false;
+/**
+ * Check if a type is a ReactAgent (has `~agentTypes` but not `~deepAgentTypes`).
+ */
+type IsReactAgent<T> = T extends {
+  "~agentTypes": AgentTypeConfigLike;
+} ? T extends {
+  "~deepAgentTypes": unknown;
+} ? false : true : false;
+/**
+ * Infer the state type from an agent, graph, or direct state type.
+ *
+ * Detection order:
+ * 1. Agent-like (`~agentTypes`) → InferAgentState
+ * 2. CompiledGraph (`~RunOutput`) → Extract RunOutput
+ * 3. Pregel (`~OutputType`) → Extract OutputType
+ * 4. Direct state type → Return as-is
+ */
+type InferStateType<T> = T extends {
+  "~agentTypes": unknown;
+} ? InferAgentState<T> : T extends {
+  "~RunOutput": infer S;
+} ? S extends Record<string, unknown> ? S : Record<string, unknown> : T extends {
+  "~OutputType": infer O;
+} ? O extends Record<string, unknown> ? O : Record<string, unknown> : T extends Record<string, unknown> ? T : Record<string, unknown>;
+/**
+ * Infer the node names from a compiled graph.
+ *
+ * Extracts the `~NodeType` phantom property from CompiledGraph instances,
+ * providing a union of all node names defined in the graph.
+ *
+ * @example
+ * ```typescript
+ * const graph = new StateGraph(StateAnnotation)
+ *   .addNode("agent", agentFn)
+ *   .addNode("tool", toolFn)
+ *   .compile();
+ *
+ * type NodeNames = InferNodeNames<typeof graph>; // "agent" | "tool"
+ * ```
+ */
+type InferNodeNames<T> = T extends {
+  "~NodeType": infer N;
+} ? N extends string ? Exclude<N, "__start__"> : string : string;
+/**
+ * Infer the per-node return types from a compiled graph.
+ *
+ * Extracts the `~NodeReturnType` phantom property from CompiledGraph instances,
+ * which is a mapped type of `{ [nodeName]: ReturnType }` for each node.
+ *
+ * @example
+ * ```typescript
+ * const graph = new StateGraph(StateAnnotation)
+ *   .addNode("dispatcher", async () => ({ topic: "foo" }))
+ *   .addNode("researcher", async () => ({ research: "bar" }))
+ *   .compile();
+ *
+ * type NodeReturns = InferNodeReturnTypes<typeof graph>;
+ * // { dispatcher: { topic: string }; researcher: { research: string } }
+ * ```
+ */
+type InferNodeReturnTypes<T> = T extends {
+  "~NodeReturnType": infer R;
+} ? R extends Record<string, unknown> ? R : Record<string, Record<string, unknown>> : Record<string, Record<string, unknown>>;
+/**
+ * Infer tool call types from an agent.
+ *
+ * For agents, extracts typed tool calls from the agent's tools.
+ * For non-agents, returns DefaultToolCall.
+ */
+type InferToolCalls<T> = T extends {
+  "~agentTypes": unknown;
+} ? InferAgentToolCalls<T> : DefaultToolCall;
+/**
+ * Infer subagent state map from a DeepAgent.
+ *
+ * For DeepAgent, creates a map of subagent names to their state types.
+ * For non-DeepAgent, returns DefaultSubagentStates.
+ */
+type InferSubagentStates<T> = T extends {
+  "~deepAgentTypes": unknown;
+} ? SubagentStateMap<T, InferAgentToolCalls<T>> : DefaultSubagentStates;
+/**
+ * Resolves the appropriate stream interface based on the agent/graph type.
+ *
+ * This type automatically selects the correct stream interface based on
+ * the type of agent or graph passed to `useStream`:
+ *
+ * 1. **DeepAgent** (`~deepAgentTypes`) → {@link UseDeepAgentStream}
+ *    - Includes: values, messages, toolCalls, subagents, getSubagentsByType, getSubagentsByMessage
+ *
+ * 2. **ReactAgent** (`~agentTypes`) → {@link UseAgentStream}
+ *    - Includes: values, messages, toolCalls, getToolCalls
+ *    - Excludes: subagents, getSubagentsByType
+ *
+ * 3. **CompiledGraph** (`~RunOutput`/`~OutputType`) → {@link UseGraphStream}
+ *    - Includes: values, messages, submit, stop, nodes, getNodeStreamsByName
+ *    - Excludes: toolCalls, subagents
+ *    - Node names are inferred from `~NodeType` for type-safe access
+ *
+ * 4. **Default** → {@link UseGraphStream}
+ *
+ * @template T - The agent or graph type (use `typeof agent` or `typeof graph`)
+ * @template Bag - Type configuration bag for interrupts, configurable, etc.
+ *
+ * @example
+ * ```typescript
+ * // Automatic detection based on agent type
+ * type GraphStream = ResolveStreamInterface<typeof compiledGraph, BagTemplate>;
+ * // → UseGraphStream (with typed node names)
+ *
+ * type AgentStream = ResolveStreamInterface<typeof reactAgent, BagTemplate>;
+ * // → UseAgentStream (has toolCalls)
+ *
+ * type DeepStream = ResolveStreamInterface<typeof deepAgent, BagTemplate>;
+ * // → UseDeepAgentStream (has toolCalls AND subagents)
+ * ```
+ */
+type ResolveStreamInterface<T, Bag extends BagTemplate = BagTemplate> = IsDeepAgent<T> extends true ? UseDeepAgentStream<InferStateType<T>, InferToolCalls<T>, InferSubagentStates<T>, Bag> : IsReactAgent<T> extends true ? UseAgentStream<InferStateType<T>, InferToolCalls<T>, Bag> : BaseStream<InferStateType<T>, InferToolCalls<T>, Bag>;
+/**
+ * Resolves the appropriate options interface based on the agent/graph type.
+ *
+ * This type automatically selects the correct options interface based on
+ * the type of agent or graph:
+ *
+ * 1. **DeepAgent** → {@link UseDeepAgentStreamOptions}
+ *    - Includes: `filterSubagentMessages` option
+ *
+ * 2. **ReactAgent** → {@link UseAgentStreamOptions}
+ *
+ * 3. **CompiledGraph** / **Default** → {@link UseGraphStreamOptions}
+ *
+ * @template T - The agent or graph type
+ * @template Bag - Type configuration bag
+ *
+ * @example
+ * ```typescript
+ * // Only DeepAgent options include filterSubagentMessages
+ * type DeepOptions = ResolveStreamOptions<typeof deepAgent, BagTemplate>;
+ * // DeepOptions.filterSubagentMessages exists
+ *
+ * type AgentOptions = ResolveStreamOptions<typeof reactAgent, BagTemplate>;
+ * // AgentOptions.filterSubagentMessages does NOT exist
+ * ```
+ */
+type ResolveStreamOptions<T, Bag extends BagTemplate = BagTemplate> = IsDeepAgent<T> extends true ? UseDeepAgentStreamOptions<InferStateType<T>, Bag> : IsReactAgent<T> extends true ? UseAgentStreamOptions<InferStateType<T>, Bag> : UseStreamOptions<InferStateType<T>, Bag>;
+/**
+ * Infer the Bag type from an agent, defaulting to the provided Bag.
+ *
+ * Currently returns the provided Bag for all types.
+ * Can be extended in the future to extract Bag from agent types.
+ */
+type InferBag<T, B extends BagTemplate = BagTemplate> = T extends {
+  "~agentTypes": unknown;
+} ? BagTemplate : B;
+//#endregion
+export { InferBag, InferNodeNames, InferNodeReturnTypes, InferStateType, InferSubagentStates, InferToolCalls, ResolveStreamInterface, ResolveStreamOptions };
+//# sourceMappingURL=index.d.ts.map