aip-agents-binary 0.0.0b2__py3-none-any.whl → 0.5.11__py3-none-any.whl

aip_agents/agent/types.pyi

@@ -1,106 +0,0 @@
-from a2a.types import AgentCard as AgentCard
-from enum import StrEnum
-from gllm_core.utils.retry import RetryConfig as RetryConfig
-from pydantic import BaseModel
-from typing import Any
-
-class CredentialType(StrEnum):
-    """Credential type enumeration for type safety and better developer experience.
-
-    This enum defines the supported credential formats for language models:
-    - API_KEY: String-based API keys (most common)
-    - FILE: File paths to credential files (e.g., Google service account JSON)
-    - DICT: Dictionary-based credentials (e.g., AWS Bedrock, LangChain)
-    """
-    API_KEY = 'api_key'
-    FILE = 'file'
-    DICT = 'dict'
-
-class StreamMode(StrEnum):
-    """LangGraph stream modes for astream operations.
-
-    These modes control what data is included in the streaming output.
-    """
-    VALUES = 'values'
-    CUSTOM = 'custom'
-
-class HttpxClientOptions(BaseModel):
-    """Options for the HTTP client.
-
-    Args:
-        timeout: The timeout for the HTTP client.
-    """
-    timeout: float | None
-    class Config:
-        """Config for HttpxClientOptions."""
-        extra: str
-
-class A2AClientConfig(BaseModel):
-    """Configuration for A2A client.
-
-    Args:
-        discovery_urls: A list of base URLs to discover agents from using .well-known/agent.json.
-        known_agents: A dictionary of known agents, keyed by AgentCard.name,
-                      storing the parsed AgentCard objects. Can be pre-populated or
-                      augmented by discovery.
-        httpx_client_options: Options for the HTTP client.
-    """
-    discovery_urls: list[str] | None
-    known_agents: dict[str, AgentCard]
-    httpx_client_options: HttpxClientOptions | None
-
-class BaseAgentConfig(BaseModel):
-    """Base configuration for agent implementations.
-
-    This class provides common configuration fields that all agent implementations
-    can use. It serves as a foundation for more specific configuration classes.
-
-    Args:
-        tools: List of tools available to the agent.
-        default_hyperparameters: Default hyperparameters for the language model.
-    """
-    tools: list[Any] | None
-    default_hyperparameters: dict[str, Any] | None
-    class Config:
-        """Config for BaseAgentConfig."""
-        extra: str
-
-class AgentConfig(BaseAgentConfig):
-    '''Configuration for agent implementations with language model settings.
-
-    This class extends BaseAgentConfig with language model specific configuration
-    fields including provider, model name, API settings, and hyperparameters.
-
-    Args:
-        lm_name: The name of the language model to use.
-        lm_hyperparameters: Hyperparameters for the language model.
-        lm_provider: The provider of the language model (e.g., \'openai\', \'google\').
-        lm_base_url: The base URL for the language model API.
-        lm_api_key: The API key for the language model service (deprecated in favor of lm_credentials).
-        lm_credentials: Enhanced credentials field supporting multiple formats with automatic type detection:
-
-            Supported Formats:
-            - str (API Key): "sk-proj-abc123..." → Auto-detected as API key
-            - str (File Path): "/path/to/creds.json" → Auto-detected as file if exists
-            - dict (Structured): {"access_key_id": "...", "secret_access_key": "..."} → Auto-detected as dict
-
-            Provider Examples:
-            - OpenAI: "sk-proj-abc123xyz"
-            - Anthropic: "sk-ant-api03-abc123xyz"
-            - Google Vertex AI: "/path/to/service-account.json"
-            - AWS Bedrock: {"access_key_id": "AKIA...", "secret_access_key": "secret..."}
-            - LangChain: {"api_key": "sk-123", "other_setting": "value"}
-
-            Migration from lm_api_key:
-            - Old: AgentConfig(lm_api_key="sk-123")
-            - New: AgentConfig(lm_credentials="sk-123")  # Same behavior, auto-detected
-
-        lm_retry_config: Retry configuration for the language model.
-    '''
-    lm_name: str | None
-    lm_hyperparameters: dict[str, Any] | None
-    lm_provider: str | None
-    lm_base_url: str | None
-    lm_api_key: str | None
-    lm_credentials: str | dict[str, Any] | None
-    lm_retry_config: RetryConfig | None

aip_agents/examples/hello_world_a2a_multi_agent_coordinator_client.pyi

