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

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

aip_agents/agent/base_langgraph_agent.pyi

@@ -1,233 +0,0 @@
-from _typeshed import Incomplete
-from a2a.types import AgentCard as AgentCard
-from abc import abstractmethod
-from aip_agents.agent.base_agent import BaseAgent as BaseAgent
-from aip_agents.agent.system_instruction_context import get_current_date_context as get_current_date_context
-from aip_agents.constants import TEXT_PREVIEW_LENGTH as TEXT_PREVIEW_LENGTH
-from aip_agents.mcp.client import LangchainMCPClient as LangchainMCPClient
-from aip_agents.memory import BaseMemory as BaseMemory, MemoryFactory as MemoryFactory, MemoryMethod as MemoryMethod
-from aip_agents.memory.constants import MemoryDefaults as MemoryDefaults
-from aip_agents.schema.agent import StreamMode as StreamMode
-from aip_agents.schema.hitl import HitlMetadata as HitlMetadata
-from aip_agents.tools.tool_config_injector import CONFIG_SCHEMA_ATTR as CONFIG_SCHEMA_ATTR, TOOL_CONFIG_SCHEMA_ATTR as TOOL_CONFIG_SCHEMA_ATTR, inject_config_methods_into_tool as inject_config_methods_into_tool
-from aip_agents.types import A2AEvent as A2AEvent, A2AStreamEventType as A2AStreamEventType
-from aip_agents.utils import augment_query_with_file_paths as augment_query_with_file_paths, validate_references as validate_references
-from aip_agents.utils.langgraph.tool_managers.a2a_tool_manager import A2AToolManager as A2AToolManager
-from aip_agents.utils.langgraph.tool_managers.delegation_tool_manager import DelegationToolManager as DelegationToolManager
-from aip_agents.utils.logger import get_logger as get_logger
-from aip_agents.utils.metadata.activity_metadata_helper import create_tool_activity_info as create_tool_activity_info
-from aip_agents.utils.metadata_helper import DefaultStepMessages as DefaultStepMessages, Kind as Kind, MetadataFieldKeys as MetadataFieldKeys, Status as Status, end_step_counter_scope as end_step_counter_scope, get_next_step_number as get_next_step_number, start_step_counter_scope as start_step_counter_scope
-from aip_agents.utils.pii import deanonymize_final_response_content as deanonymize_final_response_content
-from aip_agents.utils.sse_chunk_transformer import SSEChunkTransformer as SSEChunkTransformer
-from aip_agents.utils.token_usage_helper import STEP_USAGE_KEY as STEP_USAGE_KEY, TOTAL_USAGE_KEY as TOTAL_USAGE_KEY, USAGE_METADATA_KEY as USAGE_METADATA_KEY
-from collections.abc import AsyncGenerator, Sequence
-from dataclasses import dataclass
-from gllm_core.event import EventEmitter
-from gllm_core.schema import Chunk as Chunk
-from langchain_core.tools import BaseTool
-from langgraph.graph import StateGraph
-from langgraph.graph.message import add_messages as add_messages
-from langgraph.graph.state import CompiledStateGraph
-from langgraph.types import Checkpointer
-from typing import Any
-
-logger: Incomplete
-
-@dataclass
-class _StreamingContext:
-    """Context object for managing streaming state and configuration."""
-    original_query: str
-    graph_input: dict[str, Any]
-    config: dict[str, Any]
-    memory_user_id: str | None
-    current_thread_id: str
-    token: Any
-    enable_token_streaming: bool
-    final_event_yielded: bool = ...
-    pending_artifacts: list | None = ...
-    seen_artifact_hashes: set | None = ...
-    processed_message_count: int = ...
-    final_state: dict[str, Any] | None = ...
-    last_final_content: str | None = ...
-    saved_memory: bool = ...
-    is_token_streaming: bool = ...
-    def __post_init__(self) -> None:
-        """Initialize mutable defaults."""
-
-class BaseLangGraphAgent(BaseAgent):
-    """Base class for LangGraph-based agents with unified tool approach.
-
-    Provides core LangGraph functionality including:
-    - Graph compilation and execution
-    - State schema management
-    - I/O mapping between user inputs and graph states
-    - Event emission support
-    - Tool resolution and handling
-    - A2A communication capabilities via tools
-    - Agent delegation capabilities via tools
-    - MCP server integration via tools
-    - Enhanced output extraction from various state formats
-
-    Tool Management:
-    - regular_tools: Standard LangChain tools provided during initialization
-    - mcp_tools: Tools retrieved from MCP servers
-    - resolved_tools: Combined collection of all tools for graph execution
-
-    Subclasses must implement:
-    - define_graph(): Define the specific graph structure
-    - _prepare_graph_input(): Convert user input to graph state
-    - _format_graph_output(): Convert final graph state to user output
-    """
-    state_schema: Incomplete
-    thread_id_key: Incomplete
-    enable_a2a_token_streaming: Incomplete
-    event_emitter: Incomplete
-    checkpointer: Incomplete
-    tool_output_manager: Incomplete
-    memory: BaseMemory | None
-    a2a_tool_manager: Incomplete
-    delegation_tool_manager: Incomplete
-    regular_tools: list[BaseTool]
-    mcp_tools: list[BaseTool]
-    resolved_tools: list[BaseTool]
-    def __init__(self, name: str, instruction: str, description: str | None = None, model: Any | None = None, tools: Sequence[BaseTool] | None = None, state_schema: type | None = None, thread_id_key: str = 'thread_id', event_emitter: EventEmitter | None = None, checkpointer: Checkpointer | None = None, enable_a2a_token_streaming: bool = False, **kwargs: Any) -> None:
-        '''Initialize the BaseLangGraphAgent.
-
-        Args:
-            name: The name of the agent.
-            instruction: The system instruction for the agent.
-            description: Human-readable description of the agent.
-            model: The model to use (lm_invoker, LangChain model, string, etc.).
-            tools: Sequence of regular LangChain tools (not A2A or delegation tools).
-            state_schema: The state schema for the LangGraph. Defaults to basic message state.
-            thread_id_key: Key for thread ID in configuration.
-            event_emitter: Optional event emitter for streaming updates.
-            checkpointer: Optional checkpointer for conversation persistence.
-            enable_a2a_token_streaming: Enable token-level streaming for A2A responses.
-                - False (default): Stream message-level events only
-                - True: Stream individual tokens plus message-level events
-            **kwargs: Additional keyword arguments passed to BaseAgent (including tool_configs and memory settings).
-                Memory settings include:
-                - memory_backend: Memory backend (e.g., "mem0")
-                - agent_id: Agent identifier for memory scoping
-                - memory_namespace: Memory namespace
-                - save_interaction_to_memory: Whether to save interactions (default True)
-        '''
-    def set_operation_mode(self, mode: str) -> None:
-        '''Set the operation mode for dependency tracking.
-
-        Args:
-            mode: Operation mode - "parallel" (default) or "sequential"
-        '''
-    @abstractmethod
-    def define_graph(self, graph_builder: StateGraph) -> CompiledStateGraph:
-        """Define the specific graph structure for this agent type.
-
-        Subclasses must implement this method to:
-        1. Add nodes to the graph_builder
-        2. Add edges and conditional edges
-        3. Set entry points
-        4. Return the compiled graph
-
-        Args:
-            graph_builder: The StateGraph builder to define nodes and edges on.
-
-        Returns:
-            The compiled graph ready for execution.
-        """
-    def register_a2a_agents(self, agent_cards: list[AgentCard]) -> None:
-        """Register A2A communication capabilities using the A2A tool manager.
-
-        Args:
-            agent_cards (list[AgentCard]): List of AgentCard instances for external communication.
-        """
-    def register_delegation_agents(self, agents: list[BaseAgent]) -> None:
-        """Register internal agent delegation capabilities using the delegation tool manager.
-
-        Args:
-            agents: List of BaseAgent instances for internal task delegation.
-        """
-    tools: Incomplete
-    def update_regular_tools(self, new_tools: list[BaseTool], rebuild_graph: bool | None = None) -> None:
-        """Update regular tools (not capabilities).
-
-        Args:
-            new_tools: New list of regular tools to use.
-            rebuild_graph: Whether to rebuild graph. If None, uses auto_rebuild_graph setting.
-        """
-    def run(self, query: str, **kwargs: Any) -> dict[str, Any]:
-        """Synchronously run the LangGraph agent.
-
-        Args:
-            query: The input query for the agent.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            Dictionary containing the agent's response.
-        """
-    async def arun(self, query: str, **kwargs: Any) -> dict[str, Any]:
-        """Asynchronously run the LangGraph agent with lazy MCP initialization.
-
-        Args:
-            query: The input query for the agent.
-            **kwargs: Additional keyword arguments including configurable for LangGraph.
-
-        Returns:
-            Dictionary containing the agent's response and full final state.
-        """
-    async def arun_stream(self, query: str, **kwargs: Any) -> AsyncGenerator[str | dict[str, Any], None]:
-        """Asynchronously stream the LangGraph agent's response.
-
-        If MCP configuration exists, connects to the MCP server and registers tools before streaming.
-        This method properly handles both LM Invoker and LangChain model streaming:
-        - For LM Invoker: Uses StreamEventHandler to capture streaming events
-        - For LangChain models: Uses LangGraph's native streaming implementation
-
-        Args:
-            query: The input query for the agent.
-            **kwargs: Additional keyword arguments.
-
-        Yields:
-            Chunks of output (strings or dicts) from the streaming response.
-        """
-    async def cleanup(self) -> None:
-        """Cleanup MCP resources including persistent sessions.
-
-        This method performs best-effort cleanup of MCP client resources.
-        Errors during cleanup are logged but do not raise exceptions to ensure
-        the cleanup process completes gracefully.
-        """
-    async def arun_a2a_stream(self, query: str, **kwargs: Any) -> AsyncGenerator[A2AEvent, None]:
-        '''Asynchronously streams the agent\'s response in A2A format.
-
-        Args:
-            query: The input query for the agent.
-            **kwargs: Additional keyword arguments.
-
-        Yields:
-            Dictionaries with "status" and "content" keys.
-            Possible statuses: "working", "completed", "failed", "canceled".
-        '''
-    async def arun_sse_stream(self, query: str, task_id: str | None = None, context_id: str | None = None, **kwargs: Any) -> AsyncGenerator[A2AEvent, 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
-        '''