@langchain/langgraph-sdk 1.6.1 → 1.6.2

package/dist/ui/subagents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subagents.d.ts","names":["Message","DefaultToolCall","SubagentStream","isSubagentNamespace","extractToolCallIdFromNamespace","calculateDepthFromNamespace","extractParentIdFromNamespace","SubagentManagerOptions","SubagentManager","Record","ToolCall","Map","Array"],"sources":["../../src/ui/subagents.d.ts"],"sourcesContent":["import type { Message, DefaultToolCall } from \"../types.messages.js\";\nimport type { SubagentStream } from \"./types.js\";\n/**\n * Checks if a namespace indicates a subagent/subgraph message.\n *\n * Subagent namespaces contain a \"tools:\" segment indicating they\n * originate from a tool call that spawned a subgraph.\n *\n * @param namespace - The namespace array from stream events (or checkpoint_ns string)\n * @returns True if this is a subagent namespace\n */\nexport declare function isSubagentNamespace(namespace: string[] | string | undefined): boolean;\n/**\n * Extracts the tool call ID from a namespace path.\n *\n * Namespaces follow the pattern: [\"tools:call_abc123\", \"model_request:xyz\", ...]\n * This function extracts \"call_abc123\" from the first \"tools:\" segment.\n *\n * @param namespace - The namespace array from stream events\n * @returns The tool call ID, or undefined if not found\n */\nexport declare function extractToolCallIdFromNamespace(namespace: string[] | undefined): string | undefined;\n/**\n * Calculates the depth of a subagent based on its namespace.\n * Counts the number of \"tools:\" segments in the namespace.\n *\n * @param namespace - The namespace array\n * @returns The depth (0 for main agent, 1+ for subagents)\n */\nexport declare function calculateDepthFromNamespace(namespace: string[] | undefined): number;\n/**\n * Extracts the parent tool call ID from a namespace.\n *\n * For nested subagents, the namespace looks like:\n * [\"tools:parent_id\", \"tools:child_id\", ...]\n *\n * @param namespace - The namespace array\n * @returns The parent tool call ID, or null if this is a top-level subagent\n */\nexport declare function extractParentIdFromNamespace(namespace: string[] | undefined): string | null;\n/**\n * Options for SubagentManager.\n */\nexport interface SubagentManagerOptions {\n    /**\n     * Tool names that indicate subagent invocation.\n     * Defaults to [\"task\"].\n     */\n    subagentToolNames?: string[];\n    /**\n     * Callback when subagent state changes.\n     */\n    onSubagentChange?: () => void;\n}\n/**\n * Manages subagent execution state.\n *\n * Tracks subagents from the moment they are invoked (AI message with tool calls)\n * through streaming to completion (tool message result).\n */\nexport declare class SubagentManager<ToolCall = DefaultToolCall> {\n    private subagents;\n    /**\n     * Maps namespace IDs (pregel task IDs) to tool call IDs.\n     * LangGraph subgraphs use internal pregel task IDs in their namespace,\n     * which are different from the tool_call_id used to invoke them.\n     */\n    private namespaceToToolCallId;\n    /**\n     * Pending namespace matches that couldn't be resolved immediately.\n     * These are retried when new tool calls are registered.\n     */\n    private pendingMatches;\n    /**\n     * Message managers for each subagent.\n     * Uses the same MessageTupleManager as the main stream for proper\n     * message chunk concatenation.\n     */\n    private messageManagers;\n    private subagentToolNames;\n    private onSubagentChange?;\n    constructor(options?: SubagentManagerOptions);\n    /**\n     * Get or create a MessageTupleManager for a subagent.\n     */\n    private getMessageManager;\n    /**\n     * Get messages for a subagent with proper chunk concatenation.\n     * This mirrors how the main stream handles messages.\n     */\n    private getMessagesForSubagent;\n    /**\n     * Create a complete SubagentStream object with all derived properties.\n     * This ensures consistency with UseStream interface.\n     */\n    private createSubagentStream;\n    /**\n     * Get the tool call ID for a given namespace ID.\n     * Returns the namespace ID itself if no mapping exists.\n     */\n    getToolCallIdFromNamespace(namespaceId: string): string;\n    /**\n     * Try to match a subgraph to a pending subagent by description.\n     * Creates a mapping from namespace ID to tool call ID if a match is found.\n     *\n     * Uses a multi-pass matching strategy:\n     * 1. Exact description match\n     * 2. Description contains/partial match\n     * 3. Any unmapped pending subagent (fallback)\n     *\n     * @param namespaceId - The namespace ID (pregel task ID) from the subgraph\n     * @param description - The description from the subgraph's initial message\n     * @returns The matched tool call ID, or undefined if no match\n     */\n    matchSubgraphToSubagent(namespaceId: string, description: string): string | undefined;\n    /**\n     * Check if a tool call is a subagent invocation.\n     */\n    isSubagentToolCall(toolName: string): boolean;\n    /**\n     * Check if a subagent_type value is valid.\n     * Valid types are proper identifiers like \"weather-scout\", \"experience-curator\".\n     */\n    private isValidSubagentType;\n    /**\n     * Check if a subagent should be shown to the user.\n     * Subagents are only shown once they've actually started running.\n     *\n     * This filters out:\n     * - Pending subagents that haven't been matched to a namespace yet\n     * - Streaming artifacts with partial/corrupted data\n     *\n     * The idea is: we register subagents internally when we see tool calls,\n     * but we only show them to the user once LangGraph confirms they're\n     * actually executing (via namespace events).\n     */\n    private isValidSubagent;\n    /**\n     * Build a complete SubagentStream from internal state.\n     * Adds messages and derived properties.\n     */\n    private buildExecution;\n    /**\n     * Get all subagents as a Map.\n     * Filters out incomplete/phantom subagents that lack subagent_type.\n     */\n    getSubagents(): Map<string, SubagentStream<Record<string, unknown>, ToolCall>>;\n    /**\n     * Get all currently running subagents.\n     * Filters out incomplete/phantom subagents.\n     */\n    getActiveSubagents(): SubagentStream<Record<string, unknown>, ToolCall>[];\n    /**\n     * Get a specific subagent by tool call ID.\n     */\n    getSubagent(toolCallId: string): SubagentStream<Record<string, unknown>, ToolCall> | undefined;\n    /**\n     * Get all subagents of a specific type.\n     */\n    getSubagentsByType(type: string): SubagentStream<Record<string, unknown>, ToolCall>[];\n    /**\n     * Get all subagents triggered by a specific AI message.\n     *\n     * @param messageId - The ID of the AI message.\n     * @returns Array of subagent streams triggered by that message.\n     */\n    getSubagentsByMessage(messageId: string): SubagentStream<Record<string, unknown>, ToolCall>[];\n    /**\n     * Parse tool call args, handling both object and string formats.\n     * During streaming, args might come as a string that needs parsing.\n     */\n    private parseArgs;\n    /**\n     * Register new subagent(s) from AI message tool calls.\n     *\n     * Called when an AI message is received with tool calls.\n     * Creates pending subagent entries for each subagent tool call.\n     *\n     * @param toolCalls - The tool calls from an AI message\n     * @param aiMessageId - The ID of the AI message that triggered the tool calls\n     */\n    registerFromToolCalls(toolCalls: Array<{\n        id?: string;\n        name: string;\n        args: Record<string, unknown> | string;\n    }>, aiMessageId?: string | null): void;\n    /**\n     * Retry matching pending namespaces to newly registered tool calls.\n     */\n    private retryPendingMatches;\n    /**\n     * Mark a subagent as running and update its namespace.\n     *\n     * Called when update events are received with a namespace indicating\n     * which subagent is streaming.\n     *\n     * @param toolCallId - The tool call ID of the subagent\n     * @param options - Additional update options\n     */\n    markRunning(toolCallId: string, options?: {\n        namespace?: string[];\n    }): void;\n    /**\n     * Mark a subagent as running using a namespace ID.\n     * Resolves the namespace ID to the actual tool call ID via the mapping.\n     *\n     * @param namespaceId - The namespace ID (pregel task ID) from the subgraph\n     * @param namespace - The full namespace array\n     */\n    markRunningFromNamespace(namespaceId: string, namespace?: string[]): void;\n    /**\n     * Add a serialized message to a subagent from stream events.\n     *\n     * This method handles the raw serialized message data from SSE events.\n     * Uses MessageTupleManager for proper chunk concatenation, matching\n     * how the main stream handles messages.\n     *\n     * @param namespaceId - The namespace ID (pregel task ID) from the stream\n     * @param serialized - The serialized message from the stream\n     * @param metadata - Optional metadata from the stream event\n     */\n    addMessageToSubagent(namespaceId: string, serialized: Message<DefaultToolCall>, metadata?: Record<string, unknown>): void;\n    /**\n     * Update subagent values from a values stream event.\n     *\n     * Called when a values event is received from a subagent's namespace.\n     * This populates the subagent's state values, making them accessible\n     * via the `values` property.\n     *\n     * @param namespaceId - The namespace ID (pregel task ID) from the stream\n     * @param values - The state values from the stream event\n     */\n    updateSubagentValues(namespaceId: string, values: Record<string, unknown>): void;\n    /**\n     * Complete a subagent with a result.\n     *\n     * Called when a tool message is received for the subagent.\n     *\n     * @param toolCallId - The tool call ID of the subagent\n     * @param result - The result content\n     * @param status - The final status (complete or error)\n     */\n    complete(toolCallId: string, result: string, status?: \"complete\" | \"error\"): void;\n    /**\n     * Clear all subagent state.\n     */\n    clear(): void;\n    /**\n     * Process a tool message to complete a subagent.\n     *\n     * @param toolCallId - The tool call ID from the tool message\n     * @param content - The result content\n     * @param status - Whether the tool execution was successful\n     */\n    processToolMessage(toolCallId: string, content: string, status?: \"success\" | \"error\"): void;\n    /**\n     * Reconstruct subagent state from historical messages.\n     *\n     * This method parses an array of messages (typically from thread history)\n     * to identify subagent executions and their results. It's used to restore\n     * subagent state after:\n     * - Page refresh (when stream has already completed)\n     * - Loading thread history\n     * - Navigating between threads\n     *\n     * The reconstruction process:\n     * 1. Find AI messages with tool calls matching subagent tool names\n     * 2. Find corresponding tool messages with results\n     * 3. Create SubagentStream entries with \"complete\" status\n     *\n     * Note: Internal subagent messages (their streaming conversation) are not\n     * reconstructed since they are not persisted in the main thread state.\n     *\n     * @param messages - Array of messages from thread history\n     * @param options - Optional configuration\n     * @param options.skipIfPopulated - If true, skip reconstruction if subagents already exist\n     */\n    reconstructFromMessages(messages: Message<DefaultToolCall>[], options?: {\n        skipIfPopulated?: boolean;\n    }): void;\n    /**\n     * Check if any subagents are currently tracked.\n     */\n    hasSubagents(): boolean;\n}\n"],"mappings":";;;;;;;AAWA;AAUA;AAQA;AAUA;AAIA;AAiBA;;AAAgDC,iBAjDxBE,mBAAAA,CAiDwBF,SAAAA,EAAAA,MAAAA,EAAAA,GAAAA,MAAAA,GAAAA,SAAAA,CAAAA,EAAAA,OAAAA;;;;;;;;;;AA+F6BS,iBAtIrDN,8BAAAA,CAsIqDM,SAAAA,EAAAA,MAAAA,EAAAA,GAAAA,SAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;;;;;;;;AA6B/DD,iBA3JUJ,2BAAAA,CA2JVI,SAAAA,EAAAA,MAAAA,EAAAA,GAAAA,SAAAA,CAAAA,EAAAA,MAAAA;;;;;;;;;;iBAjJUH,4BAAAA;;;;UAIPC,sBAAAA;;;;;;;;;;;;;;;;;cAiBIC,2BAA2BP;;;;;;;;;;;;;;;;;;;;;wBAqBtBM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiENI,YAAYT,eAAeO,yBAAyBC;;;;;wBAK9CR,eAAeO,yBAAyBC;;;;mCAI7BR,eAAeO,yBAAyBC;;;;oCAIvCR,eAAeO,yBAAyBC;;;;;;;4CAOhCR,eAAeO,yBAAyBC;;;;;;;;;;;;;;;mCAejDE;;;UAGvBH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wDAqC4CT,QAAQC,6BAA6BQ;;;;;;;;;;;oDAWzCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA6ChBT,QAAQC"}
+{"version":3,"file":"subagents.d.ts","names":[],"sources":["../../src/ui/subagents.ts"],"mappings":";;;;;;AA6BA;;;;;AAuBA;;iBAvBgB,mBAAA,CACd,SAAA;;;AA4CF;;;;;AAgBA;;iBAtCgB,8BAAA,CACd,SAAA;;;AAoDF;;;;;iBA/BgB,2BAAA,CACd,SAAA;;;;;;;;;;iBAec,4BAAA,CACd,SAAA;;;;UAce,sBAAA;EA2WY;;;;EAtW3B,iBAAA;EAoXG;;;EA/WH,gBAAA;AAAA;;;;;;;cAkCW,eAAA,YAA2B,eAAA;EAAA,QAC9B,SAAA;EAAA;;;;;EAAA,QAOA,qBAAA;EAmBR;;;;EAAA,QAbQ,cAAA;EAsDA;;;;;EAAA,QA/CA,eAAA;EAAA,QAEA,iBAAA;EAAA,QAEA,gBAAA;EAER,WAAA,CAAY,OAAA,GAAU,sBAAA;EA+Nd;;;EAAA,QArNA,iBAAA;EAgPN;;;;EAAA,QAnOM,sBAAA;EAsPN;;;;EAAA,QApOM,oBAAA;EAiPmB;;;;EAxM3B,0BAAA,CAA2B,WAAA;EAkNA;;;;;;;;;;;;;EAjM3B,uBAAA,CACE,WAAA,UACA,WAAA;EA+OA;;;EAlKF,kBAAA,CAAmB,QAAA;EAoSjB;;;;EAAA,QA5RM,mBAAA;EA0TsC;;;;;;;;;;;;EAAA,QArRtC,eAAA;EAiYN;;;;EAAA,QAvXM,cAAA;EA4ZN;;;;EA7YF,YAAA,CAAA,GAAgB,GAAA,SAEd,uBAAA,CAAwB,MAAA,mBAAyB,QAAA;EAgb/B;;;;EA9ZpB,kBAAA,CAAA,GAAsB,uBAAA,CACpB,MAAA,mBACA,QAAA;EAsgBU;;;EA5fZ,WAAA,CACE,UAAA,WACC,uBAAA,CAAwB,MAAA,mBAAyB,QAAA;;;;EAQpD,kBAAA,CACE,IAAA,WACC,uBAAA,CAAwB,MAAA,mBAAyB,QAAA;;;;;;;EAYpD,qBAAA,CACE,SAAA,WACC,uBAAA,CAAwB,MAAA,mBAAyB,QAAA;;;;;UAU5C,SAAA;;;;;;;;;;EAuBR,qBAAA,CACE,SAAA,EAAW,KAAA;IACT,EAAA;IACA,IAAA;IACA,IAAA,EAAM,MAAA;EAAA,IAER,WAAA;;;;UAgGM,mBAAA;;;;;;;;;;EA4BR,WAAA,CACE,UAAA,UACA,OAAA;IACE,SAAA;EAAA;;;;;;;;EA4BJ,wBAAA,CAAyB,WAAA,UAAqB,SAAA;;;;;;;;;;;;EAgB9C,oBAAA,CACE,WAAA,UACA,UAAA,EAAY,OAAA,CAAQ,eAAA,GACpB,QAAA,GAAW,MAAA;;;;;;;;;;;EAyDb,oBAAA,CACE,WAAA,UACA,MAAA,EAAQ,MAAA;;;;;;;;;;EA6BV,QAAA,CACE,UAAA,UACA,MAAA,UACA,MAAA;;;;EAmBF,KAAA,CAAA;;;;;;;;EAeA,kBAAA,CACE,UAAA,UACA,OAAA,UACA,MAAA;;;;;;;;;;;;;;;;;;;;;;;EAkCF,uBAAA,CACE,QAAA,EAAU,OAAA,CAAQ,eAAA,KAClB,OAAA;IAAY,eAAA;EAAA;;;;EAyGd,YAAA,CAAA;AAAA"}

package/dist/ui/subagents.js.map

