aigency 0.0.1rc15474277__py3-none-any.whl → 0.0.1rc163779164__py3-none-any.whl

aigency/agents/client.py

@@ -0,0 +1,59 @@
+import httpx
+ 
+from a2a.client.client import ClientConfig
+from a2a.client.client_factory import ClientFactory
+from a2a.types import AgentCard, Message, SendMessageResponse
+#TODO: Enable when auth is implemented
+#from a2a.client.auth.interceptor import AuthInterceptor
+
+
+class AgentClient:
+    """A class to hold the connections to the remote agents.
+
+    This class manages connections to remote agents using the A2A protocol.
+    It provides methods for retrieving agent information and sending messages
+    to remote agents.
+
+    Attributes:
+        _httpx_client (httpx.AsyncClient): The HTTP client used for asynchronous requests.
+        agent_card (AgentCard): The agent card containing metadata about the remote agent.
+    """
+
+    def __init__(self, agent_card: AgentCard):
+        """Initialize a connection to a remote agent.
+
+        Args:
+            agent_card (AgentCard): The agent card containing metadata about the remote agent.
+
+        Raises:
+            None
+
+        Returns:
+            None
+        """
+        self._httpx_client = httpx.AsyncClient(timeout=60)
+        self.card = agent_card
+
+        config = ClientConfig(httpx_client=self._httpx_client)
+        factory = ClientFactory(config=config)
+        self.agent_client = factory.create(agent_card)
+
+    def get_agent(self) -> AgentCard:
+        """Get the agent card for this remote agent connection.
+
+        Returns:
+            AgentCard: The agent card containing metadata about the remote agent.
+        """
+        return self.card
+
+    async def send_message(self, message_request: Message) -> SendMessageResponse:
+        """Send a message to the remote agent.
+
+        Args:
+            message_request (Message): The message request to send to the remote agent.
+
+        Returns:
+            SendMessageResponse: The response from the remote agent.
+        """
+        async for response in self.agent_client.send_message(message_request):
+            yield response

aigency/agents/communicator.py

