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

aip_agents/tools/document_loader/excel_reader_tool.pyi

@@ -0,0 +1,26 @@
+from _typeshed import Incomplete
+from aip_agents.tools.document_loader.base_reader import BaseDocumentReaderTool as BaseDocumentReaderTool, DOCPROC_MISSING_MESSAGE as DOCPROC_MISSING_MESSAGE
+from aip_agents.utils.logger import get_logger as get_logger
+
+logger: Incomplete
+
+class ExcelReaderTool(BaseDocumentReaderTool):
+    '''Tool to read and extract content from Excel files.
+
+    This tool reads Excel files (.xlsx, .xlsm) and extracts their content using
+    the gllm_docproc loader pipeline. The content is formatted as Markdown tables
+    for easy readability.
+
+    Features:
+    - Supports .xlsx and .xlsm formats
+    - Extracts all sheets or specific sheets
+    - Formats output as Markdown tables
+    - Configurable row limits and file size limits
+
+    Examples:
+        >>> tool = ExcelReaderTool()
+        >>> result = tool._run("/tmp/data.xlsx")
+        >>> print(result)
+    '''
+    name: str
+    description: str

aip_agents/tools/document_loader/pdf_reader_tool.pyi

@@ -0,0 +1,11 @@
+from _typeshed import Incomplete
+from aip_agents.tools.document_loader.base_reader import BaseDocumentReaderTool as BaseDocumentReaderTool, DOCPROC_MISSING_MESSAGE as DOCPROC_MISSING_MESSAGE
+from aip_agents.tools.document_loader.pdf_splitter import PDFSplitter as PDFSplitter
+from aip_agents.utils.logger import get_logger as get_logger
+
+logger: Incomplete
+
+class PDFReaderTool(BaseDocumentReaderTool):
+    """Tool to read and extract text from PDF files."""
+    name: str
+    description: str

aip_agents/tools/document_loader/pdf_splitter.pyi

@@ -0,0 +1,18 @@
+class PDFSplitter:
+    """Utility class for splitting PDF files into page-based temporary files."""
+    @staticmethod
+    def split_by_pages(file_path: str, batch_size: int) -> list[str]:
+        """Split PDF into temporary files containing batch_size pages each.
+
+        Args:
+            file_path: Path to the PDF file to split
+            batch_size: Number of pages to include in each batch (1-10)
+
+        Returns:
+            List of temporary file paths containing the split PDF batches
+
+        Raises:
+            FileNotFoundError: If the input PDF file doesn't exist
+            ValueError: If batch_size is invalid or PDF is corrupted
+            Exception: For other PDF processing errors
+        """

aip_agents/tools/execute_ptc_code.pyi