@@ -1,15 +0,0 @@
-from aip_agents.agent import LangGraphAgent as LangGraphAgent
-from aip_agents.agent.types import A2AClientConfig as A2AClientConfig
-
-async def main() -> None:
-    """Main function demonstrating the Multi-Agent Coordinator client."""
-async def test_combined_request(client_agent, coordinator_card) -> None:
-    """Test a request that requires both image and table generation."""
-def handle_artifacts(result, test_name) -> None:
-    """Handle and display information about artifacts from the result."""
-def print_artifact_info(artifact: dict) -> None:
-    """Print information about an artifact.
-
-    Args:
-        artifact: Dictionary containing artifact information.
-    """

aip_agents/examples/hello_world_a2a_multi_agent_coordinator_client_streaming.pyi

@@ -1,5 +0,0 @@
-from aip_agents.agent import LangGraphAgent as LangGraphAgent
-from aip_agents.agent.types import A2AClientConfig as A2AClientConfig
-
-async def main() -> None:
-    """Main function demonstrating the Multi-Agent Coordinator streaming client."""

aip_agents/examples/hello_world_a2a_multi_agent_coordinator_server.pyi

@@ -1,11 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.agent import LangGraphAgent as LangGraphAgent
-from aip_agents.examples.tools.image_artifact_tool import ImageArtifactTool as ImageArtifactTool
-from aip_agents.examples.tools.table_generator_tool import TableGeneratorTool as TableGeneratorTool
-from aip_agents.utils.logger_manager import LoggerManager as LoggerManager
-
-logger: Incomplete
-SERVER_AGENT_NAME: str
-
-def main(host: str, port: int):
-    """Runs the Multi-Agent Coordinator A2A server."""

aip_agents/examples/hello_world_langgraph_bosa.pyi

@@ -1,5 +0,0 @@
-from aip_agents.agent import LangGraphAgent as LangGraphAgent
-from aip_agents.examples.tools.pr_details_bosa_tool import GitHubPRDetailsTool as GitHubPRDetailsTool
-
-async def langgraph_example_bosa() -> None:
-    """Demonstrates the LangGraphAgent's arun method with BOSA tools."""

aip_agents/examples/tools/pr_details_bosa_tool.pyi

@@ -1,26 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.tools.base_bosa_tools import BaseBosaTool as BaseBosaTool
-from aip_agents.tools.constants import Action as Action, ActionEndpointMap as ActionEndpointMap
-from langchain_core.tools import BaseTool as LangchainBaseTool
-from pydantic import BaseModel
-
-logger: Incomplete
-
-class GitHubPRDetailsSchema(BaseModel):
-    """Schema for retrieving details of specific GitHub Pull Requests."""
-    repository: str
-    pr_numbers: list[int]
-
-class GitHubPRDetailsTool(BaseBosaTool, LangchainBaseTool):
-    """Tool for retrieving details of specific pull requests."""
-    name: str
-    description: str
-    args_schema: type[BaseModel]
-    def __init__(self, **kwargs) -> None:
-        """Initialize the GitHubPRDetailsTool.
-
-        Calls both LangchainBaseTool and BaseBosaTool __init__ methods.
-
-        Args:
-            **kwargs: Additional keyword arguments for initialization.
-        """

aip_agents/tools/base.pyi

@@ -1,44 +0,0 @@
-from langchain_core.tools import BaseTool as LangchainBaseTool
-from typing import Any
-
-class BaseTool(LangchainBaseTool):
-    """Base class for tools inheriting from Langchain's BaseTool.
-
-    Tools should inherit from this class and implement the _run and optionally
-    _arun methods.
-
-    Attributes:
-        name (str): The name of the tool.
-        description (str): A description of what the tool does.
-        args_schema (Optional[Type[Any]]): The schema for the tool's arguments.
-        return_direct (bool): Whether to return the tool's output directly.
-    """
-    name: str
-    description: str
-    args_schema: type[Any] | None
-    return_direct: bool
-    def run(self, tool_input: Any, **_kwargs: Any) -> Any:
-        """Run the tool synchronously. (Not Implemented)
-
-        This method is intentionally not implemented to encourage asynchronous
-        operations via the `arun` method.
-
-        Args:
-            tool_input: The input for the tool.
-            **_kwargs: Unused. Additional keyword arguments.
-
-        Raises:
-            NotImplementedError: Always raised.
-        """
-    async def arun(self, tool_input: Any, **_kwargs: Any) -> Any:
-        """Run the tool asynchronously.
-
-        Args:
-            tool_input: The input for the tool.
-            **_kwargs: Unused. Additional keyword arguments.
-
-        Returns:
-            The output of the tool.
-        """
-    async def __call__(self, tool_input: Any) -> Any:
-        """Allows the tool instance to be called asynchronously."""

aip_agents/tools/base_bosa_tools.pyi

