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

aip_agents/mcp/client/google_adk/client.pyi

@@ -1,75 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.mcp.client.base_mcp_client import BaseMCPClient as BaseMCPClient
-from aip_agents.utils.logger import get_logger as get_logger
-from gllm_tools.mcp.client.config import MCPConfiguration as MCPConfiguration
-from google.adk.tools import FunctionTool
-from mcp.types import EmbeddedResource, ImageContent
-
-NonTextContent = ImageContent | EmbeddedResource
-logger: Incomplete
-
-class GoogleADKMCPClient(BaseMCPClient):
-    '''Google ADK MCP Client with Persistent Sessions.
-
-    This client extends BaseMCPClient to provide Google ADK-specific tool conversion
-    while maintaining persistent MCP sessions and connection reuse across tool calls.
-    It converts MCP tools into ADK FunctionTool instances for seamless integration.
-
-    The client handles:
-    - Converting MCP tools to ADK FunctionTool instances using persistent sessions
-    - Managing MCP server connections with automatic reconnection
-    - Converting MCP resources to ADK-compatible formats
-    - Handling tool execution with proper error formatting for ADK agents
-
-    Example:
-        ```python
-        from aip_agents.mcp.client.google_adk.client import GoogleADKMCPClient
-        from gllm_tools.mcp.client.config import MCPConfiguration
-
-        servers = {
-            "filesystem": MCPConfiguration(
-                command="npx",
-                args=["-y", "@modelcontextprotocol/server-filesystem", "/path/to/folder"]
-            )
-        }
-
-        client = GoogleADKMCPClient(servers)
-        await client.initialize()  # Initialize persistent sessions
-        tools = await client.get_tools()  # Returns list of ADK FunctionTool instances
-        ```
-    '''
-    RESOURCE_FETCH_TIMEOUT: int
-    def __init__(self, servers: dict[str, MCPConfiguration]) -> None:
-        """Initialize Google ADK MCP client.
-
-        Args:
-            servers (dict[str, MCPConfiguration]): Dictionary of MCP server configurations
-        """
-    async def initialize(self) -> None:
-        """Initialize persistent MCP sessions for Google ADK integration.
-
-        This method ensures all MCP servers are connected with persistent sessions
-        and prepares the client for ADK tool conversion.
-
-        Raises:
-            Exception: If session initialization fails
-        """
-    async def get_tools(self, server: str | None = None) -> list[FunctionTool]:
-        """Get ADK-compatible FunctionTool instances with smart caching.
-
-        Converts MCP tools to ADK format and caches them for better performance
-        on repeated access. Cache is keyed by server parameter.
-
-        Args:
-            server (str | None): Optional server name to filter tools from a specific server.
-                    If None, returns tools from all configured servers.
-
-        Returns:
-            list[FunctionTool]: List of cached ADK FunctionTool instances.
-        """
-    async def cleanup(self) -> None:
-        """Clean up Google ADK MCP client resources.
-
-        This method ensures all persistent sessions are properly closed and
-        ADK-specific resources are cleaned up.
-        """

aip_agents/mcp/client/langchain/__init__.pyi

@@ -1,3 +0,0 @@
-from aip_agents.mcp.client.langchain.client import LangchainMCPClient as LangchainMCPClient
-
-__all__ = ['LangchainMCPClient']

aip_agents/mcp/client/langchain/client.pyi

@@ -1,48 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.mcp.client.base_mcp_client import BaseMCPClient as BaseMCPClient
-from aip_agents.utils.logger import get_logger as get_logger
-from gllm_tools.mcp.client.config import MCPConfiguration as MCPConfiguration
-from langchain_core.tools import StructuredTool
-from mcp.types import EmbeddedResource, ImageContent
-
-NonTextContent = ImageContent | EmbeddedResource
-logger: Incomplete
-
-class LangchainMCPClient(BaseMCPClient):
-    """Langchain MCP Client with Session Persistence.
-
-    This client extends BaseMCPClient to provide LangChain-specific tool conversion
-    while maintaining persistent MCP sessions and connection reuse across tool calls.
-    """
-    RESOURCE_FETCH_TIMEOUT: int
-    def __init__(self, servers: dict[str, MCPConfiguration]) -> None:
-        """Initialize LangChain MCP client.
-
-        Args:
-            servers (dict[str, MCPConfiguration]): Dictionary of MCP server configurations
-        """
-    async def initialize(self) -> None:
-        """Initialize all sessions for LangChain client.
-
-        This method initializes the base MCP sessions and prepares for tool caching.
-
-        Raises:
-            Exception: If base initialization fails
-        """
-    async def get_tools(self, server: str | None = None) -> list[StructuredTool]:
-        """Get LangChain StructuredTools with smart caching.
-
-        Converts MCP tools to LangChain format and caches them for better performance
-        on repeated access. Cache is keyed by server parameter.
-
-        Args:
-            server (str | None): Optional server name to filter tools. If None, returns all tools.
-
-        Returns:
-            list[StructuredTool]: List of cached LangChain StructuredTool instances
-        """
-    async def cleanup(self) -> None:
-        """Cleanup LangChain MCP resources.
-
-        This method extends base class cleanup and clears the LangChain tool cache.
-        """

