aip-agents-binary 0.4.8__cp312-cp312-win_amd64.whl → 0.5.4__cp312-cp312-win_amd64.whl

aip_agents/agent/google_adk_agent.pyi

@@ -1,18 +1,19 @@
 from _typeshed import Incomplete
-from a2a.types import AgentCard as AgentCard
+from a2a.types import AgentCard
 from aip_agents.agent.base_agent import BaseAgent as BaseAgent
-from aip_agents.mcp.client import GoogleADKMCPClient as GoogleADKMCPClient
+from aip_agents.agent.google_adk_constants import DEFAULT_AUTH_URL as DEFAULT_AUTH_URL
+from aip_agents.mcp.client.google_adk.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 aip_agents.utils.logger import get_logger as get_logger
+from collections.abc import AsyncGenerator, AsyncIterator
 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
+from typing import Any
 
 logger: Incomplete
 MODEL_TEMPERATURE: float
-DEFAULT_AUTH_URL: str
 
 class A2AToolInput(BaseModel):
     """Input for the A2ATool."""
@@ -26,14 +27,28 @@ class A2ATool(LangchainBaseTool):
     agent_card: AgentCard
 
 def create_a2a_tool(agent_card: AgentCard) -> LangchainTool:
-    """Create a LangChain tool from an A2A agent card."""
+    """Create a LangChain tool from an A2A agent card.
+
+    Args:
+        agent_card (AgentCard): The A2A agent card to create a tool for.
+
+    Returns:
+        LangchainTool: A LangChain tool that can communicate with the A2A agent.
+    """
 
 class GoogleADKAgent(BaseAgent):
-    """An agent that wraps a native Google ADK Agent.
+    """An agent that wraps a native Google ADK Agent with MCP support.
 
     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.
+    async-first design. It includes persistent MCP session management for
+    stateful tool execution across multiple calls.
+
+    The agent supports:
+    - Native ADK tools (FunctionTool, LangchainTool)
+    - MCP tools via GoogleADKMCPClient with session persistence
+    - Sub-agent delegation using ADK's built-in multi-agent capabilities
+    - A2A communication through tool integration
     """
     adk_native_agent: LlmAgent
     model: Incomplete
@@ -43,7 +58,7 @@ class GoogleADKAgent(BaseAgent):
     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.
+        '''Initializes the GoogleADKAgent with MCP support.
 
         Args:
             name: The name of this wrapper agent.
@@ -73,15 +88,20 @@ class GoogleADKAgent(BaseAgent):
                           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.
+        '''Asynchronously runs the agent with MCP tool support.
+
+        This method ensures MCP tools are properly initialized before execution
+        and provides persistent session management for stateful MCP tools.
 
         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.
+            A dictionary containing the output, tool_calls, and session_id.
         '''
+    async def cleanup(self) -> None:
+        """Clean up ADK and MCP resources."""
     async def arun_stream(self, query: str, **kwargs: Any) -> AsyncIterator[str]:
         '''Runs the agent with the given query and streams the response parts.
 
@@ -98,18 +118,11 @@ class GoogleADKAgent(BaseAgent):
         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.
+            agent_cards (list[AgentCard]): List of A2A agent cards to register as tools.
 
-        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.
+        Returns:
+            None: The tools are added to the existing tools list.
         """
     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.

aip_agents/agent/google_adk_constants.pyi

@@ -0,0 +1,3 @@
+__all__ = ['DEFAULT_AUTH_URL']
+
+DEFAULT_AUTH_URL: str

aip_agents/agent/hitl/__init__.pyi

@@ -0,0 +1,6 @@
+from aip_agents.agent.hitl.config import ToolApprovalConfig as ToolApprovalConfig
+from aip_agents.agent.hitl.manager import ApprovalManager as ApprovalManager
+from aip_agents.agent.hitl.prompt import BasePromptHandler as BasePromptHandler, DeferredPromptHandler as DeferredPromptHandler
+from aip_agents.schema.hitl import ApprovalDecision as ApprovalDecision, ApprovalLogEntry as ApprovalLogEntry, ApprovalRequest as ApprovalRequest
+
+__all__ = ['ToolApprovalConfig', 'ApprovalManager', 'ApprovalDecision', 'ApprovalLogEntry', 'ApprovalRequest', 'BasePromptHandler', 'DeferredPromptHandler']