@@ -1,12 +0,0 @@
-from aip_agents.tools.bosa_connector import BOSAConnector as BOSAConnector
-from aip_agents.tools.bosa_tools_interface import BosaToolInterface as BosaToolInterface
-from aip_agents.tools.constants import BOSA_API_BASE_URL as BOSA_API_BASE_URL, BOSA_API_KEY as BOSA_API_KEY
-from langchain_core.callbacks import AsyncCallbackManagerForToolRun as AsyncCallbackManagerForToolRun
-
-class BaseBosaTool(BosaToolInterface):
-    """Base class for tools with BOSA Connector integration."""
-    def __init__(self, **kwargs) -> None:
-        """Initialize the BaseBosaTool.
-
-        This method calls the _init_bosa_connector method to initialize the BosaConnector.
-        """

aip_agents/tools/bosa_connector.pyi

@@ -1,30 +0,0 @@
-from _typeshed import Incomplete
-from bosa_connectors.connector import BosaConnector
-from typing import Any
-
-MAX_ATTEMPTS: int
-logger: Incomplete
-
-class BOSAConnector:
-    """Handler for fetching data using the BOSA Connector."""
-    bosa: BosaConnector
-    def __init__(self, api_base_url: str, api_key: str) -> None:
-        """Initialize the BOSA connector.
-
-        Args:
-            api_base_url: Base URL for the BOSA API
-            api_key: API key for authentication
-        """
-    def execute_endpoint(self, action: str, endpoint: str, input_: dict[str, Any], max_attempts: int = ..., forwards_cursor: bool = True) -> dict[str, Any]:
-        """Execute a BOSA endpoint and fetch data.
-
-        Args:
-            action: The BOSA API action to call
-            endpoint: The BOSA API endpoint to call
-            input_: Parameters matching the API spec
-            max_attempts: Max retry attempts
-            forwards_cursor: Whether to use cursor-based pagination (True) or page-based pagination (False)
-
-        Returns:
-            dict containing response data with '0', 'data', and 'meta' fields
-        """

aip_agents/tools/bosa_tools_interface.pyi

@@ -1,26 +0,0 @@
-import abc
-from abc import ABC, abstractmethod
-from aip_agents.tools.bosa_connector import BOSAConnector as BOSAConnector
-from pydantic import BaseModel as BaseModel
-
-class BosaToolInterface(ABC, metaclass=abc.ABCMeta):
-    """Interface for BOSA tools.
-
-    Defines the abstract base class for tools that agents can use.
-
-    Attributes:
-        name (str): The name of the tool.
-        description (Optional[str]): The description of the tool.
-        args_schema (Optional[Type[BaseModel]]): The schema for the tool arguments.
-        _bosa_connector (Optional[BOSAConnector]): The BosaConnector instance.
-    """
-    name: str
-    description: str | None
-    args_schema: type[BaseModel] | None
-    @abstractmethod
-    def __init__(self):
-        """Initialize the BosaToolInterface.
-
-        This method should be implemented by subclasses to define the tool's
-        initialization logic. The _init_bosa_connector should be called here.
-        """

aip_agents/tools/nested_agent_tool.pyi

@@ -1,45 +0,0 @@
-import logging
-from aip_agents.tools.base import BaseTool as BaseTool
-from aip_agents.types import AgentProtocol as AgentProtocol
-from gllm_core.event import EventEmitter as EventEmitter
-from pydantic import BaseModel
-from typing import Any
-
-class NestedAgentTool(BaseTool):
-    """Tool for wrapping an agent as a tool for use by another agent.
-
-    This allows agents to delegate tasks to other specialized agents.
-    The wrapped agent must conform to the AgentProtocol interface.
-
-    Attributes:
-        name: The name of the tool (derived from the agent's name).
-        description: The description of the tool (derived from the agent's description).
-        nested_agent: The agent to wrap as a tool.
-        return_direct: Whether to return the result directly to the parent agent without
-            additional processing. When True, the parent agent will receive the nested
-            agent's response directly rather than incorporating it into its reasoning.
-        logger: Logger for tracking tool execution.
-    """
-    name: str
-    description: str
-    nested_agent: AgentProtocol
-    return_direct: bool
-    logger: logging.Logger | None
-    class ArgsSchema(BaseModel):
-        """ArgsSchema is a Pydantic model that defines the schema for the arguments required by the nested agent.
-
-        Attributes:
-            query (str): User query to delegate to the nested agent. This field is required.
-        """
-        query: str
-    args_schema: type[BaseModel]
-    def __init__(self, nested_agent: AgentProtocol, **kwargs: Any) -> None:
-        """Initialize the Tool class with an agent and additional data.
-
-        Args:
-            nested_agent (AgentProtocol): The agent instance to be wrapped.
-            **kwargs (Any): Additional keyword arguments to pass to the parent constructor.
-
-        Raises:
-            ValueError: If the provided agent doesn't conform to AgentProtocol.
-        """

aip_agents/utils/logger_manager.pyi

