aip-agents-binary 0.5.25b8__py3-none-any.whl → 0.6.0__py3-none-any.whl

aip_agents/agent/hitl/prompt/base.pyi

@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+from aip_agents.agent.hitl.manager import ApprovalManager as ApprovalManager
+from aip_agents.schema.hitl import ApprovalDecision as ApprovalDecision, ApprovalRequest as ApprovalRequest
+
+class BasePromptHandler(ABC):
+    """Abstract base class for prompt handlers used in HITL flows."""
+    def attach_manager(self, manager: ApprovalManager) -> None:
+        """Optionally attach the ``ApprovalManager`` coordinating approvals.
+
+        Args:
+            manager (ApprovalManager): The approval manager instance to attach.
+        """
+    @abstractmethod
+    async def prompt_for_decision(self, request: ApprovalRequest, timeout_seconds: int, context_keys: list[str] | None = None) -> ApprovalDecision:
+        """Collect and return a decision for the given approval request.
+
+        Args:
+            request (ApprovalRequest): The approval request to prompt for.
+            timeout_seconds (int): Maximum time to wait for a decision in seconds.
+            context_keys (list[str] | None, optional): Optional keys for additional context. Defaults to None.
+
+        Returns:
+            ApprovalDecision: The decision made for the approval request.
+        """

aip_agents/agent/hitl/prompt/deferred.pyi

@@ -0,0 +1,30 @@
+from aip_agents.agent.hitl.manager import ApprovalManager as ApprovalManager
+from aip_agents.agent.hitl.prompt.base import BasePromptHandler as BasePromptHandler
+from aip_agents.schema.hitl import ApprovalDecision as ApprovalDecision, ApprovalDecisionType as ApprovalDecisionType, ApprovalRequest as ApprovalRequest
+from collections.abc import Callable
+
+class DeferredPromptHandler(BasePromptHandler):
+    """Prompt handler that defers tool execution until an external decision is received."""
+    def __init__(self, notify: Callable[[ApprovalRequest], None] | None = None) -> None:
+        """Initialize the deferred prompt handler.
+
+        Args:
+            notify: Optional callback function to notify when an approval request is made.
+        """
+    def attach_manager(self, manager: ApprovalManager) -> None:
+        """Attach the ApprovalManager orchestrating approvals.
+
+        Args:
+            manager: The ApprovalManager instance to attach for handling approval decisions.
+        """
+    async def prompt_for_decision(self, request: ApprovalRequest, timeout_seconds: int, context_keys: list[str] | None = None) -> ApprovalDecision:
+        """Register a waiter and return a pending decision sentinel.
+
+        Args:
+            request: The approval request containing the tool call details and context.
+            timeout_seconds: Number of seconds to wait for approval before timing out.
+            context_keys: Optional list of context keys to include in the approval request.
+
+        Returns:
+            ApprovalDecision with PENDING status and registered waiter for external resolution.
+        """

aip_agents/agent/hitl/registry.pyi