aip_agents/agent/hitl/config.pyi

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+
+@dataclass
+class ToolApprovalConfig:
+    """Configuration for HITL approval behavior attached to a tool.
+
+    Supplying this configuration marks the tool as requiring approval. Only the
+    timeout is configurable; timeouts always result in a safe skip.
+
+    Attributes:
+        timeout_seconds: Defaults to 300; must be >0.
+    """
+    timeout_seconds: int = ...
+    def __post_init__(self) -> None:
+        """Validate configuration after initialization."""

aip_agents/agent/hitl/langgraph_hitl_mixin.pyi

@@ -0,0 +1,42 @@
+from _typeshed import Incomplete
+from aip_agents.agent.hitl.config import ToolApprovalConfig as ToolApprovalConfig
+from aip_agents.agent.hitl.manager import ApprovalManager as ApprovalManager
+from aip_agents.schema.hitl import ApprovalDecision as ApprovalDecision, ApprovalDecisionType as ApprovalDecisionType, ApprovalRequest as ApprovalRequest, HitlMetadata as HitlMetadata
+from aip_agents.schema.langgraph import ToolCallResult as ToolCallResult
+from aip_agents.tools.tool_config_injector import TOOL_CONFIGS_KEY as TOOL_CONFIGS_KEY
+from aip_agents.utils.datetime import ensure_utc_datetime as ensure_utc_datetime
+from aip_agents.utils.logger import get_logger as get_logger
+from collections.abc import Callable
+from typing import Any
+
+logger: Incomplete
+MAX_CONTEXT_MESSAGE_LENGTH: int
+
+class LangGraphHitLMixin:
+    """Provide Human-in-the-Loop helpers for LangGraph agents."""
+    tool_configs: dict[str, Any] | None
+    name: str
+    @property
+    def hitl_manager(self) -> ApprovalManager | None:
+        """Return the active ``ApprovalManager``, creating one if needed."""
+    @hitl_manager.setter
+    def hitl_manager(self, manager: ApprovalManager | None) -> None:
+        """Set the HITL approval manager instance.
+
+        Args:
+            manager: ApprovalManager instance or None.
+        """
+    def ensure_hitl_manager(self) -> ApprovalManager | None:
+        """Ensure an ``ApprovalManager`` exists when HITL configs are present."""
+    def use_hitl_manager(self, manager: ApprovalManager) -> None:
+        """Replace the current ``ApprovalManager`` with the supplied instance.
+
+        Args:
+            manager: The ApprovalManager instance to use for HITL approvals.
+        """
+    def register_hitl_notifier(self, notifier: Callable[[ApprovalRequest], None]) -> None:
+        """Register a notifier callback to receive HITL approval requests.
+
+        Args:
+            notifier: Callback function that will be called with approval requests.
+        """

aip_agents/agent/hitl/manager.pyi

