aip-agents-binary 0.0.0b2__py3-none-any.whl → 0.5.12__py3-none-any.whl

aip_agents/agent/base_agent.pyi

@@ -1,205 +0,0 @@
-import abc
-from _typeshed import Incomplete
-from a2a.types import AgentCard
-from aip_agents.a2a.server.google_adk_executor import GoogleADKExecutor as GoogleADKExecutor
-from aip_agents.a2a.server.langgraph_executor import LangGraphA2AExecutor as LangGraphA2AExecutor
-from aip_agents.agent.interface import AgentInterface as AgentInterface
-from aip_agents.agent.types import A2AClientConfig as A2AClientConfig, AgentConfig as AgentConfig, BaseAgentConfig as BaseAgentConfig, CredentialType as CredentialType
-from aip_agents.credentials.manager import CredentialsManager as CredentialsManager
-from aip_agents.utils.a2a_connector import A2AConnector as A2AConnector
-from aip_agents.utils.logger_manager import LoggerManager as LoggerManager
-from aip_agents.utils.name_preprocessor.name_preprocessor import NamePreprocessor as NamePreprocessor
-from starlette.applications import Starlette
-from typing import Any, AsyncGenerator
-
-logger: Incomplete
-AGENT_EXECUTOR_MAPPING: Incomplete
-DEFAULT_RETRY_CONFIG: Incomplete
-LM_EXCLUDE_FIELDS: Incomplete
-CUSTOM_PROVIDERS: Incomplete
-OUTPUT_ANALYTICS_KEY: str
-
-class BaseAgent(AgentInterface, metaclass=abc.ABCMeta):
-    """Base class for agents, providing common A2A client method implementations.
-
-    Concrete agent implementations (e.g., LangGraphAgent, GoogleADKAgent)
-    should inherit from this class if they need to utilize the shared A2A
-    client functionalities.
-
-    This class now supports flexible model handling:
-    - model: Optional[Any] - can be an lm_invoker, string/ModelId, LangChain BaseChatModel, or other types
-    - Automatically sets self.lm_invoker if an lm_invoker is provided or can be built
-    - Stores the original model in self.model for subclass use
-    - Enhanced credential support with automatic type detection
-    """
-    model: Incomplete
-    tools: Incomplete
-    mcp_config: Incomplete
-    tool_configs: Incomplete
-    name_preprocessor: Incomplete
-    def __init__(self, name: str, instruction: str, description: str | None = None, model: Any | None = None, tools: list[Any] | None = None, config: BaseAgentConfig | dict[str, Any] | None = None, tool_configs: dict[str, Any] | None = None, **kwargs: Any) -> None:
-        """Initializes the BaseAgent.
-
-        Args:
-            name: The name of the agent.
-            instruction: The core directive or system prompt for the agent.
-            description: Human-readable description. Defaults to instruction if not provided.
-            model: The model to use. Can be:
-                - BaseLMInvoker instance (will be set as self.lm_invoker)
-                - String or ModelId (will build an lm_invoker)
-                - LangChain BaseChatModel (will be stored in self.model)
-                - Any other type (will be stored in self.model)
-            tools: List of tools available to the agent.
-            config: Additional configuration for the agent. Can be a BaseAgentConfig instance or dict.
-            tool_configs: Default tool configurations applied to all tool calls from this agent.
-            **kwargs: Additional keyword arguments for AgentInterface.
-        """
-    def get_name_preprocessor(self) -> NamePreprocessor:
-        """Get the name preprocessor based on the provider.
-
-        This will be used to correct the agent name and tool name. (mostly tool name)
-
-        Returns:
-            NamePreprocessor: The name preprocessor for the model.
-        """
-    @property
-    def model_provider(self) -> str:
-        """Get the provider of the model with simplified logic.
-
-        Returns:
-            str: The provider of the model.
-        """
-    def to_a2a(self, agent_card: AgentCard, **kwargs: Any) -> Starlette:
-        """Converts the agent to an A2A-compatible ASGI application.
-
-        This implementation provides a base setup for A2A server components.
-        Subclasses can override this method if they need custom executor
-        or task store implementations.
-
-        Args:
-            agent_card: The agent card to use for the A2A application.
-            **kwargs: Additional keyword arguments for ASGI application configuration.
-
-        Returns:
-            A Starlette ASGI application that can be used with any ASGI server.
-        """
-    @classmethod
-    def discover_agents(cls, a2a_config: A2AClientConfig, **kwargs: Any) -> list[AgentCard]:
-        """Discover agents from the URLs specified in a2a_config.discovery_urls.
-
-        This concrete implementation fetches and parses .well-known/agent.json
-        from each discovery URL to build a list of available agents.
-
-        Args:
-            a2a_config: Configuration containing discovery URLs and other A2A settings.
-            **kwargs: Additional keyword arguments (unused in this implementation).
-
-        Returns:
-            A list of AgentCard objects representing discovered agents.
-        """
-    def send_to_agent(self, agent_card: AgentCard, message: str | dict[str, Any], **kwargs: Any) -> dict[str, Any]:
-        """Synchronously sends a message to another agent using the A2A protocol.
-
-        This method is a synchronous wrapper around asend_to_agent. It handles the creation
-        of an event loop if one doesn't exist, and manages the asynchronous call internally.
-
-        Args:
-            agent_card: The AgentCard instance containing the target agent's details including
-                URL, authentication requirements, and capabilities.
-            message: The message to send to the agent. Can be either a string for simple text
-                messages or a dictionary for structured data.
-            **kwargs: Additional keyword arguments passed to asend_to_agent.
-
-        Returns:
-            A dictionary containing the response details:
-                - status (str): 'success' or 'error'
-                - content (str): Extracted text content from the response
-                - task_id (str, optional): ID of the created/updated task
-                - task_state (str, optional): Current state of the task
-                - raw_response (str): Complete JSON response from the A2A client
-                - error_type (str, optional): Type of error if status is 'error'
-                - message (str, optional): Error message if status is 'error'
-
-        Raises:
-            RuntimeError: If called from within an existing event loop or if asend_to_agent
-                encounters an unhandled exception.
-        """
-    async def asend_to_agent(self, agent_card: AgentCard, message: str | dict[str, Any], **kwargs: Any) -> dict[str, Any]:
-        """Asynchronously sends a message to another agent using the A2A protocol.
-
-        This method handles the core A2A communication logic, creating and sending properly
-        formatted A2A messages and processing the responses.
-
-        Args:
-            agent_card: The AgentCard instance containing the target agent's details including
-                URL, authentication requirements, and capabilities.
-            message: The message to send to the agent. Can be either a string for simple text
-                messages or a dictionary for structured data.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            A dictionary containing the response details:
-                - status (str): 'success' or 'error'
-                - content (str): Extracted text content from the response
-                - task_id (str, optional): ID of the created/updated task
-                - task_state (str, optional): Current state of the task
-                - raw_response (str): Complete JSON response from the A2A client
-                - error_type (str, optional): Type of error if status is 'error'
-                - message (str, optional): Error message if status is 'error'
-
-        Raises:
-            httpx.HTTPError: If there's an HTTP-related error during the request.
-            Exception: For any other unexpected errors during message sending or processing.
-        """
-    async def astream_to_agent(self, agent_card: AgentCard, message: str | dict[str, Any], **kwargs: Any) -> AsyncGenerator[dict[str, Any], None]:
-        """Asynchronously sends a streaming message to another agent using the A2A protocol.
-
-        This method supports streaming responses from the target agent, yielding chunks of
-        the response as they become available. It handles various types of streaming events
-        including task status updates, artifact updates, and message parts.
-
-        Args:
-            agent_card: The AgentCard instance containing the target agent's details including
-                URL, authentication requirements, and capabilities.
-            message: The message to send to the agent. Can be either a string for simple text
-                messages or a dictionary for structured data.
-            **kwargs: Additional keyword arguments.
-
-        Yields:
-            Dictionaries containing streaming response chunks:
-                For successful chunks:
-                    - status (str): 'success'
-                    - content (str): Extracted text content from the chunk
-                    - task_id (str): ID of the associated task
-                    - task_state (str): Current state of the task
-                    - final (bool): Whether this is the final chunk
-                    - artifact_name (str, optional): Name of the artifact if chunk is an artifact update
-                For error chunks:
-                    - status (str): 'error'
-                    - error_type (str): Type of error encountered
-                    - message (str): Error description
-
-        Raises:
-            httpx.HTTPError: If there's an HTTP-related error during the streaming request.
-            Exception: For any other unexpected errors during message streaming or processing.
-        """
-    @staticmethod
-    def format_agent_description(agent_card: AgentCard) -> str:
-        """Format the description of an agent card including skills information.
-
-        Args:
-            agent_card (AgentCard): The agent card to format.
-
-        Returns:
-            str: The formatted description including skills.
-        """
-    def add_mcp_server(self, mcp_config: dict[str, dict[str, Any]]) -> None:
-        """Adds MCP servers to the agent.
-
-        Args:
-            mcp_config: A dictionary containing MCP server configurations.
-
-        Raises:
-            ValueError: If the MCP configuration is empty or None.
-            KeyError: If a server with the same name already exists in the MCP configuration.
-        """