@@ -0,0 +1,90 @@
+from _typeshed import Incomplete
+from aip_agents.mcp.client.base_mcp_client import BaseMCPClient as BaseMCPClient
+from aip_agents.ptc.executor import PTCSandboxConfig as PTCSandboxConfig, PTCSandboxExecutor as PTCSandboxExecutor
+from aip_agents.ptc.naming import sanitize_function_name as sanitize_function_name
+from aip_agents.sandbox.e2b_runtime import E2BSandboxRuntime as E2BSandboxRuntime
+from aip_agents.tools.tool_config_injector import TOOL_CONFIGS_KEY as TOOL_CONFIGS_KEY
+from aip_agents.utils.logger import get_logger as get_logger
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel
+from typing import Any
+
+logger: Incomplete
+
+class PTCCodeInput(BaseModel):
+    """Input schema for PTCCodeTool."""
+    code: str
+
+def merge_tool_configs(agent_configs: dict[str, Any] | None, runtime_configs: dict[str, Any] | None) -> dict[str, dict[str, Any]]:
+    '''Merge agent-level and runtime tool configs with sanitized keys.
+
+    Merges tool configurations from two sources:
+    1. Agent-level defaults (from agent.tool_configs)
+    2. Runtime overrides (from RunnableConfig.metadata["tool_configs"])
+
+    Both sources support two formats (matching LangGraphReactAgent behavior):
+    - Direct per-tool keys: {"time_tool": {"timezone": "UTC"}}
+    - Nested structure: {"tool_configs": {"time_tool": {"timezone": "UTC"}}}
+
+    The nested "tool_configs" key has higher precedence than direct keys.
+    Tool names are sanitized to match sandbox expectations (e.g., "Time Tool" -> "time_tool").
+
+    Args:
+        agent_configs: Agent-level tool configs (may be None or contain nested dicts)
+        runtime_configs: Runtime overrides from metadata (may be None)
+
+    Returns:
+        Merged dict with sanitized tool names as keys and config dicts as values.
+        Only includes entries that are dicts (non-dict values are agent-wide defaults).
+    '''
+
+class PTCCodeTool(BaseTool):
+    """Tool for executing Python code with MCP tool access in a sandbox.
+
+    This tool uses BaseTool to properly access runtime config via run_manager.metadata.
+    The config parameter is NOT exposed to the LLM schema - it's extracted from
+    the callback manager during execution.
+    """
+    name: str
+    description: str
+    args_schema: type[BaseModel]
+    def __init__(self, executor: PTCSandboxExecutor, runtime: E2BSandboxRuntime, agent_tool_configs: dict[str, Any] | None = None, **kwargs: Any) -> None:
+        """Initialize the PTC code tool.
+
+        Args:
+            executor: The PTC sandbox executor.
+            runtime: The E2B sandbox runtime.
+            agent_tool_configs: Optional agent-level tool configs.
+            **kwargs: Additional keyword arguments passed to BaseTool.
+        """
+    async def cleanup(self) -> None:
+        """Clean up the sandbox runtime."""
+
+def create_execute_ptc_code_tool(mcp_client: BaseMCPClient | None, config: PTCSandboxConfig | None = None, agent_tool_configs: dict[str, Any] | None = None) -> PTCCodeTool:
+    '''Create a tool that executes Python code with MCP tool access.
+
+    The code runs inside an E2B sandbox with access to generated MCP tool modules.
+    This tool is designed for LLM-generated code that needs to call multiple tools
+    programmatically in a single execution.
+
+    Args:
+        mcp_client: The MCP client with configured servers.
+        config: Optional sandbox executor configuration.
+        agent_tool_configs: Optional agent-level tool configs (from agent.tool_configs).
+            These are merged with runtime overrides from RunnableConfig.metadata.
+
+    Returns:
+        PTCCodeTool configured for PTC code execution.
+
+    Example:
+        ```python
+        from aip_agents.mcp.client import LangchainMCPClient
+        from aip_agents.tools.execute_ptc_code import create_execute_ptc_code_tool
+
+        mcp_client = LangchainMCPClient()
+        await mcp_client.add_server("yfinance", {...})
+
+        tool = create_execute_ptc_code_tool(mcp_client)
+        result = await tool.ainvoke({"code": "from tools.yfinance import get_stock\\\\nprint(get_stock(\'AAPL\'))"})
+        ```
+    '''

aip_agents/tools/gl_connector/__init__.pyi

@@ -0,0 +1,3 @@
+from aip_agents.tools.gl_connector.tool import GLConnectorTool as GLConnectorTool
+
+__all__ = ['GLConnectorTool']

aip_agents/tools/gl_connector/tool.pyi

