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

aip_agents/examples/tools/langchain_graph_artifact_tool.pyi

@@ -1,25 +0,0 @@
-from aip_agents.a2a.types import MimeType as MimeType
-from aip_agents.utils.artifact_helpers import create_artifact_command as create_artifact_command
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel
-
-PIL_AVAILABLE: bool
-
-class GraphCommandInput(BaseModel):
-    """Input schema for a tiny bar/line chart artifact tool.
-
-    Note: width/height are clamped to a small size to keep artifacts lightweight.
-    """
-    chart_type: str
-    labels: list[str]
-    values: list[float]
-    title: str
-    width: int
-    height: int
-    image_name: str
-
-class GraphArtifactCommandTool(BaseTool):
-    """Generate a very small PNG chart and return it as a Command artifact."""
-    name: str
-    description: str
-    args_schema: type[BaseModel]

aip_agents/examples/tools/langchain_weather_tool.pyi

@@ -1,19 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.utils.logger import get_logger as get_logger
-from pydantic import BaseModel
-
-logger: Incomplete
-
-class WeatherToolInputSchema(BaseModel):
-    """Schema for weather tool input."""
-    city: str
-
-def weather_tool(city: str) -> str:
-    """Gets the weather for a specified city.
-
-    Args:
-        city: The name of the city to get weather for.
-
-    Returns:
-        A string describing the weather conditions.
-    """

aip_agents/examples/tools/langgraph_streaming_tool.pyi

@@ -1,43 +0,0 @@
-from aip_agents.agent.langgraph_react_agent import LangGraphReactAgent as LangGraphReactAgent
-from aip_agents.examples.tools.langchain_weather_tool import weather_tool as weather_tool
-from aip_agents.examples.tools.time_tool import TimeTool as TimeTool
-from langchain_core.runnables import RunnableConfig
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel
-from typing import Any
-
-class StreamingToolConfig(BaseModel):
-    """Tool configuration schema for the LangGraph streaming tool."""
-    time_format: str
-
-class LangGraphStreamingToolInput(BaseModel):
-    """Input schema for the LangGraphStreamingTool."""
-    query: str
-
-class LangGraphStreamingTool(BaseTool):
-    """Tool that wraps a LangGraph agent with time and weather forecast capabilities."""
-    name: str
-    description: str
-    args_schema: type[BaseModel]
-    tool_config_schema: type[BaseModel]
-    def __init__(self, model: Any = None, **kwargs) -> None:
-        """Initialize the LangGraphStreamingTool.
-
-        Args:
-            model: The model to use for the agent.
-            **kwargs: Additional keyword arguments.
-        """
-    @property
-    def agent(self):
-        """Access the internal agent."""
-    async def arun_streaming(self, query: str = None, config: RunnableConfig = None, **kwargs):
-        """Execute the LangGraph agent asynchronously with A2A streaming output.
-
-        Args:
-            query: The query to execute.
-            config: Tool configuration containing user context and preferences.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            An async generator that yields streaming events.
-        """

aip_agents/examples/tools/mock_retrieval_tool.pyi

@@ -1,13 +0,0 @@
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel
-
-class MockRetrievalInput(BaseModel):
-    """Input schema for the MockRetrievalTool."""
-    query: str
-
-class MockRetrievalTool(BaseTool):
-    """Mock tool that returns hardcoded references for testing."""
-    name: str
-    description: str
-    args_schema: type[BaseModel]
-    save_output_history: bool

aip_agents/examples/tools/pii_demo_tools.pyi

