aip-agents-binary 0.5.20__py3-none-any.whl → 0.5.22__py3-none-any.whl

aip_agents/__init__.pyi

@@ -0,0 +1,19 @@
+__all__ = ['a2a', 'agent', 'clients', 'constants', 'credentials', 'executor', 'memory', 'mcp', 'schema', 'sentry', 'storage', 'tools', 'types', 'utils', '__version__']
+
+__version__: str
+
+# Names in __all__ with no definition:
+#   a2a
+#   agent
+#   clients
+#   constants
+#   credentials
+#   executor
+#   mcp
+#   memory
+#   schema
+#   sentry
+#   storage
+#   tools
+#   types
+#   utils

aip_agents/a2a/__init__.pyi

@@ -0,0 +1,3 @@
+from aip_agents.a2a.types import ArtifactType as ArtifactType, MimeType as MimeType, get_extension_from_mime_type as get_extension_from_mime_type, get_mime_type_from_filename as get_mime_type_from_filename
+
+__all__ = ['ArtifactType', 'MimeType', 'get_mime_type_from_filename', 'get_extension_from_mime_type']

aip_agents/a2a/server/__init__.pyi

@@ -0,0 +1,4 @@
+from aip_agents.a2a.server.google_adk_executor import GoogleADKExecutor as GoogleADKExecutor
+from aip_agents.a2a.server.langgraph_executor import LangGraphA2AExecutor as LangGraphA2AExecutor
+
+__all__ = ['LangGraphA2AExecutor', 'GoogleADKExecutor']

aip_agents/a2a/server/base_executor.pyi

@@ -0,0 +1,73 @@
+from _typeshed import Incomplete
+from a2a.server.agent_execution import AgentExecutor as A2ASDKExecutor, RequestContext
+from a2a.server.events.event_queue import EventQueue
+from abc import ABC, abstractmethod
+from aip_agents.types import A2AEvent as A2AEvent, A2AStreamEventType as A2AStreamEventType
+from aip_agents.utils import serialize_references_for_metadata as serialize_references_for_metadata
+from aip_agents.utils.artifact_helpers import ArtifactHandler as ArtifactHandler
+from aip_agents.utils.logger import get_logger as get_logger
+from aip_agents.utils.metadata_helper import MetadataFieldKeys as MetadataFieldKeys
+from collections.abc import Callable as Callable
+from dataclasses import dataclass
+from typing import Any
+
+logger: Incomplete
+
+@dataclass
+class StatusUpdateParams:
+    """Parameters for status updates."""
+    metadata: dict[str, Any] | None = ...
+    final: bool = ...
+    task_id: str | None = ...
+    context_id: str | None = ...
+
+class BaseA2AExecutor(A2ASDKExecutor, ABC):
+    """Abstract base class for GLLM Agent framework's A2A server-side executors.
+
+    This class extends the A2A SDK's `AgentExecutor`. It serves as a common
+    foundation for specific executors tailored to different agent types within the
+    `aip-agents` framework, such as `LangGraphA2AExecutor` or
+    `GoogleADKA2AExecutor`.
+
+    Subclasses are required to implement the `execute` method to handle A2A
+    requests. The `cancel` method has a common implementation.
+
+    Attributes:
+        _active_tasks (dict[str, asyncio.Task]): A dictionary mapping task IDs to
+            their corresponding asyncio.Task instances for active agent executions.
+    """
+    def __init__(self) -> None:
+        """Initializes the BaseA2AExecutor."""
+    @abstractmethod
+    async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
+        """Processes an incoming agent request and manages its execution.
+
+        Implementations should interact with the underlying agent (e.g., a LangGraph
+        or Google ADK agent) based on the provided `context`. All communications
+        regarding task status, artifacts, and completion must be sent through
+        the `event_queue`.
+
+        This method typically involves:
+        1. Calling `_handle_initial_execute_checks` for validation and setup.
+        2. Defining an agent-specific coroutine for processing (e.g., `_process_stream`).
+        3. Calling `_execute_agent_processing` to manage the lifecycle of this coroutine.
+
+        Args:
+            context (RequestContext): The request context containing information about the incoming
+                     message, task, and other relevant data.
+            event_queue (EventQueue): The queue used to send events (e.g., task status updates,
+                         artifacts) back to the A2A server infrastructure.
+        """
+    async def cancel(self, context: RequestContext, event_queue: EventQueue) -> None:
+        """Handles a request to cancel an ongoing agent task.
+
+        This method attempts to cancel an active asyncio.Task associated with the
+        given `context.task_id`. It waits for a short period for the task to handle
+        the cancellation gracefully. The `event_queue` is used to report the
+        outcome of the cancellation attempt (e.g., success, error during cleanup).
+
+        Args:
+            context (RequestContext): The request context for the task to be cancelled,
+                primarily used to get the `task_id` and `context_id`.
+            event_queue (EventQueue): The queue for sending cancellation status events.
+        """

