aigency 0.0.1rc235167702__tar.gz → 0.0.1rc238211992__tar.gz

{aigency-0.0.1rc235167702 → aigency-0.0.1rc238211992}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aigency
-Version: 0.0.1rc235167702
+Version: 0.0.1rc238211992
 Summary: Add your description here
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

aigency-0.0.1rc238211992/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-0.0.1rc238211992/aigency/agents/communicator.py

@@ -0,0 +1,121 @@
+import uuid
+from typing import Any, Awaitable, List
+
+from a2a.types import Message, Task
+from google.adk.tools.tool_context import ToolContext
+
+from aigency.utils.logger import get_logger
+
+logger = get_logger()
+
+class Communicator:
+    """Clase base para la comunicación entre agentes (Agent-to-Agent)."""
+
+    def __init__(self, remote_agent_connections: dict[str, Any] | None = None):
+        """Inicializa el comunicador con las conexiones a los agentes remotos.
+
+        Args:
+            remote_agent_connections: Un diccionario que mapea nombres de agentes
+                a sus objetos de conexión de cliente.
+        """
+        self.remote_agent_connections: dict[str, Any] = remote_agent_connections or {}
+
+    async def send_message(
+        self, agent_name: str, task: str, tool_context: ToolContext
+    ) -> Awaitable[Task | None]:
+        """Delega una tarea a un agente remoto específico.
+
+        Este método envía un mensaje a un agente remoto, solicitando que realice una
+        tarea. Gestiona la creación del payload del mensaje y la comunicación.
+
+        Args:
+            agent_name: Nombre del agente remoto al que se envía la tarea.
+            task: Descripción detallada de la tarea para el agente remoto.
+            tool_context: Objeto de contexto que contiene el estado y otra información.
+
+        Returns:
+            Un objeto Task si la comunicación es exitosa, o None en caso contrario.
+
+        Raises:
+            ValueError: Si el agente especificado no se encuentra en las conexiones.
+        """
+        logger.info(
+            f"`send_message` iniciado para el agente: '{agent_name}' con la tarea: '{task}'"
+        )
+        client = self.remote_agent_connections.get(agent_name)
+        if not client:
+            available_agents = list(self.remote_agent_connections.keys())
+            logger.error(
+                f"El LLM intentó llamar a '{agent_name}', pero no se encontró. "
+                f"Agentes disponibles: {available_agents}"
+            )
+            raise ValueError(f"Agente '{agent_name}' no encontrado. Agentes disponibles: {available_agents}")
+
+        state = tool_context.state
+
+        # Simplifica la creación y obtención de contextos de agente usando setdefault
+        contexts = state.setdefault("remote_agent_contexts", {})
+        agent_context = contexts.setdefault(agent_name, {"context_id": str(uuid.uuid4())})
+        context_id = agent_context["context_id"]
+
+        # Obtiene IDs de forma más segura y clara
+        task_id = state.get("task_id")
+        input_metadata = state.get("input_message_metadata", {})
+        message_id = input_metadata.get("message_id")
+
+        # El message_id se pasa directamente al creador del payload
+        payload = self.create_send_message_payload(
+            text=task, task_id=task_id, context_id=context_id, message_id=message_id
+        )
+        logger.debug("`send_message` con el siguiente payload: %s", payload)
+
+        send_response = None
+        # Este bucle está diseñado para consumir un generador asíncrono y obtener
+        # la última respuesta, que suele ser el resultado final.
+        async for resp in client.send_message(
+            message_request=Message(**payload["message"])
+        ):
+            send_response = resp
+
+        if isinstance(send_response, tuple):
+            send_response, _ = send_response
+
+        if not isinstance(send_response, Task):
+            logger.warning(
+                f"La respuesta recibida del agente '{agent_name}' no es un objeto Task. "
+                f"Tipo recibido: {type(send_response)}"
+            )
+            return None
+
+        return send_response
+
+    @staticmethod
+    def create_send_message_payload(
+        text: str,
+        task_id: str | None = None,
+        context_id: str | None = None,
+        message_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Crea el payload de un mensaje para enviarlo a un agente remoto.
+
+        Args:
+            text: El contenido de texto del mensaje.
+            task_id: ID de tarea opcional para asociar con el mensaje.
+            context_id: ID de contexto opcional para asociar con el mensaje.
+            message_id: ID de mensaje opcional. Si es None, se generará uno nuevo.
+
+        Returns:
+            Un diccionario que contiene el payload del mensaje formateado.
+        """
+        payload: dict[str, Any] = {
+            "message": {
+                "role": "user",
+                "parts": [{"type": "text", "text": text}],
+                "message_id": message_id or uuid.uuid4().hex,
+            },
+        }
+        if task_id:
+            payload["message"]["task_id"] = task_id
+        if context_id:
+            payload["message"]["context_id"] = context_id
+        return payload

aigency-0.0.1rc238211992/aigency/agents/generator.py

@@ -0,0 +1,138 @@
+import logging
+import httpx
+from typing import List
+import asyncio
+
+from a2a.types import AgentCapabilities, AgentCard, AgentSkill
+from a2a.client import A2ACardResolver
+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.agents.client import AgentClient
+from aigency.schemas.aigency_config import AigencyConfig
+from aigency.schemas.agent.remote_agent import RemoteAgent
+from aigency.tools.generator import ToolGenerator
+from aigency.utils.utils import generate_url, safe_async_run
+from aigency.agents.communicator import Communicator
+from aigency.utils.logger import get_logger
+
+logger = get_logger()
+
+class AgentA2AGenerator:
+
+    @staticmethod
+    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)
+
+        return Agent(
+            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: AigencyConfig) -> AgentCard:
+
+        # TODO: Parse properly
+        capabilities = AgentCapabilities(
+            streaming=agent_config.service.capabilities.streaming
+        )
+
+        skills = [
+            AgentSkill(
+                id=skill.id,
+                name=skill.name,
+                description=skill.description,
+                tags=skill.tags,
+                examples=skill.examples,
+            )
+            for skill in agent_config.agent.skills
+        ]
+
+        return AgentCard(
+            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:
+
+        runner = Runner(
+            app_name=agent.name,
+            agent=agent,
+            artifact_service=InMemoryArtifactService(),
+            session_service=InMemorySessionService(),
+            memory_service=InMemoryMemoryService(),
+        )
+
+        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-0.0.1rc235167702 → aigency-0.0.1rc238211992}/aigency/schemas/agent/agent.py

@@ -2,11 +2,15 @@ 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 FunctionTool, McpTool
+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[FunctionTool | McpTool]] = []
+    tools: Optional[List[Tool]] = []
+    remote_agents: Optional[List[RemoteAgent]] = []

aigency-0.0.1rc238211992/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-0.0.1rc235167702 → aigency-0.0.1rc238211992}/aigency/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-0.0.1rc235167702 → aigency-0.0.1rc238211992}/aigency/utils/utils.py

@@ -11,6 +11,7 @@ from aigency.utils.logger import get_logger
 
 logger = get_logger()
 
+
 def convert_a2a_part_to_genai(part: Part) -> types.Part:
     """Convert a single A2A Part type into a Google Gen AI Part type.
 
@@ -54,6 +55,7 @@ def convert_genai_part_to_a2a(part: types.Part) -> Part:
         )
     raise ValueError(f"Unsupported part type: {part}")
 