@@ -1 +1 @@
-{"version":3,"file":"subagents.js","names":[],"sources":["../../src/ui/subagents.ts"],"sourcesContent":["import type {\n  Message,\n  DefaultToolCall,\n  AIMessage,\n  ToolCallWithResult,\n} from \"../types.messages.js\";\nimport type {\n  SubagentStream,\n  SubagentToolCall,\n  SubagentStatus,\n} from \"./types.js\";\nimport { MessageTupleManager, toMessageDict } from \"./messages.js\";\nimport { getToolCallsWithResults } from \"../utils/tools.js\";\n\n/**\n * Default tool names that indicate subagent invocation.\n * Can be customized via SubagentManager options.\n */\nconst DEFAULT_SUBAGENT_TOOL_NAMES = [\"task\"];\n\n/**\n * Checks if a namespace indicates a subagent/subgraph message.\n *\n * Subagent namespaces contain a \"tools:\" segment indicating they\n * originate from a tool call that spawned a subgraph.\n *\n * @param namespace - The namespace array from stream events (or checkpoint_ns string)\n * @returns True if this is a subagent namespace\n */\nexport function isSubagentNamespace(\n  namespace: string[] | string | undefined\n): boolean {\n  if (!namespace) return false;\n\n  // Handle string namespace (from checkpoint_ns)\n  if (typeof namespace === \"string\") {\n    return namespace.includes(\"tools:\");\n  }\n\n  // Handle array namespace\n  return namespace.some((s) => s.startsWith(\"tools:\"));\n}\n\n/**\n * Extracts the tool call ID from a namespace path.\n *\n * Namespaces follow the pattern: [\"tools:call_abc123\", \"model_request:xyz\", ...]\n * This function extracts \"call_abc123\" from the first \"tools:\" segment.\n *\n * @param namespace - The namespace array from stream events\n * @returns The tool call ID, or undefined if not found\n */\nexport function extractToolCallIdFromNamespace(\n  namespace: string[] | undefined\n): string | undefined {\n  if (!namespace || namespace.length === 0) return undefined;\n\n  // Find the first namespace segment that starts with \"tools:\"\n  for (const segment of namespace) {\n    if (segment.startsWith(\"tools:\")) {\n      return segment.slice(6); // Remove \"tools:\" prefix\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Calculates the depth of a subagent based on its namespace.\n * Counts the number of \"tools:\" segments in the namespace.\n *\n * @param namespace - The namespace array\n * @returns The depth (0 for main agent, 1+ for subagents)\n */\nexport function calculateDepthFromNamespace(\n  namespace: string[] | undefined\n): number {\n  if (!namespace) return 0;\n  return namespace.filter((s) => s.startsWith(\"tools:\")).length;\n}\n\n/**\n * Extracts the parent tool call ID from a namespace.\n *\n * For nested subagents, the namespace looks like:\n * [\"tools:parent_id\", \"tools:child_id\", ...]\n *\n * @param namespace - The namespace array\n * @returns The parent tool call ID, or null if this is a top-level subagent\n */\nexport function extractParentIdFromNamespace(\n  namespace: string[] | undefined\n): string | null {\n  if (!namespace || namespace.length < 2) return null;\n\n  const toolSegments = namespace.filter((s) => s.startsWith(\"tools:\"));\n  if (toolSegments.length < 2) return null;\n\n  // The second-to-last \"tools:\" segment is the parent\n  return toolSegments[toolSegments.length - 2]?.slice(6) ?? null;\n}\n\n/**\n * Options for SubagentManager.\n */\nexport interface SubagentManagerOptions {\n  /**\n   * Tool names that indicate subagent invocation.\n   * Defaults to [\"task\"].\n   */\n  subagentToolNames?: string[];\n\n  /**\n   * Callback when subagent state changes.\n   */\n  onSubagentChange?: () => void;\n}\n\n/**\n * Internal base type for SubagentStream storage.\n * Excludes derived properties that are computed on retrieval.\n */\ntype SubagentStreamBase<ToolCall> = Omit<\n  SubagentStream<Record<string, unknown>, ToolCall>,\n  | \"isLoading\"\n  | \"toolCalls\"\n  | \"getToolCalls\"\n  | \"interrupt\"\n  | \"interrupts\"\n  | \"subagents\"\n  | \"activeSubagents\"\n  | \"getSubagent\"\n  | \"getSubagentsByType\"\n  | \"getSubagentsByMessage\"\n  | \"nodes\"\n  | \"activeNodes\"\n  | \"getNodeStream\"\n  | \"getNodeStreamsByName\"\n> & {\n  /** Internal: ID of the AI message that triggered this subagent */\n  aiMessageId: string | null;\n};\n\n/**\n * Manages subagent execution state.\n *\n * Tracks subagents from the moment they are invoked (AI message with tool calls)\n * through streaming to completion (tool message result).\n */\nexport class SubagentManager<ToolCall = DefaultToolCall> {\n  private subagents = new Map<string, SubagentStreamBase<ToolCall>>();\n\n  /**\n   * Maps namespace IDs (pregel task IDs) to tool call IDs.\n   * LangGraph subgraphs use internal pregel task IDs in their namespace,\n   * which are different from the tool_call_id used to invoke them.\n   */\n  private namespaceToToolCallId = new Map<string, string>();\n\n  /**\n   * Pending namespace matches that couldn't be resolved immediately.\n   * These are retried when new tool calls are registered.\n   */\n  private pendingMatches = new Map<string, string>(); // namespaceId -> description\n\n  /**\n   * Message managers for each subagent.\n   * Uses the same MessageTupleManager as the main stream for proper\n   * message chunk concatenation.\n   */\n  private messageManagers = new Map<string, MessageTupleManager>();\n\n  private subagentToolNames: Set<string>;\n\n  private onSubagentChange?: () => void;\n\n  constructor(options?: SubagentManagerOptions) {\n    this.subagentToolNames = new Set(\n      options?.subagentToolNames ?? DEFAULT_SUBAGENT_TOOL_NAMES\n    );\n    this.onSubagentChange = options?.onSubagentChange;\n  }\n\n  /**\n   * Get or create a MessageTupleManager for a subagent.\n   */\n  private getMessageManager(toolCallId: string): MessageTupleManager {\n    let manager = this.messageManagers.get(toolCallId);\n    if (!manager) {\n      manager = new MessageTupleManager();\n      this.messageManagers.set(toolCallId, manager);\n    }\n    return manager;\n  }\n\n  /**\n   * Get messages for a subagent with proper chunk concatenation.\n   * This mirrors how the main stream handles messages.\n   */\n  private getMessagesForSubagent(toolCallId: string): Message<ToolCall>[] {\n    const manager = this.messageManagers.get(toolCallId);\n    if (!manager) return [];\n\n    // Convert chunks to messages in order\n    const messages: Message<ToolCall>[] = [];\n    for (const entry of Object.values(manager.chunks)) {\n      if (entry.chunk) {\n        messages.push(toMessageDict(entry.chunk) as Message<ToolCall>);\n      }\n    }\n    return messages;\n  }\n\n  /**\n   * Create a complete SubagentStream object with all derived properties.\n   * This ensures consistency with UseStream interface.\n   */\n  private createSubagentStream(\n    base: SubagentStreamBase<ToolCall>\n  ): SubagentStream<Record<string, unknown>, ToolCall> {\n    const { messages } = base;\n    const allToolCalls = getToolCallsWithResults<ToolCall>(messages);\n\n    return {\n      ...base,\n      // Derived from status for UseStream consistency\n      isLoading: base.status === \"running\",\n\n      // Tool calls derived from messages\n      toolCalls: allToolCalls,\n\n      // Method to get tool calls for a specific message\n      getToolCalls: (\n        message: AIMessage<ToolCall>\n      ): ToolCallWithResult<ToolCall>[] => {\n        return allToolCalls.filter((tc) => tc.aiMessage.id === message.id);\n      },\n\n      // Subagents don't have interrupts yet (future enhancement)\n      interrupt: undefined,\n      interrupts: [],\n\n      // Nested subagent tracking (empty for now, future enhancement)\n      subagents: new Map<\n        string,\n        SubagentStream<Record<string, unknown>, ToolCall>\n      >(),\n      activeSubagents: [],\n      getSubagent: () => undefined,\n      getSubagentsByType: () => [],\n      getSubagentsByMessage: () => [],\n    };\n  }\n\n  /**\n   * Get the tool call ID for a given namespace ID.\n   * Returns the namespace ID itself if no mapping exists.\n   */\n  getToolCallIdFromNamespace(namespaceId: string): string {\n    return this.namespaceToToolCallId.get(namespaceId) ?? namespaceId;\n  }\n\n  /**\n   * Try to match a subgraph to a pending subagent by description.\n   * Creates a mapping from namespace ID to tool call ID if a match is found.\n   *\n   * Uses a multi-pass matching strategy:\n   * 1. Exact description match\n   * 2. Description contains/partial match\n   * 3. Any unmapped pending subagent (fallback)\n   *\n   * @param namespaceId - The namespace ID (pregel task ID) from the subgraph\n   * @param description - The description from the subgraph's initial message\n   * @returns The matched tool call ID, or undefined if no match\n   */\n  matchSubgraphToSubagent(\n    namespaceId: string,\n    description: string\n  ): string | undefined {\n    // Skip if we already have a mapping\n    if (this.namespaceToToolCallId.has(namespaceId)) {\n      return this.namespaceToToolCallId.get(namespaceId);\n    }\n\n    // Get all already-mapped tool call IDs\n    const mappedToolCallIds = new Set(this.namespaceToToolCallId.values());\n\n    // Helper to establish mapping and mark as running\n    const establishMapping = (toolCallId: string): string => {\n      this.namespaceToToolCallId.set(namespaceId, toolCallId);\n      // Also mark the subagent as running since we now have its namespace\n      const subagent = this.subagents.get(toolCallId);\n      if (subagent && subagent.status === \"pending\") {\n        this.subagents.set(toolCallId, {\n          ...subagent,\n          status: \"running\",\n          namespace: [namespaceId],\n          startedAt: new Date(),\n        });\n        this.onSubagentChange?.();\n      }\n      return toolCallId;\n    };\n\n    // Pass 1: Find a pending subagent with exact description match\n    for (const [toolCallId, subagent] of this.subagents) {\n      if (\n        (subagent.status === \"pending\" || subagent.status === \"running\") &&\n        !mappedToolCallIds.has(toolCallId) &&\n        subagent.toolCall.args.description === description\n      ) {\n        return establishMapping(toolCallId);\n      }\n    }\n\n    // Pass 2: Find a pending subagent where description contains or is contained\n    for (const [toolCallId, subagent] of this.subagents) {\n      if (\n        (subagent.status === \"pending\" || subagent.status === \"running\") &&\n        !mappedToolCallIds.has(toolCallId)\n      ) {\n        const subagentDesc = subagent.toolCall.args.description || \"\";\n        if (\n          (subagentDesc && description.includes(subagentDesc)) ||\n          (subagentDesc && subagentDesc.includes(description))\n        ) {\n          // Update the description if the new one is longer\n          if (description.length > subagentDesc.length) {\n            this.subagents.set(toolCallId, {\n              ...subagent,\n              toolCall: {\n                ...subagent.toolCall,\n                args: {\n                  ...subagent.toolCall.args,\n                  description,\n                },\n              },\n            });\n          }\n          return establishMapping(toolCallId);\n        }\n      }\n    }\n\n    // No match found - store for retry when more tool calls are registered\n    if (description) {\n      this.pendingMatches.set(namespaceId, description);\n    }\n    return undefined;\n  }\n\n  /**\n   * Check if a tool call is a subagent invocation.\n   */\n  isSubagentToolCall(toolName: string): boolean {\n    return this.subagentToolNames.has(toolName);\n  }\n\n  /**\n   * Check if a subagent_type value is valid.\n   * Valid types are proper identifiers like \"weather-scout\", \"experience-curator\".\n   */\n  private isValidSubagentType(type: unknown): boolean {\n    // Must be a non-empty string\n    if (!type || typeof type !== \"string\") {\n      return false;\n    }\n\n    // Must be at least 3 characters (avoids partial streaming like \"ex\")\n    if (type.length < 3) {\n      return false;\n    }\n\n    // Must look like a valid identifier (letters, numbers, hyphens, underscores)\n    // Examples: \"weather-scout\", \"experience_curator\", \"budget-optimizer\"\n    if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(type)) {\n      return false;\n    }\n\n    // Must not be unreasonably long (corruption indicator)\n    if (type.length > 50) {\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Check if a subagent should be shown to the user.\n   * Subagents are only shown once they've actually started running.\n   *\n   * This filters out:\n   * - Pending subagents that haven't been matched to a namespace yet\n   * - Streaming artifacts with partial/corrupted data\n   *\n   * The idea is: we register subagents internally when we see tool calls,\n   * but we only show them to the user once LangGraph confirms they're\n   * actually executing (via namespace events).\n   */\n  private isValidSubagent(subagent: SubagentStreamBase<ToolCall>): boolean {\n    // Only show subagents that have started running or completed\n    // This ensures we don't show partial/pending subagents\n    return subagent.status === \"running\" || subagent.status === \"complete\";\n  }\n\n  /**\n   * Build a complete SubagentStream from internal state.\n   * Adds messages and derived properties.\n   */\n  private buildExecution(\n    base: SubagentStreamBase<ToolCall>\n  ): SubagentStream<Record<string, unknown>, ToolCall> {\n    // Get fresh messages from the manager\n    const messages = this.getMessagesForSubagent(base.id);\n    return this.createSubagentStream({\n      ...base,\n      messages,\n    });\n  }\n\n  /**\n   * Get all subagents as a Map.\n   * Filters out incomplete/phantom subagents that lack subagent_type.\n   */\n  getSubagents(): Map<\n    string,\n    SubagentStream<Record<string, unknown>, ToolCall>\n  > {\n    const result = new Map<\n      string,\n      SubagentStream<Record<string, unknown>, ToolCall>\n    >();\n    for (const [id, subagent] of this.subagents) {\n      if (this.isValidSubagent(subagent)) {\n        result.set(id, this.buildExecution(subagent));\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Get all currently running subagents.\n   * Filters out incomplete/phantom subagents.\n   */\n  getActiveSubagents(): SubagentStream<Record<string, unknown>, ToolCall>[] {\n    return [...this.subagents.values()]\n      .filter((s) => s.status === \"running\" && this.isValidSubagent(s))\n      .map((s) => this.buildExecution(s));\n  }\n\n  /**\n   * Get a specific subagent by tool call ID.\n   */\n  getSubagent(\n    toolCallId: string\n  ): SubagentStream<Record<string, unknown>, ToolCall> | undefined {\n    const subagent = this.subagents.get(toolCallId);\n    return subagent ? this.buildExecution(subagent) : undefined;\n  }\n\n  /**\n   * Get all subagents of a specific type.\n   */\n  getSubagentsByType(\n    type: string\n  ): SubagentStream<Record<string, unknown>, ToolCall>[] {\n    return [...this.subagents.values()]\n      .filter((s) => s.toolCall.args.subagent_type === type)\n      .map((s) => this.buildExecution(s));\n  }\n\n  /**\n   * Get all subagents triggered by a specific AI message.\n   *\n   * @param messageId - The ID of the AI message.\n   * @returns Array of subagent streams triggered by that message.\n   */\n  getSubagentsByMessage(\n    messageId: string\n  ): SubagentStream<Record<string, unknown>, ToolCall>[] {\n    return [...this.subagents.values()]\n      .filter((s) => s.aiMessageId === messageId && this.isValidSubagent(s))\n      .map((s) => this.buildExecution(s));\n  }\n\n  /**\n   * Parse tool call args, handling both object and string formats.\n   * During streaming, args might come as a string that needs parsing.\n   */\n  private parseArgs(\n    args: Record<string, unknown> | string | undefined\n  ): Record<string, unknown> {\n    if (!args) return {};\n    if (typeof args === \"string\") {\n      try {\n        return JSON.parse(args);\n      } catch {\n        return {};\n      }\n    }\n    return args;\n  }\n\n  /**\n   * Register new subagent(s) from AI message tool calls.\n   *\n   * Called when an AI message is received with tool calls.\n   * Creates pending subagent entries for each subagent tool call.\n   *\n   * @param toolCalls - The tool calls from an AI message\n   * @param aiMessageId - The ID of the AI message that triggered the tool calls\n   */\n  registerFromToolCalls(\n    toolCalls: Array<{\n      id?: string;\n      name: string;\n      args: Record<string, unknown> | string;\n    }>,\n    aiMessageId?: string | null\n  ): void {\n    let hasChanges = false;\n\n    for (const toolCall of toolCalls) {\n      if (!toolCall.id) continue;\n      if (!this.isSubagentToolCall(toolCall.name)) continue;\n\n      // Parse args (may be string during streaming)\n      const parsedArgs = this.parseArgs(toolCall.args);\n\n      // Skip tool calls that have no meaningful info (likely streaming artifacts)\n      // We require a valid subagent_type that looks like a proper identifier\n      const hasValidType = this.isValidSubagentType(parsedArgs.subagent_type);\n\n      // If we already have this subagent, update the args if they're now more complete\n      const existing = this.subagents.get(toolCall.id);\n      if (existing) {\n        // Only update if new values are valid AND longer (more complete)\n        const newType = (parsedArgs.subagent_type as string) || \"\";\n        const oldType = existing.toolCall.args.subagent_type || \"\";\n        const newDesc = (parsedArgs.description as string) || \"\";\n        const oldDesc = existing.toolCall.args.description || \"\";\n\n        // Only accept new type if it's valid (not corrupted)\n        const newTypeIsValid = this.isValidSubagentType(newType);\n        const shouldUpdateType =\n          newTypeIsValid && newType.length > oldType.length;\n        const shouldUpdateDesc = newDesc.length > oldDesc.length;\n\n        if (shouldUpdateType || shouldUpdateDesc) {\n          this.subagents.set(toolCall.id, {\n            ...existing,\n            toolCall: {\n              ...existing.toolCall,\n              args: {\n                ...existing.toolCall.args,\n                ...parsedArgs,\n                description: shouldUpdateDesc ? newDesc : oldDesc,\n                subagent_type: shouldUpdateType ? newType : oldType,\n              },\n            },\n          });\n          hasChanges = true;\n        }\n        continue;\n      }\n\n      // Don't register subagents without at least a valid-looking subagent_type\n      // Partial streaming is OK - we filter by status when displaying\n      if (!hasValidType) {\n        continue;\n      }\n\n      const subagentToolCall: SubagentToolCall = {\n        id: toolCall.id,\n        name: toolCall.name,\n        args: {\n          description: parsedArgs.description as string | undefined,\n          subagent_type: parsedArgs.subagent_type as string | undefined,\n          ...parsedArgs,\n        },\n      };\n\n      const execution: SubagentStreamBase<ToolCall> = {\n        id: toolCall.id,\n        toolCall: subagentToolCall,\n        status: \"pending\",\n        values: {},\n        result: null,\n        error: null,\n        namespace: [],\n        messages: [],\n        aiMessageId: aiMessageId ?? null,\n        parentId: null,\n        depth: 0,\n        startedAt: null,\n        completedAt: null,\n      };\n\n      this.subagents.set(toolCall.id, execution);\n      // Create a message manager for this subagent\n      this.getMessageManager(toolCall.id);\n      hasChanges = true;\n    }\n\n    // Retry any pending matches now that we have new/updated tool calls\n    if (hasChanges) {\n      this.retryPendingMatches();\n      this.onSubagentChange?.();\n    }\n  }\n\n  /**\n   * Retry matching pending namespaces to newly registered tool calls.\n   */\n  private retryPendingMatches(): void {\n    if (this.pendingMatches.size === 0) return;\n\n    // Try to match each pending namespace\n    for (const [namespaceId, description] of this.pendingMatches) {\n      // Skip if already matched\n      if (this.namespaceToToolCallId.has(namespaceId)) {\n        this.pendingMatches.delete(namespaceId);\n        continue;\n      }\n\n      // Try to match - this will establish mapping if successful\n      const matched = this.matchSubgraphToSubagent(namespaceId, description);\n      if (matched) {\n        this.pendingMatches.delete(namespaceId);\n      }\n    }\n  }\n\n  /**\n   * Mark a subagent as running and update its namespace.\n   *\n   * Called when update events are received with a namespace indicating\n   * which subagent is streaming.\n   *\n   * @param toolCallId - The tool call ID of the subagent\n   * @param options - Additional update options\n   */\n  markRunning(\n    toolCallId: string,\n    options?: {\n      namespace?: string[];\n    }\n  ): void {\n    const existing = this.subagents.get(toolCallId);\n    if (!existing) return;\n\n    const namespace = options?.namespace ?? existing.namespace;\n\n    this.subagents.set(toolCallId, {\n      ...existing,\n      status: \"running\",\n      namespace,\n      parentId:\n        existing.parentId ?? extractParentIdFromNamespace(namespace) ?? null,\n      depth: existing.depth || calculateDepthFromNamespace(namespace),\n      startedAt: existing.startedAt ?? new Date(),\n    });\n\n    this.onSubagentChange?.();\n  }\n\n  /**\n   * Mark a subagent as running using a namespace ID.\n   * Resolves the namespace ID to the actual tool call ID via the mapping.\n   *\n   * @param namespaceId - The namespace ID (pregel task ID) from the subgraph\n   * @param namespace - The full namespace array\n   */\n  markRunningFromNamespace(namespaceId: string, namespace?: string[]): void {\n    const toolCallId = this.getToolCallIdFromNamespace(namespaceId);\n    this.markRunning(toolCallId, { namespace });\n  }\n\n  /**\n   * Add a serialized message to a subagent from stream events.\n   *\n   * This method handles the raw serialized message data from SSE events.\n   * Uses MessageTupleManager for proper chunk concatenation, matching\n   * how the main stream handles messages.\n   *\n   * @param namespaceId - The namespace ID (pregel task ID) from the stream\n   * @param serialized - The serialized message from the stream\n   * @param metadata - Optional metadata from the stream event\n   */\n  addMessageToSubagent(\n    namespaceId: string,\n    serialized: Message<DefaultToolCall>,\n    metadata?: Record<string, unknown>\n  ): void {\n    // First, try to match this namespace to an existing subagent\n    // For human messages (which contain the description), try to establish the mapping\n    if (serialized.type === \"human\" && typeof serialized.content === \"string\") {\n      this.matchSubgraphToSubagent(namespaceId, serialized.content);\n    }\n\n    // Resolve the actual tool call ID from the namespace mapping\n    const toolCallId = this.getToolCallIdFromNamespace(namespaceId);\n    const existing = this.subagents.get(toolCallId);\n\n    // If we still don't have a match, the mapping hasn't been established yet.\n    // Don't create a placeholder - just skip this message.\n    // The values event will establish the mapping, and subsequent messages\n    // will be routed correctly.\n    if (!existing) {\n      return;\n    }\n\n    // Use MessageTupleManager for proper chunk concatenation\n    // This is the same approach used by the main stream\n    const manager = this.getMessageManager(toolCallId);\n    const messageId = manager.add(serialized, metadata);\n\n    if (messageId) {\n      // Update the subagent status if this is an AI message with content\n      if (serialized.type === \"ai\") {\n        this.subagents.set(toolCallId, {\n          ...existing,\n          status: \"running\",\n          startedAt: existing.startedAt ?? new Date(),\n          // Messages are derived from the manager, so we update them here\n          messages: this.getMessagesForSubagent(toolCallId),\n        });\n      } else {\n        // For other message types, just update the messages\n        this.subagents.set(toolCallId, {\n          ...existing,\n          messages: this.getMessagesForSubagent(toolCallId),\n        });\n      }\n    }\n\n    this.onSubagentChange?.();\n  }\n\n  /**\n   * Update subagent values from a values stream event.\n   *\n   * Called when a values event is received from a subagent's namespace.\n   * This populates the subagent's state values, making them accessible\n   * via the `values` property.\n   *\n   * @param namespaceId - The namespace ID (pregel task ID) from the stream\n   * @param values - The state values from the stream event\n   */\n  updateSubagentValues(\n    namespaceId: string,\n    values: Record<string, unknown>\n  ): void {\n    // Resolve the actual tool call ID from the namespace mapping\n    const toolCallId = this.getToolCallIdFromNamespace(namespaceId);\n    const existing = this.subagents.get(toolCallId);\n\n    if (!existing) {\n      return;\n    }\n\n    this.subagents.set(toolCallId, {\n      ...existing,\n      values,\n      status: existing.status === \"pending\" ? \"running\" : existing.status,\n      startedAt: existing.startedAt ?? new Date(),\n    });\n\n    this.onSubagentChange?.();\n  }\n\n  /**\n   * Complete a subagent with a result.\n   *\n   * Called when a tool message is received for the subagent.\n   *\n   * @param toolCallId - The tool call ID of the subagent\n   * @param result - The result content\n   * @param status - The final status (complete or error)\n   */\n  complete(\n    toolCallId: string,\n    result: string,\n    status: \"complete\" | \"error\" = \"complete\"\n  ): void {\n    const existing = this.subagents.get(toolCallId);\n    if (!existing) return;\n\n    this.subagents.set(toolCallId, {\n      ...existing,\n      status,\n      result: status === \"complete\" ? result : null,\n      error: status === \"error\" ? result : null,\n      completedAt: new Date(),\n    });\n\n    this.onSubagentChange?.();\n  }\n\n  /**\n   * Clear all subagent state.\n   */\n  clear(): void {\n    this.subagents.clear();\n    this.namespaceToToolCallId.clear();\n    this.messageManagers.clear();\n    this.pendingMatches.clear();\n    this.onSubagentChange?.();\n  }\n\n  /**\n   * Process a tool message to complete a subagent.\n   *\n   * @param toolCallId - The tool call ID from the tool message\n   * @param content - The result content\n   * @param status - Whether the tool execution was successful\n   */\n  processToolMessage(\n    toolCallId: string,\n    content: string,\n    status: \"success\" | \"error\" = \"success\"\n  ): void {\n    const existing = this.subagents.get(toolCallId);\n    if (!existing) return;\n\n    this.complete(\n      toolCallId,\n      content,\n      status === \"success\" ? \"complete\" : \"error\"\n    );\n  }\n\n  /**\n   * Reconstruct subagent state from historical messages.\n   *\n   * This method parses an array of messages (typically from thread history)\n   * to identify subagent executions and their results. It's used to restore\n   * subagent state after:\n   * - Page refresh (when stream has already completed)\n   * - Loading thread history\n   * - Navigating between threads\n   *\n   * The reconstruction process:\n   * 1. Find AI messages with tool calls matching subagent tool names\n   * 2. Find corresponding tool messages with results\n   * 3. Create SubagentStream entries with \"complete\" status\n   *\n   * Note: Internal subagent messages (their streaming conversation) are not\n   * reconstructed since they are not persisted in the main thread state.\n   *\n   * @param messages - Array of messages from thread history\n   * @param options - Optional configuration\n   * @param options.skipIfPopulated - If true, skip reconstruction if subagents already exist\n   */\n  reconstructFromMessages(\n    messages: Message<DefaultToolCall>[],\n    options?: { skipIfPopulated?: boolean }\n  ): void {\n    // Skip if we already have subagents (from active streaming)\n    if (options?.skipIfPopulated && this.subagents.size > 0) {\n      return;\n    }\n\n    // Build a map of tool_call_id -> tool message content for quick lookup\n    const toolResults = new Map<\n      string,\n      { content: string; status: \"success\" | \"error\" }\n    >();\n\n    for (const message of messages) {\n      if (message.type === \"tool\" && \"tool_call_id\" in message) {\n        const toolCallId = message.tool_call_id as string;\n        const content =\n          typeof message.content === \"string\"\n            ? message.content\n            : JSON.stringify(message.content);\n        const status =\n          \"status\" in message && message.status === \"error\"\n            ? \"error\"\n            : \"success\";\n        toolResults.set(toolCallId, { content, status });\n      }\n    }\n\n    // Find AI messages with subagent tool calls\n    let hasChanges = false;\n\n    for (const message of messages) {\n      if (\n        message.type !== \"ai\" ||\n        !(\"tool_calls\" in message) ||\n        !Array.isArray(message.tool_calls)\n      ) {\n        continue;\n      }\n\n      for (const toolCall of message.tool_calls) {\n        if (!toolCall.id) continue;\n        if (!this.isSubagentToolCall(toolCall.name)) continue;\n\n        // Skip if we already have this subagent\n        if (this.subagents.has(toolCall.id)) continue;\n\n        // Parse args\n        const parsedArgs = this.parseArgs(toolCall.args);\n\n        // Skip if no valid subagent_type\n        if (!this.isValidSubagentType(parsedArgs.subagent_type)) continue;\n\n        // Create the subagent tool call\n        const subagentToolCall: SubagentToolCall = {\n          id: toolCall.id,\n          name: toolCall.name,\n          args: {\n            description: parsedArgs.description as string | undefined,\n            subagent_type: parsedArgs.subagent_type as string | undefined,\n            ...parsedArgs,\n          },\n        };\n\n        // Check if we have a result for this tool call\n        const toolResult = toolResults.get(toolCall.id);\n        const isComplete = !!toolResult;\n        // eslint-disable-next-line no-nested-ternary\n        const status: SubagentStatus = isComplete\n          ? toolResult.status === \"error\"\n            ? \"error\"\n            : \"complete\"\n          : \"running\";\n\n        // Create the subagent execution\n        const execution: SubagentStreamBase<ToolCall> = {\n          id: toolCall.id,\n          toolCall: subagentToolCall,\n          status,\n          values: {}, // Values not available from history\n          result:\n            isComplete && status === \"complete\" ? toolResult.content : null,\n          error: isComplete && status === \"error\" ? toolResult.content : null,\n          namespace: [],\n          messages: [], // Internal messages are not available from history\n          aiMessageId: (message.id as string) ?? null,\n          parentId: null,\n          depth: 0,\n          startedAt: null,\n          completedAt: isComplete ? new Date() : null,\n        };\n\n        this.subagents.set(toolCall.id, execution);\n        hasChanges = true;\n      }\n    }\n\n    if (hasChanges) {\n      this.onSubagentChange?.();\n    }\n  }\n\n  /**\n   * Check if any subagents are currently tracked.\n   */\n  hasSubagents(): boolean {\n    return this.subagents.size > 0;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"subagents.js","names":[],"sources":["../../src/ui/subagents.ts"],"sourcesContent":["import type {\n  Message,\n  DefaultToolCall,\n  AIMessage,\n  ToolCallWithResult,\n} from \"../types.messages.js\";\nimport type {\n  SubagentStreamInterface,\n  SubagentToolCall,\n  SubagentStatus,\n} from \"./types.js\";\nimport { MessageTupleManager, toMessageDict } from \"./messages.js\";\nimport { getToolCallsWithResults } from \"../utils/tools.js\";\n\n/**\n * Default tool names that indicate subagent invocation.\n * Can be customized via SubagentManager options.\n */\nconst DEFAULT_SUBAGENT_TOOL_NAMES = [\"task\"];\n\n/**\n * Checks if a namespace indicates a subagent/subgraph message.\n *\n * Subagent namespaces contain a \"tools:\" segment indicating they\n * originate from a tool call that spawned a subgraph.\n *\n * @param namespace - The namespace array from stream events (or checkpoint_ns string)\n * @returns True if this is a subagent namespace\n */\nexport function isSubagentNamespace(\n  namespace: string[] | string | undefined\n): boolean {\n  if (!namespace) return false;\n\n  // Handle string namespace (from checkpoint_ns)\n  if (typeof namespace === \"string\") {\n    return namespace.includes(\"tools:\");\n  }\n\n  // Handle array namespace\n  return namespace.some((s) => s.startsWith(\"tools:\"));\n}\n\n/**\n * Extracts the tool call ID from a namespace path.\n *\n * Namespaces follow the pattern: [\"tools:call_abc123\", \"model_request:xyz\", ...]\n * This function extracts \"call_abc123\" from the first \"tools:\" segment.\n *\n * @param namespace - The namespace array from stream events\n * @returns The tool call ID, or undefined if not found\n */\nexport function extractToolCallIdFromNamespace(\n  namespace: string[] | undefined\n): string | undefined {\n  if (!namespace || namespace.length === 0) return undefined;\n\n  // Find the first namespace segment that starts with \"tools:\"\n  for (const segment of namespace) {\n    if (segment.startsWith(\"tools:\")) {\n      return segment.slice(6); // Remove \"tools:\" prefix\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Calculates the depth of a subagent based on its namespace.\n * Counts the number of \"tools:\" segments in the namespace.\n *\n * @param namespace - The namespace array\n * @returns The depth (0 for main agent, 1+ for subagents)\n */\nexport function calculateDepthFromNamespace(\n  namespace: string[] | undefined\n): number {\n  if (!namespace) return 0;\n  return namespace.filter((s) => s.startsWith(\"tools:\")).length;\n}\n\n/**\n * Extracts the parent tool call ID from a namespace.\n *\n * For nested subagents, the namespace looks like:\n * [\"tools:parent_id\", \"tools:child_id\", ...]\n *\n * @param namespace - The namespace array\n * @returns The parent tool call ID, or null if this is a top-level subagent\n */\nexport function extractParentIdFromNamespace(\n  namespace: string[] | undefined\n): string | null {\n  if (!namespace || namespace.length < 2) return null;\n\n  const toolSegments = namespace.filter((s) => s.startsWith(\"tools:\"));\n  if (toolSegments.length < 2) return null;\n\n  // The second-to-last \"tools:\" segment is the parent\n  return toolSegments[toolSegments.length - 2]?.slice(6) ?? null;\n}\n\n/**\n * Options for SubagentManager.\n */\nexport interface SubagentManagerOptions {\n  /**\n   * Tool names that indicate subagent invocation.\n   * Defaults to [\"task\"].\n   */\n  subagentToolNames?: string[];\n\n  /**\n   * Callback when subagent state changes.\n   */\n  onSubagentChange?: () => void;\n}\n\n/**\n * Internal base type for SubagentStream storage.\n * Excludes derived properties that are computed on retrieval.\n */\ntype SubagentStreamBase<ToolCall> = Omit<\n  SubagentStreamInterface<Record<string, unknown>, ToolCall>,\n  | \"isLoading\"\n  | \"toolCalls\"\n  | \"getToolCalls\"\n  | \"interrupt\"\n  | \"interrupts\"\n  | \"subagents\"\n  | \"activeSubagents\"\n  | \"getSubagent\"\n  | \"getSubagentsByType\"\n  | \"getSubagentsByMessage\"\n  | \"nodes\"\n  | \"activeNodes\"\n  | \"getNodeStream\"\n  | \"getNodeStreamsByName\"\n> & {\n  /** Internal: ID of the AI message that triggered this subagent */\n  aiMessageId: string | null;\n};\n\n/**\n * Manages subagent execution state.\n *\n * Tracks subagents from the moment they are invoked (AI message with tool calls)\n * through streaming to completion (tool message result).\n */\nexport class SubagentManager<ToolCall = DefaultToolCall> {\n  private subagents = new Map<string, SubagentStreamBase<ToolCall>>();\n\n  /**\n   * Maps namespace IDs (pregel task IDs) to tool call IDs.\n   * LangGraph subgraphs use internal pregel task IDs in their namespace,\n   * which are different from the tool_call_id used to invoke them.\n   */\n  private namespaceToToolCallId = new Map<string, string>();\n\n  /**\n   * Pending namespace matches that couldn't be resolved immediately.\n   * These are retried when new tool calls are registered.\n   */\n  private pendingMatches = new Map<string, string>(); // namespaceId -> description\n\n  /**\n   * Message managers for each subagent.\n   * Uses the same MessageTupleManager as the main stream for proper\n   * message chunk concatenation.\n   */\n  private messageManagers = new Map<string, MessageTupleManager>();\n\n  private subagentToolNames: Set<string>;\n\n  private onSubagentChange?: () => void;\n\n  constructor(options?: SubagentManagerOptions) {\n    this.subagentToolNames = new Set(\n      options?.subagentToolNames ?? DEFAULT_SUBAGENT_TOOL_NAMES\n    );\n    this.onSubagentChange = options?.onSubagentChange;\n  }\n\n  /**\n   * Get or create a MessageTupleManager for a subagent.\n   */\n  private getMessageManager(toolCallId: string): MessageTupleManager {\n    let manager = this.messageManagers.get(toolCallId);\n    if (!manager) {\n      manager = new MessageTupleManager();\n      this.messageManagers.set(toolCallId, manager);\n    }\n    return manager;\n  }\n\n  /**\n   * Get messages for a subagent with proper chunk concatenation.\n   * This mirrors how the main stream handles messages.\n   */\n  private getMessagesForSubagent(toolCallId: string): Message<ToolCall>[] {\n    const manager = this.messageManagers.get(toolCallId);\n    if (!manager) return [];\n\n    // Convert chunks to messages in order\n    const messages: Message<ToolCall>[] = [];\n    for (const entry of Object.values(manager.chunks)) {\n      if (entry.chunk) {\n        messages.push(toMessageDict(entry.chunk) as Message<ToolCall>);\n      }\n    }\n    return messages;\n  }\n\n  /**\n   * Create a complete SubagentStream object with all derived properties.\n   * This ensures consistency with UseStream interface.\n   */\n  private createSubagentStream(\n    base: SubagentStreamBase<ToolCall>\n  ): SubagentStreamInterface<Record<string, unknown>, ToolCall> {\n    const { messages } = base;\n    const allToolCalls = getToolCallsWithResults<ToolCall>(messages);\n\n    return {\n      ...base,\n      // Derived from status for UseStream consistency\n      isLoading: base.status === \"running\",\n\n      // Tool calls derived from messages\n      toolCalls: allToolCalls,\n\n      // Method to get tool calls for a specific message\n      getToolCalls: (\n        message: AIMessage<ToolCall>\n      ): ToolCallWithResult<ToolCall>[] => {\n        return allToolCalls.filter((tc) => tc.aiMessage.id === message.id);\n      },\n\n      // Subagents don't have interrupts yet (future enhancement)\n      interrupt: undefined,\n      interrupts: [],\n\n      // Nested subagent tracking (empty for now, future enhancement)\n      subagents: new Map<\n        string,\n        SubagentStreamInterface<Record<string, unknown>, ToolCall>\n      >(),\n      activeSubagents: [],\n      getSubagent: () => undefined,\n      getSubagentsByType: () => [],\n      getSubagentsByMessage: () => [],\n    };\n  }\n\n  /**\n   * Get the tool call ID for a given namespace ID.\n   * Returns the namespace ID itself if no mapping exists.\n   */\n  getToolCallIdFromNamespace(namespaceId: string): string {\n    return this.namespaceToToolCallId.get(namespaceId) ?? namespaceId;\n  }\n\n  /**\n   * Try to match a subgraph to a pending subagent by description.\n   * Creates a mapping from namespace ID to tool call ID if a match is found.\n   *\n   * Uses a multi-pass matching strategy:\n   * 1. Exact description match\n   * 2. Description contains/partial match\n   * 3. Any unmapped pending subagent (fallback)\n   *\n   * @param namespaceId - The namespace ID (pregel task ID) from the subgraph\n   * @param description - The description from the subgraph's initial message\n   * @returns The matched tool call ID, or undefined if no match\n   */\n  matchSubgraphToSubagent(\n    namespaceId: string,\n    description: string\n  ): string | undefined {\n    // Skip if we already have a mapping\n    if (this.namespaceToToolCallId.has(namespaceId)) {\n      return this.namespaceToToolCallId.get(namespaceId);\n    }\n\n    // Get all already-mapped tool call IDs\n    const mappedToolCallIds = new Set(this.namespaceToToolCallId.values());\n\n    // Helper to establish mapping and mark as running\n    const establishMapping = (toolCallId: string): string => {\n      this.namespaceToToolCallId.set(namespaceId, toolCallId);\n      // Also mark the subagent as running since we now have its namespace\n      const subagent = this.subagents.get(toolCallId);\n      if (subagent && subagent.status === \"pending\") {\n        this.subagents.set(toolCallId, {\n          ...subagent,\n          status: \"running\",\n          namespace: [namespaceId],\n          startedAt: new Date(),\n        });\n        this.onSubagentChange?.();\n      }\n      return toolCallId;\n    };\n\n    // Pass 1: Find a pending subagent with exact description match\n    for (const [toolCallId, subagent] of this.subagents) {\n      if (\n        (subagent.status === \"pending\" || subagent.status === \"running\") &&\n        !mappedToolCallIds.has(toolCallId) &&\n        subagent.toolCall.args.description === description\n      ) {\n        return establishMapping(toolCallId);\n      }\n    }\n\n    // Pass 2: Find a pending subagent where description contains or is contained\n    for (const [toolCallId, subagent] of this.subagents) {\n      if (\n        (subagent.status === \"pending\" || subagent.status === \"running\") &&\n        !mappedToolCallIds.has(toolCallId)\n      ) {\n        const subagentDesc = subagent.toolCall.args.description || \"\";\n        if (\n          (subagentDesc && description.includes(subagentDesc)) ||\n          (subagentDesc && subagentDesc.includes(description))\n        ) {\n          // Update the description if the new one is longer\n          if (description.length > subagentDesc.length) {\n            this.subagents.set(toolCallId, {\n              ...subagent,\n              toolCall: {\n                ...subagent.toolCall,\n                args: {\n                  ...subagent.toolCall.args,\n                  description,\n                },\n              },\n            });\n          }\n          return establishMapping(toolCallId);\n        }\n      }\n    }\n\n    // No match found - store for retry when more tool calls are registered\n    if (description) {\n      this.pendingMatches.set(namespaceId, description);\n    }\n    return undefined;\n  }\n\n  /**\n   * Check if a tool call is a subagent invocation.\n   */\n  isSubagentToolCall(toolName: string): boolean {\n    return this.subagentToolNames.has(toolName);\n  }\n\n  /**\n   * Check if a subagent_type value is valid.\n   * Valid types are proper identifiers like \"weather-scout\", \"experience-curator\".\n   */\n  private isValidSubagentType(type: unknown): boolean {\n    // Must be a non-empty string\n    if (!type || typeof type !== \"string\") {\n      return false;\n    }\n\n    // Must be at least 3 characters (avoids partial streaming like \"ex\")\n    if (type.length < 3) {\n      return false;\n    }\n\n    // Must look like a valid identifier (letters, numbers, hyphens, underscores)\n    // Examples: \"weather-scout\", \"experience_curator\", \"budget-optimizer\"\n    if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(type)) {\n      return false;\n    }\n\n    // Must not be unreasonably long (corruption indicator)\n    if (type.length > 50) {\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Check if a subagent should be shown to the user.\n   * Subagents are only shown once they've actually started running.\n   *\n   * This filters out:\n   * - Pending subagents that haven't been matched to a namespace yet\n   * - Streaming artifacts with partial/corrupted data\n   *\n   * The idea is: we register subagents internally when we see tool calls,\n   * but we only show them to the user once LangGraph confirms they're\n   * actually executing (via namespace events).\n   */\n  private isValidSubagent(subagent: SubagentStreamBase<ToolCall>): boolean {\n    // Only show subagents that have started running or completed\n    // This ensures we don't show partial/pending subagents\n    return subagent.status === \"running\" || subagent.status === \"complete\";\n  }\n\n  /**\n   * Build a complete SubagentStream from internal state.\n   * Adds messages and derived properties.\n   */\n  private buildExecution(\n    base: SubagentStreamBase<ToolCall>\n  ): SubagentStreamInterface<Record<string, unknown>, ToolCall> {\n    // Get fresh messages from the manager\n    const messages = this.getMessagesForSubagent(base.id);\n    return this.createSubagentStream({\n      ...base,\n      messages,\n    });\n  }\n\n  /**\n   * Get all subagents as a Map.\n   * Filters out incomplete/phantom subagents that lack subagent_type.\n   */\n  getSubagents(): Map<\n    string,\n    SubagentStreamInterface<Record<string, unknown>, ToolCall>\n  > {\n    const result = new Map<\n      string,\n      SubagentStreamInterface<Record<string, unknown>, ToolCall>\n    >();\n    for (const [id, subagent] of this.subagents) {\n      if (this.isValidSubagent(subagent)) {\n        result.set(id, this.buildExecution(subagent));\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Get all currently running subagents.\n   * Filters out incomplete/phantom subagents.\n   */\n  getActiveSubagents(): SubagentStreamInterface<\n    Record<string, unknown>,\n    ToolCall\n  >[] {\n    return [...this.subagents.values()]\n      .filter((s) => s.status === \"running\" && this.isValidSubagent(s))\n      .map((s) => this.buildExecution(s));\n  }\n\n  /**\n   * Get a specific subagent by tool call ID.\n   */\n  getSubagent(\n    toolCallId: string\n  ): SubagentStreamInterface<Record<string, unknown>, ToolCall> | undefined {\n    const subagent = this.subagents.get(toolCallId);\n    return subagent ? this.buildExecution(subagent) : undefined;\n  }\n\n  /**\n   * Get all subagents of a specific type.\n   */\n  getSubagentsByType(\n    type: string\n  ): SubagentStreamInterface<Record<string, unknown>, ToolCall>[] {\n    return [...this.subagents.values()]\n      .filter((s) => s.toolCall.args.subagent_type === type)\n      .map((s) => this.buildExecution(s));\n  }\n\n  /**\n   * Get all subagents triggered by a specific AI message.\n   *\n   * @param messageId - The ID of the AI message.\n   * @returns Array of subagent streams triggered by that message.\n   */\n  getSubagentsByMessage(\n    messageId: string\n  ): SubagentStreamInterface<Record<string, unknown>, ToolCall>[] {\n    return [...this.subagents.values()]\n      .filter((s) => s.aiMessageId === messageId && this.isValidSubagent(s))\n      .map((s) => this.buildExecution(s));\n  }\n\n  /**\n   * Parse tool call args, handling both object and string formats.\n   * During streaming, args might come as a string that needs parsing.\n   */\n  private parseArgs(\n    args: Record<string, unknown> | string | undefined\n  ): Record<string, unknown> {\n    if (!args) return {};\n    if (typeof args === \"string\") {\n      try {\n        return JSON.parse(args);\n      } catch {\n        return {};\n      }\n    }\n    return args;\n  }\n\n  /**\n   * Register new subagent(s) from AI message tool calls.\n   *\n   * Called when an AI message is received with tool calls.\n   * Creates pending subagent entries for each subagent tool call.\n   *\n   * @param toolCalls - The tool calls from an AI message\n   * @param aiMessageId - The ID of the AI message that triggered the tool calls\n   */\n  registerFromToolCalls(\n    toolCalls: Array<{\n      id?: string;\n      name: string;\n      args: Record<string, unknown> | string;\n    }>,\n    aiMessageId?: string | null\n  ): void {\n    let hasChanges = false;\n\n    for (const toolCall of toolCalls) {\n      if (!toolCall.id) continue;\n      if (!this.isSubagentToolCall(toolCall.name)) continue;\n\n      // Parse args (may be string during streaming)\n      const parsedArgs = this.parseArgs(toolCall.args);\n\n      // Skip tool calls that have no meaningful info (likely streaming artifacts)\n      // We require a valid subagent_type that looks like a proper identifier\n      const hasValidType = this.isValidSubagentType(parsedArgs.subagent_type);\n\n      // If we already have this subagent, update the args if they're now more complete\n      const existing = this.subagents.get(toolCall.id);\n      if (existing) {\n        // Only update if new values are valid AND longer (more complete)\n        const newType = (parsedArgs.subagent_type as string) || \"\";\n        const oldType = existing.toolCall.args.subagent_type || \"\";\n        const newDesc = (parsedArgs.description as string) || \"\";\n        const oldDesc = existing.toolCall.args.description || \"\";\n\n        // Only accept new type if it's valid (not corrupted)\n        const newTypeIsValid = this.isValidSubagentType(newType);\n        const shouldUpdateType =\n          newTypeIsValid && newType.length > oldType.length;\n        const shouldUpdateDesc = newDesc.length > oldDesc.length;\n\n        if (shouldUpdateType || shouldUpdateDesc) {\n          this.subagents.set(toolCall.id, {\n            ...existing,\n            toolCall: {\n              ...existing.toolCall,\n              args: {\n                ...existing.toolCall.args,\n                ...parsedArgs,\n                description: shouldUpdateDesc ? newDesc : oldDesc,\n                subagent_type: shouldUpdateType ? newType : oldType,\n              },\n            },\n          });\n          hasChanges = true;\n        }\n        continue;\n      }\n\n      // Don't register subagents without at least a valid-looking subagent_type\n      // Partial streaming is OK - we filter by status when displaying\n      if (!hasValidType) {\n        continue;\n      }\n\n      const subagentToolCall: SubagentToolCall = {\n        id: toolCall.id,\n        name: toolCall.name,\n        args: {\n          description: parsedArgs.description as string | undefined,\n          subagent_type: parsedArgs.subagent_type as string | undefined,\n          ...parsedArgs,\n        },\n      };\n\n      const execution: SubagentStreamBase<ToolCall> = {\n        id: toolCall.id,\n        toolCall: subagentToolCall,\n        status: \"pending\",\n        values: {},\n        result: null,\n        error: null,\n        namespace: [],\n        messages: [],\n        aiMessageId: aiMessageId ?? null,\n        parentId: null,\n        depth: 0,\n        startedAt: null,\n        completedAt: null,\n      };\n\n      this.subagents.set(toolCall.id, execution);\n      // Create a message manager for this subagent\n      this.getMessageManager(toolCall.id);\n      hasChanges = true;\n    }\n\n    // Retry any pending matches now that we have new/updated tool calls\n    if (hasChanges) {\n      this.retryPendingMatches();\n      this.onSubagentChange?.();\n    }\n  }\n\n  /**\n   * Retry matching pending namespaces to newly registered tool calls.\n   */\n  private retryPendingMatches(): void {\n    if (this.pendingMatches.size === 0) return;\n\n    // Try to match each pending namespace\n    for (const [namespaceId, description] of this.pendingMatches) {\n      // Skip if already matched\n      if (this.namespaceToToolCallId.has(namespaceId)) {\n        this.pendingMatches.delete(namespaceId);\n        continue;\n      }\n\n      // Try to match - this will establish mapping if successful\n      const matched = this.matchSubgraphToSubagent(namespaceId, description);\n      if (matched) {\n        this.pendingMatches.delete(namespaceId);\n      }\n    }\n  }\n\n  /**\n   * Mark a subagent as running and update its namespace.\n   *\n   * Called when update events are received with a namespace indicating\n   * which subagent is streaming.\n   *\n   * @param toolCallId - The tool call ID of the subagent\n   * @param options - Additional update options\n   */\n  markRunning(\n    toolCallId: string,\n    options?: {\n      namespace?: string[];\n    }\n  ): void {\n    const existing = this.subagents.get(toolCallId);\n    if (!existing) return;\n\n    const namespace = options?.namespace ?? existing.namespace;\n\n    this.subagents.set(toolCallId, {\n      ...existing,\n      status: \"running\",\n      namespace,\n      parentId:\n        existing.parentId ?? extractParentIdFromNamespace(namespace) ?? null,\n      depth: existing.depth || calculateDepthFromNamespace(namespace),\n      startedAt: existing.startedAt ?? new Date(),\n    });\n\n    this.onSubagentChange?.();\n  }\n\n  /**\n   * Mark a subagent as running using a namespace ID.\n   * Resolves the namespace ID to the actual tool call ID via the mapping.\n   *\n   * @param namespaceId - The namespace ID (pregel task ID) from the subgraph\n   * @param namespace - The full namespace array\n   */\n  markRunningFromNamespace(namespaceId: string, namespace?: string[]): void {\n    const toolCallId = this.getToolCallIdFromNamespace(namespaceId);\n    this.markRunning(toolCallId, { namespace });\n  }\n\n  /**\n   * Add a serialized message to a subagent from stream events.\n   *\n   * This method handles the raw serialized message data from SSE events.\n   * Uses MessageTupleManager for proper chunk concatenation, matching\n   * how the main stream handles messages.\n   *\n   * @param namespaceId - The namespace ID (pregel task ID) from the stream\n   * @param serialized - The serialized message from the stream\n   * @param metadata - Optional metadata from the stream event\n   */\n  addMessageToSubagent(\n    namespaceId: string,\n    serialized: Message<DefaultToolCall>,\n    metadata?: Record<string, unknown>\n  ): void {\n    // First, try to match this namespace to an existing subagent\n    // For human messages (which contain the description), try to establish the mapping\n    if (serialized.type === \"human\" && typeof serialized.content === \"string\") {\n      this.matchSubgraphToSubagent(namespaceId, serialized.content);\n    }\n\n    // Resolve the actual tool call ID from the namespace mapping\n    const toolCallId = this.getToolCallIdFromNamespace(namespaceId);\n    const existing = this.subagents.get(toolCallId);\n\n    // If we still don't have a match, the mapping hasn't been established yet.\n    // Don't create a placeholder - just skip this message.\n    // The values event will establish the mapping, and subsequent messages\n    // will be routed correctly.\n    if (!existing) {\n      return;\n    }\n\n    // Use MessageTupleManager for proper chunk concatenation\n    // This is the same approach used by the main stream\n    const manager = this.getMessageManager(toolCallId);\n    const messageId = manager.add(serialized, metadata);\n\n    if (messageId) {\n      // Update the subagent status if this is an AI message with content\n      if (serialized.type === \"ai\") {\n        this.subagents.set(toolCallId, {\n          ...existing,\n          status: \"running\",\n          startedAt: existing.startedAt ?? new Date(),\n          // Messages are derived from the manager, so we update them here\n          messages: this.getMessagesForSubagent(toolCallId),\n        });\n      } else {\n        // For other message types, just update the messages\n        this.subagents.set(toolCallId, {\n          ...existing,\n          messages: this.getMessagesForSubagent(toolCallId),\n        });\n      }\n    }\n\n    this.onSubagentChange?.();\n  }\n\n  /**\n   * Update subagent values from a values stream event.\n   *\n   * Called when a values event is received from a subagent's namespace.\n   * This populates the subagent's state values, making them accessible\n   * via the `values` property.\n   *\n   * @param namespaceId - The namespace ID (pregel task ID) from the stream\n   * @param values - The state values from the stream event\n   */\n  updateSubagentValues(\n    namespaceId: string,\n    values: Record<string, unknown>\n  ): void {\n    // Resolve the actual tool call ID from the namespace mapping\n    const toolCallId = this.getToolCallIdFromNamespace(namespaceId);\n    const existing = this.subagents.get(toolCallId);\n\n    if (!existing) {\n      return;\n    }\n\n    this.subagents.set(toolCallId, {\n      ...existing,\n      values,\n      status: existing.status === \"pending\" ? \"running\" : existing.status,\n      startedAt: existing.startedAt ?? new Date(),\n    });\n\n    this.onSubagentChange?.();\n  }\n\n  /**\n   * Complete a subagent with a result.\n   *\n   * Called when a tool message is received for the subagent.\n   *\n   * @param toolCallId - The tool call ID of the subagent\n   * @param result - The result content\n   * @param status - The final status (complete or error)\n   */\n  complete(\n    toolCallId: string,\n    result: string,\n    status: \"complete\" | \"error\" = \"complete\"\n  ): void {\n    const existing = this.subagents.get(toolCallId);\n    if (!existing) return;\n\n    this.subagents.set(toolCallId, {\n      ...existing,\n      status,\n      result: status === \"complete\" ? result : null,\n      error: status === \"error\" ? result : null,\n      completedAt: new Date(),\n    });\n\n    this.onSubagentChange?.();\n  }\n\n  /**\n   * Clear all subagent state.\n   */\n  clear(): void {\n    this.subagents.clear();\n    this.namespaceToToolCallId.clear();\n    this.messageManagers.clear();\n    this.pendingMatches.clear();\n    this.onSubagentChange?.();\n  }\n\n  /**\n   * Process a tool message to complete a subagent.\n   *\n   * @param toolCallId - The tool call ID from the tool message\n   * @param content - The result content\n   * @param status - Whether the tool execution was successful\n   */\n  processToolMessage(\n    toolCallId: string,\n    content: string,\n    status: \"success\" | \"error\" = \"success\"\n  ): void {\n    const existing = this.subagents.get(toolCallId);\n    if (!existing) return;\n\n    this.complete(\n      toolCallId,\n      content,\n      status === \"success\" ? \"complete\" : \"error\"\n    );\n  }\n\n  /**\n   * Reconstruct subagent state from historical messages.\n   *\n   * This method parses an array of messages (typically from thread history)\n   * to identify subagent executions and their results. It's used to restore\n   * subagent state after:\n   * - Page refresh (when stream has already completed)\n   * - Loading thread history\n   * - Navigating between threads\n   *\n   * The reconstruction process:\n   * 1. Find AI messages with tool calls matching subagent tool names\n   * 2. Find corresponding tool messages with results\n   * 3. Create SubagentStream entries with \"complete\" status\n   *\n   * Note: Internal subagent messages (their streaming conversation) are not\n   * reconstructed since they are not persisted in the main thread state.\n   *\n   * @param messages - Array of messages from thread history\n   * @param options - Optional configuration\n   * @param options.skipIfPopulated - If true, skip reconstruction if subagents already exist\n   */\n  reconstructFromMessages(\n    messages: Message<DefaultToolCall>[],\n    options?: { skipIfPopulated?: boolean }\n  ): void {\n    // Skip if we already have subagents (from active streaming)\n    if (options?.skipIfPopulated && this.subagents.size > 0) {\n      return;\n    }\n\n    // Build a map of tool_call_id -> tool message content for quick lookup\n    const toolResults = new Map<\n      string,\n      { content: string; status: \"success\" | \"error\" }\n    >();\n\n    for (const message of messages) {\n      if (message.type === \"tool\" && \"tool_call_id\" in message) {\n        const toolCallId = message.tool_call_id as string;\n        const content =\n          typeof message.content === \"string\"\n            ? message.content\n            : JSON.stringify(message.content);\n        const status =\n          \"status\" in message && message.status === \"error\"\n            ? \"error\"\n            : \"success\";\n        toolResults.set(toolCallId, { content, status });\n      }\n    }\n\n    // Find AI messages with subagent tool calls\n    let hasChanges = false;\n\n    for (const message of messages) {\n      if (\n        message.type !== \"ai\" ||\n        !(\"tool_calls\" in message) ||\n        !Array.isArray(message.tool_calls)\n      ) {\n        continue;\n      }\n\n      for (const toolCall of message.tool_calls) {\n        if (!toolCall.id) continue;\n        if (!this.isSubagentToolCall(toolCall.name)) continue;\n\n        // Skip if we already have this subagent\n        if (this.subagents.has(toolCall.id)) continue;\n\n        // Parse args\n        const parsedArgs = this.parseArgs(toolCall.args);\n\n        // Skip if no valid subagent_type\n        if (!this.isValidSubagentType(parsedArgs.subagent_type)) continue;\n\n        // Create the subagent tool call\n        const subagentToolCall: SubagentToolCall = {\n          id: toolCall.id,\n          name: toolCall.name,\n          args: {\n            description: parsedArgs.description as string | undefined,\n            subagent_type: parsedArgs.subagent_type as string | undefined,\n            ...parsedArgs,\n          },\n        };\n\n        // Check if we have a result for this tool call\n        const toolResult = toolResults.get(toolCall.id);\n        const isComplete = !!toolResult;\n        // eslint-disable-next-line no-nested-ternary\n        const status: SubagentStatus = isComplete\n          ? toolResult.status === \"error\"\n            ? \"error\"\n            : \"complete\"\n          : \"running\";\n\n        // Create the subagent execution\n        const execution: SubagentStreamBase<ToolCall> = {\n          id: toolCall.id,\n          toolCall: subagentToolCall,\n          status,\n          values: {}, // Values not available from history\n          result:\n            isComplete && status === \"complete\" ? toolResult.content : null,\n          error: isComplete && status === \"error\" ? toolResult.content : null,\n          namespace: [],\n          messages: [], // Internal messages are not available from history\n          aiMessageId: (message.id as string) ?? null,\n          parentId: null,\n          depth: 0,\n          startedAt: null,\n          completedAt: isComplete ? new Date() : null,\n        };\n\n        this.subagents.set(toolCall.id, execution);\n        hasChanges = true;\n      }\n    }\n\n    if (hasChanges) {\n      this.onSubagentChange?.();\n    }\n  }\n\n  /**\n   * Check if any subagents are currently tracked.\n   */\n  hasSubagents(): boolean {\n    return this.subagents.size > 0;\n  }\n}\n"],"mappings":";;;;;;;;AAkBA,MAAM,8BAA8B,CAAC,OAAO;;;;;;;;;;AAW5C,SAAgB,oBACd,WACS;AACT,KAAI,CAAC,UAAW,QAAO;AAGvB,KAAI,OAAO,cAAc,SACvB,QAAO,UAAU,SAAS,SAAS;AAIrC,QAAO,UAAU,MAAM,MAAM,EAAE,WAAW,SAAS,CAAC;;;;;;;;;;;AAYtD,SAAgB,+BACd,WACoB;AACpB,KAAI,CAAC,aAAa,UAAU,WAAW,EAAG,QAAO;AAGjD,MAAK,MAAM,WAAW,UACpB,KAAI,QAAQ,WAAW,SAAS,CAC9B,QAAO,QAAQ,MAAM,EAAE;;;;;;;;;AAc7B,SAAgB,4BACd,WACQ;AACR,KAAI,CAAC,UAAW,QAAO;AACvB,QAAO,UAAU,QAAQ,MAAM,EAAE,WAAW,SAAS,CAAC,CAAC;;;;;;;;;;;AAYzD,SAAgB,6BACd,WACe;AACf,KAAI,CAAC,aAAa,UAAU,SAAS,EAAG,QAAO;CAE/C,MAAM,eAAe,UAAU,QAAQ,MAAM,EAAE,WAAW,SAAS,CAAC;AACpE,KAAI,aAAa,SAAS,EAAG,QAAO;AAGpC,QAAO,aAAa,aAAa,SAAS,IAAI,MAAM,EAAE,IAAI;;;;;;;;AAkD5D,IAAa,kBAAb,MAAyD;CACvD,AAAQ,4BAAY,IAAI,KAA2C;;;;;;CAOnE,AAAQ,wCAAwB,IAAI,KAAqB;;;;;CAMzD,AAAQ,iCAAiB,IAAI,KAAqB;;;;;;CAOlD,AAAQ,kCAAkB,IAAI,KAAkC;CAEhE,AAAQ;CAER,AAAQ;CAER,YAAY,SAAkC;AAC5C,OAAK,oBAAoB,IAAI,IAC3B,SAAS,qBAAqB,4BAC/B;AACD,OAAK,mBAAmB,SAAS;;;;;CAMnC,AAAQ,kBAAkB,YAAyC;EACjE,IAAI,UAAU,KAAK,gBAAgB,IAAI,WAAW;AAClD,MAAI,CAAC,SAAS;AACZ,aAAU,IAAI,qBAAqB;AACnC,QAAK,gBAAgB,IAAI,YAAY,QAAQ;;AAE/C,SAAO;;;;;;CAOT,AAAQ,uBAAuB,YAAyC;EACtE,MAAM,UAAU,KAAK,gBAAgB,IAAI,WAAW;AACpD,MAAI,CAAC,QAAS,QAAO,EAAE;EAGvB,MAAM,WAAgC,EAAE;AACxC,OAAK,MAAM,SAAS,OAAO,OAAO,QAAQ,OAAO,CAC/C,KAAI,MAAM,MACR,UAAS,KAAK,cAAc,MAAM,MAAM,CAAsB;AAGlE,SAAO;;;;;;CAOT,AAAQ,qBACN,MAC4D;EAC5D,MAAM,EAAE,aAAa;EACrB,MAAM,eAAe,wBAAkC,SAAS;AAEhE,SAAO;GACL,GAAG;GAEH,WAAW,KAAK,WAAW;GAG3B,WAAW;GAGX,eACE,YACmC;AACnC,WAAO,aAAa,QAAQ,OAAO,GAAG,UAAU,OAAO,QAAQ,GAAG;;GAIpE,WAAW;GACX,YAAY,EAAE;GAGd,2BAAW,IAAI,KAGZ;GACH,iBAAiB,EAAE;GACnB,mBAAmB;GACnB,0BAA0B,EAAE;GAC5B,6BAA6B,EAAE;GAChC;;;;;;CAOH,2BAA2B,aAA6B;AACtD,SAAO,KAAK,sBAAsB,IAAI,YAAY,IAAI;;;;;;;;;;;;;;;CAgBxD,wBACE,aACA,aACoB;AAEpB,MAAI,KAAK,sBAAsB,IAAI,YAAY,CAC7C,QAAO,KAAK,sBAAsB,IAAI,YAAY;EAIpD,MAAM,oBAAoB,IAAI,IAAI,KAAK,sBAAsB,QAAQ,CAAC;EAGtE,MAAM,oBAAoB,eAA+B;AACvD,QAAK,sBAAsB,IAAI,aAAa,WAAW;GAEvD,MAAM,WAAW,KAAK,UAAU,IAAI,WAAW;AAC/C,OAAI,YAAY,SAAS,WAAW,WAAW;AAC7C,SAAK,UAAU,IAAI,YAAY;KAC7B,GAAG;KACH,QAAQ;KACR,WAAW,CAAC,YAAY;KACxB,2BAAW,IAAI,MAAM;KACtB,CAAC;AACF,SAAK,oBAAoB;;AAE3B,UAAO;;AAIT,OAAK,MAAM,CAAC,YAAY,aAAa,KAAK,UACxC,MACG,SAAS,WAAW,aAAa,SAAS,WAAW,cACtD,CAAC,kBAAkB,IAAI,WAAW,IAClC,SAAS,SAAS,KAAK,gBAAgB,YAEvC,QAAO,iBAAiB,WAAW;AAKvC,OAAK,MAAM,CAAC,YAAY,aAAa,KAAK,UACxC,MACG,SAAS,WAAW,aAAa,SAAS,WAAW,cACtD,CAAC,kBAAkB,IAAI,WAAW,EAClC;GACA,MAAM,eAAe,SAAS,SAAS,KAAK,eAAe;AAC3D,OACG,gBAAgB,YAAY,SAAS,aAAa,IAClD,gBAAgB,aAAa,SAAS,YAAY,EACnD;AAEA,QAAI,YAAY,SAAS,aAAa,OACpC,MAAK,UAAU,IAAI,YAAY;KAC7B,GAAG;KACH,UAAU;MACR,GAAG,SAAS;MACZ,MAAM;OACJ,GAAG,SAAS,SAAS;OACrB;OACD;MACF;KACF,CAAC;AAEJ,WAAO,iBAAiB,WAAW;;;AAMzC,MAAI,YACF,MAAK,eAAe,IAAI,aAAa,YAAY;;;;;CAQrD,mBAAmB,UAA2B;AAC5C,SAAO,KAAK,kBAAkB,IAAI,SAAS;;;;;;CAO7C,AAAQ,oBAAoB,MAAwB;AAElD,MAAI,CAAC,QAAQ,OAAO,SAAS,SAC3B,QAAO;AAIT,MAAI,KAAK,SAAS,EAChB,QAAO;AAKT,MAAI,CAAC,2BAA2B,KAAK,KAAK,CACxC,QAAO;AAIT,MAAI,KAAK,SAAS,GAChB,QAAO;AAGT,SAAO;;;;;;;;;;;;;;CAeT,AAAQ,gBAAgB,UAAiD;AAGvE,SAAO,SAAS,WAAW,aAAa,SAAS,WAAW;;;;;;CAO9D,AAAQ,eACN,MAC4D;EAE5D,MAAM,WAAW,KAAK,uBAAuB,KAAK,GAAG;AACrD,SAAO,KAAK,qBAAqB;GAC/B,GAAG;GACH;GACD,CAAC;;;;;;CAOJ,eAGE;EACA,MAAM,yBAAS,IAAI,KAGhB;AACH,OAAK,MAAM,CAAC,IAAI,aAAa,KAAK,UAChC,KAAI,KAAK,gBAAgB,SAAS,CAChC,QAAO,IAAI,IAAI,KAAK,eAAe,SAAS,CAAC;AAGjD,SAAO;;;;;;CAOT,qBAGI;AACF,SAAO,CAAC,GAAG,KAAK,UAAU,QAAQ,CAAC,CAChC,QAAQ,MAAM,EAAE,WAAW,aAAa,KAAK,gBAAgB,EAAE,CAAC,CAChE,KAAK,MAAM,KAAK,eAAe,EAAE,CAAC;;;;;CAMvC,YACE,YACwE;EACxE,MAAM,WAAW,KAAK,UAAU,IAAI,WAAW;AAC/C,SAAO,WAAW,KAAK,eAAe,SAAS,GAAG;;;;;CAMpD,mBACE,MAC8D;AAC9D,SAAO,CAAC,GAAG,KAAK,UAAU,QAAQ,CAAC,CAChC,QAAQ,MAAM,EAAE,SAAS,KAAK,kBAAkB,KAAK,CACrD,KAAK,MAAM,KAAK,eAAe,EAAE,CAAC;;;;;;;;CASvC,sBACE,WAC8D;AAC9D,SAAO,CAAC,GAAG,KAAK,UAAU,QAAQ,CAAC,CAChC,QAAQ,MAAM,EAAE,gBAAgB,aAAa,KAAK,gBAAgB,EAAE,CAAC,CACrE,KAAK,MAAM,KAAK,eAAe,EAAE,CAAC;;;;;;CAOvC,AAAQ,UACN,MACyB;AACzB,MAAI,CAAC,KAAM,QAAO,EAAE;AACpB,MAAI,OAAO,SAAS,SAClB,KAAI;AACF,UAAO,KAAK,MAAM,KAAK;UACjB;AACN,UAAO,EAAE;;AAGb,SAAO;;;;;;;;;;;CAYT,sBACE,WAKA,aACM;EACN,IAAI,aAAa;AAEjB,OAAK,MAAM,YAAY,WAAW;AAChC,OAAI,CAAC,SAAS,GAAI;AAClB,OAAI,CAAC,KAAK,mBAAmB,SAAS,KAAK,CAAE;GAG7C,MAAM,aAAa,KAAK,UAAU,SAAS,KAAK;GAIhD,MAAM,eAAe,KAAK,oBAAoB,WAAW,cAAc;GAGvE,MAAM,WAAW,KAAK,UAAU,IAAI,SAAS,GAAG;AAChD,OAAI,UAAU;IAEZ,MAAM,UAAW,WAAW,iBAA4B;IACxD,MAAM,UAAU,SAAS,SAAS,KAAK,iBAAiB;IACxD,MAAM,UAAW,WAAW,eAA0B;IACtD,MAAM,UAAU,SAAS,SAAS,KAAK,eAAe;IAItD,MAAM,mBADiB,KAAK,oBAAoB,QAAQ,IAEpC,QAAQ,SAAS,QAAQ;IAC7C,MAAM,mBAAmB,QAAQ,SAAS,QAAQ;AAElD,QAAI,oBAAoB,kBAAkB;AACxC,UAAK,UAAU,IAAI,SAAS,IAAI;MAC9B,GAAG;MACH,UAAU;OACR,GAAG,SAAS;OACZ,MAAM;QACJ,GAAG,SAAS,SAAS;QACrB,GAAG;QACH,aAAa,mBAAmB,UAAU;QAC1C,eAAe,mBAAmB,UAAU;QAC7C;OACF;MACF,CAAC;AACF,kBAAa;;AAEf;;AAKF,OAAI,CAAC,aACH;GAGF,MAAM,mBAAqC;IACzC,IAAI,SAAS;IACb,MAAM,SAAS;IACf,MAAM;KACJ,aAAa,WAAW;KACxB,eAAe,WAAW;KAC1B,GAAG;KACJ;IACF;GAED,MAAM,YAA0C;IAC9C,IAAI,SAAS;IACb,UAAU;IACV,QAAQ;IACR,QAAQ,EAAE;IACV,QAAQ;IACR,OAAO;IACP,WAAW,EAAE;IACb,UAAU,EAAE;IACZ,aAAa,eAAe;IAC5B,UAAU;IACV,OAAO;IACP,WAAW;IACX,aAAa;IACd;AAED,QAAK,UAAU,IAAI,SAAS,IAAI,UAAU;AAE1C,QAAK,kBAAkB,SAAS,GAAG;AACnC,gBAAa;;AAIf,MAAI,YAAY;AACd,QAAK,qBAAqB;AAC1B,QAAK,oBAAoB;;;;;;CAO7B,AAAQ,sBAA4B;AAClC,MAAI,KAAK,eAAe,SAAS,EAAG;AAGpC,OAAK,MAAM,CAAC,aAAa,gBAAgB,KAAK,gBAAgB;AAE5D,OAAI,KAAK,sBAAsB,IAAI,YAAY,EAAE;AAC/C,SAAK,eAAe,OAAO,YAAY;AACvC;;AAKF,OADgB,KAAK,wBAAwB,aAAa,YAAY,CAEpE,MAAK,eAAe,OAAO,YAAY;;;;;;;;;;;;CAc7C,YACE,YACA,SAGM;EACN,MAAM,WAAW,KAAK,UAAU,IAAI,WAAW;AAC/C,MAAI,CAAC,SAAU;EAEf,MAAM,YAAY,SAAS,aAAa,SAAS;AAEjD,OAAK,UAAU,IAAI,YAAY;GAC7B,GAAG;GACH,QAAQ;GACR;GACA,UACE,SAAS,YAAY,6BAA6B,UAAU,IAAI;GAClE,OAAO,SAAS,SAAS,4BAA4B,UAAU;GAC/D,WAAW,SAAS,6BAAa,IAAI,MAAM;GAC5C,CAAC;AAEF,OAAK,oBAAoB;;;;;;;;;CAU3B,yBAAyB,aAAqB,WAA4B;EACxE,MAAM,aAAa,KAAK,2BAA2B,YAAY;AAC/D,OAAK,YAAY,YAAY,EAAE,WAAW,CAAC;;;;;;;;;;;;;CAc7C,qBACE,aACA,YACA,UACM;AAGN,MAAI,WAAW,SAAS,WAAW,OAAO,WAAW,YAAY,SAC/D,MAAK,wBAAwB,aAAa,WAAW,QAAQ;EAI/D,MAAM,aAAa,KAAK,2BAA2B,YAAY;EAC/D,MAAM,WAAW,KAAK,UAAU,IAAI,WAAW;AAM/C,MAAI,CAAC,SACH;AAQF,MAHgB,KAAK,kBAAkB,WAAW,CACxB,IAAI,YAAY,SAAS,CAIjD,KAAI,WAAW,SAAS,KACtB,MAAK,UAAU,IAAI,YAAY;GAC7B,GAAG;GACH,QAAQ;GACR,WAAW,SAAS,6BAAa,IAAI,MAAM;GAE3C,UAAU,KAAK,uBAAuB,WAAW;GAClD,CAAC;MAGF,MAAK,UAAU,IAAI,YAAY;GAC7B,GAAG;GACH,UAAU,KAAK,uBAAuB,WAAW;GAClD,CAAC;AAIN,OAAK,oBAAoB;;;;;;;;;;;;CAa3B,qBACE,aACA,QACM;EAEN,MAAM,aAAa,KAAK,2BAA2B,YAAY;EAC/D,MAAM,WAAW,KAAK,UAAU,IAAI,WAAW;AAE/C,MAAI,CAAC,SACH;AAGF,OAAK,UAAU,IAAI,YAAY;GAC7B,GAAG;GACH;GACA,QAAQ,SAAS,WAAW,YAAY,YAAY,SAAS;GAC7D,WAAW,SAAS,6BAAa,IAAI,MAAM;GAC5C,CAAC;AAEF,OAAK,oBAAoB;;;;;;;;;;;CAY3B,SACE,YACA,QACA,SAA+B,YACzB;EACN,MAAM,WAAW,KAAK,UAAU,IAAI,WAAW;AAC/C,MAAI,CAAC,SAAU;AAEf,OAAK,UAAU,IAAI,YAAY;GAC7B,GAAG;GACH;GACA,QAAQ,WAAW,aAAa,SAAS;GACzC,OAAO,WAAW,UAAU,SAAS;GACrC,6BAAa,IAAI,MAAM;GACxB,CAAC;AAEF,OAAK,oBAAoB;;;;;CAM3B,QAAc;AACZ,OAAK,UAAU,OAAO;AACtB,OAAK,sBAAsB,OAAO;AAClC,OAAK,gBAAgB,OAAO;AAC5B,OAAK,eAAe,OAAO;AAC3B,OAAK,oBAAoB;;;;;;;;;CAU3B,mBACE,YACA,SACA,SAA8B,WACxB;AAEN,MAAI,CADa,KAAK,UAAU,IAAI,WAAW,CAChC;AAEf,OAAK,SACH,YACA,SACA,WAAW,YAAY,aAAa,QACrC;;;;;;;;;;;;;;;;;;;;;;;;CAyBH,wBACE,UACA,SACM;AAEN,MAAI,SAAS,mBAAmB,KAAK,UAAU,OAAO,EACpD;EAIF,MAAM,8BAAc,IAAI,KAGrB;AAEH,OAAK,MAAM,WAAW,SACpB,KAAI,QAAQ,SAAS,UAAU,kBAAkB,SAAS;GACxD,MAAM,aAAa,QAAQ;GAC3B,MAAM,UACJ,OAAO,QAAQ,YAAY,WACvB,QAAQ,UACR,KAAK,UAAU,QAAQ,QAAQ;GACrC,MAAM,SACJ,YAAY,WAAW,QAAQ,WAAW,UACtC,UACA;AACN,eAAY,IAAI,YAAY;IAAE;IAAS;IAAQ,CAAC;;EAKpD,IAAI,aAAa;AAEjB,OAAK,MAAM,WAAW,UAAU;AAC9B,OACE,QAAQ,SAAS,QACjB,EAAE,gBAAgB,YAClB,CAAC,MAAM,QAAQ,QAAQ,WAAW,CAElC;AAGF,QAAK,MAAM,YAAY,QAAQ,YAAY;AACzC,QAAI,CAAC,SAAS,GAAI;AAClB,QAAI,CAAC,KAAK,mBAAmB,SAAS,KAAK,CAAE;AAG7C,QAAI,KAAK,UAAU,IAAI,SAAS,GAAG,CAAE;IAGrC,MAAM,aAAa,KAAK,UAAU,SAAS,KAAK;AAGhD,QAAI,CAAC,KAAK,oBAAoB,WAAW,cAAc,CAAE;IAGzD,MAAM,mBAAqC;KACzC,IAAI,SAAS;KACb,MAAM,SAAS;KACf,MAAM;MACJ,aAAa,WAAW;MACxB,eAAe,WAAW;MAC1B,GAAG;MACJ;KACF;IAGD,MAAM,aAAa,YAAY,IAAI,SAAS,GAAG;IAC/C,MAAM,aAAa,CAAC,CAAC;IAErB,MAAM,SAAyB,aAC3B,WAAW,WAAW,UACpB,UACA,aACF;IAGJ,MAAM,YAA0C;KAC9C,IAAI,SAAS;KACb,UAAU;KACV;KACA,QAAQ,EAAE;KACV,QACE,cAAc,WAAW,aAAa,WAAW,UAAU;KAC7D,OAAO,cAAc,WAAW,UAAU,WAAW,UAAU;KAC/D,WAAW,EAAE;KACb,UAAU,EAAE;KACZ,aAAc,QAAQ,MAAiB;KACvC,UAAU;KACV,OAAO;KACP,WAAW;KACX,aAAa,6BAAa,IAAI,MAAM,GAAG;KACxC;AAED,SAAK,UAAU,IAAI,SAAS,IAAI,UAAU;AAC1C,iBAAa;;;AAIjB,MAAI,WACF,MAAK,oBAAoB;;;;;CAO7B,eAAwB;AACtB,SAAO,KAAK,UAAU,OAAO"}