@@ -0,0 +1,101 @@
+from _typeshed import Incomplete
+from aip_agents.agent.hitl.manager import ApprovalManager as ApprovalManager
+
+class HITLManagerRegistry:
+    '''Global registry mapping request_id → owning ApprovalManager.
+
+    Uses weak references to avoid preventing manager garbage collection.
+    Thread-safe for concurrent agent execution.
+
+    This singleton registry allows the HITL decision endpoint to route decisions
+    to the correct manager in hierarchical agent setups, where a sub-agent may
+    create a pending request but the parent agent receives the decision.
+
+    Example:
+        >>> from aip_agents.agent.hitl.registry import hitl_registry
+        >>> # Manager auto-registers when creating requests
+        >>> manager.create_approval_request(...)
+        >>> # Later, decision handler looks up the owning manager
+        >>> owning_manager = hitl_registry.get_manager(request_id)
+        >>> owning_manager.resolve_pending_request(request_id, "approved")
+    '''
+    def __new__(cls) -> HITLManagerRegistry:
+        """Ensure only one instance exists (singleton pattern).
+
+        Returns:
+            The singleton HITLManagerRegistry instance.
+        """
+    def register(self, request_id: str, manager: ApprovalManager) -> None:
+        '''Register a pending request with its owning manager.
+
+        This method is typically called automatically by ApprovalManager when
+        creating a new pending request. It establishes the ownership mapping
+        needed for proper decision routing.
+
+        Args:
+            request_id: Unique identifier for the pending request
+            manager: ApprovalManager instance that owns this request
+
+        Example:
+            >>> hitl_registry.register("req_abc123", my_manager)
+        '''
+    def unregister(self, request_id: str) -> None:
+        '''Remove a request from the registry.
+
+        This method is called when a request is resolved, times out, or expires.
+        It\'s important for cleanup to prevent the registry from growing unbounded.
+
+        Args:
+            request_id: Unique identifier to remove
+
+        Example:
+            >>> hitl_registry.unregister("req_abc123")
+        '''
+    def get_manager(self, request_id: str) -> ApprovalManager | None:
+        '''Retrieve the manager owning a specific request.
+
+        This is the primary lookup method used by decision handlers to route
+        decisions to the correct manager in hierarchical agent setups.
+
+        Args:
+            request_id: Unique identifier to lookup
+
+        Returns:
+            ApprovalManager instance if found, None otherwise. None can indicate
+            the request was resolved, timed out, or the manager was garbage collected.
+
+        Example:
+            >>> manager = hitl_registry.get_manager("req_abc123")
+            >>> if manager:
+            ...     manager.resolve_pending_request("req_abc123", "approved")
+        '''
+    def clear(self) -> None:
+        """Clear all registrations.
+
+        This method is primarily intended for testing to ensure a clean state
+        between test cases. It removes all registered mappings.
+
+        Warning:
+            This should not be called in production code as it will prevent
+            pending requests from being resolved.
+
+        Example:
+            >>> hitl_registry.clear()  # For testing only
+        """
+    def list_all(self) -> list[str]:
+        '''List all currently registered request IDs.
+
+        Returns:
+            List of request IDs currently in the registry.
+
+        Note:
+            Due to weak references, managers may be garbage collected between
+            calling this method and accessing them, so the actual available
+            managers might be fewer than the returned list length.
+
+        Example:
+            >>> request_ids = hitl_registry.list_all()
+            >>> print(f"Pending requests: {request_ids}")
+        '''
+
+hitl_registry: Incomplete

aip_agents/agent/interface.pyi