@@ -0,0 +1,74 @@
+from _typeshed import Incomplete
+from aip_agents.tools.constants import ToolType as ToolType
+from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import BaseTool
+from typing import Any
+
+class _InjectedTool(BaseTool):
+    """Wrap a BaseTool to inject token and optional identifier into inputs."""
+    model_config: Incomplete
+    def __init__(self, base_tool: BaseTool, token: str, identifier: str | None) -> None:
+        """Initialize the injected tool wrapper.
+
+        Args:
+            base_tool: The base tool to wrap.
+            token: Authentication token to inject into tool inputs.
+            identifier: Optional identifier to inject into tool inputs.
+
+        Returns:
+            None
+        """
+    def invoke(self, input: Any, config: RunnableConfig | None = None, **kwargs: Any) -> Any:
+        """Invoke the tool with token and optional identifier injected.
+
+        Args:
+            input: Tool input to process.
+            config: Optional runnable configuration.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            The result of invoking the tool with injected parameters.
+        """
+    async def ainvoke(self, input: Any, config: RunnableConfig | None = None, **kwargs: Any) -> Any:
+        """Invoke the tool asynchronously with token and optional identifier injected.
+
+        Args:
+            input: Tool input to process.
+            config: Optional runnable configuration.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            The result of invoking the tool with injected parameters.
+        """
+    def run(self, tool_input: Any, **kwargs: Any) -> Any:
+        """Run the tool with token and optional identifier injected.
+
+        Args:
+            tool_input: Tool input to process.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            The result of running the tool with injected parameters.
+        """
+    async def arun(self, tool_input: Any, **kwargs: Any) -> Any:
+        """Run the tool asynchronously with token and optional identifier injected.
+
+        Args:
+            tool_input: Tool input to process.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            The result of running the tool with injected parameters.
+        """
+
+def GLConnectorTool(tool_name: str, *, api_key: str | None = None, identifier: str | None = None) -> BaseTool:
+    """Create a single tool from GL Connectors by exact tool name.
+
+    Args:
+        tool_name: Exact tool name (not module name).
+        api_key: Optional override for GL Connectors API key.
+        identifier: Optional override for GL Connectors identifier.
+
+    Returns:
+        A single LangChain BaseTool with token injection.
+    """

aip_agents/tools/gl_connector_tools.pyi

@@ -0,0 +1,39 @@
+from _typeshed import Incomplete
+from aip_agents.tools.constants import GL_CONNECTORS_API_KEY as GL_CONNECTORS_API_KEY, GL_CONNECTORS_BASE_URL as GL_CONNECTORS_BASE_URL, GL_CONNECTORS_FETCH_MAX_RETRIES as GL_CONNECTORS_FETCH_MAX_RETRIES, ToolType as ToolType
+from aip_agents.utils.logger import get_logger as get_logger
+from langchain_core.tools import BaseTool as BaseTool
+
+logger: Incomplete
+
+def get_gl_connector_modules_with_retry() -> list[str]:
+    """Try to get available modules with retries.
+
+    Returns:
+        List of available modules.
+    """
+
+class LazyGLConnectorToolsDict(dict):
+    """Lazy dictionary for GL Connectors."""
+    def __missing__(self, app):
+        """When a key is missing, create the tools and store them in the dictionary.
+
+        Args:
+            app: Name of the GL Connectors.
+
+        Returns:
+            List of tools generated by the GL Connectors tool generator.
+        """
+
+def get_gl_connector_modules() -> list[str]:
+    """Lazily fetch and cache GL Connectors modules.
+
+    Returns:
+        List of GL Connectors modules.
+    """
+def get_bosa_modules() -> list[str]:
+    """Backward-compatible alias for get_gl_connector_modules."""
+
+GL_CONNECTORS_MODULES: Incomplete
+BOSA_MODULES = GL_CONNECTORS_MODULES
+GL_CONNECTORS_AUTOMATED_TOOLS: dict[str, list[BaseTool]]
+BOSA_AUTOMATED_TOOLS = GL_CONNECTORS_AUTOMATED_TOOLS

aip_agents/tools/memory_search/__init__.pyi

@@ -0,0 +1,5 @@
+from aip_agents.tools.memory_search.base import LongTermMemorySearchTool as LongTermMemorySearchTool
+from aip_agents.tools.memory_search.mem0 import MEMORY_SEARCH_TOOL_NAME as MEMORY_SEARCH_TOOL_NAME, Mem0SearchInput as Mem0SearchInput, Mem0SearchTool as Mem0SearchTool
+from aip_agents.tools.memory_search.schema import LongTermMemorySearchInput as LongTermMemorySearchInput, MemoryConfig as MemoryConfig
+
+__all__ = ['MemoryConfig', 'LongTermMemorySearchInput', 'LongTermMemorySearchTool', 'Mem0SearchInput', 'Mem0SearchTool', 'MEMORY_SEARCH_TOOL_NAME']

aip_agents/tools/memory_search/base.pyi