@@ -0,0 +1,199 @@
+from _typeshed import Incomplete
+from aip_agents.agent.hitl.config import ToolApprovalConfig as ToolApprovalConfig
+from aip_agents.agent.hitl.prompt import BasePromptHandler as BasePromptHandler, DeferredPromptHandler as DeferredPromptHandler
+from aip_agents.schema.hitl import ApprovalDecision as ApprovalDecision, ApprovalDecisionType as ApprovalDecisionType, ApprovalLogEntry as ApprovalLogEntry, ApprovalRequest as ApprovalRequest
+from collections.abc import Callable as Callable, Iterable
+from typing import Any
+
+MAX_ARGUMENTS_PREVIEW_LENGTH: int
+DECISION_MESSAGE_MAP: Incomplete
+TOOL_EXECUTION_BLOCKING_DECISIONS: Incomplete
+
+class ApprovalManager:
+    """Manages the HITL approval workflow for tools.
+
+    This class coordinates the approval process from configuration through
+    to final decision, handling timeouts and cleanup.
+    """
+    def __init__(self, prompt_handler: BasePromptHandler | None = None) -> None:
+        """Initialize the approval manager.
+
+        Args:
+            prompt_handler: Optional prompt handler for user interaction.
+                Defaults to DeferredPromptHandler which exposes pending requests
+                for out-of-band resolution.
+        """
+    def create_approval_request(self, tool_name: str, arguments: dict[str, Any], config: ToolApprovalConfig, context: dict[str, str] | None = None) -> ApprovalRequest:
+        """Create a new approval request for a tool call.
+
+        Args:
+            tool_name: Name of the tool being called.
+            arguments: Tool arguments (will be JSON serialized).
+            config: Approval configuration for this tool.
+            context: Optional context metadata. Defaults to None.
+
+        Returns:
+            The created approval request.
+        """
+    def get_pending_request(self, request_id: str) -> ApprovalRequest | None:
+        """Get a pending approval request by ID.
+
+        Args:
+            request_id: The unique identifier of the approval request.
+
+        Returns:
+            The pending approval request if found, None otherwise.
+        """
+    def approve_request(self, request: ApprovalRequest, operator_input: str = 'approved') -> ApprovalDecision:
+        '''Record an approval decision for a request.
+
+        This method creates an approval decision, calculates latency metrics,
+        and removes the request from the active requests queue.
+
+        Args:
+            request: The approval request to approve.
+            operator_input: Raw operator input that led to this decision. Defaults to "approved".
+
+        Returns:
+            The recorded approval decision.
+        '''
+    def reject_request(self, request: ApprovalRequest, operator_input: str = 'rejected') -> ApprovalDecision:
+        '''Record a rejection decision for a request.
+
+        This method creates a rejection decision, calculates latency metrics,
+        and removes the request from the active requests queue.
+
+        Args:
+            request: The approval request to reject.
+            operator_input: Raw operator input that led to this decision. Defaults to "rejected".
+
+        Returns:
+            The recorded rejection decision.
+        '''
+    def skip_request(self, request: ApprovalRequest, operator_input: str = 'skipped') -> ApprovalDecision:
+        '''Record a skip decision for a request.
+
+        This method creates a skip decision, calculates latency metrics,
+        and removes the request from the active requests queue.
+
+        Args:
+            request: The approval request to skip.
+            operator_input: Raw operator input that led to this decision. Defaults to "skipped".
+
+        Returns:
+            The recorded skip decision.
+        '''
+    def timeout_request(self, request: ApprovalRequest, operator_input: str = 'TIMEOUT') -> ApprovalDecision:
+        '''Record a timeout decision for a request, always skipping the tool.
+
+        Args:
+            request (ApprovalRequest): The approval request that timed out.
+            operator_input (str, optional): Input from the operator (defaults to "TIMEOUT").
+
+        Returns:
+            ApprovalDecision: The timeout decision.
+        '''
+    def check_timeout(self, request: ApprovalRequest) -> ApprovalDecision | None:
+        """Check if a request has timed out and return timeout decision if so.
+
+        Args:
+            request: The approval request to check.
+
+        Returns:
+            Timeout decision if timed out, None otherwise.
+        """
+    async def prompt_for_decision(self, request: ApprovalRequest, timeout_seconds: int, context_keys: list[str] | None = None) -> ApprovalDecision:
+        """Prompt for a decision using the configured handler.
+
+        This method delegates to the configured prompt handler to obtain
+        an approval decision from the operator. The handler may be interactive
+        (CLI) or deferred (programmatic, resume-in-place).
+
+        Args:
+            request: The approval request to prompt for.
+            timeout_seconds: How long to wait for input.
+            context_keys: Optional keys to display from context. Defaults to None.
+
+        Returns:
+            The operator's decision on the request.
+        """
+    def list_pending_requests(self) -> Iterable[ApprovalRequest]:
+        """Return a snapshot of currently pending requests.
+
+        This method provides a thread-safe snapshot of all currently active
+        approval requests that are waiting for operator decisions.
+
+        Returns:
+            An iterable of all pending approval requests.
+        """
+    def resolve_pending_request(self, request_id: str, decision: str, operator_input: str = '') -> ApprovalDecision:
+        '''Resolve a pending request with an explicit decision.
+
+        Args:
+            request_id: The unique identifier of the pending approval request.
+            decision: The decision string (e.g., "approved", "rejected", "skipped").
+            operator_input: Optional raw operator input, defaults to the decision string. Defaults to "".
+
+        Returns:
+            The recorded approval decision.
+
+        Raises:
+            KeyError: If no pending request exists with the given request_id.
+            ValueError: If the decision string is not supported.
+        '''
+    def create_log_entry(self, decision: ApprovalDecision, tool_name: str, agent_id: str | None = None, thread_id: str | None = None, additional_context: dict[str, Any] | None = None) -> ApprovalLogEntry:
+        """Create a log entry for a decision.
+
+        Args:
+            decision: The approval decision.
+            tool_name: Name of the tool.
+            agent_id: Optional agent identifier. Defaults to None.
+            thread_id: Optional thread/session identifier. Defaults to None.
+            additional_context: Optional additional logging context. Defaults to None.
+
+        Returns:
+            Structured log entry.
+        """
+    def cleanup_expired_requests(self) -> int:
+        """Clean up expired requests and return count of cleaned requests.
+
+        This method removes all approval requests that have exceeded their
+        timeout period from the active requests queue. This is typically
+        called periodically to prevent memory leaks from abandoned requests.
+
+        Returns:
+            The number of expired requests that were cleaned up.
+        """
+    def register_waiter(self, request_id: str, future: Any) -> None:
+        """Register a waiter future for an approval request.
+
+        Args:
+            request_id: The id for which to wait.
+            future: An asyncio.Future that will receive a tuple(decision, operator_input).
+        """
+    def unregister_waiter(self, request_id: str) -> None:
+        """Unregister a waiter if present (used on timeout/cancellation).
+
+        Args:
+            request_id (str): The ID of the request to unregister the waiter for.
+        """
+    async def wait_for_pending_decision(self, request: ApprovalRequest, timeout_seconds: int) -> ApprovalDecision:
+        """Wait for a pending request to be resolved and return the final decision.
+
+        Args:
+            request: The pending approval request to wait for.
+            timeout_seconds: Maximum time to wait before treating as timeout.
+
+        Returns:
+            The finalized approval decision.
+        """
+    @staticmethod
+    def get_decision_message(decision: ApprovalDecision) -> str:
+        """Get the appropriate message for a HITL decision.
+
+        Args:
+            decision: The approval decision to get a message for.
+
+        Returns:
+            A human-readable message explaining the decision outcome.
+        """