aip_agents/agent/base_langgraph_agent.pyi

@@ -1,164 +0,0 @@
-import abc
-from _typeshed import Incomplete
-from a2a.types import AgentCard as AgentCard
-from abc import abstractmethod
-from aip_agents.agent.base_agent import BaseAgent as BaseAgent
-from aip_agents.agent.types import StreamMode as StreamMode
-from aip_agents.mcp.client.langchain import LangchainMCPClient as LangchainMCPClient
-from aip_agents.tools.tool_config_injector import CONFIG_SCHEMA_ATTR as CONFIG_SCHEMA_ATTR, TOOL_CONFIG_SCHEMA_ATTR as TOOL_CONFIG_SCHEMA_ATTR, inject_config_methods_into_tool as inject_config_methods_into_tool
-from aip_agents.types import A2AEvent as A2AEvent, A2AStreamEventType as A2AStreamEventType
-from aip_agents.utils import validate_references as validate_references
-from aip_agents.utils.logger_manager import LoggerManager as LoggerManager
-from aip_agents.utils.metadata_helper import DEFAULT_STEP_INDICATOR_MESSAGE as DEFAULT_STEP_INDICATOR_MESSAGE, FINAL_AGENT_THINKING_FINISHED_CONTENT as FINAL_AGENT_THINKING_FINISHED_CONTENT, Status as Status
-from aip_agents.utils.token_usage_helper import STEP_USAGE_KEY as STEP_USAGE_KEY, TOTAL_USAGE_KEY as TOTAL_USAGE_KEY, USAGE_METADATA_KEY as USAGE_METADATA_KEY
-from gllm_core.event import EventEmitter
-from langchain_core.messages import BaseMessage as BaseMessage
-from langchain_core.tools import BaseTool
-from langgraph.graph import StateGraph
-from langgraph.graph.message import add_messages as add_messages
-from langgraph.graph.state import CompiledStateGraph as CompiledStateGraph
-from langgraph.types import Checkpointer as Checkpointer, StreamWriter as StreamWriter
-from typing import Any, AsyncGenerator, Sequence
-
-logger: Incomplete
-
-class BaseLangGraphAgent(BaseAgent, metaclass=abc.ABCMeta):
-    """Base class for LangGraph-based agents with unified tool approach.
-
-    Provides core LangGraph functionality including:
-    - Graph compilation and execution
-    - State schema management
-    - I/O mapping between user inputs and graph states
-    - Event emission support
-    - Tool resolution and handling
-    - A2A communication capabilities via tools
-    - Agent delegation capabilities via tools
-    - MCP server integration via tools
-    - Enhanced output extraction from various state formats
-
-    Tool Management:
-    - regular_tools: Standard LangChain tools provided during initialization
-    - mcp_tools: Tools retrieved from MCP servers
-    - resolved_tools: Combined collection of all tools for graph execution
-
-    Subclasses must implement:
-    - define_graph(): Define the specific graph structure
-    - _prepare_graph_input(): Convert user input to graph state
-    - _format_graph_output(): Convert final graph state to user output
-    """
-    state_schema: Incomplete
-    thread_id_key: Incomplete
-    event_emitter: Incomplete
-    checkpointer: Incomplete
-    a2a_tool_manager: Incomplete
-    delegation_tool_manager: Incomplete
-    regular_tools: list[BaseTool]
-    mcp_tools: list[BaseTool]
-    resolved_tools: list[BaseTool]
-    def __init__(self, name: str, instruction: str, description: str | None = None, model: Any | None = None, tools: Sequence[BaseTool] | None = None, state_schema: type | None = None, thread_id_key: str = 'thread_id', event_emitter: EventEmitter | None = None, checkpointer: Checkpointer | None = None, **kwargs: Any) -> None:
-        """Initialize the BaseLangGraphAgent.
-
-        Args:
-            name: The name of the agent.
-            instruction: The system instruction for the agent.
-            description: Human-readable description of the agent.
-            model: The model to use (lm_invoker, LangChain model, string, etc.).
-            tools: Sequence of regular LangChain tools (not A2A or delegation tools).
-            state_schema: The state schema for the LangGraph. Defaults to basic message state.
-            thread_id_key: Key for thread ID in configuration.
-            event_emitter: Optional event emitter for streaming updates.
-            checkpointer: Optional checkpointer for conversation persistence.
-            **kwargs: Additional keyword arguments passed to BaseAgent (including tool_configs).
-        """
-    @abstractmethod
-    def define_graph(self, graph_builder: StateGraph) -> CompiledStateGraph:
-        """Define the specific graph structure for this agent type.
-
-        Subclasses must implement this method to:
-        1. Add nodes to the graph_builder
-        2. Add edges and conditional edges
-        3. Set entry points
-        4. Return the compiled graph
-
-        Args:
-            graph_builder: The StateGraph builder to define nodes and edges on.
-
-        Returns:
-            The compiled graph ready for execution.
-        """
-    def register_a2a_agents(self, agent_cards: list[AgentCard]) -> None:
-        """Register A2A communication capabilities using the A2A tool manager.
-
-        Args:
-            agent_cards (list[AgentCard]): List of AgentCard instances for external communication.
-        """
-    def register_delegation_agents(self, agents: list[BaseAgent]) -> None:
-        """Register internal agent delegation capabilities using the delegation tool manager.
-
-        Args:
-            agents: List of BaseAgent instances for internal task delegation.
-        """
-    tools: Incomplete
-    def update_regular_tools(self, new_tools: list[BaseTool], rebuild_graph: bool | None = None) -> None:
-        """Update regular tools (not capabilities).
-
-        Args:
-            new_tools: New list of regular tools to use.
-            rebuild_graph: Whether to rebuild graph. If None, uses auto_rebuild_graph setting.
-        """
-    def run(self, query: str, **kwargs: Any) -> dict[str, Any]:
-        """Synchronously run the LangGraph agent.
-
-        Args:
-            query: The input query for the agent.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            Dictionary containing the agent's response.
-        """
-    async def arun(self, query: str, **kwargs: Any) -> dict[str, Any]:
-        """Asynchronously run the LangGraph agent.
-
-        If MCP configuration exists, connects to the MCP server and registers tools before running.
-
-        Args:
-            query: The input query for the agent.
-            **kwargs: Additional keyword arguments including configurable for LangGraph.
-
-        Returns:
-            Dictionary containing the agent's response and full final state.
-        """
-    async def arun_stream(self, query: str, **kwargs: Any) -> AsyncGenerator[str | dict[str, Any], None]:
-        """Asynchronously stream the LangGraph agent's response.
-
-        If MCP configuration exists, connects to the MCP server and registers tools before streaming.
-        This method properly handles both LM Invoker and LangChain model streaming:
-        - For LM Invoker: Uses StreamEventHandler to capture streaming events
-        - For LangChain models: Uses LangGraph's native streaming implementation
-
-        Args:
-            query: The input query for the agent.
-            **kwargs: Additional keyword arguments.
-
-        Yields:
-            Chunks of output (strings or dicts) from the streaming response.
-        """
-    def add_mcp_server(self, mcp_config: dict[str, dict[str, Any]]) -> None:
-        """Add MCP server configuration.
-
-        Args:
-            mcp_config (dict[str, dict[str, Any]]): Dictionary containing MCP server configurations.
-        """
-    async def arun_a2a_stream(self, query: str, **kwargs: Any) -> AsyncGenerator[dict[str, Any], None]:
-        '''Asynchronously streams the agent\'s response in a generic format for A2A.
-
-        If MCP configuration exists, connects to the MCP server and registers tools before streaming.
-
-        Args:
-            query: The input query for the agent.
-            **kwargs: Additional keyword arguments.
-
-        Yields:
-            Dictionaries with "status" and "content" keys.
-            Possible statuses: "working", "completed", "failed", "canceled".
-        '''