@@ -0,0 +1,69 @@
+from _typeshed import Incomplete
+from abc import ABC
+from aip_agents.memory.constants import MemoryDefaults as MemoryDefaults
+from aip_agents.tools.memory_search.schema import LongTermMemorySearchInput as LongTermMemorySearchInput, MemoryConfig as MemoryConfig
+from aip_agents.utils.logger import get_logger as get_logger
+from collections.abc import Callable
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel as BaseModel
+from typing import Any, ClassVar, Protocol
+
+logger: Incomplete
+
+class LongTermMemoryBackend(Protocol):
+    """Protocol for memory adapters that support retrieval and formatting."""
+    def retrieve(self, *, query: str | None, user_id: str, limit: int | None = None, filters: dict[str, Any] | None = None, page: int | None = None) -> list[dict[str, Any]]:
+        """Retrieve memories matching the given query and filters.
+
+        Args:
+            query: Optional search query string.
+            user_id: User identifier for scoped retrieval.
+            limit: Maximum number of results to return.
+            filters: Optional filters to apply to the retrieval.
+            page: Page number for pagination.
+
+        Returns:
+            List of memory hit dictionaries.
+        """
+    def format_hits(self, hits: list[dict[str, Any]], max_items: int = ..., with_tag: bool = True) -> str:
+        """Format memory hits into a readable string.
+
+        Args:
+            hits: List of memory hit dictionaries to format.
+            max_items: Maximum number of hits to include in output.
+            with_tag: Whether to wrap output with memory tags.
+
+        Returns:
+            Formatted string representation of memory hits.
+        """
+
+class LongTermMemorySearchTool(BaseTool, ABC):
+    """Abstract base class for provider-specific long-term memory search tools."""
+    name: str
+    description: str
+    args_schema: type[LongTermMemorySearchInput]
+    tool_config_schema: type[BaseModel]
+    memory: LongTermMemoryBackend
+    default_user_id: str | None
+    user_id_provider: Callable[[], str | None] | None
+    MINIMUM_MEMORY_RETRIEVAL: ClassVar[int]
+    LOG_PREFIX: ClassVar[str]
+    def __init__(self, memory: LongTermMemoryBackend, *, default_user_id: str | None = None, user_id_provider: Callable[[], str | None] | None = None, **kwargs: Any) -> None:
+        """Initialize the long-term memory search tool.
+
+        Args:
+            memory: Memory adapter instance with retrieve() and format_hits() methods.
+            default_user_id: Default user ID to use if not provided in metadata.
+            user_id_provider: Callable that returns a user ID.
+            **kwargs: Additional keyword arguments passed to the parent class.
+        """
+    def format_hits(self, hits: list[dict[str, Any]], with_tag: bool = False) -> str:
+        """Format hits into a string with optional tags.
+
+        Args:
+            hits: List of memory hit dictionaries to format.
+            with_tag: Whether to wrap the output with memory tags.
+
+        Returns:
+            Formatted string representation of the memory hits.
+        """

aip_agents/tools/memory_search/mem0.pyi

@@ -0,0 +1,19 @@
+from _typeshed import Incomplete
+from aip_agents.memory.constants import MemoryDefaults as MemoryDefaults
+from aip_agents.tools.memory_search.base import LongTermMemorySearchTool as LongTermMemorySearchTool
+from aip_agents.tools.memory_search.schema import LongTermMemorySearchInput as LongTermMemorySearchInput
+from aip_agents.utils.datetime import is_valid_date_string as is_valid_date_string, next_day_iso as next_day_iso
+from aip_agents.utils.logger import get_logger as get_logger
+from typing import ClassVar
+
+logger: Incomplete
+MEMORY_SEARCH_TOOL_NAME: str
+
+class Mem0SearchTool(LongTermMemorySearchTool):
+    """Mem0-specific implementation of the long-term memory search tool."""
+    name: str
+    description: str
+    args_schema: type[LongTermMemorySearchInput]
+    LOG_PREFIX: ClassVar[str]
+    METADATA_FILTER_BLOCKLIST: ClassVar[set[str]]
+Mem0SearchInput = LongTermMemorySearchInput