package/dist/ui/types.d.cts

@@ -7,22 +7,22 @@ import { BagTemplate } from "../types.template.cjs";
 import { InferInteropZodInput } from "@langchain/core/utils/types";
 
 //#region src/ui/types.d.ts
-
 /**
  * Represents a tool call that initiated a subagent.
+ *
+ * @template SubagentName - The subagent name type. When inferred from a
+ *   DeepAgent, this is a union of all subagent names (e.g. `"researcher" | "writer"`),
+ *   making `args.subagent_type` a typed discriminant.
  */
-interface SubagentToolCall {
+interface SubagentToolCall<SubagentName extends string = string> {
   /** The tool call ID */
   id: string;
   /** The name of the tool (typically "task") */
   name: string;
   /** The arguments passed to the tool */
   args: {
-    /** The task description for the subagent */
-    description?: string;
-    /** The type of subagent to use */
-    subagent_type?: string;
-    /** Additional custom arguments */
+    /** The task description for the subagent */description?: string; /** The type of subagent to use */
+    subagent_type?: SubagentName; /** Additional custom arguments */
     [key: string]: unknown;
   };
 }
@@ -104,18 +104,18 @@ interface StreamBase<StateType = Record<string, unknown>, ToolCall = DefaultTool
    * All currently active and completed subagent streams.
    * Keyed by tool call ID for easy lookup.
    */
-  subagents: Map<string, SubagentStream<SubagentStates[keyof SubagentStates], ToolCall>>;
+  subagents: Map<string, SubagentStreamInterface<SubagentStates[keyof SubagentStates], ToolCall, keyof SubagentStates & string>>;
   /**
    * Currently active subagents (where status === "running").
    */
-  activeSubagents: SubagentStream<SubagentStates[keyof SubagentStates], ToolCall>[];
+  activeSubagents: SubagentStreamInterface<SubagentStates[keyof SubagentStates], ToolCall, keyof SubagentStates & string>[];
   /**
    * Get subagent stream by tool call ID.
    *
    * @param toolCallId - The tool call ID that initiated the subagent.
    * @returns The subagent stream, or undefined if not found.
    */
-  getSubagent: (toolCallId: string) => SubagentStream<SubagentStates[keyof SubagentStates], ToolCall> | undefined;
+  getSubagent: (toolCallId: string) => SubagentStreamInterface<SubagentStates[keyof SubagentStates], ToolCall, keyof SubagentStates & string> | undefined;
   /**
    * Get all subagents of a specific type.
    * When called with a literal type name that matches a key in SubagentStates,
@@ -133,8 +133,8 @@ interface StreamBase<StateType = Record<string, unknown>, ToolCall = DefaultTool
    * ```
    */
   getSubagentsByType: {
-    <TName extends keyof SubagentStates & string>(type: TName): SubagentStream<SubagentStates[TName], ToolCall>[];
-    (type: string): SubagentStream<Record<string, unknown>, ToolCall>[];
+    <TName extends keyof SubagentStates & string>(type: TName): SubagentStreamInterface<SubagentStates[TName], ToolCall, TName>[];
+    (type: string): SubagentStreamInterface<Record<string, unknown>, ToolCall>[];
   };
   /**
    * Get all subagents triggered by a specific AI message.
@@ -160,36 +160,30 @@ interface StreamBase<StateType = Record<string, unknown>, ToolCall = DefaultTool
    * ))}
    * ```
    */
-  getSubagentsByMessage: (messageId: string) => SubagentStream<SubagentStates[keyof SubagentStates], ToolCall>[];
+  getSubagentsByMessage: (messageId: string) => SubagentStreamInterface<SubagentStates[keyof SubagentStates], ToolCall, keyof SubagentStates & string>[];
 }
 /**
- * Represents a single subagent stream.
+ * Base interface for a single subagent stream.
  * Tracks the lifecycle of a subagent from invocation to completion.
  *
  * Extends StreamBase to share common properties with UseStream,
  * allowing subagents to be treated similarly to the main stream.
  *
+ * Prefer using {@link SubagentStream} which supports passing an agent type
+ * directly for automatic type inference.
+ *
  * @template StateType - The state type of the subagent. Defaults to Record<string, unknown>
  *   since different subagents may have different state types. Can be narrowed using
  *   DeepAgent type helpers like `InferSubagentByName` when the specific subagent is known.
  * @template ToolCall - The type of tool calls in messages.
- *
- * @example
- * ```typescript
- * // Default usage with unknown state
- * const subagent: SubagentStream = stream.getSubagent("call_123");
- *
- * // Narrowed state type when subagent type is known
- * type ResearcherState = { research_notes: string };
- * const researcher = stream.getSubagent("call_123") as SubagentStream<ResearcherState>;
- * console.log(researcher.values.research_notes);
- * ```
+ * @template SubagentName - The subagent name union type. When inferred from a DeepAgent,
+ *   enables typed `toolCall.args.subagent_type`.
  */