aip_agents/agent/google_adk_agent.pyi

@@ -1,128 +0,0 @@
-from _typeshed import Incomplete
-from a2a.types import AgentCard as AgentCard
-from aip_agents.agent.base_agent import BaseAgent as BaseAgent
-from aip_agents.mcp.client import GoogleADKMCPClient as GoogleADKMCPClient
-from aip_agents.utils.a2a_connector import A2AConnector as A2AConnector
-from aip_agents.utils.logger_manager import LoggerManager as LoggerManager
-from google.adk.agents import LlmAgent
-from google.adk.tools.langchain_tool import LangchainTool
-from langchain.tools import BaseTool as LangchainBaseTool
-from pydantic import BaseModel
-from typing import Any, AsyncGenerator, AsyncIterator
-
-logger: Incomplete
-MODEL_TEMPERATURE: float
-DEFAULT_AUTH_URL: str
-
-class A2AToolInput(BaseModel):
-    """Input for the A2ATool."""
-    query: str
-
-class A2ATool(LangchainBaseTool):
-    """A tool that communicates with an A2A agent."""
-    name: str
-    description: str
-    args_schema: type[BaseModel]
-    agent_card: AgentCard
-
-def create_a2a_tool(agent_card: AgentCard) -> LangchainTool:
-    """Create a LangChain tool from an A2A agent card."""
-
-class GoogleADKAgent(BaseAgent):
-    """An agent that wraps a native Google ADK Agent.
-
-    This class implements the AgentInterface and uses Google's LlmAgent
-    to handle the core conversation and tool execution logic via ADK's
-    async-first design.
-    """
-    adk_native_agent: LlmAgent
-    model: Incomplete
-    max_iterations: Incomplete
-    tools: Incomplete
-    agents: Incomplete
-    session_service: Incomplete
-    name: Incomplete
-    def __init__(self, name: str, instruction: str, model: str, tools: list[Any] | None = None, description: str | None = None, max_iterations: int = 3, agents: list['GoogleADKAgent'] | None = None, **kwargs: Any) -> None:
-        '''Initializes the GoogleADKAgent.
-
-        Args:
-            name: The name of this wrapper agent.
-            instruction: The instruction for this wrapper agent.
-            model: The name of the Google ADK model to use (e.g., "gemini-1.5-pro-latest").
-            tools: An optional list of callable tools for the ADK agent.
-            description: An optional human-readable description.
-            max_iterations: Maximum number of iterations to run (default: 3).
-            agents: Optional list of sub-agents that this agent can delegate to using ADK\'s
-                   built-in multi-agent capabilities. These will be passed as sub_agents to the
-                   underlying LlmAgent.
-            **kwargs: Additional keyword arguments passed to the parent `__init__`.
-        '''
-    def run(self, query: str, **kwargs: Any) -> dict[str, Any]:
-        '''Synchronously runs the Google ADK agent by wrapping the internal async run method.
-
-        Args:
-            query: The input query for the agent.
-            **kwargs: Additional keyword arguments passed to the internal async run method.
-                      Supports "session_id", "user_id", "app_name".
-
-        Returns:
-            A dictionary containing the agent\'s response.
-
-        Raises:
-            RuntimeError: If `asyncio.run()` is called from an already running event loop,
-                          or for other unhandled errors during synchronous execution.
-        '''
-    async def arun(self, query: str, **kwargs: Any) -> dict[str, Any]:
-        '''Asynchronously runs the agent with the given query and returns the response.
-
-        Args:
-            query: The user\'s query to process.
-            **kwargs: Additional keyword arguments. Supports "session_id", "user_id", "app_name".
-
-        Returns:
-            A dictionary containing the output and other metadata.
-        '''
-    async def arun_stream(self, query: str, **kwargs: Any) -> AsyncIterator[str]:
-        '''Runs the agent with the given query and streams the response parts.
-
-        Args:
-            query: The user\'s query to process.
-            **kwargs: Additional keyword arguments. Supports "session_id", "user_id", "app_name".
-
-        Yields:
-            Text response chunks from the model. If an error occurs, the error message is yielded.
-        '''
-    def register_a2a_agents(self, agent_cards: list[AgentCard]) -> None:
-        """Convert known A2A agents to LangChain tools.
-
-        This method takes the agents from a2a_config.known_agents, creates A2AAgent
-        instances for each one, and wraps them in LangChain tools.
-
-        Returns:
-            None: The tools are added to the existing tools list.
-        """
-    def add_mcp_server(self, mcp_config: dict[str, dict[str, Any]]) -> None:
-        """Adds a new MCP server configuration.
-
-        Args:
-            mcp_config: Dictionary containing server name as key and its configuration as value.
-
-        Raises:
-            ValueError: If mcp_config is empty or None, or if any server configuration is invalid.
-            KeyError: If any server name already exists in the configuration.
-        """
-    async def arun_a2a_stream(self, query: str, configurable: dict[str, Any] | None = None, **kwargs: Any) -> AsyncGenerator[dict[str, Any], None]:
-        '''Asynchronously streams the agent\'s response in a format compatible with A2A.
-
-        This method formats the ADK agent\'s streaming responses into a consistent format
-        that the A2A executor can understand and process.
-
-        Args:
-            query: The input query for the agent.
-            configurable: Optional dictionary for configuration, may include:
-                - thread_id: The A2A task ID (used as session_id).
-            **kwargs: Additional keyword arguments. Supports "user_id", "app_name".
-
-        Yields:
-            Dictionary with \'status\' and \'content\' fields that describe the agent\'s response state.
-        '''