aip_agents/tools/memory_search/schema.pyi

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+from typing import Any
+
+class MemoryConfig(BaseModel):
+    """Tool configuration schema for memory operations."""
+    user_id: str
+
+class LongTermMemorySearchInput(BaseModel):
+    """Input schema for unified long-term memory retrieval."""
+    query: str | None
+    start_date: str | None
+    end_date: str | None
+    limit: int | None
+    categories: list[str] | None
+    metadata: dict[str, Any] | None

aip_agents/tools/memory_search_tool.pyi

@@ -0,0 +1,3 @@
+from aip_agents.tools.memory_search import LongTermMemorySearchInput as LongTermMemorySearchInput, LongTermMemorySearchTool as LongTermMemorySearchTool, MEMORY_SEARCH_TOOL_NAME as MEMORY_SEARCH_TOOL_NAME, Mem0SearchInput as Mem0SearchInput, Mem0SearchTool as Mem0SearchTool, MemoryConfig as MemoryConfig
+
+__all__ = ['MemoryConfig', 'LongTermMemorySearchInput', 'LongTermMemorySearchTool', 'Mem0SearchInput', 'Mem0SearchTool', 'MEMORY_SEARCH_TOOL_NAME']

aip_agents/tools/time_tool.pyi

@@ -0,0 +1,16 @@
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel
+
+FORMAT_STRING: str
+DEFAULT_TIMEZONE: str
+
+class TimeToolInput(BaseModel):
+    """Input schema for the TimeTool."""
+    datetime_format: str
+    timezone: str | None
+
+class TimeTool(BaseTool):
+    """Tool to get the current time."""
+    name: str
+    description: str
+    args_schema: type[BaseModel]

aip_agents/tools/tool_config_injector.pyi

@@ -0,0 +1,26 @@
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel
+from typing import TypeVar
+
+__all__ = ['inject_config_methods_into_tool', 'CONFIG_SCHEMA_ATTR', 'CONFIG_ATTR', 'TOOL_CONFIG_SCHEMA_ATTR', 'TOOL_CONFIGS_KEY']
+
+ConfigSchema = TypeVar('ConfigSchema', bound=BaseModel)
+CONFIG_SCHEMA_ATTR: str
+CONFIG_ATTR: str
+TOOL_CONFIG_SCHEMA_ATTR: str
+TOOL_CONFIGS_KEY: str
+
+def inject_config_methods_into_tool(tool: BaseTool, config_schema: type[ConfigSchema]) -> None:
+    """Inject configuration methods into a tool.
+
+    This function is used by the SDK to automatically inject configuration capabilities
+    into tools that have a tool_config_schema attribute. It can also be used directly
+    by developers who want to add configuration support to their tools.
+
+    Args:
+        tool: The tool to inject configuration capabilities into.
+        config_schema: Pydantic model class for configuration validation.
+
+    Raises:
+        ValueError: If tool is not a BaseTool instance or config_schema is not a Pydantic BaseModel subclass.
+    """

aip_agents/tools/web_search/__init__.pyi

@@ -0,0 +1,3 @@
+from aip_agents.tools.web_search.serper_tool import GoogleSerperTool as GoogleSerperTool
+
+__all__ = ['GoogleSerperTool']

aip_agents/tools/web_search/serper_tool.pyi

@@ -0,0 +1,19 @@
+from _typeshed import Incomplete
+from aip_agents.utils.logger import get_logger as get_logger
+from langchain_community.utilities.google_serper import GoogleSerperAPIWrapper
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel
+
+logger: Incomplete
+
+class GoogleSerperInput(BaseModel):
+    """Input schema for the GoogleSerperTool."""
+    query: str
+
+class GoogleSerperTool(BaseTool):
+    """Tool to search Google Serper API."""
+    name: str
+    description: str
+    save_output_history: bool
+    args_schema: type[BaseModel]
+    api_wrapper: GoogleSerperAPIWrapper

aip_agents/types/__init__.pyi

