@langchain/langgraph-sdk 1.5.6 → 1.6.1

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

@@ -0,0 +1,144 @@
+import { Interrupt, ThreadState } from "../../schema.js";
+import { DefaultToolCall, Message } from "../../types.messages.js";
+import { StreamMode } from "../../types.stream.js";
+import { StreamEvent } from "../../types.js";
+import { Client } from "../../client.js";
+import { BagTemplate } from "../../types.template.js";
+import { GetConfigurableType, GetInterruptType, GetUpdateType, MessageMetadata, SubmitOptions } from "../types.js";
+import { Sequence } from "../branching.js";
+
+//#region src/ui/stream/base.d.ts
+
+/**
+ * Base stream interface shared by all stream types.
+ *
+ * Contains core properties for state management, messaging, and stream control
+ * that are common to CompiledStateGraph, ReactAgent, and DeepAgent streams.
+ *
+ * This interface provides the foundation that all stream types build upon:
+ * - State management (`values`, `isLoading`, `error`)
+ * - Message handling (`messages`)
+ * - Interrupt handling (`interrupt`)
+ * - Stream lifecycle (`submit`, `stop`)
+ * - Branching and history (`branch`, `history`)
+ *
+ * @template StateType - The state type of the stream
+ * @template ToolCall - The tool call type for messages (inferred from agent tools)
+ * @template Bag - Type configuration bag for interrupts, configurable, updates, etc.
+ *
+ * @example
+ * ```typescript
+ * // BaseStream is not used directly - use one of the specialized interfaces:
+ * // - UseGraphStream for CompiledStateGraph
+ * // - UseAgentStream for ReactAgent (createAgent)
+ * // - UseDeepAgentStream for DeepAgent (createDeepAgent)
+ * ```
+ */
+interface BaseStream<StateType extends Record<string, unknown> = Record<string, unknown>, ToolCall = DefaultToolCall, Bag extends BagTemplate = BagTemplate> {
+  /**
+   * The current state values of the stream.
+   * Updated as streaming events are received.
+   */
+  values: StateType;
+  /**
+   * Last seen error from the stream, if any.
+   * Reset to `undefined` when a new stream starts.
+   */
+  error: unknown;
+  /**
+   * Whether the stream is currently running.
+   * `true` while streaming, `false` when idle or completed.
+   */
+  isLoading: boolean;
+  /**
+   * Whether the thread is currently being loaded.
+   * `true` during initial thread data fetch.
+   */
+  isThreadLoading: boolean;
+  /**
+   * Messages accumulated during the stream.
+   * Includes both human and AI messages.
+   * AI messages include typed tool calls based on the agent's tools.
+   */
+  messages: Message<ToolCall>[];
+  /**
+   * Current interrupt, if the stream is interrupted.
+   * Convenience alias for `interrupts[0]`.
+   * For workflows with multiple concurrent interrupts, use `interrupts` instead.
+   */
+  interrupt: Interrupt<GetInterruptType<Bag>> | undefined;
+  /**
+   * All current interrupts from the stream.
+   * When using Send() fan-out with per-task interrupt() calls,
+   * multiple interrupts may be pending simultaneously.
+   */
+  interrupts: Interrupt<GetInterruptType<Bag>>[];
+  /**
+   * Stops the currently running stream.
+   * @returns A promise that resolves when the stream is stopped.
+   */
+  stop: () => Promise<void>;
+  /**
+   * Create and stream a run to the thread.
+   *
+   * @param values - The input values to send, or null/undefined for empty input
+   * @param options - Optional configuration for the submission
+   * @returns A promise that resolves when the stream completes
+   */
+  submit: (values: GetUpdateType<Bag, StateType> | null | undefined, options?: SubmitOptions<StateType, GetConfigurableType<Bag>>) => Promise<void>;
+  /**
+   * The current branch of the thread.
+   * Used for navigating between different conversation branches.
+   */
+  branch: string;
+  /**
+   * Set the branch of the thread.
+   * @param branch - The branch identifier to switch to
+   */
+  setBranch: (branch: string) => void;
+  /**
+   * Flattened history of thread states of a thread.
+   * Contains all states in the current branch's history.
+   */
+  history: ThreadState<StateType>[];
+  /**
+   * Tree of all branches for the thread.
+   * @experimental This API is experimental and subject to change.
+   */
+  experimental_branchTree: Sequence<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, or undefined if not found
+   */
+  getMessagesMetadata: (message: Message<ToolCall>, index?: number) => MessageMetadata<StateType> | undefined;
+  /**
+   * LangGraph SDK client used to send requests and receive responses.
+   */
+  client: Client;
+  /**
+   * The ID of the assistant to use.
+   */
+  assistantId: string;
+  /**
+   * Join an active stream that's already running.
+   *
+   * @param runId - The ID of the run to join
+   * @param lastEventId - Optional last event ID for resuming from a specific point
+   * @param options - Optional configuration for the stream
+   */
+  joinStream: (runId: string, lastEventId?: string, options?: {
+    streamMode?: StreamMode | StreamMode[];
+    filter?: (event: {
+      id?: string;
+      event: StreamEvent;
+      data: unknown;
+    }) => boolean;
+  }) => Promise<void>;
+}
+//#endregion
+export { BaseStream };
+//# sourceMappingURL=base.d.ts.map