aip_agents/agent/hitl/models.pyi

@@ -0,0 +1,3 @@
+from aip_agents.schema.hitl import ApprovalDecision as ApprovalDecision, ApprovalDecisionType as ApprovalDecisionType, ApprovalLogEntry as ApprovalLogEntry, ApprovalRequest as ApprovalRequest
+
+__all__ = ['ApprovalDecisionType', 'ApprovalRequest', 'ApprovalDecision', 'ApprovalLogEntry']

aip_agents/agent/hitl/prompt/__init__.pyi

@@ -0,0 +1,4 @@
+from aip_agents.agent.hitl.prompt.base import BasePromptHandler as BasePromptHandler
+from aip_agents.agent.hitl.prompt.deferred import DeferredPromptHandler as DeferredPromptHandler
+
+__all__ = ['BasePromptHandler', 'DeferredPromptHandler']

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/interface.pyi

@@ -1,11 +1,11 @@
-import abc
 from a2a.types import AgentCard as AgentCard
 from abc import ABC, abstractmethod
-from aip_agents.agent.types import BaseAgentConfig as BaseAgentConfig
-from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
-from typing import Any, AsyncGenerator
+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, metaclass=abc.ABCMeta):
+class AgentInterface(ABC):
     """A general and minimal interface for agent implementations.
 
     Defines core execution methods (`__init__`, `run`, `arun`, `arun_stream`).

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.
+        """