@@ -0,0 +1,81 @@
+from a2a.types import AgentCard as AgentCard
+from abc import ABC, abstractmethod
+from aip_agents.schema.agent import BaseAgentConfig as BaseAgentConfig
+from collections.abc import AsyncGenerator
+from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker
+from typing import Any
+
+class AgentInterface(ABC):
+    """A general and minimal interface for agent implementations.
+
+    Defines core execution methods (`__init__`, `run`, `arun`, `arun_stream`).
+    Concrete subclasses must implement all abstract methods.
+    """
+    name: str
+    instruction: str
+    description: str | None
+    mcp_config: dict[str, Any]
+    lm_invoker: BaseLMInvoker | None
+    config: BaseAgentConfig | None
+    def __init__(self, name: str, instruction: str, description: str | None = None, lm_invoker: BaseLMInvoker | None = None, config: BaseAgentConfig | None = None, **kwargs: Any) -> None:
+        """Initializes the agent.
+
+        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.
+            lm_invoker: The language model invoker to use for LLM interactions. Defaults to None.
+            config: Additional configuration for the agent.
+            **kwargs: Additional keyword arguments for concrete implementations.
+        """
+    @abstractmethod
+    def run(self, query: str, **kwargs: Any) -> dict[str, Any]:
+        """Synchronously runs the agent.
+
+        Args:
+            query: The input query for the agent.
+            **kwargs: Additional keyword arguments for execution.
+
+        Returns:
+            Dict containing at least {'output': ...}.
+        """
+    @abstractmethod
+    async def arun(self, query: str, **kwargs: Any) -> dict[str, Any]:
+        """Asynchronously runs the agent.
+
+        Args:
+            query: The input query for the agent.
+            **kwargs: Additional keyword arguments for execution.
+
+        Returns:
+            Dict containing at least {'output': ...}.
+        """
+    @abstractmethod
+    async def arun_stream(self, query: str, **kwargs: Any) -> AsyncGenerator[str | dict[str, Any], None]:
+        """Asynchronously streams the agent's response.
+
+        Args:
+            query: The input query.
+            **kwargs: Extra parameters for execution.
+
+        Yields:
+            Chunks of output (strings or dicts).
+        """
+    @abstractmethod
+    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.
+        """
+    @abstractmethod
+    def register_a2a_agents(self, agents: list[AgentCard]):
+        """Registers A2A agents from a list of AgentCards.
+
+        Args:
+            agents: A list of AgentCard instances.
+        """

aip_agents/agent/interfaces.pyi

@@ -0,0 +1,44 @@
+from collections.abc import AsyncIterator
+from typing import Any, Protocol
+
+class LangGraphAgentProtocol(Protocol):
+    """Minimal interface required by LangGraphA2AExecutor."""
+    name: str
+    async def arun_a2a_stream(self, query: str, **kwargs: Any) -> AsyncIterator[dict[str, Any]]:
+        """Stream A2A-compatible chunks for the given query.
+
+        Args:
+            query (str): The query to execute and stream.
+            **kwargs (Any): Additional keyword arguments for execution.
+
+        Yields:
+            dict[str, Any]: A2A-compatible streaming chunks.
+        """
+
+class LangflowAgentProtocol(Protocol):
+    """Minimal interface required by LangflowA2AExecutor."""
+    name: str
+    async def arun_a2a_stream(self, query: str, **kwargs: Any) -> AsyncIterator[dict[str, Any]]:
+        """Stream A2A-compatible chunks for the given query.
+
+        Args:
+            query (str): The query to execute and stream.
+            **kwargs (Any): Additional keyword arguments for execution.
+
+        Yields:
+            dict[str, Any]: A2A-compatible streaming chunks.
+        """
+
+class GoogleADKAgentProtocol(Protocol):
+    """Minimal interface required by GoogleADKExecutor."""
+    name: str
+    async def arun_a2a_stream(self, query: str, **kwargs: Any) -> AsyncIterator[dict[str, Any]]:
+        """Stream A2A-compatible chunks for the given query.
+
+        Args:
+            query (str): The query to execute and stream.
+            **kwargs (Any): Additional keyword arguments for execution.
+
+        Yields:
+            dict[str, Any]: A2A-compatible streaming chunks.
+        """

aip_agents/agent/langflow_agent.pyi

@@ -0,0 +1,133 @@
+from _typeshed import Incomplete
+from a2a.types import AgentCard as AgentCard
+from aip_agents.agent.base_agent import BaseAgent as BaseAgent
+from aip_agents.clients.langflow import LangflowApiClient as LangflowApiClient
+from aip_agents.clients.langflow.types import LangflowEventType as LangflowEventType
+from aip_agents.schema.agent import LangflowAgentConfig as LangflowAgentConfig
+from aip_agents.types import A2AEvent as A2AEvent, A2AStreamEventType as A2AStreamEventType
+from aip_agents.utils.logger import get_logger as get_logger
+from aip_agents.utils.sse_chunk_transformer import SSEChunkTransformer as SSEChunkTransformer
+from collections.abc import AsyncGenerator
+from typing import Any
+
+logger: Incomplete
+
+class LangflowAgent(BaseAgent):
+    """Langflow agent implementation for executing Langflow flows.
+
+    This agent integrates with Langflow APIs to execute flows while providing
+    full compatibility with the SDK's agent framework, including:
+    - Synchronous and asynchronous execution
+    - Regular and A2A streaming support
+    - Session management for conversation continuity
+    - Error handling and retry logic
+    - Credential management through BaseAgent
+
+    The agent builds on BaseAgent to gain shared A2A utilities while focusing on
+    Langflow-specific execution logic.
+    """
+    langflow_config: Incomplete
+    flow_id: Incomplete
+    api_client: Incomplete
+    def __init__(self, name: str, flow_id: str, description: str | None = None, base_url: str | None = None, api_key: str | None = None, config: LangflowAgentConfig | dict[str, Any] | None = None, **kwargs: Any) -> None:
+        """Initialize the LangflowAgent.
+
+        Args:
+            name: The name of the agent.
+            flow_id: The unique identifier of the Langflow flow to execute.
+            description: Human-readable description.
+            base_url: The base URL of the Langflow API server.
+            api_key: The API key for Langflow authentication.
+            config: Langflow-specific configuration or dict.
+            **kwargs: Additional keyword arguments passed to BaseAgent.
+        """
+    def run(self, query: str, **kwargs: Any) -> dict[str, Any]:
+        """Synchronously run the Langflow 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 Langflow agent.
+
+        Args:
+            query: The input query for the agent.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            Dictionary containing the agent's response and metadata.
+        """
+    async def arun_stream(self, query: str, **kwargs: Any) -> AsyncGenerator[str | dict[str, Any], None]:
+        """Asynchronously stream the Langflow agent's response.
+
+        Args:
+            query: The input query for the agent.
+            **kwargs: Additional keyword arguments.
+
+        Yields:
+            Chunks of output (strings or dicts) from the streaming response.
+        """
+    async def arun_a2a_stream(self, query: str, **kwargs: Any) -> AsyncGenerator[dict[str, Any], None]:
+        """Asynchronously stream the agent's response in A2A format.
+
+        This method converts Langflow streaming events into A2A-compatible events
+        following the patterns established by BaseLangGraphAgent.
+
+        Args:
+            query: The input query for the agent.
+            **kwargs: Additional keyword arguments.
+
+        Yields:
+            A2A-compatible event dictionaries with semantic event types.
+        """
+    async def arun_sse_stream(self, query: str, task_id: str | None = None, context_id: str | None = None, **kwargs: Any) -> AsyncGenerator[dict[str, Any], None]:
+        '''Stream agent response as SSE-compatible chunks.
+
+        This method wraps arun_a2a_stream and transforms output to the normalized
+        dict format matching A2AConnector.astream_to_agent output, enabling direct
+        streaming without A2A server overhead.
+
+        Args:
+            query: The input query for the agent.
+            task_id: Optional task identifier for the stream.
+            context_id: Optional context identifier for the stream.
+            **kwargs: Additional arguments passed to arun_a2a_stream.
+
+        Yields:
+            SSEChunk dicts with normalized structure:
+            - status: "success" | "error"
+            - task_state: "working" | "completed" | "failed" | "canceled"
+            - content: Text content or None
+            - event_type: Always string (never enum)
+            - final: True for terminal events
+            - metadata: Normalized metadata dict
+            - artifacts: Only present when non-empty
+        '''
+    def register_a2a_agents(self, agents: list[AgentCard]) -> None:
+        """Register A2A agents (not supported for Langflow agents).
+
+        Args:
+            agents: List of AgentCard instances.
+
+        Raises:
+            NotImplementedError: Langflow agents don't support A2A agent registration.
+        """
+    def add_mcp_server(self, mcp_config: dict[str, dict[str, Any]]) -> None:
+        """Add MCP server configuration (not supported for Langflow agents).
+
+        Args:
+            mcp_config: MCP server configuration.
+
+        Raises:
+            NotImplementedError: Langflow agents don't support MCP servers.
+        """
+    async def health_check(self) -> bool:
+        """Check if the Langflow API is accessible.
+
+        Returns:
+            True if the API is accessible, False otherwise.
+        """

aip_agents/agent/langgraph_memory_enhancer_agent.pyi

@@ -0,0 +1,49 @@
+from _typeshed import Incomplete
+from aip_agents.agent.langgraph_react_agent import LangGraphReactAgent as LangGraphReactAgent
+from aip_agents.agent.system_instruction_context import get_current_date_context as get_current_date_context
+from aip_agents.memory.guidance import MEM0_MEMORY_RECALL_GUIDANCE as MEM0_MEMORY_RECALL_GUIDANCE
+from aip_agents.tools.memory_search_tool import LongTermMemorySearchTool as LongTermMemorySearchTool, MEMORY_SEARCH_TOOL_NAME as MEMORY_SEARCH_TOOL_NAME, Mem0SearchTool as Mem0SearchTool
+from aip_agents.utils.logger import get_logger as get_logger
+from langgraph.graph import StateGraph
+from langgraph.graph.state import CompiledStateGraph
+
+logger: Incomplete
+
+class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
+    """Simplified mini-agent for automatic memory retrieval and query enhancement.
+
+    This agent has a simple 2-node LangGraph (agent + tools) and uses existing memory
+    infrastructure to enhance user queries with relevant context. It acts as a
+    preprocessing layer that automatically attempts memory retrieval for every query.
+
+    Key features:
+    - Uses runtime `memory_user_id` provided via call arguments (no static storage)
+    - Uses simplified instruction reusing existing guidance
+    - Standard 2-node LangGraph pattern (agent -> tools -> agent)
+    - Automatically enhances queries with memory context when available
+    - Returns original query unchanged if no relevant memories found
+    """
+    def __init__(self, memory, **kwargs) -> None:
+        """Initialize the LangGraphMemoryEnhancerAgent with memory backend and configuration.
+
+        Args:
+            memory: Memory backend instance (Mem0Memory or compatible)
+            **kwargs: Additional arguments passed to BaseLangGraphAgent, including:
+                - memory_agent_id: Fallback user ID for memory operations
+                - model: LLM model to use for memory decisions
+                - Other BaseLangGraphAgent parameters
+        """
+    def define_graph(self, graph_builder: StateGraph) -> CompiledStateGraph:
+        """Define the 3-node memory recall LangGraph for this agent.
+
+        This creates a streamlined ReAct-inspired structure that reuses
+        `LangGraphReactAgent` helpers for robust LM invocation, token usage tracking,
+        error handling, and tool execution.
+
+        Args:
+            graph_builder: LangGraph `StateGraph` builder instance used to register nodes and
+                edges for compilation.
+
+        Returns:
+            CompiledStateGraph: The compiled memory recall graph ready for execution.
+        """

aip_agents/agent/langgraph_react_agent.py

@@ -18,14 +18,14 @@ from collections.abc import Awaitable, Callable, Sequence
 from dataclasses import asdict, dataclass
 from functools import reduce
 from textwrap import dedent
-from typing import TYPE_CHECKING, Annotated, Any
+from typing import TYPE_CHECKING, Annotated, Any, cast
 
-from deprecated import deprecated
+from deprecated import deprecated  # type: ignore[import-untyped]
 
 if TYPE_CHECKING:
     from aip_agents.guardrails.manager import GuardrailManager
-from gllm_core.event import EventEmitter
-from gllm_core.schema import Chunk
+from gllm_core.event import EventEmitter  # type: ignore[import-untyped]
+from gllm_core.schema import Chunk  # type: ignore[import-untyped]
 from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import (
     AIMessage,
@@ -212,6 +212,12 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
             **kwargs,
         )
 
+        if self.model is None and self.lm_invoker is None:
+            logger.warning(
+                "Agent '%s': Model and LM invoker are both unset. Calls that require a model will fail.",
+                self.name,
+            )
+
         # Handle tool output management
         self.tool_output_manager = tool_output_manager
         self._pii_handlers_by_thread: dict[str, ToolPIIHandler] = {}
@@ -256,7 +262,7 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
 
         # Auto-configure TodoListMiddleware if planning enabled
         if planning:
-            middleware_list.append(TodoListMiddleware())
+            middleware_list.append(cast(AgentMiddleware, TodoListMiddleware()))
 
         # Auto-configure GuardrailMiddleware if guardrail provided
         if guardrail:
@@ -732,7 +738,7 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
         pending_artifacts: list[dict[str, Any]] = state.get("artifacts") or []
         reference_updates: list[Chunk] = []
         tool_map = {tool.name: tool for tool in self.resolved_tools}
-        pii_mapping = {}
+        pii_mapping: dict[str, str] = {}
 
         aggregated_metadata_delta: dict[str, Any] = {}
         total_tools_token_usage: list[UsageMetadata] = []
@@ -756,7 +762,8 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
                 ),
             )
 
-        tasks = [asyncio.create_task(run_tool(tc)) for tc in last_message.tool_calls]
+        normalized_tool_calls = [self._normalize_tool_call(tc) for tc in last_message.tool_calls]
+        tasks = [asyncio.create_task(run_tool(tc)) for tc in normalized_tool_calls]
 
         for coro in asyncio.as_completed(tasks):
             tool_result = await coro
@@ -779,6 +786,31 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
             pii_mapping,
         )
 
+    def _normalize_tool_call(self, tool_call: Any) -> dict[str, Any]:
+        """Normalize tool call inputs into a dict with required keys."""
+        if isinstance(tool_call, dict):
+            normalized = dict(tool_call)
+        elif hasattr(tool_call, "model_dump"):
+            normalized = tool_call.model_dump()
+        elif hasattr(tool_call, "dict"):
+            normalized = tool_call.dict()
+        elif hasattr(tool_call, "name") and hasattr(tool_call, "args"):
+            normalized = {
+                "id": getattr(tool_call, "id", None),
+                "name": getattr(tool_call, "name", None),
+                "args": getattr(tool_call, "args", None),
+            }
+        else:
+            raise TypeError("Tool call must be a dict-like object or ToolCall instance.")
+
+        if not isinstance(normalized, dict):
+            raise TypeError("Tool call normalization did not produce a dict.")
+
+        if "name" not in normalized or "args" not in normalized:
+            raise TypeError("Tool call must include 'name' and 'args' fields.")
+
+        return normalized
+
     def _accumulate_tool_result(  # noqa: PLR0913
         self,
         tool_result: Any,
@@ -787,7 +819,7 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
         aggregated_metadata_delta: dict[str, Any],
         reference_updates: list[Chunk],
         total_tools_token_usage: list[UsageMetadata],
-        pii_mapping: dict[str, str] | None,
+        pii_mapping: dict[str, str],
     ) -> None:  # noqa: PLR0913
         """Accumulate results from a single tool call.
 