@@ -1,151 +0,0 @@
-import logging
-from _typeshed import Incomplete
-
-BOSA_CORE_AVAILABLE: bool
-DEFAULT_LOG_FORMAT: Incomplete
-DEFAULT_DATE_FORMAT: str
-LOG_COLORS: Incomplete
-MAX_LOG_COLORS_LENGTH: Incomplete
-TRUNCATED_MESSAGE: str
-MAX_MESSAGE_LENGTH: Incomplete
-
-class StandardizedFormatter(logging.Formatter):
-    """Custom formatter that outputs logs in standardized JSON format with colors.
-
-    Follows the standardized log format:
-    - level: string (e.g., INFO, ERROR)
-    - timestamp: ISO 8601 with timezone (e.g., 2025-07-23T00:29:05.091Z)
-    - message: string (the content of the log) (max 500000 context length)
-    - error: object (for error logs only)
-        - message: string (the error message)
-        - code: string (specific error code)
-        - stacktrace: string (the stack trace for debugging)
-    """
-    def format(self, record: logging.LogRecord) -> str:
-        """Format the log record in standardized JSON format with colors.
-
-        Args:
-            record (logging.LogRecord): The log record to be formatted.
-
-        Returns:
-            str: The formatted log message in JSON format.
-        """
-
-class ColoredFormatter(logging.Formatter):
-    """Custom formatter to add colors based on log level."""
-    def format(self, record: logging.LogRecord) -> str:
-        """Format the log record with colors based on log level.
-
-        Args:
-            record (logging.LogRecord): The log record to be formatted.
-
-        Returns:
-            str: The formatted log message with color codes.
-        """
-
-class LoggerManager:
-    '''A singleton class to manage logging configuration.
-
-    This class ensures that the root logger is initialized only once and is used across the application.
-    Supports both traditional colored output and standardized format with colors.
-
-    Example to get and use the logger:
-    ```python
-    manager = LoggerManager()
-
-    logger = manager.get_logger()
-
-    logger.info("This is an info message")
-    ```
-
-    Example to set logging configuration:
-    ```python
-    manager = LoggerManager()
-
-    manager.set_level(logging.DEBUG)
-    manager.set_output_format("traditional")  # or "standardized"
-    ```
-
-    Example to add a custom handler:
-    ```python
-    manager = LoggerManager()
-
-    handler = logging.FileHandler("app.log")
-    manager.add_handler(handler)
-    ```
-
-    Output format examples:
-
-    Traditional format:
-    ```python
-    [16/04/2025 15:08:18.323 GDPLabsGenAILogger INFO] Loading prompt_builder catalog for chatbot `general-purpose`
-    ```
-
-    Standardized format:
-    ```json
-    {
-        "level": "INFO",
-        "timestamp": "2025-07-23T00:29:05.091Z",
-        "message": "Loading prompt_builder catalog for chatbot `general-purpose`"
-    }
-    ```
-
-    Error standardized format:
-    ```json
-    {
-        "level": "ERROR",
-        "timestamp": "2025-07-23T00:29:05.091Z",
-        "message": "Failed to load configuration",
-        "error": {
-            "message": "Configuration file not found",
-            "code": "CONFIG_NOT_FOUND",
-            "stacktrace": "Traceback (most recent call last):..."
-        }
-    }
-    ```
-    '''
-    def __new__(cls):
-        """Initialize the singleton instance."""
-    def get_logger(self, name: str | None = None) -> logging.Logger:
-        """Get a logger instance.
-
-        This method returns a logger instance that is a child of the root logger. If name is not provided,
-        the root logger will be returned instead.
-
-        Args:
-            name (str | None, optional): The name of the child logger.
-                If None, the root logger will be returned. Defaults to None.
-
-        Returns:
-            logging.Logger: Configured logger instance.
-        """
-    def set_level(self, level: int) -> None:
-        """Set logging level for all loggers in the hierarchy.
-
-        Args:
-            level (int): The logging level to set (e.g., logging.INFO, logging.DEBUG).
-        """
-    def set_output_format(self, output_format: str) -> None:
-        '''Set the output format for all loggers in the hierarchy.
-
-        Args:
-            output_format (str): The output format to set. Must be either "standardized" or "traditional".
-        '''
-    def set_log_format(self, log_format: str) -> None:
-        """Set logging format for all loggers in the hierarchy (traditional mode only).
-
-        Args:
-            log_format (str): The log format to set.
-        """
-    def set_date_format(self, date_format: str) -> None:
-        """Set date format for all loggers in the hierarchy (traditional mode only).
-
-        Args:
-            date_format (str): The date format to set.
-        """
-    def add_handler(self, handler: logging.Handler) -> None:
-        """Add a custom handler to the root logger.
-
-        Args:
-            handler (logging.Handler): The handler to add to the root logger.
-        """