aip_agents/mcp/client/persistent_session.pyi

@@ -1,122 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.mcp.client.connection_manager import MCPConnectionManager as MCPConnectionManager
-from aip_agents.mcp.utils.config_validator import validate_allowed_tools_list as validate_allowed_tools_list
-from aip_agents.utils.logger import get_logger as get_logger
-from collections.abc import Awaitable as Awaitable
-from gllm_tools.mcp.client.config import MCPConfiguration
-from mcp import ClientSession
-from mcp.types import CallToolResult, Tool as Tool
-from typing import Any
-
-logger: Incomplete
-
-class PersistentMCPSession:
-    """Persistent MCP session that reuses connections.
-
-    This session wrapper manages the connection lifecycle and caches tools
-    to avoid repeated initialization overhead. It provides automatic reconnection
-    and thread-safe operations.
-
-    Tool Filtering:
-        When allowed_tools is configured, tools are filtered inline during list_tools()
-        and permission checked in call_tool() using set lookup.
-    """
-    server_name: Incomplete
-    config: Incomplete
-    connection_manager: Incomplete
-    client_session: ClientSession | None
-    tools: list[Tool]
-    def __init__(self, server_name: str, config: MCPConfiguration, allowed_tools: list[str] | None = None) -> None:
-        """Initialize persistent session.
-
-        Args:
-            server_name: Name of the MCP server
-            config: MCP server configuration
-            allowed_tools: Optional list of tool names to allow. None or empty means all tools allowed.
-        """
-    async def initialize(self) -> None:
-        """Initialize session once and cache tools.
-
-        This method is idempotent and can be called multiple times safely.
-
-        Raises:
-            Exception: If session initialization fails
-        """
-    async def call_tool(self, name: str, arguments: dict[str, Any]) -> CallToolResult:
-        """Call MCP tool using persistent session.
-
-        Args:
-            name (str): Tool name
-            arguments (dict[str, Any]): Tool arguments
-
-        Returns:
-            CallToolResult: Tool call result
-
-        Raises:
-            Exception: If tool call fails
-        """
-    async def read_resource(self, uri: str) -> Any:
-        """Read an MCP resource using persistent session.
-
-        Args:
-            uri (str): The URI of the resource to read
-
-        Returns:
-            Any: The resource content
-
-        Raises:
-            Exception: If resource reading fails
-        """
-    async def list_tools(self) -> list[Tool]:
-        """Get cached tools list with allowed tools filtering applied.
-
-        Returns:
-            list[Tool]: a copy of list of available tools, filtered to only allowed tools if configured
-        """
-    def get_tools_count(self) -> int:
-        """Get count of allowed tools.
-
-        Returns:
-            Count of allowed tools
-        """
-    async def ensure_connected(self) -> None:
-        """Ensure connection is healthy, reconnect if needed.
-
-        This method provides automatic reconnection capability.
-
-        Raises:
-            Exception: If reconnection fails
-        """
-    async def disconnect(self) -> None:
-        """Disconnect session gracefully.
-
-        This method cleans up all resources and connections.
-        Always succeeds, even if the session was already in an error state.
-        """
-    @property
-    def is_initialized(self) -> bool:
-        """Check if session is initialized.
-
-        Returns:
-            bool: True if initialized and connected, False otherwise
-        """
-    @property
-    def allowed_tools(self) -> list[str] | None:
-        """Return the configured allowed tools, sorted if present.
-
-        Returns:
-            Sorted list of allowed tool names, or None if unrestricted.
-        """
-    def update_allowed_tools(self, allowed_tools: list[str] | None) -> bool:
-        """Update the list of allowed tools for this session.
-
-        Args:
-            allowed_tools: New list of allowed tool names or None for no restriction.
-                None and empty list both mean 'no restrictions, allow all tools'.
-
-        Returns:
-            bool: True if the configuration changed, False otherwise.
-
-        Raises:
-            ValueError: If allowed_tools contains invalid entries.
-        """