-interface SubagentStream<StateType = Record<string, unknown>, ToolCall = DefaultToolCall> extends StreamBase<StateType, ToolCall> {
+interface SubagentStreamInterface<StateType = Record<string, unknown>, ToolCall = DefaultToolCall, SubagentName extends string = string> extends StreamBase<StateType, ToolCall> {
   /** Unique identifier (the tool call ID) */
   id: string;
   /** The tool call that invoked this subagent */
-  toolCall: SubagentToolCall;
+  toolCall: SubagentToolCall<SubagentName>;
   /** Current execution status */
   status: SubagentStatus;
   /** Final result content (when complete) */
@@ -205,6 +199,34 @@ interface SubagentStream<StateType = Record<string, unknown>, ToolCall = Default
   /** When the subagent completed */
   completedAt: Date | null;
 }
+/**
+ * Represents a single subagent stream.
+ *
+ * Supports two usage patterns:
+ *
+ * 1. **Agent type inference** (recommended): Pass a DeepAgent type directly and
+ *    let TypeScript infer the correct state and tool call types.
+ *
+ * ```typescript
+ * import type { agent } from "./agent";
+ *
+ * // Automatically infers state and tool call types from the agent
+ * const subagent: SubagentStream<typeof agent> = ...;
+ * ```
+ *
+ * 2. **Explicit generics**: Pass state and tool call types manually.
+ *
+ * ```typescript
+ * type ResearcherState = { research_notes: string };
+ * const researcher: SubagentStream<ResearcherState, MyToolCall> = ...;
+ * ```
+ *
+ * @template T - Either a DeepAgent/Agent type for automatic inference,
+ *   or a state type (Record) for explicit typing. Defaults to Record<string, unknown>.
+ * @template ToolCall - The type of tool calls in messages.
+ *   Only used when T is a state type. Defaults to DefaultToolCall.
+ */
+type SubagentStream<T = Record<string, unknown>, ToolCall = DefaultToolCall> = IsDeepAgentLike<T> extends true ? SubagentStreamInterface<SubagentStateMap<T, InferAgentToolCalls<T>>[InferSubagentNames<T>], InferAgentToolCalls<T>, InferSubagentNames<T>> : IsAgentLike<T> extends true ? SubagentStreamInterface<InferAgentState<T>, InferAgentToolCalls<T>> : SubagentStreamInterface<T, ToolCall>;
 /**
  * Minimal interface matching the structure of AgentTypeConfig from @langchain/langgraph.
  * This allows type inference from ReactAgent without requiring the langchain dependency.
@@ -765,16 +787,6 @@ interface UseStreamOptions<StateType extends Record<string, unknown> = Record<st
    */
   throttle?: number | boolean;
 }