@@ -0,0 +1,36 @@
+from aip_agents.schema.a2a import A2AEvent as A2AEvent, A2AStreamEventType as A2AStreamEventType, ToolCallInfo as ToolCallInfo, ToolResultInfo as ToolResultInfo
+from pydantic import BaseModel
+from typing import Any, Protocol
+
+__all__ = ['A2AEvent', 'A2AStreamEventType', 'ToolCallInfo', 'ToolResultInfo', 'AgentProtocol', 'ChatMessage']
+
+class ChatMessage(BaseModel):
+    """Represents a single message in a chat conversation."""
+    role: str
+    content: str
+
+class AgentProtocol(Protocol):
+    """Defines the expected interface for an agent."""
+    id: str
+    name: str
+    description: str
+    def run(self, query: str, **kwargs: Any) -> dict[str, Any]:
+        """Synchronous execution method.
+
+        Args:
+            query (str): The query to execute.
+            **kwargs (Any): Additional keyword arguments.
+
+        Returns:
+            dict[str, Any]: The execution result.
+        """
+    async def arun(self, query: str, **kwargs: Any) -> dict[str, Any]:
+        """Asynchronous execution method.
+
+        Args:
+            query (str): The query to execute.
+            **kwargs (Any): Additional keyword arguments.
+
+        Returns:
+            dict[str, Any]: The execution result.
+        """

aip_agents/types/a2a_events.pyi

@@ -0,0 +1,3 @@
+from aip_agents.schema.a2a import A2AEvent as A2AEvent, A2AStreamEventType as A2AStreamEventType, ToolCallInfo as ToolCallInfo, ToolResultInfo as ToolResultInfo
+
+__all__ = ['A2AStreamEventType', 'A2AEvent', 'ToolCallInfo', 'ToolResultInfo']

aip_agents/utils/__init__.pyi

@@ -0,0 +1,11 @@
+from aip_agents.utils.artifact_helpers import create_artifact_command as create_artifact_command, create_artifact_response as create_artifact_response, create_error_response as create_error_response, create_multiple_artifacts_command as create_multiple_artifacts_command, create_text_artifact_response as create_text_artifact_response
+from aip_agents.utils.file_prompt_utils import augment_query_with_file_paths as augment_query_with_file_paths
+from aip_agents.utils.final_response_builder import assemble_final_response as assemble_final_response
+from aip_agents.utils.logger import LoggerManager as LoggerManager, get_logger as get_logger
+from aip_agents.utils.pii.pii_handler import ToolPIIHandler as ToolPIIHandler
+from aip_agents.utils.pii.pii_helper import add_pii_mappings as add_pii_mappings, extract_pii_mapping_from_agent_response as extract_pii_mapping_from_agent_response
+from aip_agents.utils.reference_helper import add_references_chunks as add_references_chunks, serialize_references_for_metadata as serialize_references_for_metadata, validate_references as validate_references
+from aip_agents.utils.sse_chunk_transformer import SSEChunkTransformer as SSEChunkTransformer
+from aip_agents.utils.step_limit_manager import StepExecutionContext as StepExecutionContext, StepLimitManager as StepLimitManager, _DELEGATION_CHAIN_CVAR as _DELEGATION_CHAIN_CVAR, _DELEGATION_DEPTH_CVAR as _DELEGATION_DEPTH_CVAR, _REMAINING_STEP_BUDGET_CVAR as _REMAINING_STEP_BUDGET_CVAR, _STEP_LIMIT_CONFIG_CVAR as _STEP_LIMIT_CONFIG_CVAR
+
+__all__ = ['get_logger', 'LoggerManager', 'create_artifact_response', 'create_error_response', 'create_artifact_command', 'create_multiple_artifacts_command', 'create_text_artifact_response', 'validate_references', 'serialize_references_for_metadata', 'add_references_chunks', 'assemble_final_response', 'augment_query_with_file_paths', 'SSEChunkTransformer', 'StepExecutionContext', 'StepLimitManager', '_DELEGATION_CHAIN_CVAR', '_DELEGATION_DEPTH_CVAR', '_REMAINING_STEP_BUDGET_CVAR', '_STEP_LIMIT_CONFIG_CVAR', 'ToolPIIHandler', 'add_pii_mappings', 'extract_pii_mapping_from_agent_response']