+
 def expand_env_vars(env_dict):
     """
     Expande los valores del diccionario usando variables de entorno solo si el valor es una clave de entorno existente.
@@ -67,6 +69,21 @@ def expand_env_vars(env_dict):
             logger.warning(f"Environment variable {v} not found")
     return result
 
+
+def generate_url(host: str, port: int, path: str = "") -> str:
+    """Generate a URL from host, port, and path components.
+
+    Args:
+        host (str): Hostname or IP address.
+        port (int): Port number.
+        path (str, optional): URL path. Defaults to "".
+
+    Returns:
+        str: Complete URL in the format http://host:port/path.
+    """
+    return f"http://{host}:{port}{path}"
+
+
 def safe_async_run(coro):
     """Simple wrapper to safely run async code."""
     try:
@@ -93,4 +110,5 @@ def safe_async_run(coro):
         else:
             return loop.run_until_complete(coro)
     except RuntimeError:
-        return asyncio.run(coro)
+        return asyncio.run(coro)
+

{aigency-0.0.1rc235167702 → aigency-0.0.1rc238211992}/aigency.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aigency
-Version: 0.0.1rc235167702
+Version: 0.0.1rc238211992
 Summary: Add your description here
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{aigency-0.0.1rc235167702 → aigency-0.0.1rc238211992}/aigency.egg-info/SOURCES.txt

@@ -6,11 +6,14 @@ aigency.egg-info/SOURCES.txt
 aigency.egg-info/dependency_links.txt
 aigency.egg-info/requires.txt
 aigency.egg-info/top_level.txt
+aigency/agents/client.py
+aigency/agents/communicator.py
 aigency/agents/executor.py
 aigency/agents/generator.py
 aigency/schemas/aigency_config.py
 aigency/schemas/agent/agent.py
 aigency/schemas/agent/model.py
+aigency/schemas/agent/remote_agent.py
 aigency/schemas/agent/skills.py
 aigency/schemas/agent/tools.py
 aigency/schemas/metadata/metadata.py

{aigency-0.0.1rc235167702 → aigency-0.0.1rc238211992}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aigency"
-version = "0.0.1rc235167702"
+version = "0.0.1rc238211992"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"

aigency-0.0.1rc235167702/aigency/agents/generator.py

@@ -1,75 +0,0 @@
-"""Agent generator module for creating A2A agents."""
-
-from typing import Any, Dict, List
-
-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.schemas.aigency_config import AigencyConfig
-from aigency.tools.generator import ToolGenerator
-
-
-class AgentA2AGenerator:
-    """Generator for creating A2A agents and related components."""
-
-    @staticmethod
-    def create_agent(agent_config: AigencyConfig) -> Agent:
-
-        tools = [
-            ToolGenerator.create_tool(tool_cfg) for tool_cfg in agent_config.agent.tools
-        ]
-
-        return Agent(
-            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: AigencyConfig) -> AgentCard:
-
-        # TODO: Parse properly
-        capabilities = AgentCapabilities(
-            streaming=agent_config.service.capabilities.streaming
-        )
-
-        skills = [
-            AgentSkill(
-                id=skill.id,
-                name=skill.name,
-                description=skill.description,
-                tags=skill.tags,
-                examples=skill.examples,
-            )
-            for skill in agent_config.agent.skills
-        ]
-
-        return AgentCard(
-            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:
-
-        runner = Runner(
-            app_name=agent.name,
-            agent=agent,
-            artifact_service=InMemoryArtifactService(),
-            session_service=InMemorySessionService(),
-            memory_service=InMemoryMemoryService(),
-        )
-
-        return AgentA2AExecutor(runner=runner, card=agent_card)