aip_agents/agent/langgraph_react_agent.pyi

@@ -1,131 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.agent.base_langgraph_agent import BaseLangGraphAgent as BaseLangGraphAgent
-from aip_agents.tools.tool_config_injector import TOOL_CONFIGS_KEY as TOOL_CONFIGS_KEY
-from aip_agents.types.a2a_events import A2AStreamEventType as A2AStreamEventType
-from aip_agents.utils import add_references_chunks as add_references_chunks
-from aip_agents.utils.langgraph import convert_langchain_messages_to_gllm_messages as convert_langchain_messages_to_gllm_messages, convert_lm_output_to_langchain_message as convert_lm_output_to_langchain_message
-from aip_agents.utils.langgraph.tool_output_management import StoreOutputParams as StoreOutputParams, ToolOutputManager as ToolOutputManager, ToolReferenceError as ToolReferenceError, ToolReferenceResolver as ToolReferenceResolver
-from aip_agents.utils.logger_manager import LoggerManager as LoggerManager
-from aip_agents.utils.token_usage_helper import TOTAL_USAGE_KEY as TOTAL_USAGE_KEY, USAGE_METADATA_KEY as USAGE_METADATA_KEY, add_usage_metadata as add_usage_metadata, extract_and_update_token_usage_from_ai_message as extract_and_update_token_usage_from_ai_message, extract_token_usage_from_tool_output as extract_token_usage_from_tool_output
-from dataclasses import dataclass
-from gllm_core.event import EventEmitter as EventEmitter
-from gllm_core.schema import Chunk
-from langchain_core.language_models import BaseChatModel
-from langchain_core.messages import BaseMessage as BaseMessage, ToolMessage
-from langchain_core.messages.ai import UsageMetadata as UsageMetadata
-from langchain_core.tools import BaseTool as BaseTool
-from langgraph.graph import StateGraph as StateGraph
-from langgraph.graph.message import add_messages as add_messages
-from langgraph.graph.state import CompiledStateGraph as CompiledStateGraph
-from langgraph.managed import IsLastStep as IsLastStep, RemainingSteps as RemainingSteps
-from langgraph.types import StreamWriter as StreamWriter
-from typing import Any, Sequence
-from typing_extensions import Annotated, TypedDict
-
-logger: Incomplete
-DEFAULT_INSTRUCTION: str
-TOOL_RUN_STREAMING_METHOD: str
-SAVE_OUTPUT_HISTORY: str
-FORMAT_AGENT_REFERENCE: str
-TOOL_OUTPUT_MANAGER_KEY: str
-CALL_ID_KEY: str
-
-@dataclass
-class ToolCallResult:
-    """Container for the results of a single tool call execution.
-
-    Holds all the data returned from a tool execution in a structured format.
-
-    Attributes:
-        messages: List of tool messages generated from the tool call.
-        artifacts: List of artifacts produced by the tool call.
-        metadata_delta: Dictionary of metadata updates from the tool call.
-        references: List of reference chunks from the tool call.
-        step_usage: Token usage metadata from the tool call.
-    """
-    messages: list[ToolMessage]
-    artifacts: list[dict[str, Any]]
-    metadata_delta: dict[str, Any]
-    references: list[Chunk]
-    step_usage: UsageMetadata | None
-
-@dataclass
-class ToolStorageParams:
-    """Parameters for automatic tool storage.
-
-    Reduces the number of arguments passed to _handle_automatic_tool_storage method.
-
-    Attributes:
-        tool: The tool instance that was executed.
-        tool_output: The output returned by the tool.
-        tool_call: The tool call information from the AI message.
-        tool_call_id: Unique identifier for this tool call.
-        resolved_args: The resolved arguments passed to the tool.
-        state: Current agent state containing tool output manager.
-    """
-    tool: BaseTool
-    tool_output: Any
-    tool_call: dict[str, Any]
-    tool_call_id: str
-    resolved_args: dict[str, Any]
-    state: dict[str, Any]
-
-class ReactAgentState(TypedDict):
-    """State schema for the ReAct agent.
-
-    Includes messages, step tracking, optional event emission support, artifacts, references,
-    metadata, and tool output management for efficient tool result sharing and reference resolution.
-    """
-    messages: Annotated[Sequence[BaseMessage], add_messages]
-    is_last_step: IsLastStep
-    remaining_steps: RemainingSteps
-    event_emitter: EventEmitter | None
-    artifacts: list[dict[str, Any]] | None
-    references: Annotated[list[Chunk], add_references_chunks]
-    metadata: dict[str, Any] | None
-    tool_output_manager: ToolOutputManager | None
-    total_usage: Annotated[UsageMetadata | None, add_usage_metadata]
-
-class LangGraphReactAgent(BaseLangGraphAgent):
-    """A ReAct agent template built on LangGraph.
-
-    This agent can use either:
-    - An LMInvoker (if self.lm_invoker is set by BaseAgent)
-    - A LangChain BaseChatModel (if self.model is set by BaseAgent)
-
-    The graph structure follows the standard ReAct pattern:
-    agent -> tools -> agent (loop) -> END
-    """
-    tool_output_manager: Incomplete
-    def __init__(self, name: str, instruction: str = ..., model: BaseChatModel | str | Any | None = None, tools: Sequence[BaseTool] | None = None, agents: Sequence[Any] | None = None, description: str | None = None, thread_id_key: str = 'thread_id', event_emitter: EventEmitter | None = None, tool_output_manager: ToolOutputManager | None = None, **kwargs: Any) -> None:
-        """Initialize the LangGraph ReAct Agent.
-
-        Args:
-            name: The name of the agent.
-            instruction: The system instruction for the agent.
-            model: The model to use (lm_invoker, LangChain model, string, etc.).
-            tools: Sequence of LangChain tools available to the agent.
-            agents: Optional sequence of sub-agents for delegation (coordinator mode).
-            description: Human-readable description of the agent.
-            thread_id_key: Key for thread ID in configuration.
-            event_emitter: Optional event emitter for streaming updates.
-            tool_output_manager: Optional ToolOutputManager instance for tool output management.
-                When provided, enables tool output storage, reference resolution, and sharing capabilities.
-                This enables multi-agent workflows where agents can access each other's tool outputs.
-                If None, tool output management is disabled for this agent.
-            **kwargs: Additional keyword arguments passed to BaseLangGraphAgent.
-        """
-    def define_graph(self, graph_builder: StateGraph) -> CompiledStateGraph:
-        """Define the ReAct agent graph structure.
-
-        Args:
-            graph_builder: The StateGraph builder to define the graph structure.
-
-        Returns:
-            Compiled LangGraph ready for execution.
-        """
-
-class LangGraphAgent(LangGraphReactAgent):
-    """Alias for LangGraphReactAgent."""
-class LangChainAgent(LangGraphReactAgent):
-    """Alias for LangGraphReactAgent."""