aip_agents/a2a/server/google_adk_executor.pyi

@@ -0,0 +1,51 @@
+from _typeshed import Incomplete
+from a2a.server.agent_execution import RequestContext
+from a2a.server.events.event_queue import EventQueue
+from aip_agents.a2a.server.base_executor import BaseA2AExecutor as BaseA2AExecutor, StatusUpdateParams as StatusUpdateParams
+from aip_agents.agent.google_adk_constants import DEFAULT_AUTH_URL as DEFAULT_AUTH_URL
+from aip_agents.agent.interfaces import GoogleADKAgentProtocol as GoogleADKAgentProtocol
+from aip_agents.utils.logger import get_logger as get_logger
+
+logger: Incomplete
+
+class GoogleADKExecutor(BaseA2AExecutor):
+    '''A2A Executor for serving a `GoogleADKAgent`.
+
+    This executor bridges the A2A server protocol with a `aip_agents.agent.GoogleADKAgent`.
+    It handles incoming requests by invoking the agent\'s `arun_a2a_stream` method,
+    which is specifically designed to yield ADK events in an A2A-compatible dictionary
+    format. This executor\'s `_process_stream` method is tailored to handle this stream,
+    including ADK-specific statuses like "auth_required", before delegating common
+    status handling to `BaseA2AExecutor._handle_stream_event`.
+
+    It leverages common functionality from `BaseA2AExecutor` for task management,
+    initial request checks, and cancellation.
+
+    Attributes:
+        agent (GoogleADKAgentProtocol): The instance of `GoogleADKAgent`-compatible class to execute.
+    '''
+    agent: GoogleADKAgentProtocol
+    def __init__(self, agent: GoogleADKAgentProtocol) -> None:
+        """Initializes the GoogleADKExecutor.
+
+        Args:
+            agent: Component implementing `GoogleADKAgentProtocol`.
+
+        Raises:
+            TypeError: If the provided agent does not satisfy `GoogleADKAgentProtocol`.
+        """
+    async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
+        """Processes an incoming agent request using the `GoogleADKAgent`.
+
+        This method first performs initial checks using `_handle_initial_execute_checks`
+        from the base class. If successful, it prepares the `_process_stream` coroutine
+        and passes it to `_execute_agent_processing` (also from the base class) to
+        manage its execution lifecycle. The `_process_stream` method is responsible for
+        calling the agent's `arun_a2a_stream` and handling its ADK-specific output.
+
+        Args:
+            context (RequestContext): The A2A request context containing message details,
+                task ID, and context ID.
+            event_queue (EventQueue): The queue for sending A2A events (task status,
+                artifacts) back to the server.
+        """

aip_agents/a2a/server/langflow_executor.pyi