@@ -0,0 +1,107 @@
+import logging
+import uuid
+from typing import Any
+from a2a.types import Message, Task
+from google.adk.tools.tool_context import ToolContext
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class Communicator:
+    """Base class for Agent-to-Agent communication."""
+
+    def __init__(self, remote_agent_connections=None):
+        self.remote_agent_connections = remote_agent_connections
+
+    async def send_message(self, agent_name: str, task: str, tool_context: ToolContext):
+        """Delegate a task to a specified remote agent.
+
+        This method sends a message to a remote agent, requesting it to perform a task.
+        It handles the creation of the message payload and manages the communication
+        with the remote agent.
+
+        Args:
+            agent_name: Name of the remote agent to send the task to.
+            task: Detailed description of the task for the remote agent to perform.
+            tool_context: Context object containing state and other information.
+
+        Returns:
+            Task object if successful, None otherwise.
+
+        Raises:
+            ValueError: If the specified agent is not found in the available connections.
+        """
+        logger.info(
+            f"`send_message` triggered with agent_name: {agent_name}, task: {task}"
+        )
+        if agent_name not in self.remote_agent_connections:
+            logger.error(
+                f"LLM tried to call '{agent_name}' but it was not found. "
+                f"Available agents: {list(self.remote_agent_connections.keys())}"
+            )
+            raise ValueError(f"Agent '{agent_name}' not found.")
+
+        state = tool_context.state
+        client = self.remote_agent_connections[agent_name]
+
+        if "remote_agent_contexts" not in state:
+            state["remote_agent_contexts"] = {}
+
+        if agent_name not in state["remote_agent_contexts"]:
+            logger.debug(f"Creating new context for agent: {agent_name}")
+            state["remote_agent_contexts"][agent_name] = {
+                "context_id": str(uuid.uuid4())
+            }
+        context_id = state["remote_agent_contexts"][agent_name]["context_id"]
+        task_id = state.get("task_id", None)
+        message_id = state.get("input_message_metadata", {}).get(
+            "message_id", str(uuid.uuid4())
+        )
+
+        payload = self.create_send_message_payload(task, task_id, context_id)
+        payload["message"]["message_id"] = message_id
+        logger.debug("`send_message` triggered with payload: %s", payload)
+
+        send_response = None
+        async for resp in client.send_message(
+            message_request=Message(**payload.get("message"))
+        ):
+            send_response = resp
+
+        if isinstance(send_response, tuple):
+            send_response, _ = send_response
+
+        if not isinstance(send_response, Task):
+            return None
+        return send_response
+
+    @staticmethod
+    def create_send_message_payload(
+        text: str,
+        task_id: str | None = None,
+        context_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Create a message payload for sending to a remote agent.
+
+        Args:
+            text: The text content of the message.
+            task_id: Optional task ID to associate with the message.
+            context_id: Optional context ID to associate with the message.
+
+        Returns:
+            dict: A dictionary containing the formatted message payload ready
+                to be sent to a remote agent.
+        """
+        payload: dict[str, Any] = {
+            "message": {
+                "role": "user",
+                "parts": [{"type": "text", "text": text}],
+                "message_id": uuid.uuid4().hex,
+            },
+        }
+        if task_id:
+            payload["message"]["task_id"] = task_id
+        if context_id:
+            payload["message"]["context_id"] = context_id
+        return payload

aigency/agents/generator.py

@@ -1,39 +1,57 @@
-"""Agent generator module for creating A2A agents."""
+import logging
+import httpx
+from google.adk.agents import Agent
+from a2a.types import AgentCapabilities, AgentCard, AgentSkill
 
-from typing import Any, Dict, List
+from aigency.agents.executor import AgentA2AExecutor
+from aigency.agents.client import AgentClient
+from aigency.schemas.aigency_config import AigencyConfig
+from aigency.tools.generator import ToolGenerator
+from aigency.utils.utils import generate_url, safe_async_run
+from aigency.agents.communicator import Communicator
 
-from a2a.types import AgentCapabilities, AgentCard, AgentSkill
-from google.adk.agents import Agent
 from google.adk.artifacts import InMemoryArtifactService
 from google.adk.memory.in_memory_memory_service import InMemoryMemoryService
 from google.adk.runners import Runner
 from google.adk.sessions import InMemorySessionService
 
-from aigency.agents.executor import AgentA2AExecutor
-from aigency.models.config import AgentConfig
-from aigency.tools.generator import ToolGenerator
+from a2a.client import A2ACardResolver
 
 
 class AgentA2AGenerator:
-    """Generator for creating A2A agents and related components."""
 
     @staticmethod
-    def create_agent(agent_config: AgentConfig) -> Agent:
+    def create_agent(agent_config: AigencyConfig) -> Agent:
+
+        tools = [
+            ToolGenerator.create_tool(tool_cfg) for tool_cfg in agent_config.agent.tools
+        ]
+
+        remote_agents = agent_config.agent.remote_agents
+        if remote_agents:
+            remote_agent_connections = AgentA2AGenerator.build_remote_agent_connections(
+                agent_config
+            )
+            logger.info(f"Remote agent connections: {remote_agent_connections}")
+            communicator = Communicator(
+                remote_agent_connections=remote_agent_connections
+            )
+            tools.append(communicator.send_message)
 
-        tools = [ToolGenerator.create_tool(tool_cfg) for tool_cfg in agent_config.tools]
-        
         return Agent(
-            name=agent_config.name,
-            model=agent_config.model.name,
-            instruction=agent_config.instruction,
+            name=agent_config.metadata.name,
+            model=agent_config.agent.model.name,
+            instruction=agent_config.agent.instruction,
             tools=tools,
         )
 
     @staticmethod
-    def build_agent_card(agent_config: AgentConfig) -> AgentCard:
+    def build_agent_card(agent_config: AigencyConfig) -> AgentCard:
 
         # TODO: Parse properly
-        capabilities = AgentCapabilities(streaming=agent_config.capabilities.streaming)
+        capabilities = AgentCapabilities(
+            streaming=agent_config.service.capabilities.streaming
+        )
 
         skills = [
             AgentSkill(
@@ -43,24 +61,22 @@ class AgentA2AGenerator:
                 tags=skill.tags,
                 examples=skill.examples,
             )
-            for skill in agent_config.skills
+            for skill in agent_config.agent.skills
         ]
 
         return AgentCard(
-            name=agent_config.name,
-            description=agent_config.description,
-            url=agent_config.url,
-            version=agent_config.version,
-            default_input_modes=agent_config.default_input_modes,
-            default_output_modes=agent_config.default_output_modes,
+            name=agent_config.metadata.name,
+            description=agent_config.metadata.description,
+            url=agent_config.service.url,
+            version=agent_config.metadata.version,
+            default_input_modes=agent_config.service.interface.default_input_modes,
+            default_output_modes=agent_config.service.interface.default_output_modes,
             capabilities=capabilities,
             skills=skills,
         )
 
     @staticmethod
-    def build_executor(
-        agent: Agent, agent_card: AgentCard
-    ) -> AgentA2AExecutor:
+    def build_executor(agent: Agent, agent_card: AgentCard) -> AgentA2AExecutor:
 
         runner = Runner(
             app_name=agent.name,
@@ -71,3 +87,48 @@ class AgentA2AGenerator:
         )
 
         return AgentA2AExecutor(runner=runner, card=agent_card)
+
+    @staticmethod
+    def build_remote_agent_connections(agent_config: AigencyConfig):
+        """Initialize connections to all remote agents asynchronously.
+
+        Tests each connection individually with detailed logging to help identify
+        any connection issues. It attempts to connect to each remote agent address,
+        retrieve its agent card, and store the connection for later use.
+
+        Raises:
+            No exceptions are raised, but errors are logged.
+        """
+
+        if not agent_config.agent.remote_agents:
+            return {}
+
+        remote_agent_configs = [
+            {"url": generate_url(host=remote_agent.host, port=remote_agent.port)}
+            for remote_agent in agent_config.agent.remote_agents
+        ]
+
+        async def _connect():
+            remote_agent_connections = {}
+            async with httpx.AsyncClient(timeout=60) as client:
+                for config in remote_agent_configs:
+                    address = config.get("url")
+                    logger.debug(f"--- Attempting connection to: {address} ---")
+                    try:
+                        card_resolver = A2ACardResolver(client, address)
+                        card = await card_resolver.get_agent_card()
+                        remote_connection = AgentClient(agent_card=card)
+                        remote_agent_connections[card.name] = remote_connection
+                    except Exception as e:
+                        logger.error(
+                            f"--- CRITICAL FAILURE for address: {address} ---",
+                            exc_info=True,
+                        )
+                        raise e
+            return remote_agent_connections
+
+        try:
+            return safe_async_run(_connect())
+        except Exception as e:
+            logger.error("--- CRITICAL FAILURE", exc_info=True)
+            raise e

aigency/schemas/agent/agent.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+from typing import List, Optional
+from aigency.schemas.agent.model import AgentModel
+from aigency.schemas.agent.skills import Skill
+from aigency.schemas.agent.tools import Tool
+from aigency.schemas.agent.remote_agent import RemoteAgent
+
+
+class Agent(BaseModel):
+    """El 'cerebro' del agente: su lógica, modelo y capacidades."""
+
+    model: AgentModel
+    instruction: str
+    skills: List[Skill]
+    tools: Optional[List[Tool]] = []
+    remote_agents: Optional[List[RemoteAgent]] = []

aigency/schemas/agent/model.py

@@ -0,0 +1,12 @@
+from typing import Optional
+from pydantic import BaseModel
+
+class ProviderConfig(BaseModel):
+    """Configuration for AI model provider."""
+    name: str
+    endpoint: Optional[str] = None
+
+class AgentModel(BaseModel):
+    """Configuration for AI model."""
+    name: str
+    provider: Optional[ProviderConfig] = None

aigency/schemas/agent/remote_agent.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel, Field
+
+
+class RemoteAgent(BaseModel):
+    """Remote agent configuration."""
+
+    name: str
+    host: str
+    port: int = Field(..., ge=1, le=65535)

aigency/schemas/agent/skills.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+from typing import List
+
+class Skill(BaseModel):
+    """Define una habilidad específica del agente."""
+    id: str
+    name: str
+    description: str
+    tags: List[str]
+    examples: List[str]

aigency/{models → schemas/agent}/tools.py

@@ -1,39 +1,53 @@
 """Tool models for agent configuration."""
 
 from enum import Enum
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, TypeAlias
 
 from pydantic import BaseModel
 
 
 class ToolType(str, Enum):
     """Enum for tool types."""
+
     MCP = "mcp"
     FUNCTION = "function"
 
-class Tool(BaseModel):
+
+class BaseTool(BaseModel):
     """Define an external tool that the agent can use."""
+
     type: ToolType
     name: str
     description: str
 
-class FunctionTool(Tool):
+
+class FunctionTool(BaseTool):
     """Configuration for function-based tools."""
+
     module_path: str
     function_name: str
 
+
 class McpTypeStreamable(BaseModel):
     """Model for streamable tool type."""
+
     url: str
     port: int
     path: str = "/"
 
+
 class McpTypeStdio(BaseModel):
     """Model for stdio tool type."""
+
     command: str
     args: List[str]
     env: Optional[Dict[str, str]] = None
 
-class McpTool(Tool):
+
+class McpTool(BaseTool):
     """Configuration for MCP-based tools."""
-    mcp_config: McpTypeStreamable | McpTypeStdio
+
+    mcp_config: McpTypeStreamable | McpTypeStdio
+
+
+Tool: TypeAlias = FunctionTool | McpTool

aigency/schemas/aigency_config.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+from typing import Optional
+from aigency.schemas.observability.observability import Observability
+from aigency.schemas.metadata.metadata import Metadata
+from aigency.schemas.agent.agent import Agent
+from aigency.schemas.service.service import Service
+
+class AigencyConfig(BaseModel):
+    """Root Pydantic model for complete agent configuration."""
+
+    metadata: Metadata
+    service: Service
+    agent: Agent
+    observability: Optional[Observability] = None

aigency/schemas/metadata/metadata.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+
+
+class Metadata(BaseModel):
+    """Metadatos descriptivos del agente."""
+    name: str
+    version: str
+    description: str

aigency/schemas/observability/observability.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+from aigency.schemas.observability.phoenix import Phoenix
+
+class Monitoring(BaseModel):
+    """Configuración de las herramientas de monitoreo."""
+    phoenix: Phoenix
+
+class Observability(BaseModel):
+    """Agrupa todas las configuraciones de observabilidad."""
+    monitoring: Monitoring

aigency/schemas/observability/phoenix.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+
+class Phoenix(BaseModel):
+    """Configuración del monitor Phoenix."""
+    host: str
+    port: int

aigency/schemas/service/capabilities.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+class Capabilities(BaseModel):
+    """Capacidades técnicas del servicio del agente."""
+    streaming: bool

aigency/schemas/service/interface.py

@@ -0,0 +1,7 @@
+from typing import List
+from pydantic import BaseModel
+
+class Interface(BaseModel):
+    """Define los modos de comunicación del agente."""
+    default_input_modes: List[str]
+    default_output_modes: List[str]

aigency/schemas/service/service.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+from aigency.schemas.service.interface import Interface
+from aigency.schemas.service.capabilities import Capabilities
+
+class Service(BaseModel):
+    """Configuración de red y comunicación del agente."""
+    url: str
+    interface: Interface
+    capabilities: Capabilities

aigency/tools/generator.py

@@ -14,7 +14,7 @@ from google.adk.tools.mcp_tool.mcp_toolset import (
     StreamableHTTPConnectionParams,
 )
 
-from aigency.models.tools import (
+from aigency.schemas.agent.tools import (
     FunctionTool,
     McpTool,
     McpTypeStdio,
@@ -43,11 +43,7 @@ class ToolGenerator:
 
         if isinstance(config.mcp_config, McpTypeStreamable):
             url = f"http://{config.mcp_config.url}:{config.mcp_config.port}{config.mcp_config.path}"
-            return MCPToolset(
-                connection_params=StreamableHTTPConnectionParams(
-                    url=url
-                )
-            )
+            return MCPToolset(connection_params=StreamableHTTPConnectionParams(url=url))
         elif isinstance(config.mcp_config, McpTypeStdio):
             command = config.mcp_config.command
             args = config.mcp_config.args
@@ -65,7 +61,7 @@ class ToolGenerator:
         ToolType.MCP: load_mcp_tool,
         ToolType.FUNCTION: load_function_tool,
     }
-    
+
     @staticmethod
     def create_tool(tool: Tool) -> Optional[Any]:
         """Create a tool based on its configuration.

aigency/utils/config_service.py

@@ -6,36 +6,46 @@ from typing import Any, Dict, Optional
 
 import yaml
 
-from aigency.models.config import AgentConfig
+from aigency.schemas.aigency_config import AigencyConfig
 from aigency.utils.logger import get_logger
 
 
 logger = get_logger()
 
+
 class ConfigService:
     """Service for loading and managing agent configurations."""
+
     def __init__(self, config_file: str, environment: Optional[str] = None):
         self.config_file = config_file
-        self.environment = environment or os.getenv('ENVIRONMENT', None)
+        self.environment = environment or os.getenv("ENVIRONMENT", None)
         self.config = self._load_and_parse()
 
-    def _load_and_parse(self) -> AgentConfig:
-        """Carga los YAMLs, los mergea y parsea según AgentConfig."""
+    def _load_and_parse(self) -> AigencyConfig:
+        """Carga los YAMLs, los mergea y parsea según AigencyConfig."""
 
         logger.info(f"Loading configuration from {self.config_file}")
         config = self._load_yaml(self.config_file)
 
         if self.environment is not None:
-            logger.info(f"Environment '{self.environment}' detected, loading environment-specific configuration")
+            logger.info(
+                f"Environment '{self.environment}' detected, loading environment-specific configuration"
+            )
             env_config = self._load_env_config()
             if env_config:
-                logger.info(f"Successfully loaded environment configuration with {len(env_config)} keys: {list(env_config.keys())}")
+                logger.info(
+                    f"Successfully loaded environment configuration with {len(env_config)} keys: {list(env_config.keys())}"
+                )
                 config = self._merge_configs(config, env_config)
-                logger.debug(f"Configuration merged successfully for environment '{self.environment}'")
+                logger.debug(
+                    f"Configuration merged successfully for environment '{self.environment}'"
+                )
             else:
-                logger.warning(f"No environment-specific configuration found for '{self.environment}', using base configuration only")
-        
-        return AgentConfig(**config)
+                logger.warning(
+                    f"No environment-specific configuration found for '{self.environment}', using base configuration only"
+                )
+
+        return AigencyConfig(**config)
 
     def _load_yaml(self, file_path: str) -> Dict[str, Any]:
         """Carga un archivo YAML."""
@@ -43,26 +53,37 @@ class ConfigService:
             with open(file_path, "r", encoding="utf-8") as file:
                 return yaml.safe_load(file) or {}
         except FileNotFoundError:
-            raise FileNotFoundError(f"Archivo de configuración no encontrado: {file_path}")
+            raise FileNotFoundError(
+                f"Archivo de configuración no encontrado: {file_path}"
+            )
         except yaml.YAMLError as e:
             raise ValueError(f"Error al parsear YAML {file_path}: {e}")
 
     def _load_env_config(self) -> Optional[Dict[str, Any]]:
         """Carga configuración específica del entorno."""
         config_path = Path(self.config_file)
-        env_file = config_path.parent / f"{config_path.stem}.{self.environment}{config_path.suffix}"
-        
+        env_file = (
+            config_path.parent
+            / f"{config_path.stem}.{self.environment}{config_path.suffix}"
+        )
+
         return self._load_yaml(str(env_file)) if env_file.exists() else None
 
-    def _merge_configs(self, base: Dict[str, Any], env: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+    def _merge_configs(
+        self, base: Dict[str, Any], env: Optional[Dict[str, Any]]
+    ) -> Dict[str, Any]:
         """Mergea configuración base con configuración de entorno."""
         if not env:
             return base
-            
+
         result = base.copy()
         for key, value in env.items():
-            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            if (
+                key in result
+                and isinstance(result[key], dict)
+                and isinstance(value, dict)
+            ):
                 result[key] = self._merge_configs(result[key], value)
             else:
                 result[key] = value
-        return result
+        return result