-/**
- * Union of all stream options types.
- *
- * Used internally by the implementation to accept any options type.
- * This allows the implementation functions to handle options from
- * any agent type while maintaining type safety at the public API level.
- *
- * @internal
- */
-
 interface RunMetadataStorage {
   getItem(key: `lg:stream:${string}`): string | null;
   setItem(key: `lg:stream:${string}`, value: string): void;
@@ -846,17 +858,7 @@ interface UseStreamTransport<StateType extends Record<string, unknown> = Record<
 type UseStreamCustomOptions<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> = Pick<UseStreamOptions<StateType, Bag>, "messagesKey" | "threadId" | "onThreadId" | "onError" | "onCreated" | "onUpdateEvent" | "onCustomEvent" | "onMetadataEvent" | "onLangChainEvent" | "onDebugEvent" | "onCheckpointEvent" | "onTaskEvent" | "onStop" | "initialValues" | "throttle"> & {
   transport: UseStreamTransport<StateType, Bag>;
 };
-/**
- * Union of all custom stream options types.
- *
- * Used internally by the implementation to accept any custom options type.
- * This allows the implementation functions to handle options from
- * any agent type while maintaining type safety at the public API level.
- *
- * @internal
- */
-
 type CustomSubmitOptions<StateType extends Record<string, unknown> = Record<string, unknown>, ConfigurableType extends Record<string, unknown> = Record<string, unknown>> = Pick<SubmitOptions<StateType, ConfigurableType>, "optimisticValues" | "context" | "command" | "config">;
 //#endregion
-export { AgentTypeConfigLike, BaseSubagentState, CompiledSubAgentLike, CustomSubmitOptions, DeepAgentTypeConfigLike, DefaultSubagentStates, ExtractAgentConfig, ExtractDeepAgentConfig, ExtractSubAgentMiddleware, GetConfigurableType, GetInterruptType, GetToolCallsType, GetUpdateType, InferAgentState, InferAgentToolCalls, InferDeepAgentSubagents, InferSubagentByName, InferSubagentNames, InferSubagentState, IsAgentLike, IsDeepAgentLike, MessageMetadata, RunCallbackMeta, StreamBase, SubAgentLike, SubagentStateMap, SubagentStatus, SubagentStream, SubagentToolCall, SubmitOptions, UseStreamCustomOptions, UseStreamOptions, UseStreamThread, UseStreamTransport };
+export { AgentTypeConfigLike, BaseSubagentState, CompiledSubAgentLike, CustomSubmitOptions, DeepAgentTypeConfigLike, DefaultSubagentStates, ExtractAgentConfig, ExtractDeepAgentConfig, ExtractSubAgentMiddleware, GetConfigurableType, GetInterruptType, GetToolCallsType, GetUpdateType, InferAgentState, InferAgentToolCalls, InferDeepAgentSubagents, InferSubagentByName, InferSubagentNames, InferSubagentState, IsAgentLike, IsDeepAgentLike, MessageMetadata, RunCallbackMeta, StreamBase, SubAgentLike, SubagentStateMap, SubagentStatus, SubagentStream, SubagentStreamInterface, SubagentToolCall, SubmitOptions, UseStreamCustomOptions, UseStreamOptions, UseStreamThread, UseStreamTransport };
 //# sourceMappingURL=types.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":["InferInteropZodInput","Client","ClientConfig","ThreadState","Config","Checkpoint","Metadata","Interrupt","Command","MultitaskStrategy","OnCompletionBehavior","DisconnectMode","Durability","UpdatesStreamEvent","CustomStreamEvent","MetadataStreamEvent","EventsStreamEvent","DebugStreamEvent","CheckpointsStreamEvent","TasksStreamEvent","StreamMode","DefaultToolCall","AIMessage","Message","ToolCallWithResult","BagTemplate","SubagentToolCall","SubagentStatus","DefaultSubagentStates","Record","StreamBase","StateType","ToolCall","InterruptType","SubagentStates","SubagentStream","Map","TName","Date","AgentTypeConfigLike","IsAgentLike","T","ExtractAgentConfig","AgentMiddlewareLike","TSchema","TContextSchema","TFullContext","TTools","InferMiddlewareState","S","IsAny","InferMiddlewareStatesFromArray","First","Rest","U","BaseAgentState","InferAgentState","InferAgentToolCalls","RunOutput","InferToolInput","Args","IsLiteralString","ToolCallFromAgentTool","N","Tool","SubAgentLike","CompiledSubAgentLike","DeepAgentTypeConfigLike","IsDeepAgentLike","ExtractDeepAgentConfig","ExtractSubAgentMiddleware","M","InferDeepAgentSubagents","InferSubagentByName","SA","BaseSubagentState","InferSubagentState","InferSubagentNames","SubagentStateMap","K","ExtractToolCallFromMessageUnion","TC","ExtractToolCallsFromState","Messages","MessageMetadata","GetUpdateType","Bag","Partial","GetConfigurableType","GetInterruptType","GetCustomEventType","GetToolCallsType","RunCallbackMeta","UseStreamThread","Promise","UseStreamOptions","RunMetadataStorage","AnyStreamOptions","ConfigWithConfigurable","ConfigurableType","SubmitOptions","ContextType","Omit","Array","UseStreamTransport","AbortSignal","AsyncGenerator","UseStreamCustomOptions","Pick","AnyStreamCustomOptions","CustomSubmitOptions"],"sources":["../../src/ui/types.d.ts"],"sourcesContent":["import type { InferInteropZodInput } from \"@langchain/core/utils/types\";\nimport type { Client, ClientConfig } from \"../client.js\";\nimport type { ThreadState, Config, Checkpoint, Metadata, Interrupt } from \"../schema.js\";\nimport type { Command, MultitaskStrategy, OnCompletionBehavior, DisconnectMode, Durability } from \"../types.js\";\nimport type { UpdatesStreamEvent, CustomStreamEvent, MetadataStreamEvent, EventsStreamEvent, DebugStreamEvent, CheckpointsStreamEvent, TasksStreamEvent, StreamMode } from \"../types.stream.js\";\nimport type { DefaultToolCall, AIMessage, Message, ToolCallWithResult } from \"../types.messages.js\";\nimport type { BagTemplate } from \"../types.template.js\";\n/**\n * Represents a tool call that initiated a subagent.\n */\nexport interface SubagentToolCall {\n    /** The tool call ID */\n    id: string;\n    /** The name of the tool (typically \"task\") */\n    name: string;\n    /** The arguments passed to the tool */\n    args: {\n        /** The task description for the subagent */\n        description?: string;\n        /** The type of subagent to use */\n        subagent_type?: string;\n        /** Additional custom arguments */\n        [key: string]: unknown;\n    };\n}\n/**\n * The execution status of a subagent.\n *\n * - `\"pending\"` - The subagent has been invoked but hasn't started processing yet.\n *   This is the initial state when a tool call is detected but before any\n *   streaming events are received from the subgraph.\n *\n * - `\"running\"` - The subagent is actively executing and streaming updates.\n *   The subagent transitions to this state when the first update event is\n *   received from its namespace.\n *\n * - `\"complete\"` - The subagent has finished execution successfully.\n *   A tool message with the result has been received, and the `result`\n *   property contains the final output.\n *\n * - `\"error\"` - The subagent encountered an error during execution.\n *   The `error` property on the SubagentStream contains error details.\n */\nexport type SubagentStatus = \"pending\" | \"running\" | \"complete\" | \"error\";\n/**\n * Default subagent state map used when no specific subagent types are provided.\n * Maps any string key to Record<string, unknown>.\n */\nexport type DefaultSubagentStates = Record<string, Record<string, unknown>>;\n/**\n * Base interface for stream-like objects.\n * Contains common properties shared between UseStream and SubagentStream.\n *\n * @template StateType - The type of the stream's state values.\n * @template ToolCall - The type of tool calls in messages.\n * @template InterruptType - The type of interrupt values.\n * @template SubagentStates - A map of subagent names to their state types.\n *   Use `SubagentStateMap<typeof agent>` to infer from a DeepAgent.\n */\nexport interface StreamBase<StateType = Record<string, unknown>, ToolCall = DefaultToolCall, InterruptType = unknown, SubagentStates extends Record<string, unknown> = DefaultSubagentStates> {\n    /**\n     * The current state values of the stream.\n     */\n    values: StateType;\n    /**\n     * Last seen error from the stream.\n     */\n    error: unknown;\n    /**\n     * Whether the stream is currently running.\n     */\n    isLoading: boolean;\n    /**\n     * Messages accumulated during the stream.\n     */\n    messages: Message<ToolCall>[];\n    /**\n     * Tool calls paired with their results.\n     * Useful for rendering tool invocations and their outputs together.\n     */\n    toolCalls: ToolCallWithResult<ToolCall>[];\n    /**\n     * Get tool calls for a specific AI message.\n     *\n     * @param message - The AI message to get tool calls for.\n     * @returns Array of tool calls initiated by the message.\n     */\n    getToolCalls: (message: AIMessage<ToolCall>) => ToolCallWithResult<ToolCall>[];\n    /**\n     * Get the interrupt value for the stream if interrupted.\n     * Convenience alias for `interrupts[0]`.\n     */\n    interrupt: Interrupt<InterruptType> | 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<InterruptType>[];\n    /**\n     * All currently active and completed subagent streams.\n     * Keyed by tool call ID for easy lookup.\n     */\n    subagents: Map<string, SubagentStream<SubagentStates[keyof SubagentStates], ToolCall>>;\n    /**\n     * Currently active subagents (where status === \"running\").\n     */\n    activeSubagents: SubagentStream<SubagentStates[keyof SubagentStates], ToolCall>[];\n    /**\n     * Get subagent stream by tool call ID.\n     *\n     * @param toolCallId - The tool call ID that initiated the subagent.\n     * @returns The subagent stream, or undefined if not found.\n     */\n    getSubagent: (toolCallId: string) => SubagentStream<SubagentStates[keyof SubagentStates], ToolCall> | undefined;\n    /**\n     * Get all subagents of a specific type.\n     * When called with a literal type name that matches a key in SubagentStates,\n     * returns streams with properly inferred state types.\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     * ```ts\n     * // With DeepAgent type inference\n     * const stream = useStream<typeof agent>(...);\n     * const researchers = stream.getSubagentsByType(\"researcher\");\n     * // researchers[0].values is typed with ResearcherMiddleware state\n     * ```\n     */\n    getSubagentsByType: {\n        <TName extends keyof SubagentStates & string>(type: TName): SubagentStream<SubagentStates[TName], ToolCall>[];\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 the AI message\n     * (and therefore conversation turn) that spawned them.\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 after each 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 * Represents a single subagent stream.\n * Tracks the lifecycle of a subagent from invocation to completion.\n *\n * Extends StreamBase to share common properties with UseStream,\n * allowing subagents to be treated similarly to the main stream.\n *\n * @template StateType - The state type of the subagent. Defaults to Record<string, unknown>\n *   since different subagents may have different state types. Can be narrowed using\n *   DeepAgent type helpers like `InferSubagentByName` when the specific subagent is known.\n * @template ToolCall - The type of tool calls in messages.\n *\n * @example\n * ```typescript\n * // Default usage with unknown state\n * const subagent: SubagentStream = stream.getSubagent(\"call_123\");\n *\n * // Narrowed state type when subagent type is known\n * type ResearcherState = { research_notes: string };\n * const researcher = stream.getSubagent(\"call_123\") as SubagentStream<ResearcherState>;\n * console.log(researcher.values.research_notes);\n * ```\n */\nexport interface SubagentStream<StateType = Record<string, unknown>, ToolCall = DefaultToolCall> extends StreamBase<StateType, ToolCall> {\n    /** Unique identifier (the tool call ID) */\n    id: string;\n    /** The tool call that invoked this subagent */\n    toolCall: SubagentToolCall;\n    /** Current execution status */\n    status: SubagentStatus;\n    /** Final result content (when complete) */\n    result: string | null;\n    /** Namespace path for this subagent execution */\n    namespace: string[];\n    /** Tool call ID of parent subagent (for nested subagents) */\n    parentId: string | null;\n    /** Nesting depth (0 = called by main agent, 1 = called by subagent, etc.) */\n    depth: number;\n    /** When the subagent started */\n    startedAt: Date | null;\n    /** When the subagent completed */\n    completedAt: Date | null;\n}\n/**\n * Minimal interface matching the structure of AgentTypeConfig from @langchain/langgraph.\n * This allows type inference from ReactAgent without requiring the langchain dependency.\n */\nexport interface AgentTypeConfigLike {\n    Response: unknown;\n    State: unknown;\n    Context: unknown;\n    Middleware: unknown;\n    Tools: unknown;\n}\n/**\n * Check if a type is agent-like (has `~agentTypes` phantom property).\n * This property is present on `ReactAgent` instances created with `createAgent`.\n */\nexport type IsAgentLike<T> = T extends {\n    \"~agentTypes\": AgentTypeConfigLike;\n} ? true : false;\n/**\n * Extract the AgentTypeConfig from an agent-like type.\n *\n * @example\n * ```ts\n * const agent = createAgent({ ... });\n * type Config = ExtractAgentConfig<typeof agent>;\n * // Config is the AgentTypeConfig with Response, State, Context, Middleware, Tools\n * ```\n */\nexport type ExtractAgentConfig<T> = T extends {\n    \"~agentTypes\": infer Config;\n} ? Config extends AgentTypeConfigLike ? Config : never : never;\n/**\n * Minimal interface to structurally match AgentMiddleware from langchain.\n * We can't import AgentMiddleware due to circular dependencies, so we match\n * against its structure to extract type information.\n */\nexport interface AgentMiddlewareLike<TSchema = unknown, TContextSchema = unknown, TFullContext = unknown, TTools = unknown> {\n    name: string;\n    stateSchema?: TSchema;\n    \"~middlewareTypes\"?: {\n        Schema: TSchema;\n        ContextSchema: TContextSchema;\n        FullContext: TFullContext;\n        Tools: TTools;\n    };\n}\n/**\n * Helper type to extract state from a single middleware instance.\n * Uses structural matching against AgentMiddleware to extract the state schema\n * type parameter, similar to how langchain's InferMiddlewareState works.\n */\ntype InferMiddlewareState<T> = T extends AgentMiddlewareLike<infer TSchema, unknown, unknown, unknown> ? TSchema extends Record<string, any> ? InferInteropZodInput<TSchema> : {} : T extends {\n    stateSchema: infer S;\n} ? InferInteropZodInput<S> : {};\n/**\n * Helper type to detect if a type is `any`.\n * Uses the fact that `any` is both a subtype and supertype of all types.\n */\ntype IsAny<T> = 0 extends 1 & T ? true : false;\n/**\n * Helper type to extract and merge states from an array of middleware.\n * Recursively processes each middleware and intersects their state types.\n *\n * Handles both readonly and mutable arrays/tuples explicitly.\n *\n * @example\n * ```ts\n * type States = InferMiddlewareStatesFromArray<typeof middlewareArray>;\n * // Returns intersection of all middleware state types\n * ```\n */\nexport type InferMiddlewareStatesFromArray<T> = IsAny<T> extends true ? {} : T extends undefined | null ? {} : T extends readonly [] ? {} : T extends [] ? {} : T extends readonly [infer First, ...infer Rest extends readonly unknown[]] ? InferMiddlewareState<First> & InferMiddlewareStatesFromArray<Rest> : T extends [infer First, ...infer Rest extends unknown[]] ? InferMiddlewareState<First> & InferMiddlewareStatesFromArray<Rest> : T extends readonly (infer U)[] ? InferMiddlewareState<U> : T extends (infer U)[] ? InferMiddlewareState<U> : {};\n/**\n * Infer the complete merged state from an agent, including:\n * - The agent's own state schema (via State)\n * - All middleware states (via Middleware)\n *\n * This is the SDK equivalent of langchain's `InferAgentState` type.\n *\n * @example\n * ```ts\n * const agent = createAgent({\n *   middleware: [todoListMiddleware()],\n *   // ...\n * });\n *\n * type State = InferAgentState<typeof agent>;\n * // State includes { todos: Todo[], ... }\n * ```\n */\n/**\n * Base agent state that all agents have by default.\n * This includes the messages array which is fundamental to agent operation.\n * The ToolCall type parameter allows proper typing of tool calls in messages.\n */\ntype BaseAgentState<ToolCall = DefaultToolCall> = {\n    messages: Message<ToolCall>[];\n};\nexport type InferAgentState<T> = T extends {\n    \"~agentTypes\": unknown;\n} ? ExtractAgentConfig<T> extends never ? {} : BaseAgentState<InferAgentToolCalls<T>> & (ExtractAgentConfig<T>[\"State\"] extends undefined ? {} : InferInteropZodInput<ExtractAgentConfig<T>[\"State\"]>) & InferMiddlewareStatesFromArray<ExtractAgentConfig<T>[\"Middleware\"]> : T extends {\n    \"~RunOutput\": infer RunOutput;\n} ? RunOutput : T extends {\n    messages: unknown;\n} ? T : {};\n/**\n * Helper type to extract the input type from a DynamicStructuredTool's _call method.\n * This is more reliable than trying to infer from the schema directly because\n * DynamicStructuredTool has the input type baked into its _call signature.\n */\ntype InferToolInput<T> = T extends {\n    _call: (arg: infer Args, ...rest: any[]) => any;\n} ? Args : T extends {\n    schema: infer S;\n} ? InferInteropZodInput<S> : never;\n/**\n * Helper type to check if a type is a literal string (not generic `string`).\n * Returns true only for literal types like \"get_weather\", false for `string`.\n */\ntype IsLiteralString<T> = string extends T ? false : T extends string ? true : false;\n/**\n * Extract a tool call type from a single tool.\n * Works with tools created via `tool()` from `@langchain/core/tools`.\n *\n * This extracts the literal name type from DynamicStructuredTool's NameT parameter\n * and the args type from the _call method or schema's input property.\n *\n * Note: Only tools with literal string names (e.g., \"get_weather\") are included.\n * Tools with generic `name: string` are filtered out to ensure discriminated\n * union narrowing works correctly in TypeScript.\n */\ntype ToolCallFromAgentTool<T> = T extends {\n    name: infer N;\n} ? N extends string ? IsLiteralString<N> extends true ? InferToolInput<T> extends infer Args ? Args extends never ? never : Args extends Record<string, any> ? {\n    name: N;\n    args: Args;\n    id?: string;\n    type?: \"tool_call\";\n} : never : never : never : never : never;\n/**\n * Extract tool calls type from an agent's tools.\n * Converts the tools array to a discriminated union of tool calls.\n *\n * This handles both tuple types (e.g., `readonly [Tool1, Tool2]`) and\n * array-of-union types (e.g., `readonly (Tool1 | Tool2)[]`) which is how\n * `createAgent` captures tool types.\n *\n * @example\n * ```ts\n * const agent = createAgent({ tools: [getWeather, search], ... });\n * type ToolCalls = InferAgentToolCalls<typeof agent>;\n * // ToolCalls is:\n * // | { name: \"get_weather\"; args: { location: string }; id?: string }\n * // | { name: \"search\"; args: { query: string }; id?: string }\n * ```\n */\nexport type InferAgentToolCalls<T> = ExtractAgentConfig<T>[\"Tools\"] extends readonly (infer Tool)[] ? ToolCallFromAgentTool<Tool> extends never ? DefaultToolCall : ToolCallFromAgentTool<Tool> : DefaultToolCall;\n/**\n * Minimal interface matching the structure of a SubAgent from deepagents.\n * Used for structural type matching without importing deepagents.\n */\nexport interface SubAgentLike {\n    name: string;\n    description: string;\n    middleware?: readonly AgentMiddlewareLike[];\n}\n/**\n * Minimal interface matching the structure of a CompiledSubAgent from deepagents.\n * Used for structural type matching without importing deepagents.\n */\nexport interface CompiledSubAgentLike {\n    name: string;\n    description: string;\n    runnable: unknown;\n}\n/**\n * Minimal interface matching the structure of DeepAgentTypeConfig from deepagents.\n * Extends AgentTypeConfigLike to include subagent type information.\n */\nexport interface DeepAgentTypeConfigLike extends AgentTypeConfigLike {\n    Subagents: unknown;\n}\n/**\n * Check if a type is a DeepAgent (has `~deepAgentTypes` phantom property).\n * This property is present on DeepAgent instances created with `createDeepAgent`.\n */\nexport type IsDeepAgentLike<T> = T extends {\n    \"~deepAgentTypes\": DeepAgentTypeConfigLike;\n} ? true : false;\n/**\n * Extract the DeepAgentTypeConfig from a DeepAgent-like type.\n *\n * @example\n * ```ts\n * const agent = createDeepAgent({ subagents: [...] });\n * type Config = ExtractDeepAgentConfig<typeof agent>;\n * // Config includes { Subagents: [...] }\n * ```\n */\nexport type ExtractDeepAgentConfig<T> = T extends {\n    \"~deepAgentTypes\": infer Config;\n} ? Config extends DeepAgentTypeConfigLike ? Config : never : never;\n/**\n * Helper type to extract middleware from a SubAgent definition.\n * Handles both mutable and readonly middleware arrays.\n */\nexport type ExtractSubAgentMiddleware<T> = T extends {\n    middleware?: infer M;\n} ? M extends readonly AgentMiddlewareLike[] ? M : M extends AgentMiddlewareLike[] ? M : readonly [] : readonly [];\n/**\n * Extract the Subagents array type from a DeepAgent.\n *\n * @example\n * ```ts\n * const agent = createDeepAgent({ subagents: [researcher, writer] as const });\n * type Subagents = InferDeepAgentSubagents<typeof agent>;\n * // Subagents is the readonly tuple of subagent definitions\n * ```\n */\nexport type InferDeepAgentSubagents<T> = ExtractDeepAgentConfig<T> extends never ? never : ExtractDeepAgentConfig<T>[\"Subagents\"];\n/**\n * Helper type to extract a subagent by name from a DeepAgent.\n *\n * @typeParam T - The DeepAgent to extract from\n * @typeParam TName - The name of the subagent to extract\n *\n * @example\n * ```ts\n * const agent = createDeepAgent({\n *   subagents: [\n *     { name: \"researcher\", description: \"...\", middleware: [ResearchMiddleware] }\n *   ] as const,\n * });\n *\n * type Researcher = InferSubagentByName<typeof agent, \"researcher\">;\n * ```\n */\nexport type InferSubagentByName<T, TName extends string> = InferDeepAgentSubagents<T> extends readonly (infer SA)[] ? SA extends {\n    name: TName;\n} ? SA : never : never;\n/**\n * Base state type for subagents.\n * All subagents have at least a messages array, similar to the main agent.\n *\n * @template ToolCall - The tool call type for messages. Defaults to DefaultToolCall.\n */\nexport type BaseSubagentState<ToolCall = DefaultToolCall> = {\n    messages: Message<ToolCall>[];\n};\n/**\n * Infer the state type for a specific subagent by extracting and merging\n * its middleware state schemas, plus the base agent state (messages).\n *\n * @typeParam T - The DeepAgent to extract from\n * @typeParam TName - The name of the subagent\n * @typeParam ToolCall - The tool call type for messages. Defaults to DefaultToolCall.\n *\n * @example\n * ```ts\n * const agent = createDeepAgent({\n *   subagents: [\n *     { name: \"researcher\", middleware: [ResearchMiddleware] }\n *   ] as const,\n * });\n *\n * type ResearcherState = InferSubagentState<typeof agent, \"researcher\">;\n * // ResearcherState includes { messages: Message<ToolCall>[], ...ResearchMiddleware state }\n * ```\n */\nexport type InferSubagentState<T, TName extends string, ToolCall = DefaultToolCall> = InferSubagentByName<T, TName> extends never ? Record<string, unknown> : InferSubagentByName<T, TName> extends infer SA ? BaseSubagentState<ToolCall> & InferMiddlewareStatesFromArray<ExtractSubAgentMiddleware<SA>> : Record<string, unknown>;\n/**\n * Extract all subagent names as a string union from a DeepAgent.\n *\n * @example\n * ```ts\n * const agent = createDeepAgent({\n *   subagents: [\n *     { name: \"researcher\", ... },\n *     { name: \"writer\", ... }\n *   ] as const,\n * });\n *\n * type SubagentNames = InferSubagentNames<typeof agent>;\n * // SubagentNames = \"researcher\" | \"writer\"\n * ```\n */\nexport type InferSubagentNames<T> = InferDeepAgentSubagents<T> extends readonly (infer SA)[] ? SA extends {\n    name: infer N;\n} ? N extends string ? N : never : never : never;\n/**\n * Create a map of subagent names to their state types.\n * This is useful for type-safe `getSubagentsByType` calls.\n *\n * @typeParam T - The DeepAgent to extract from\n * @typeParam ToolCall - The tool call type for messages. Defaults to DefaultToolCall.\n *\n * @example\n * ```ts\n * const agent = createDeepAgent({\n *   subagents: [\n *     { name: \"researcher\", middleware: [ResearchMiddleware] },\n *     { name: \"writer\", middleware: [WriterMiddleware] }\n *   ] as const,\n * });\n *\n * type StateMap = SubagentStateMap<typeof agent>;\n * // StateMap = { researcher: ResearchState; writer: WriterState }\n * ```\n */\nexport type SubagentStateMap<T, ToolCall = DefaultToolCall> = {\n    [K in InferSubagentNames<T>]: InferSubagentState<T, K, ToolCall>;\n};\n/**\n * Extract the tool call type parameter from an AIMessage in a message union.\n * Returns `never` if the message is not an AIMessage or uses DefaultToolCall.\n *\n * The key distinction: custom tool calls have literal `name` types (e.g., \"get_weather\"),\n * while DefaultToolCall has `name: string`. We check if `string extends TC[\"name\"]` -\n * if true, it's DefaultToolCall; if false, it's a custom type with literal names.\n */\ntype ExtractToolCallFromMessageUnion<M> = M extends AIMessage<infer TC> ? TC extends {\n    name: infer N;\n} ? string extends N ? never : TC : never : never;\n/**\n * Extract the tool call type from a StateType's messages property.\n * This is the primary way to specify tool call types when using useStream.\n *\n * @example\n * ```ts\n * // Define state with typed messages\n * type MyToolCalls =\n *   | { name: \"get_weather\"; args: { location: string }; id?: string }\n *   | { name: \"search\"; args: { query: string }; id?: string };\n *\n * interface MyState {\n *   messages: Message<MyToolCalls>[];\n * }\n *\n * // ExtractToolCallsFromState<MyState> = MyToolCalls\n * ```\n */\nexport type ExtractToolCallsFromState<StateType extends Record<string, unknown>> = StateType extends {\n    messages: infer Messages;\n} ? Messages extends readonly (infer M)[] ? ExtractToolCallFromMessageUnion<M> : Messages extends (infer M)[] ? ExtractToolCallFromMessageUnion<M> : never : never;\nexport type MessageMetadata<StateType extends Record<string, unknown>> = {\n    /**\n     * The ID of the message used.\n     */\n    messageId: string;\n    /**\n     * The first thread state the message was seen in.\n     */\n    firstSeenState: ThreadState<StateType> | undefined;\n    /**\n     * The branch of the message.\n     */\n    branch: string | undefined;\n    /**\n     * The list of branches this message is part of.\n     * This is useful for displaying branching controls.\n     */\n    branchOptions: string[] | undefined;\n    /**\n     * Metadata sent alongside the message during run streaming.\n     * @remarks This metadata only exists temporarily in browser memory during streaming and is not persisted after completion.\n     */\n    streamMetadata: Record<string, unknown> | undefined;\n};\nexport type GetUpdateType<Bag extends BagTemplate, StateType extends Record<string, unknown>> = Bag extends {\n    UpdateType: unknown;\n} ? Bag[\"UpdateType\"] : Partial<StateType>;\nexport type GetConfigurableType<Bag extends BagTemplate> = Bag extends {\n    ConfigurableType: Record<string, unknown>;\n} ? Bag[\"ConfigurableType\"] : Record<string, unknown>;\nexport type GetInterruptType<Bag extends BagTemplate> = Bag extends {\n    InterruptType: unknown;\n} ? Bag[\"InterruptType\"] : unknown;\nexport type GetCustomEventType<Bag extends BagTemplate> = Bag extends {\n    CustomEventType: unknown;\n} ? Bag[\"CustomEventType\"] : unknown;\n/**\n * Extract the tool call type from a StateType's messages property.\n * This is the canonical way to get typed tool calls in useStream.\n *\n * Tool call types are now extracted from the messages property of StateType,\n * rather than being specified separately in the Bag.\n *\n * @example\n * ```ts\n * // Define state with typed messages\n * type MyToolCalls =\n *   | { name: \"get_weather\"; args: { location: string }; id?: string }\n *   | { name: \"search\"; args: { query: string }; id?: string };\n *\n * interface MyState {\n *   messages: Message<MyToolCalls>[];\n * }\n *\n * // GetToolCallsType<MyState> = MyToolCalls\n * ```\n */\nexport type GetToolCallsType<StateType extends Record<string, unknown>> = ExtractToolCallsFromState<StateType> extends never ? DefaultToolCall : ExtractToolCallsFromState<StateType>;\nexport interface RunCallbackMeta {\n    run_id: string;\n    thread_id: string;\n}\nexport interface UseStreamThread<StateType extends Record<string, unknown>> {\n    data: ThreadState<StateType>[] | null | undefined;\n    error: unknown;\n    isLoading: boolean;\n    mutate: (mutateId?: string) => Promise<ThreadState<StateType>[] | null | undefined>;\n}\nexport interface UseStreamOptions<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> {\n    /**\n     * The ID of the assistant to use.\n     */\n    assistantId: string;\n    /**\n     * Client used to send requests.\n     */\n    client?: Client;\n    /**\n     * The URL of the API to use.\n     */\n    apiUrl?: ClientConfig[\"apiUrl\"];\n    /**\n     * The API key to use.\n     */\n    apiKey?: ClientConfig[\"apiKey\"];\n    /**\n     * Custom call options, such as custom fetch implementation.\n     */\n    callerOptions?: ClientConfig[\"callerOptions\"];\n    /**\n     * Default headers to send with requests.\n     */\n    defaultHeaders?: ClientConfig[\"defaultHeaders\"];\n    /**\n     * Specify the key within the state that contains messages.\n     * Defaults to \"messages\".\n     *\n     * @default \"messages\"\n     */\n    messagesKey?: string;\n    /**\n     * Callback that is called when an error occurs.\n     */\n    onError?: (error: unknown, run: RunCallbackMeta | undefined) => void;\n    /**\n     * Callback that is called when the stream is finished.\n     */\n    onFinish?: (state: ThreadState<StateType>, run: RunCallbackMeta | undefined) => void;\n    /**\n     * Callback that is called when a new stream is created.\n     */\n    onCreated?: (run: RunCallbackMeta) => void;\n    /**\n     * Callback that is called when an update event is received.\n     */\n    onUpdateEvent?: (data: UpdatesStreamEvent<GetUpdateType<Bag, StateType>>[\"data\"], options: {\n        namespace: string[] | undefined;\n        mutate: (update: Partial<StateType> | ((prev: StateType) => Partial<StateType>)) => void;\n    }) => void;\n    /**\n     * Callback that is called when a custom event is received.\n     */\n    onCustomEvent?: (data: CustomStreamEvent<GetCustomEventType<Bag>>[\"data\"], options: {\n        namespace: string[] | undefined;\n        mutate: (update: Partial<StateType> | ((prev: StateType) => Partial<StateType>)) => void;\n    }) => void;\n    /**\n     * Callback that is called when a metadata event is received.\n     */\n    onMetadataEvent?: (data: MetadataStreamEvent[\"data\"]) => void;\n    /**\n     * Callback that is called when a LangChain event is received.\n     * @see https://langchain-ai.github.io/langgraph/cloud/how-tos/stream_events/#stream-graph-in-events-mode for more details.\n     */\n    onLangChainEvent?: (data: EventsStreamEvent[\"data\"]) => void;\n    /**\n     * Callback that is called when a debug event is received.\n     * @internal This API is experimental and subject to change.\n     */\n    onDebugEvent?: (data: DebugStreamEvent[\"data\"], options: {\n        namespace: string[] | undefined;\n    }) => void;\n    /**\n     * Callback that is called when a checkpoints event is received.\n     */\n    onCheckpointEvent?: (data: CheckpointsStreamEvent<StateType>[\"data\"], options: {\n        namespace: string[] | undefined;\n    }) => void;\n    /**\n     * Callback that is called when a tasks event is received.\n     */\n    onTaskEvent?: (data: TasksStreamEvent<StateType, GetUpdateType<Bag, StateType>>[\"data\"], options: {\n        namespace: string[] | undefined;\n    }) => void;\n    /**\n     * Callback that is called when the stream is stopped by the user.\n     * Provides a mutate function to update the stream state immediately\n     * without requiring a server roundtrip.\n     *\n     * @example\n     * ```typescript\n     * onStop: ({ mutate }) => {\n     *   mutate((prev) => ({\n     *     ...prev,\n     *     ui: prev.ui?.map(component =>\n     *       component.props.isLoading\n     *         ? { ...component, props: { ...component.props, stopped: true, isLoading: false }}\n     *         : component\n     *     )\n     *   }));\n     * }\n     * ```\n     */\n    onStop?: (options: {\n        mutate: (update: Partial<StateType> | ((prev: StateType) => Partial<StateType>)) => void;\n    }) => void;\n    /**\n     * The ID of the thread to fetch history and current values from.\n     */\n    threadId?: string | null;\n    /**\n     * Callback that is called when the thread ID is updated (ie when a new thread is created).\n     */\n    onThreadId?: (threadId: string) => void;\n    /** Will reconnect the stream on mount */\n    reconnectOnMount?: boolean | (() => RunMetadataStorage);\n    /**\n     * Initial values to display immediately when loading a thread.\n     * Useful for displaying cached thread data while official history loads.\n     * These values will be replaced when official thread data is fetched.\n     *\n     * Note: UI components from initialValues will render immediately if they're\n     * predefined in LoadExternalComponent's components prop, providing instant\n     * cached UI display without server fetches.\n     */\n    initialValues?: StateType | null;\n    /**\n     * Whether to fetch the history of the thread.\n     * If true, the history will be fetched from the server. Defaults to 10 entries.\n     * If false, only the last state will be fetched from the server.\n     * @default true\n     */\n    fetchStateHistory?: boolean | {\n        limit: number;\n    };\n    /**\n     * Manage the thread state externally.\n     */\n    thread?: UseStreamThread<StateType>;\n    /**\n     * Throttle the stream.\n     * If a number is provided, the stream will be throttled to the given number of milliseconds.\n     * If `true`, updates are batched in a single macrotask.\n     * If `false`, updates are not throttled or batched.\n     * @default true\n     */\n    throttle?: number | boolean;\n}\n/**\n * Union of all stream options types.\n *\n * Used internally by the implementation to accept any options type.\n * This allows the implementation functions to handle options from\n * any agent type while maintaining type safety at the public API level.\n *\n * @internal\n */\nexport type AnyStreamOptions<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> = UseStreamOptions<StateType, Bag> & {\n    subagentToolNames?: string[];\n    filterSubagentMessages?: boolean;\n};\ninterface RunMetadataStorage {\n    getItem(key: `lg:stream:${string}`): string | null;\n    setItem(key: `lg:stream:${string}`, value: string): void;\n    removeItem(key: `lg:stream:${string}`): void;\n}\ntype ConfigWithConfigurable<ConfigurableType extends Record<string, unknown>> = Config & {\n    configurable?: ConfigurableType;\n};\nexport interface SubmitOptions<StateType extends Record<string, unknown> = Record<string, unknown>, ContextType extends Record<string, unknown> = Record<string, unknown>> {\n    config?: ConfigWithConfigurable<ContextType>;\n    context?: ContextType;\n    checkpoint?: Omit<Checkpoint, \"thread_id\"> | null;\n    command?: Command;\n    interruptBefore?: \"*\" | string[];\n    interruptAfter?: \"*\" | string[];\n    metadata?: Metadata;\n    multitaskStrategy?: MultitaskStrategy;\n    onCompletion?: OnCompletionBehavior;\n    onDisconnect?: DisconnectMode;\n    feedbackKeys?: string[];\n    streamMode?: Array<StreamMode>;\n    runId?: string;\n    optimisticValues?: Partial<StateType> | ((prev: StateType) => Partial<StateType>);\n    /**\n     * Whether or not to stream the nodes of any subgraphs called\n     * by the assistant.\n     * @default false\n     */\n    streamSubgraphs?: boolean;\n    /**\n     * Mark the stream as resumable. All events emitted during the run will be temporarily persisted\n     * in order to be re-emitted if the stream is re-joined.\n     * @default false\n     */\n    streamResumable?: boolean;\n    /**\n     * Whether to checkpoint during the run (or only at the end/interruption).\n     * - `\"async\"`: Save checkpoint asynchronously while the next step executes (default).\n     * - `\"sync\"`: Save checkpoint synchronously before the next step starts.\n     * - `\"exit\"`: Save checkpoint only when the graph exits.\n     * @default \"async\"\n     */\n    durability?: Durability;\n    /**\n     * The ID to use when creating a new thread. When provided, this ID will be used\n     * for thread creation when threadId is `null` or `undefined`.\n     * This enables optimistic UI updates where you know the thread ID\n     * before the thread is actually created.\n     */\n    threadId?: string;\n}\n/**\n * Transport used to stream the thread.\n * Only applicable for custom endpoints using `toLangGraphEventStream` or `toLangGraphEventStreamResponse`.\n */\nexport interface UseStreamTransport<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> {\n    stream: (payload: {\n        input: GetUpdateType<Bag, StateType> | null | undefined;\n        context: GetConfigurableType<Bag> | undefined;\n        command: Command | undefined;\n        config: ConfigWithConfigurable<GetConfigurableType<Bag>> | undefined;\n        signal: AbortSignal;\n    }) => Promise<AsyncGenerator<{\n        id?: string;\n        event: string;\n        data: unknown;\n    }>>;\n}\nexport type UseStreamCustomOptions<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> = Pick<UseStreamOptions<StateType, Bag>, \"messagesKey\" | \"threadId\" | \"onThreadId\" | \"onError\" | \"onCreated\" | \"onUpdateEvent\" | \"onCustomEvent\" | \"onMetadataEvent\" | \"onLangChainEvent\" | \"onDebugEvent\" | \"onCheckpointEvent\" | \"onTaskEvent\" | \"onStop\" | \"initialValues\" | \"throttle\"> & {\n    transport: UseStreamTransport<StateType, Bag>;\n};\n/**\n * Union of all custom stream options types.\n *\n * Used internally by the implementation to accept any custom options type.\n * This allows the implementation functions to handle options from\n * any agent type while maintaining type safety at the public API level.\n *\n * @internal\n */\nexport type AnyStreamCustomOptions<StateType extends Record<string, unknown> = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> = UseStreamCustomOptions<StateType, Bag> & {\n    subagentToolNames?: string[];\n    filterSubagentMessages?: boolean;\n};\nexport type CustomSubmitOptions<StateType extends Record<string, unknown> = Record<string, unknown>, ConfigurableType extends Record<string, unknown> = Record<string, unknown>> = Pick<SubmitOptions<StateType, ConfigurableType>, \"optimisticValues\" | \"context\" | \"command\" | \"config\">;\nexport {};\n"],"mappings":"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"}
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/ui/types.ts"],"mappings":"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"}