@@ -0,0 +1,43 @@
+from _typeshed import Incomplete
+from a2a.server.agent_execution import RequestContext
+from a2a.server.events.event_queue import EventQueue
+from abc import ABC
+from aip_agents.a2a.server.base_executor import BaseA2AExecutor as BaseA2AExecutor, StatusUpdateParams as StatusUpdateParams
+from aip_agents.agent.interfaces import LangflowAgentProtocol as LangflowAgentProtocol
+from aip_agents.utils.logger import get_logger as get_logger
+
+logger: Incomplete
+
+class LangflowA2AExecutor(BaseA2AExecutor, ABC):
+    """A2A executor for Langflow agents.
+
+    This class extends BaseA2AExecutor to provide A2A execution capabilities
+    for Langflow agents. It follows the same patterns as LangGraphA2AExecutor
+    but handles Langflow-specific streaming and execution logic.
+
+    Attributes:
+        agent: The LangflowAgent-compatible instance to be executed.
+    """
+    agent: LangflowAgentProtocol
+    def __init__(self, langflow_agent_instance: LangflowAgentProtocol) -> None:
+        """Initialize the LangflowA2AExecutor.
+
+        Args:
+            langflow_agent_instance: Component implementing `LangflowAgentProtocol`.
+
+        Raises:
+            TypeError: If the agent does not satisfy `LangflowAgentProtocol`.
+        """
+    async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
+        """Process an incoming agent request using a Langflow agent.
+
+        This method handles the execution lifecycle for Langflow agents:
+        1. Performs initial validation and setup
+        2. Creates agent processing coroutine
+        3. Manages the execution lifecycle through BaseA2AExecutor
+
+        Args:
+            context: The A2A request context containing message details,
+                task ID, and context ID.
+            event_queue: The queue for sending A2A events back to the server.
+        """

aip_agents/a2a/server/langgraph_executor.pyi

@@ -0,0 +1,47 @@
+from _typeshed import Incomplete
+from a2a.server.agent_execution import RequestContext
+from a2a.server.events.event_queue import EventQueue
+from abc import ABC
+from aip_agents.a2a.server.base_executor import BaseA2AExecutor as BaseA2AExecutor, StatusUpdateParams as StatusUpdateParams
+from aip_agents.agent.interfaces import LangGraphAgentProtocol as LangGraphAgentProtocol
+from aip_agents.schema.step_limit import StepLimitConfig as StepLimitConfig
+from aip_agents.utils.logger import get_logger as get_logger
+
+logger: Incomplete
+
+class LangGraphA2AExecutor(BaseA2AExecutor, ABC):
+    """Base class for LangChain-based A2A executors.
+
+    This class extends BaseA2AExecutor to provide common functionality for executors
+    that work with LangChain-based agents (LangChainAgent and LangGraphAgent).
+    It implements shared methods for handling streaming responses and managing
+    agent execution, while leaving agent-specific initialization to subclasses.
+
+    Attributes:
+        agent (LangGraphAgentProtocol): The LangChain-based agent instance to be executed.
+    """
+    agent: LangGraphAgentProtocol
+    def __init__(self, langgraph_agent_instance: LangGraphAgentProtocol) -> None:
+        """Initializes the LangGraphA2AExecutor.
+
+        Args:
+            langgraph_agent_instance: Component implementing `LangGraphAgentProtocol`.
+
+        Raises:
+            TypeError: If the provided agent does not satisfy `LangGraphAgentProtocol`.
+        """
+    async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
+        """Processes an incoming agent request using a LangChain-based agent.
+
+        This method first performs initial checks using _handle_initial_execute_checks.
+        If successful, it prepares the _process_stream coroutine and passes it to
+        _execute_agent_processing from the base class to manage its lifecycle.
+        The _process_stream method is responsible for calling the agent's
+        arun_a2a_stream and handling its output.
+
+        Args:
+            context (RequestContext): The A2A request context containing message details,
+                task ID, and context ID.
+            event_queue (EventQueue): The queue for sending A2A events (task status,
+                artifacts) back to the server.
+        """

aip_agents/a2a/types.pyi