@@ -1,54 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.utils.logger import LoggerManager as LoggerManager
-from pydantic import BaseModel
-
-logger: Incomplete
-
-class CustomerIdSchema(BaseModel):
-    """Schema for customer ID input."""
-    customer_id: str
-
-class EmployeeIdSchema(BaseModel):
-    """Schema for employee ID input."""
-    employee_id: str
-
-class UserIdSchema(BaseModel):
-    """Schema for user ID input."""
-    user_id: str
-
-def get_customer_info(customer_id: str) -> str:
-    """Gets customer information including email and phone number.
-
-    This tool demonstrates PII handling by returning sensitive customer data
-    that will be automatically anonymized by the PII handler.
-
-    Args:
-        customer_id: The ID of the customer to retrieve information for.
-
-    Returns:
-        A string containing customer information with PII.
-    """
-def get_employee_data(employee_id: str) -> str:
-    """Gets employee data including name, email, and salary information.
-
-    This tool demonstrates PII handling with employee-specific data that includes
-    sensitive information like salary and personal email addresses.
-
-    Args:
-        employee_id: The ID of the employee to retrieve data for.
-
-    Returns:
-        A string containing employee information with PII.
-    """
-def get_user_profile(user_id: str) -> str:
-    """Gets user profile information with personal details.
-
-    This tool demonstrates PII handling with user profile data that includes
-    personal information like email, phone, and date of birth.
-
-    Args:
-        user_id: The ID of the user to retrieve profile for.
-
-    Returns:
-        A string containing user profile information with PII.
-    """

aip_agents/examples/tools/random_chart_tool.pyi

@@ -1,20 +0,0 @@
-from aip_agents.a2a.types import MimeType as MimeType
-from aip_agents.utils.artifact_helpers import create_artifact_command as create_artifact_command
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel
-
-DEFAULT_RANDOM_CHART_TITLE: str
-PIL_AVAILABLE: bool
-
-class RandomChartInput(BaseModel):
-    """Input schema for random chart generation."""
-    title: str
-    num_bars: int
-    min_value: int
-    max_value: int
-
-class RandomChartTool(BaseTool):
-    """Generate random bar chart images without relying on upstream data."""
-    name: str
-    description: str
-    args_schema: type[BaseModel]

aip_agents/examples/tools/serper_tool.pyi

@@ -1,16 +0,0 @@
-from _typeshed import Incomplete
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel
-
-logger: Incomplete
-
-class GoogleSerperInput(BaseModel):
-    """Input schema for the GoogleSerperTool."""
-    query: str
-
-class MockGoogleSerperTool(BaseTool):
-    """Mock Tool to simulate Google Serper API results for testing."""
-    name: str
-    description: str
-    save_output_history: bool
-    args_schema: type[BaseModel]

aip_agents/examples/tools/stock_tools.pyi

@@ -1,36 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.utils.logger import get_logger as get_logger
-from pydantic import BaseModel
-from typing import Any
-
-logger: Incomplete
-
-class StockPriceInput(BaseModel):
-    """Input for the stock price tool."""
-    symbol: str
-
-def get_stock_price(symbol: str) -> dict[str, Any]:
-    """Get current stock price and performance data for a given symbol.
-
-    Args:
-        symbol (str): The stock symbol (e.g., AAPL, MSFT) to get the price for.
-
-    Returns:
-        dict[str, Any]: Dictionary containing stock price and performance data.
-    """
-
-class StockNewsInput(BaseModel):
-    """Input for the stock news tool."""
-    symbol: str
-    days: int
-
-def get_stock_news(symbol: str, days: int = 7) -> dict[str, Any]:
-    """Get recent news for a stock for a specified number of days.
-
-    Args:
-        symbol (str): The stock symbol (e.g., AAPL, MSFT) to get news for.
-        days (int, optional): Number of days of news to retrieve. Defaults to 7.
-
-    Returns:
-        dict[str, Any]: Dictionary containing stock news data.
-    """

aip_agents/examples/tools/table_generator_tool.pyi

@@ -1,22 +0,0 @@
-from aip_agents.a2a.types import MimeType as MimeType
-from aip_agents.utils.artifact_helpers import create_artifact_response as create_artifact_response
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel
-
-class TableGeneratorInput(BaseModel):
-    """Input schema for table generator tool."""
-    rows: int
-    columns: list[str]
-    table_name: str
-
-class TableGeneratorTool(BaseTool):
-    """Tool that generates sample data tables with artifact support.
-
-    This tool demonstrates the standardized artifact format by:
-    1. Generating sample data
-    2. Creating a markdown table for the agent's context
-    3. Creating a CSV file artifact for the user
-    """
-    name: str
-    description: str
-    args_schema: type[BaseModel]