@@ -1233,13 +1265,16 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
 
             # Create enhanced tool configuration with output management
             tool_config = self._create_enhanced_tool_config(config, state, tool_call["name"], tool_call_id)
+            if not isinstance(tool_config, dict):
+                raise TypeError("Tool configuration must be a dictionary.")
+            tool_config_runnable = tool_config
 
             arun_streaming_method = getattr(tool, TOOL_RUN_STREAMING_METHOD, None)
 
             if arun_streaming_method and callable(arun_streaming_method):
                 tool_output = await self._execute_tool_with_streaming(tool, tool_call, tool_config)
             else:
-                tool_output = await tool.ainvoke(resolved_args, tool_config)
+                tool_output = await tool.ainvoke(resolved_args, tool_config_runnable)
 
             references = extract_references_from_tool(tool, tool_output)
 
@@ -1513,7 +1548,7 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
         tool_call: dict[str, Any],
         execution_time: float,
         pending_artifacts: list[dict[str, Any]],
-    ) -> tuple[list[BaseMessage], list[dict[str, Any]], dict[str, Any]]:
+    ) -> tuple[list[ToolMessage], list[dict[str, Any]], dict[str, Any]]:
         """Process tool output into messages, artifacts, and metadata.
 
         Args:
@@ -1541,7 +1576,7 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
 
     def _handle_command_output(
         self, tool_output: Command, tool_call: dict[str, Any], execution_time: float, metadata_delta: dict[str, Any]
-    ) -> tuple[list[BaseMessage], list[dict[str, Any]], dict[str, Any]]:
+    ) -> tuple[list[ToolMessage], list[dict[str, Any]], dict[str, Any]]:
         """Handle Command type tool outputs.
 
         Args:
@@ -1570,7 +1605,7 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
 
     def _handle_string_output(
         self, tool_output: str, tool_call: dict[str, Any], execution_time: float
-    ) -> tuple[list[BaseMessage], list[dict[str, Any]], dict[str, Any]]:
+    ) -> tuple[list[ToolMessage], list[dict[str, Any]], dict[str, Any]]:
         """Handle string type tool outputs.
 
         Args:
@@ -1596,7 +1631,7 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
         execution_time: float,
         pending_artifacts: list[dict[str, Any]],
         metadata_delta: dict[str, Any],
-    ) -> tuple[list[BaseMessage], list[dict[str, Any]], dict[str, Any]]:
+    ) -> tuple[list[ToolMessage], list[dict[str, Any]], dict[str, Any]]:
         """Handle legacy dict and other tool outputs.
 
         Args:
@@ -1694,8 +1729,11 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
             self._emit_default_tool_call_event(writer, tool_name, tool_call_id, tool_args)
 
             streaming_kwargs = self._build_streaming_kwargs(tool_args, tool_config)
+            arun_streaming_method = getattr(tool, TOOL_RUN_STREAMING_METHOD, None)
+            if not callable(arun_streaming_method):
+                raise RuntimeError(f"Tool '{tool_name}' does not implement streaming.")
 
-            async for chunk in tool.arun_streaming(**streaming_kwargs):
+            async for chunk in arun_streaming_method(**streaming_kwargs):
                 final_output, saw_tool_result = self._handle_streaming_chunk(
                     chunk=chunk,
                     writer=writer,
@@ -2125,6 +2163,9 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
 
         effective_event_emitter = state.get("event_emitter") or self.event_emitter
 
+        if self.lm_invoker is None:
+            raise RuntimeError("LM invoker is required for this execution path.")
+
         if self.resolved_tools:
             self.lm_invoker.set_tools(self.resolved_tools)
 
@@ -2183,6 +2224,9 @@ class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
         ):
             langchain_prompt = [SystemMessage(content=enhanced_instruction)] + list(current_messages)
 
+        if self.model is None:
+            raise RuntimeError("Model is required for this execution path.")
+
         model_with_tools = self.model.bind_tools(self.resolved_tools) if self.resolved_tools else self.model
 
         ai_message = await model_with_tools.ainvoke(langchain_prompt, config)