@@ -0,0 +1,132 @@
+from _typeshed import Incomplete
+from enum import StrEnum
+from pydantic import BaseModel
+from typing import Any
+
+class MimeType(StrEnum):
+    """Common MIME types for A2A artifacts.
+
+    This class provides constants for commonly used MIME types in artifact generation,
+    ensuring consistency and reducing typos across the codebase.
+    """
+    TEXT_PLAIN: str
+    TEXT_HTML: str
+    TEXT_CSS: str
+    TEXT_JAVASCRIPT: str
+    TEXT_CSV: str
+    TEXT_XML: str
+    TEXT_MARKDOWN: str
+    APPLICATION_JSON: str
+    APPLICATION_XML: str
+    APPLICATION_PDF: str
+    APPLICATION_ZIP: str
+    APPLICATION_GZIP: str
+    APPLICATION_TAR: str
+    APPLICATION_OCTET_STREAM: str
+    APPLICATION_MSWORD: str
+    APPLICATION_EXCEL: str
+    APPLICATION_POWERPOINT: str
+    APPLICATION_DOCX: str
+    APPLICATION_XLSX: str
+    APPLICATION_PPTX: str
+    IMAGE_JPEG: str
+    IMAGE_PNG: str
+    IMAGE_GIF: str
+    IMAGE_WEBP: str
+    IMAGE_SVG: str
+    IMAGE_BMP: str
+    IMAGE_TIFF: str
+    IMAGE_ICO: str
+    AUDIO_MP3: str
+    AUDIO_WAV: str
+    AUDIO_OGG: str
+    AUDIO_AAC: str
+    AUDIO_FLAC: str
+    VIDEO_MP4: str
+    VIDEO_AVI: str
+    VIDEO_MOV: str
+    VIDEO_WMV: str
+    VIDEO_WEBM: str
+    VIDEO_MKV: str
+    FONT_TTF: str
+    FONT_OTF: str
+    FONT_WOFF: str
+    FONT_WOFF2: str
+
+class ArtifactType(StrEnum):
+    """Common artifact types for A2A artifacts.
+
+    This class provides constants for artifact types used in the A2A protocol.
+    """
+    FILE: str
+    DATA: str
+    TEXT: str
+
+EXTENSION_TO_MIME_TYPE: Incomplete
+MIME_TYPE_TO_EXTENSION: Incomplete
+
+def get_mime_type_from_filename(filename: str) -> str:
+    '''Get MIME type from filename extension.
+
+    Args:
+        filename: The filename to get the MIME type for.
+
+    Returns:
+        The MIME type string, or application/octet-stream if unknown.
+
+    Example:
+        >>> get_mime_type_from_filename("data.csv")
+        \'text/csv\'
+        >>> get_mime_type_from_filename("image.png")
+        \'image/png\'
+        >>> get_mime_type_from_filename("unknown.xyz")
+        \'application/octet-stream\'
+    '''
+def get_extension_from_mime_type(mime_type: str) -> str | None:
+    '''Get file extension from MIME type.
+
+    Args:
+        mime_type: The MIME type to get the extension for.
+
+    Returns:
+        The file extension (with dot) or None if not found.
+
+    Example:
+        >>> get_extension_from_mime_type("text/csv")
+        \'.csv\'
+        >>> get_extension_from_mime_type("image/png")
+        \'.png\'
+        >>> get_extension_from_mime_type("unknown/type")
+        None
+    '''
+
+class Artifact(BaseModel):
+    """Represents an artifact payload used by A2A helpers and executors.
+
+    This model standardizes the structure for artifacts generated by tools and
+    passed through the A2A pipeline.
+
+    Attributes:
+        artifact_type (ArtifactType): The type of artifact. Defaults to FILE.
+        data (str): Base64-encoded content of the artifact.
+        name (str): Display name or filename of the artifact.
+        description (str): Optional description for the artifact. Defaults to empty string.
+        mime_type (str): MIME type of the artifact content.
+        metadata (dict[str, Any] | None): Optional per-artifact metadata to pass through.
+    """
+    artifact_type: ArtifactType
+    data: str
+    name: str
+    description: str
+    mime_type: str
+    metadata: dict[str, Any] | None
+    @classmethod
+    def validate_base64(cls, v: str) -> str:
+        """Validate that 'data' is a valid base64 string.
+
+        Args:
+            v (str): The base64 string to validate.
+
+        Returns:
+            str: The validated base64 string if valid.
+        """