package/dist/ui/stream/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","names":["Client","ThreadState","Interrupt","StreamMode","StreamEvent","Message","DefaultToolCall","BagTemplate","Sequence","GetUpdateType","GetConfigurableType","GetInterruptType","MessageMetadata","SubmitOptions","BaseStream","Record","StateType","ToolCall","Bag","Promise"],"sources":["../../../src/ui/stream/base.d.ts"],"sourcesContent":["/**\n * Base stream types shared by all stream interfaces.\n *\n * This module contains the foundational types that are common to all streaming\n * scenarios: CompiledStateGraph, ReactAgent (createAgent), and DeepAgent (createDeepAgent).\n *\n * @module\n */\nimport type { Client } from \"../../client.js\";\nimport type { ThreadState, Interrupt } from \"../../schema.js\";\nimport type { StreamMode } from \"../../types.stream.js\";\nimport type { StreamEvent } from \"../../types.js\";\nimport type { Message, DefaultToolCall } from \"../../types.messages.js\";\nimport type { BagTemplate } from \"../../types.template.js\";\nimport type { Sequence } from \"../branching.js\";\nimport type { GetUpdateType, GetConfigurableType, GetInterruptType, MessageMetadata, SubmitOptions } from \"../types.js\";\n/**\n * Base stream interface shared by all stream types.\n *\n * Contains core properties for state management, messaging, and stream control\n * that are common to CompiledStateGraph, ReactAgent, and DeepAgent streams.\n *\n * This interface provides the foundation that all stream types build upon:\n * - State management (`values`, `isLoading`, `error`)\n * - Message handling (`messages`)\n * - Interrupt handling (`interrupt`)\n * - Stream lifecycle (`submit`, `stop`)\n * - Branching and history (`branch`, `history`)\n *\n * @template StateType - The state type of the stream\n * @template ToolCall - The tool call type for messages (inferred from agent tools)\n * @template Bag - Type configuration bag for interrupts, configurable, updates, etc.\n *\n * @example\n * ```typescript\n * // BaseStream is not used directly - use one of the specialized interfaces:\n * // - UseGraphStream for CompiledStateGraph\n * // - UseAgentStream for ReactAgent (createAgent)\n * // - UseDeepAgentStream for DeepAgent (createDeepAgent)\n * ```\n */\nexport interface BaseStream<StateType extends Record<string, unknown> = Record<string, unknown>, ToolCall = DefaultToolCall, Bag extends BagTemplate = BagTemplate> {\n    /**\n     * The current state values of the stream.\n     * Updated as streaming events are received.\n     */\n    values: StateType;\n    /**\n     * Last seen error from the stream, if any.\n     * Reset to `undefined` when a new stream starts.\n     */\n    error: unknown;\n    /**\n     * Whether the stream is currently running.\n     * `true` while streaming, `false` when idle or completed.\n     */\n    isLoading: boolean;\n    /**\n     * Whether the thread is currently being loaded.\n     * `true` during initial thread data fetch.\n     */\n    isThreadLoading: boolean;\n    /**\n     * Messages accumulated during the stream.\n     * Includes both human and AI messages.\n     * AI messages include typed tool calls based on the agent's tools.\n     */\n    messages: Message<ToolCall>[];\n    /**\n     * Current interrupt, if the stream is interrupted.\n     * Convenience alias for `interrupts[0]`.\n     * For workflows with multiple concurrent interrupts, use `interrupts` instead.\n     */\n    interrupt: Interrupt<GetInterruptType<Bag>> | undefined;\n    /**\n     * All current interrupts from the stream.\n     * When using Send() fan-out with per-task interrupt() calls,\n     * multiple interrupts may be pending simultaneously.\n     */\n    interrupts: Interrupt<GetInterruptType<Bag>>[];\n    /**\n     * Stops the currently running stream.\n     * @returns A promise that resolves when the stream is stopped.\n     */\n    stop: () => Promise<void>;\n    /**\n     * Create and stream a run to the thread.\n     *\n     * @param values - The input values to send, or null/undefined for empty input\n     * @param options - Optional configuration for the submission\n     * @returns A promise that resolves when the stream completes\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     * Used for navigating between different conversation branches.\n     */\n    branch: string;\n    /**\n     * Set the branch of the thread.\n     * @param branch - The branch identifier to switch to\n     */\n    setBranch: (branch: string) => void;\n    /**\n     * Flattened history of thread states of a thread.\n     * Contains all states in the current branch's history.\n     */\n    history: ThreadState<StateType>[];\n    /**\n     * Tree of all branches for the thread.\n     * @experimental This API is experimental and subject to change.\n     */\n    experimental_branchTree: Sequence<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, or undefined if not found\n     */\n    getMessagesMetadata: (message: Message<ToolCall>, index?: number) => MessageMetadata<StateType> | undefined;\n    /**\n     * LangGraph SDK client used to send requests 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 that's already running.\n     *\n     * @param runId - The ID of the run to join\n     * @param lastEventId - Optional last event ID for resuming from a specific point\n     * @param options - Optional configuration for the stream\n     */\n    joinStream: (runId: string, lastEventId?: string, options?: {\n        streamMode?: StreamMode | StreamMode[];\n        filter?: (event: {\n            id?: string;\n            event: StreamEvent;\n            data: unknown;\n        }) => boolean;\n    }) => Promise<void>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyHyFgB,UAhFxEF,UAgFwEE,CAAAA,kBAhF3CD,MAgF2CC,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GAhFjBD,MAgFiBC,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,WAhFmBV,eAgFnBU,EAAAA,YAhFgDT,WAgFhDS,GAhF8DT,WAgF9DS,CAAAA,CAAAA;;;;;QAoBtEZ,EA/FPY,SA+FOZ;;;;;;;;;;;;;;;;;;;;;YA1ELC,QAAQY;;;;;;aAMPf,UAAUS,iBAAiBO;;;;;;cAM1BhB,UAAUS,iBAAiBO;;;;;cAK3BC;;;;;;;;mBAQKV,cAAcS,KAAKF,yCAAyCH,cAAcG,WAAWN,oBAAoBQ,UAAUC;;;;;;;;;;;;;;;WAe3HlB,YAAYe;;;;;2BAKIR,SAASQ;;;;;;;;;iCASHX,QAAQY,8BAA8BL,gBAAgBI;;;;UAI7EhB;;;;;;;;;;;;;iBAaSG,aAAaA;;;aAGfC;;;QAGTe"}

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

@@ -0,0 +1,277 @@
+import { DefaultToolCall } from "../../types.messages.cjs";
+import { BagTemplate } from "../../types.template.cjs";
+import { DefaultSubagentStates, SubagentStream } from "../types.cjs";
+import { UseAgentStream, UseAgentStreamOptions } from "./agent.cjs";
+
+//#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.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deep-agent.d.cts","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"}