aip_agents/utils/a2a_connector.pyi

@@ -0,0 +1,146 @@
+from _typeshed import Incomplete
+from a2a.types import AgentCard
+from aip_agents.schema.a2a import A2AStreamEventType as A2AStreamEventType
+from aip_agents.utils.event_handler_registry import DEFAULT_EVENT_HANDLER_REGISTRY as DEFAULT_EVENT_HANDLER_REGISTRY, EventHandlerRegistry as EventHandlerRegistry
+from aip_agents.utils.final_response_builder import FinalResponseMetadataOptions as FinalResponseMetadataOptions, assemble_final_response as assemble_final_response
+from aip_agents.utils.logger import get_logger as get_logger
+from aip_agents.utils.metadata_helper import Kind as Kind, MetadataFieldKeys as MetadataFieldKeys, MetadataTimeTracker as MetadataTimeTracker, Status as Status, create_metadata as create_metadata, create_status_update_metadata as create_status_update_metadata, create_tool_processing_metadata as create_tool_processing_metadata
+from aip_agents.utils.sse_chunk_transformer import SSEChunkTransformer as SSEChunkTransformer
+from collections.abc import AsyncGenerator
+from pydantic import BaseModel
+from typing import Any
+
+logger: Incomplete
+
+class ArtifactInfo(BaseModel):
+    """Structured artifact information for A2A communication.
+
+    This Pydantic model provides type safety and validation for artifact data
+    exchanged between agents through the A2A protocol.
+    """
+    artifact_id: str | None
+    name: str | None
+    content_type: str | None
+    mime_type: str | None
+    file_name: str | None
+    has_file_data: bool
+    has_file_uri: bool
+    file_data: str | None
+    file_uri: str | None
+    description: str | None
+    parts: int | None
+
+class StreamingConfig(BaseModel):
+    """Configuration for A2A streaming operations."""
+    http_kwargs: dict[str, Any] | None
+
+class A2AConnector:
+    """Handles A2A protocol communication between agents.
+
+    This class provides methods for sending messages to other agents using the A2A protocol,
+    supporting both synchronous and asynchronous communication patterns, as well as streaming
+    responses with immediate artifact event handling.
+    """
+    FLOAT_EPSILON: float
+    event_registry: EventHandlerRegistry
+    @staticmethod
+    def send_to_agent(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 asend_to_agent encounters an unhandled exception.
+        """
+    @staticmethod
+    async def asend_to_agent(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 uses the streaming approach internally but only returns the final response,
+        avoiding direct httpx usage that can cause issues with Nuitka compilation.
+
+        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 final response with the simplified structure:
+                - status (str): "success" or "error"
+                - task_state (str): Final A2A TaskState value
+                - content (str): Final text content from the agent
+                - task_id (str): ID of the associated task
+                - context_id (str): Context ID of the task
+                - final (bool): Always True for final responses
+                - artifacts (list): List of all artifacts created during execution
+
+        Raises:
+            Exception: If there\'s an error during message sending or processing.
+        '''
+    @staticmethod
+    async def astream_to_agent(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 the official A2A streaming event
+        types as defined in the specification.
+
+        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 with a simplified structure:
+
+            For successful responses:
+                - status (str): "success" or "error"
+                - task_state (str): A2A TaskState value
+                - content (str): Text content from the agent
+                - task_id (str): ID of the associated task
+                - context_id (str): Context ID of the task
+                - final (bool): Whether this is the final update
+                - artifacts (list, optional): List of artifacts created in this step
+
+            Each artifact in the artifacts list contains:
+                - artifact_id (str): ID of the artifact
+                - name (str): Name of the artifact
+                - content_type (str): "text" or "file"
+                - mime_type (str): MIME type of the artifact
+                - file_name (str, optional): Name of the file for file artifacts
+                - has_file_data (bool): Whether file data is included
+                - has_file_uri (bool): Whether file URI is included
+                - file_data (str, optional): Base64 encoded file content
+                - file_uri (str, optional): URI reference to the file
+
+            For errors:
+                - 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.
+        '''