aip_agents/agent/__init__.pyi

@@ -0,0 +1,9 @@
+from aip_agents.agent.base_agent import BaseAgent as BaseAgent
+from aip_agents.agent.base_langgraph_agent import BaseLangGraphAgent as BaseLangGraphAgent
+from aip_agents.agent.google_adk_agent import GoogleADKAgent as GoogleADKAgent
+from aip_agents.agent.interface import AgentInterface as AgentInterface
+from aip_agents.agent.langflow_agent import LangflowAgent as LangflowAgent
+from aip_agents.agent.langgraph_memory_enhancer_agent import LangGraphMemoryEnhancerAgent as LangGraphMemoryEnhancerAgent
+from aip_agents.agent.langgraph_react_agent import LangChainAgent as LangChainAgent, LangGraphAgent as LangGraphAgent, LangGraphReactAgent as LangGraphReactAgent
+
+__all__ = ['AgentInterface', 'BaseAgent', 'BaseLangGraphAgent', 'LangGraphReactAgent', 'GoogleADKAgent', 'LangGraphAgent', 'LangChainAgent', 'LangflowAgent', 'LangGraphMemoryEnhancerAgent']

aip_agents/agent/base_agent.pyi

@@ -0,0 +1,221 @@
+from _typeshed import Incomplete
+from a2a.types import AgentCard
+from aip_agents.agent.interface import AgentInterface as AgentInterface
+from aip_agents.credentials.manager import CredentialsManager as CredentialsManager
+from aip_agents.mcp.client.base_mcp_client import BaseMCPClient as BaseMCPClient
+from aip_agents.schema.agent import A2AClientConfig as A2AClientConfig, AgentConfig as AgentConfig, BaseAgentConfig as BaseAgentConfig, CredentialType as CredentialType
+from aip_agents.schema.model_id import ModelId as ModelId, ModelProvider as ModelProvider
+from aip_agents.utils.a2a_connector import A2AConnector as A2AConnector
+from aip_agents.utils.logger import get_logger as get_logger
+from aip_agents.utils.name_preprocessor.name_preprocessor import NamePreprocessor as NamePreprocessor
+from collections.abc import AsyncGenerator
+from starlette.applications import Starlette
+from typing import Any
+
+logger: Incomplete
+AGENT_EXECUTOR_MAPPING: Incomplete
+DEFAULT_RETRY_CONFIG: Incomplete
+LM_EXCLUDE_FIELDS: Incomplete
+CUSTOM_PROVIDERS: Incomplete
+OUTPUT_ANALYTICS_KEY: str
+
+class BaseAgent(AgentInterface):
+    """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
+    tool_configs: Incomplete
+    mcp_client: BaseMCPClient | None
+    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.
+        """
+    @property
+    def mcp_config(self) -> dict[str, dict[str, Any]]:
+        """Read-only view of MCP configuration.
+
+        Returns a copy to prevent direct mutation; use add_mcp_server() for changes.
+        """
+    @mcp_config.setter
+    def mcp_config(self, value: dict[str, dict[str, Any]]) -> None:
+        """Set MCP configuration and maintain synchronization.
+
+        Automatically resets initialization flag and recreates client to ensure consistency.
+        Prefer using add_mcp_server() for proper validation.
+
+        Args:
+            value (dict[str, dict[str, Any]]): The MCP configuration to set.
+        """
+    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.
+        """