aip_agents/mcp/client/session_pool.pyi

@@ -1,101 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.mcp.client.persistent_session import PersistentMCPSession as PersistentMCPSession
-from aip_agents.mcp.utils.config_validator import validate_allowed_tools_config as validate_allowed_tools_config, validate_allowed_tools_list as validate_allowed_tools_list
-from aip_agents.utils.logger import get_logger as get_logger
-from gllm_tools.mcp.client.config import MCPConfiguration
-from mcp.types import Tool as Tool
-
-logger: Incomplete
-
-class MCPSessionPool:
-    """Manages pool of persistent MCP sessions.
-
-    This pool provides centralized management of MCP sessions, including
-    initialization, tool collection, and resource cleanup. Sessions are
-    reused across the agent lifecycle.
-    """
-    sessions: dict[str, PersistentMCPSession]
-    def __init__(self) -> None:
-        """Initialize empty session pool."""
-    async def get_or_create_session(self, server_name: str, config: MCPConfiguration, allowed_tools: list[str] | None = None) -> PersistentMCPSession:
-        """Get existing session or create new one.
-
-        Args:
-            server_name (str): Name of the MCP server
-            config (MCPConfiguration): MCP server configuration
-            allowed_tools (list[str] | None): Optional list of tool names to allow. None means all tools allowed.
-
-        Returns:
-            PersistentMCPSession: Persistent MCP session
-
-        Raises:
-            Exception: If session creation fails
-        """
-    async def initialize_all_sessions(self, server_configs: dict[str, MCPConfiguration]) -> None:
-        """Initialize all sessions and cache tools.
-
-        This method initializes all configured MCP servers concurrently
-        for better performance.
-
-        Args:
-            server_configs (dict[str, MCPConfiguration]): Dictionary of server configurations
-
-        Raises:
-            Exception: If any session initialization fails
-        """
-    def get_all_active_sessions(self) -> dict[str, PersistentMCPSession]:
-        """Get all active sessions.
-
-        Returns:
-            dict[str, PersistentMCPSession]: Dictionary of active sessions by server name
-        """
-    @property
-    def active_sessions(self) -> list[str]:
-        """Get list of active session names.
-
-        Returns:
-            list[str]: List of active session names
-        """
-    async def get_all_tools(self) -> list[Tool]:
-        """Get all cached tools from all active sessions.
-
-        Returns:
-            list[Tool]: List of all available tools across all sessions
-        """
-    async def close_session(self, server_name: str) -> None:
-        """Close specific session.
-
-        Args:
-            server_name (str): Name of the server session to close
-        """
-    async def close_all_sessions(self) -> None:
-        """Close all sessions gracefully.
-
-        This method ensures all resources are cleaned up properly.
-        """
-    @property
-    def is_initialized(self) -> bool:
-        """Check if session pool is initialized.
-
-        Returns:
-            bool: True if initialized, False otherwise
-        """
-    @property
-    def session_count(self) -> int:
-        """Get number of active sessions.
-
-        Returns:
-            int: Number of active sessions
-        """
-    def get_session(self, server_name: str) -> PersistentMCPSession:
-        """Get specific session by name.
-
-        Args:
-            server_name (str): Name of the server
-
-        Returns:
-            PersistentMCPSession: The requested session
-
-        Raises:
-            KeyError: If session doesn't exist
-        """

aip_agents/mcp/client/transports.pyi

