aip-agents-binary 0.6.4__py3-none-any.whl → 0.6.5__py3-none-any.whl

aip_agents/__init__.pyi

@@ -1,19 +0,0 @@
-__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

@@ -1,3 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,132 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,221 +0,0 @@
-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.
-        """