aip_agents/examples/tools/time_tool.pyi

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

aip_agents/examples/tools/weather_forecast_tool.pyi

@@ -1,14 +0,0 @@
-from _typeshed import Incomplete
-
-DAILY_WEATHER: Incomplete
-DayOfWeek: Incomplete
-
-def get_weather_forecast(day: DayOfWeek) -> str:
-    """Get the weather forecast for a specific day of the week.
-
-    Args:
-        day: The day of the week (monday, tuesday, wednesday, etc.)
-
-    Returns:
-        str: A weather forecast message including conditions and temperature.
-    """

aip_agents/mcp/client/__init__.pyi

@@ -1,5 +0,0 @@
-from aip_agents.mcp.client.base_mcp_client import BaseMCPClient as BaseMCPClient
-from aip_agents.mcp.client.google_adk.client import GoogleADKMCPClient as GoogleADKMCPClient
-from aip_agents.mcp.client.langchain.client import LangchainMCPClient as LangchainMCPClient
-
-__all__ = ['GoogleADKMCPClient', 'LangchainMCPClient', 'BaseMCPClient']

aip_agents/mcp/client/base_mcp_client.pyi

@@ -1,148 +0,0 @@
-from _typeshed import Incomplete
-from abc import ABC, abstractmethod
-from aip_agents.mcp.client.persistent_session import PersistentMCPSession as PersistentMCPSession
-from aip_agents.mcp.client.session_pool import MCPSessionPool as MCPSessionPool
-from aip_agents.utils.logger import get_logger as get_logger
-from gllm_tools.mcp.client.client import MCPClient
-from gllm_tools.mcp.client.config import MCPConfiguration as MCPConfiguration
-from mcp.types import CallToolResult, Tool as Tool
-from typing import Any
-
-logger: Incomplete
-
-class BaseMCPClient(MCPClient, ABC):
-    """Base MCP Client with persistent session management for aip-agents.
-
-    This class provides:
-    - Persistent session management across tool calls
-    - One-time tool registration and caching
-    - Automatic connection health monitoring and reconnection
-    - Centralized cleanup of all MCP resources
-    - Generic tool discovery from all configured MCP servers
-
-    Subclasses should implement SDK-specific tool conversion in _process_tool() method.
-    """
-    session_pool: Incomplete
-    def __init__(self, servers: dict[str, MCPConfiguration]) -> None:
-        """Initialize the base MCP client with session pool.
-
-        Args:
-            servers (dict[str, MCPConfiguration]): Dictionary of MCP server configurations by server name
-        """
-    async def initialize(self) -> None:
-        """Initialize all MCP sessions and cache tools once.
-
-        This method is idempotent and only performs initialization if not already done.
-        It establishes persistent connections to all configured MCP servers and caches
-        available tools for efficient access.
-
-        Raises:
-            Exception: If any session initialization fails
-        """
-    @abstractmethod
-    async def get_tools(self, server: str | None = None) -> list[Any]:
-        """Get framework-specific tools from MCP servers.
-
-        This method must be implemented by subclasses to provide framework-specific
-        tool conversion (e.g., StructuredTool for LangChain, FunctionTool for Google ADK).
-
-        Args:
-            server (str | None): Optional server name to filter tools from a specific server.
-                    If None, returns tools from all configured servers.
-
-        Returns:
-            list[Any]: List of framework-specific tool objects.
-        """
-    async def get_raw_mcp_tools(self, server: str | None = None) -> list[Tool]:
-        """Get raw MCP tools - for subclasses to perform framework-specific conversions.
-
-        This method provides access to the cached raw MCP Tool objects.
-        Subclasses use this to convert to framework-specific tools.
-
-        Args:
-            server (str | None): Optional server name to filter tools from a specific server.
-                    If None, returns tools from all configured servers.
-
-        Returns:
-            list[Tool]: List of raw MCP Tool objects. Empty list if not initialized or no tools available.
-        """
-    def get_tools_count(self, server: str | None = None) -> int:
-        """Get count of raw MCP tools without expensive copying.
-
-        This is an efficient way to get tool counts for logging/metrics
-        without the overhead of copying tool lists.
-
-        Args:
-            server (str | None): Optional server name to filter tools from a specific server.
-                    If None, returns count from all configured servers.
-
-        Returns:
-            int: Count of raw MCP tools available.
-        """
-    async def get_session(self, server_name: str) -> PersistentMCPSession:
-        """Get a persistent session for a specific server.
-
-        Args:
-            server_name (str): The name of the MCP server
-
-        Returns:
-            PersistentMCPSession: Persistent MCP session for the specified server
-
-        Raises:
-            KeyError: If the server is not configured or no active session exists
-        """
-    async def call_tool(self, server_name: str, tool_name: str, arguments: dict[str, Any]) -> CallToolResult:
-        """Execute a tool on a specific MCP server using persistent session.
-
-        Args:
-            server_name (str): The MCP server to execute the tool on
-            tool_name (str): The name of the tool to execute
-            arguments (dict[str, Any]): Arguments for the tool execution
-
-        Returns:
-            CallToolResult: The result of the tool execution
-
-        Raises:
-            KeyError: If the server doesn't exist
-            Exception: If tool execution fails
-        """
-    async def read_resource(self, server_name: str, resource_uri: str):
-        """Read an MCP resource from a specific server using persistent session.
-
-        Args:
-            server_name (str): The MCP server to read the resource from
-            resource_uri (str): The URI of the resource to read
-
-        Returns:
-            Any: The resource content
-
-        Raises:
-            KeyError: If the server doesn't exist
-            Exception: If resource reading fails
-        """
-    async def cleanup(self) -> None:
-        """Clean up all MCP resources and close sessions.
-
-        This method properly closes all persistent sessions and cleans up resources.
-        It can be called multiple times safely.
-        """
-    @property
-    def is_initialized(self) -> bool:
-        """Check if the client is fully initialized.
-
-        Returns:
-            bool: True if sessions are initialized and tools are cached, False otherwise
-        """
-    @property
-    def active_sessions(self) -> dict[str, PersistentMCPSession]:
-        """Get all active persistent sessions.
-
-        Returns:
-            dict[str, PersistentMCPSession]: Dictionary of active sessions by server name
-        """
-    def get_session_count(self) -> int:
-        """Get the number of active MCP sessions.
-
-        Returns:
-            Number of active persistent sessions
-        """