@@ -1,132 +0,0 @@
-from _typeshed import Incomplete
-from abc import ABC, abstractmethod
-from aip_agents.utils.logger import get_logger as get_logger
-from collections.abc import AsyncIterator as AsyncIterator
-from enum import StrEnum
-from gllm_tools.mcp.client.config import MCPConfiguration
-from typing import Any, Protocol
-
-class TransportContext(Protocol):
-    """Protocol defining the interface for async context managers used in MCP transport connections."""
-    async def __aenter__(self) -> None:
-        """Enter the async context, establishing the connection and returning read/write streams."""
-    async def __aexit__(self, _exc_type, _exc_val, _exc_tb) -> None:
-        """Exit the async context, performing cleanup and closing the connection.
-
-        Args:
-            _exc_type: Exception type if an exception occurred.
-            _exc_val: Exception value if an exception occurred.
-            _exc_tb: Exception traceback if an exception occurred.
-        """
-
-logger: Incomplete
-DEFAULT_TIMEOUT: float
-
-class TransportType(StrEnum):
-    """Enum for supported MCP transport types."""
-    HTTP: str
-    SSE: str
-    STDIO: str
-
-class Transport(ABC):
-    """Abstract base class for MCP transports."""
-    server_name: Incomplete
-    config: Incomplete
-    ctx: Any
-    def __init__(self, server_name: str, config: MCPConfiguration) -> None:
-        """Initialize the transport.
-
-        Args:
-            server_name (str): Name of the MCP server.
-            config (MCPConfiguration): Configuration for the transport.
-        """
-    @abstractmethod
-    async def connect(self) -> tuple[AsyncIterator[bytes], AsyncIterator[bytes], TransportContext]:
-        """Establish connection and return read/write streams and context manager.
-
-        Returns:
-            tuple[AsyncIterator[bytes], AsyncIterator[bytes], Any]:
-                (read_stream, write_stream, ctx)
-            Where:
-                - read_stream: AsyncIterator[bytes] for reading from the server.
-                - write_stream: AsyncIterator[bytes] for writing to the server.
-                - ctx: The async context manager instance for cleanup via __aexit__.
-
-        Raises:
-            ValueError: If required config (e.g., URL or command) is missing.
-            ConnectionError: If connection establishment fails.
-        """
-    async def close(self) -> None:
-        """Clean up the transport connection."""
-
-class SSETransport(Transport):
-    """SSE transport handler."""
-    ctx: Incomplete
-    async def connect(self) -> tuple[AsyncIterator[bytes], AsyncIterator[bytes], TransportContext]:
-        """Connect using SSE transport.
-
-        Builds SSE URL from config, initializes client with timeout, and enters context.
-
-        Returns:
-            tuple[AsyncIterator[bytes], AsyncIterator[bytes], Any]: (read_stream, write_stream, ctx)
-
-        Raises:
-            ValueError: If URL is missing.
-            ConnectionError: If SSE connection fails.
-        """
-
-class HTTPTransport(Transport):
-    """Streamable HTTP transport handler."""
-    def __init__(self, server_name: str, config: MCPConfiguration) -> None:
-        """Initialize the HTTP transport.
-
-        Args:
-            server_name (str): Name of the MCP server.
-            config (MCPConfiguration): Configuration for the transport.
-        """
-    async def close(self) -> None:
-        """Clean up the transport connection and any owned HTTP client."""
-    ctx: Incomplete
-    async def connect(self) -> tuple[AsyncIterator[bytes], AsyncIterator[bytes], TransportContext]:
-        """Connect using streamable HTTP transport.
-
-        Builds MCP URL from config, initializes client with timeout, and enters context.
-
-        Returns:
-            tuple[AsyncIterator[bytes], AsyncIterator[bytes], Any]: (read_stream, write_stream, ctx)
-
-        Raises:
-            ValueError: If URL is missing.
-            ConnectionError: If HTTP connection fails.
-        """
-
-class StdioTransport(Transport):
-    """STDIO transport handler."""
-    ctx: Incomplete
-    async def connect(self) -> tuple[AsyncIterator[bytes], AsyncIterator[bytes], TransportContext]:
-        """Connect using STDIO transport.
-
-        Initializes stdio client from command/args/env in config and enters context.
-
-        Returns:
-            tuple[AsyncIterator[bytes], AsyncIterator[bytes], Any]: (read_stream, write_stream, ctx)
-
-        Raises:
-            ValueError: If command is missing.
-            ConnectionError: If STDIO connection fails.
-        """
-
-def create_transport(server_name: str, config: MCPConfiguration, transport_type: TransportType | str) -> Transport:
-    """Factory to create the appropriate transport instance.
-
-    Args:
-        server_name (str): Server name
-        config (MCPConfiguration): Config
-        transport_type (str): Transport type ('http', 'sse', 'stdio')
-
-    Returns:
-        Transport: Concrete transport instance
-
-    Raises:
-        ValueError: If transport_type is unsupported.
-    """

aip_agents/mcp/utils/config_validator.pyi

@@ -1,82 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.utils.logger import get_logger as get_logger
-from typing import Any
-
-logger: Incomplete
-
-def validate_allowed_tools_list(allowed_tools: list[str] | None, context: str) -> list[str] | None:
-    '''Validate that allowed_tools is a list of strings or None.
-
-    This function validates the type and contents of allowed_tools parameter.
-    It can be used to validate allowed_tools from any source (config dict, function parameter, etc).
-
-    Args:
-        allowed_tools: The allowed_tools value to validate (can be any type)
-        context: Context string for error messages (e.g., "Server \'my_server\'", "\'allowed_tools\' parameter")
-
-    Returns:
-        Validated list of allowed tool names, or None if allowed_tools is None or empty.
-        None/empty means no restriction (all tools allowed).
-
-    Raises:
-        ValueError: If allowed_tools is not None/list or contains non-string elements
-
-    Examples:
-        >>> validate_allowed_tools_list(None, "test")
-        None
-        >>> validate_allowed_tools_list([], "test")
-        None
-        >>> validate_allowed_tools_list(["tool1", "tool2"], "test")
-        [\'tool1\', \'tool2\']
-        >>> validate_allowed_tools_list("invalid", "test")  # doctest: +SKIP
-        ValueError: test: \'allowed_tools\' must be a list of strings, got str
-    '''
-def validate_allowed_tools_config(config: dict[str, Any], server_name: str) -> list[str] | None:
-    '''Validate and extract allowed_tools configuration from server config.
-
-    This function validates that the allowed_tools field, if present, is a list of strings.
-    It returns a normalized list of allowed tool names, or None if not specified/empty.
-
-    Args:
-        config: Server configuration dictionary that may contain \'allowed_tools\' field
-        server_name: Name of the server (for error messages)
-
-    Returns:
-        List of allowed tool names, or None if allowed_tools is not specified or is empty.
-        None means no restriction (all tools allowed).
-
-    Raises:
-        ValueError: If allowed_tools is present but not a list
-        ValueError: If allowed_tools contains non-string elements
-
-    Examples:
-        >>> validate_allowed_tools_config({"url": "..."}, "my_server")
-        None
-        >>> validate_allowed_tools_config({"url": "...", "allowed_tools": []}, "my_server")
-        None
-        >>> validate_allowed_tools_config({"url": "...", "allowed_tools": ["tool1", "tool2"]}, "my_server")
-        [\'tool1\', \'tool2\']
-    '''
-def validate_mcp_server_config(config: dict[str, Any], server_name: str) -> dict[str, Any]:
-    '''Validate complete MCP server configuration including allowed_tools.
-
-    This function performs comprehensive validation on an MCP server configuration,
-    ensuring all required fields are present and allowed_tools (if present) is valid.
-    Unknown configuration fields (such as any leftover disabled_tools) are silently ignored.
-
-    Args:
-        config: Server configuration dictionary
-        server_name: Name of the server (for error messages)
-
-    Returns:
-        Validated configuration dictionary (same as input, after validation)
-
-    Raises:
-        ValueError: If configuration is invalid
-
-    Examples:
-        >>> validate_mcp_server_config({"url": "http://localhost:8080"}, "my_server")
-        {\'url\': \'http://localhost:8080\'}
-        >>> validate_mcp_server_config({"command": "python", "args": ["server.py"]}, "my_server")
-        {\'command\': \'python\', \'args\': [\'server.py\']}
-    '''

aip_agents/memory/__init__.pyi

@@ -1,5 +0,0 @@
-from aip_agents.memory.base import BaseMemory as BaseMemory
-from aip_agents.memory.constants import MemoryMethod as MemoryMethod
-from aip_agents.memory.factory import MemoryFactory as MemoryFactory
-
-__all__ = ['BaseMemory', 'MemoryMethod', 'MemoryFactory']

aip_agents/memory/adapters/__init__.pyi

@@ -1,4 +0,0 @@
-from aip_agents.memory.adapters.base_adapter import BaseMemoryAdapter as BaseMemoryAdapter
-from aip_agents.memory.adapters.mem0 import Mem0Memory as Mem0Memory
-
-__all__ = ['Mem0Memory', 'BaseMemoryAdapter']