aip_agents/mcp/client/connection_manager.pyi

@@ -1,48 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.mcp.client.transports import TransportType as TransportType, create_transport as create_transport
-from aip_agents.utils.logger import get_logger as get_logger
-from gllm_tools.mcp.client.config import MCPConfiguration
-from typing import Any
-
-logger: Incomplete
-
-class MCPConnectionManager:
-    """Manages MCP connection lifecycle following mcp-use patterns.
-
-    This connection manager handles the transport connection lifecycle in a background
-    task to avoid cancel scope issues during cleanup. It supports automatic transport
-    negotiation (HTTP -> SSE fallback) and graceful shutdown. Invalid explicit transports
-    are normalized via aliases (e.g., 'streamable_http' -> 'http') or fall back to
-    auto-detection with a warning.
-    """
-    TRANSPORT_ALIASES: Incomplete
-    server_name: Incomplete
-    config: Incomplete
-    transport_type: Incomplete
-    max_retries: Incomplete
-    initial_retry_delay: Incomplete
-    def __init__(self, server_name: str, config: MCPConfiguration) -> None:
-        """Initialize connection manager.
-
-        Args:
-            server_name (str): Name of the MCP server
-            config (MCPConfiguration): MCP server configuration
-        """
-    async def start(self) -> tuple[Any, Any]:
-        """Start connection in background task.
-
-        Returns:
-            tuple[Any, Any]: Tuple of (read_stream, write_stream) for ClientSession
-
-        Raises:
-            Exception: If connection establishment fails
-        """
-    async def stop(self) -> None:
-        """Stop connection gracefully."""
-    @property
-    def is_connected(self) -> bool:
-        """Check if connection is active.
-
-        Returns:
-            bool: True if connected, False otherwise
-        """

aip_agents/mcp/client/google_adk/__init__.pyi

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

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