aigency 0.0.1__tar.gz

aigency-0.0.1/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: aigency
+Version: 0.0.1
+Summary: Add your description here
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: google-adk>=1.11.0
+Requires-Dist: a2a-sdk==0.3.0
+Requires-Dist: litellm<1.73.0,>=1.72.6
+Requires-Dist: pyyaml==6.0.2
+Requires-Dist: PyJWT==2.10.1
+
+# aigency-lib
+
+
+aigency-lib/examples/simple_agents/hello_world_agent
+
+docker compose up

aigency-0.0.1/README.md

@@ -0,0 +1,6 @@
+# aigency-lib
+
+
+aigency-lib/examples/simple_agents/hello_world_agent
+
+docker compose up

aigency-0.0.1/aigency/agents/executor.py

@@ -0,0 +1,141 @@
+"""Agent executor module for A2A integration."""
+
+from a2a.server.agent_execution import AgentExecutor
+from a2a.server.agent_execution.context import RequestContext
+from a2a.server.events.event_queue import EventQueue
+from a2a.server.tasks import TaskUpdater
+from a2a.types import AgentCard, TaskState, UnsupportedOperationError
+from a2a.utils.errors import ServerError
+from google.adk.runners import Runner
+from google.genai import types
+
+from aigency.utils.logger import get_logger
+from aigency.utils.utils import (
+    convert_a2a_part_to_genai,
+    convert_genai_part_to_a2a,
+)
+
+logger = get_logger()
+
+# TODO: This needs to be changed
+DEFAULT_USER_ID = "self"
+
+class AgentA2AExecutor(AgentExecutor):
+    """Agent executor for A2A integration with Google ADK runners."""
+
+    def __init__(self, runner: Runner, card: AgentCard):
+        """Initialize the BaseAgentA2AExecutor.
+
+        Args:
+            card (AgentCard): The agent card containing metadata about the agent.
+        """
+        self._card = card
+        # Track active sessions for potential cancellation
+        self._active_sessions: set[str] = set()
+        self.runner = runner
+
+    async def _upsert_session(self, session_id: str) -> "Session":
+        """Retrieve a session if it exists, otherwise create a new one.
+
+        Ensures that async session service methods are properly awaited.
+
+        Args:
+            session_id (str): The ID of the session to retrieve or create.
+
+        Returns:
+            Session: The retrieved or newly created session object.
+        """
+        logger.info("session_id: %s", session_id)
+        session = await self.runner.session_service.get_session(
+            app_name=self.runner.app_name,
+            user_id=DEFAULT_USER_ID,
+            session_id=session_id,
+        )
+        if session is None:
+            session = await self.runner.session_service.create_session(
+                app_name=self.runner.app_name,
+                user_id=DEFAULT_USER_ID,
+                session_id=session_id,
+            )
+        return session
+
+    async def _process_request(
+        self,
+        new_message: types.Content,
+        session_id: str,
+        task_updater: TaskUpdater,
+    ) -> None:
+        session_obj = await self._upsert_session(session_id)
+        session_id = session_obj.id
+
+        self._active_sessions.add(session_id)
+
+        try:
+            async for event in self.runner.run_async(
+                session_id=session_id,
+                user_id=DEFAULT_USER_ID,
+                new_message=new_message,
+            ):
+                if event.is_final_response():
+                    parts = []
+                    if event.content:
+                        parts = [
+                            convert_genai_part_to_a2a(part)
+                            for part in event.content.parts
+                            if (part.text or part.file_data or part.inline_data)
+                        ]
+                    logger.debug("Yielding final response: %s", parts)
+                    await task_updater.add_artifact(parts)
+                    await task_updater.update_status(TaskState.completed, final=True)
+                    break
+                if not event.get_function_calls():
+                    logger.debug("Yielding update response")
+                    message_parts = []
+                    if event.content:
+                        message_parts = [
+                            convert_genai_part_to_a2a(part)
+                            for part in event.content.parts
+                            if (part.text)
+                        ]
+                    await task_updater.update_status(
+                        TaskState.working,
+                        message=task_updater.new_agent_message(message_parts),
+                    )
+                else:
+                    logger.debug("Skipping event")
+        finally:
+            # Remove from active sessions when done
+            self._active_sessions.discard(session_id)
+
+    async def execute(
+        self,
+        context: RequestContext,
+        event_queue: EventQueue,
+    ):
+        # Run the agent until either complete or the task is suspended.
+        updater = TaskUpdater(event_queue, context.task_id, context.context_id)
+        # Immediately notify that the task is submitted.
+        if not context.current_task:
+            await updater.update_status(TaskState.submitted)
+        await updater.update_status(TaskState.working)
+        await self._process_request(
+            types.UserContent(
+                parts=[
+                    convert_a2a_part_to_genai(part) for part in context.message.parts
+                ],
+            ),
+            context.context_id,
+            updater,
+        )
+
+        logger.debug("[ADKAgentA2AExecutor] execute exiting")
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue):
+        session_id = context.context_id
+        if session_id in self._active_sessions:
+            logger.info("Cancellation requested for active session: %s", session_id)
+            self._active_sessions.discard(session_id)
+        else:
+            logger.debug("Cancellation requested for inactive session: %s", session_id)
+
+        raise ServerError(error=UnsupportedOperationError())

aigency-0.0.1/aigency/agents/generator.py

@@ -0,0 +1,73 @@
+"""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.models.config import AgentConfig
+from aigency.tools.generator import ToolGenerator
+
+
+class AgentA2AGenerator:
+    """Generator for creating A2A agents and related components."""
+
+    @staticmethod
+    def create_agent(agent_config: AgentConfig) -> Agent:
+
+        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,
+            tools=tools,
+        )
+
+    @staticmethod
+    def build_agent_card(agent_config: AgentConfig) -> AgentCard:
+
+        # TODO: Parse properly
+        capabilities = AgentCapabilities(streaming=agent_config.capabilities.streaming)
+
+        skills = [
+            AgentSkill(
+                id=skill.id,
+                name=skill.name,
+                description=skill.description,
+                tags=skill.tags,
+                examples=skill.examples,
+            )
+            for skill in agent_config.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,
+            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)

aigency-0.0.1/aigency/models/config.py

@@ -0,0 +1,69 @@
+"""Configuration models for agents."""
+
+from typing import List, Optional, Union
+
+from pydantic import BaseModel
+
+from aigency.models.core import Capabilities, ModelConfig, Skill
+from aigency.models.tools import FunctionTool, McpTool, Tool
+
+#class SecurityScheme(BaseModel):
+#    """Define un esquema de seguridad individual."""
+#    type: str
+#    description: Optional[str] = None
+#    scheme: str
+#    bearerFormat: Optional[str] = None
+#
+#class AuthConfig(BaseModel):
+#    """Configuración de autenticación."""
+#    type: str
+#    securitySchemes: Optional[Dict[str, SecurityScheme]] = None
+#    security: Optional[List[Dict[str, List[str]]]] = None
+
+# --- Modelos para secciones opcionales ---
+
+#class MonitoringConfig(BaseModel):
+#    """Configuración de monitorización y observabilidad."""
+#    phoenix_host: Optional[str] = None
+#    phoenix_port: Optional[int] = None
+
+#class RemoteAgent(BaseModel):
+#    """Configuración para la comunicación con un agente remoto."""
+#    name: str
+#    host: str
+#    port: int
+    #auth: Optional[AuthConfig] = None # Reutilizamos la configuración de Auth
+
+# --- Clase Principal que une todo ---
+
+class AgentConfig(BaseModel):
+    """Root Pydantic model for complete agent configuration."""
+    # Configuración Básica
+    name: str
+    description: str
+    url: str
+    version: str
+    default_input_modes: Optional[List[str]] = None
+    default_output_modes: Optional[List[str]] = None
+    capabilities: Optional[Capabilities] = None
+
+    # Autenticación
+    #auth: Optional[AuthConfig] = None
+    
+    # Configuración del Modelo
+    model: ModelConfig
+        
+    # Comportamiento
+    instruction: Optional[str] = None
+    skills: Optional[List[Skill]] = None
+
+    # Herramientas
+    tools: Optional[List[Union[FunctionTool, McpTool, Tool]]] = None
+
+    # Comunicación Multi-Agente
+    #remote_agents_addresses: Optional[List[RemoteAgent]] = None
+    
+    # Monitorización
+    #monitoring: Optional[MonitoringConfig] = None
+    
+

aigency-0.0.1/aigency/models/core.py

@@ -0,0 +1,28 @@
+"""Core models for agent configuration."""
+
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel
+
+
+class ProviderConfig(BaseModel):
+    """Configuration for AI model provider."""
+    name: str
+    endpoint: Optional[str] = None
+
+class ModelConfig(BaseModel):
+    """Configuration for AI model."""
+    name: str
+    provider: Optional[ProviderConfig] = None
+
+class Capabilities(BaseModel):
+    """Agent capabilities, such as streaming."""
+    streaming: Optional[bool] = None
+
+class Skill(BaseModel):
+    """Define a specific agent skill."""
+    id: str
+    name: str
+    description: str
+    tags: Optional[List[str]] = None
+    examples: Optional[List[str]] = None

aigency-0.0.1/aigency/models/tools.py

@@ -0,0 +1,39 @@
+"""Tool models for agent configuration."""
+
+from enum import Enum
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel
+
+
+class ToolType(str, Enum):
+    """Enum for tool types."""
+    MCP = "mcp"
+    FUNCTION = "function"
+
+class Tool(BaseModel):
+    """Define an external tool that the agent can use."""
+    type: ToolType
+    name: str
+    description: str
+
+class FunctionTool(Tool):
+    """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):
+    """Configuration for MCP-based tools."""
+    mcp_config: McpTypeStreamable | McpTypeStdio

aigency-0.0.1/aigency/tools/generator.py

@@ -0,0 +1,83 @@
+"""Tool Factory for dynamically loading and managing agent tools.
+
+This module provides a flexible way to load different types of tools based on
+configuration. It uses the Strategy pattern and Pydantic for validation.
+"""
+
+import importlib
+from typing import Any, Optional
+
+from google.adk.tools.mcp_tool.mcp_toolset import (
+    MCPToolset,
+    StdioConnectionParams,
+    StdioServerParameters,
+    StreamableHTTPConnectionParams,
+)
+
+from aigency.models.tools import (
+    FunctionTool,
+    McpTool,
+    McpTypeStdio,
+    McpTypeStreamable,
+    Tool,
+    ToolType,
+)
+from aigency.utils.utils import expand_env_vars
+
+
+class ToolGenerator:
+    """Generator for creating tools based on configuration."""
+
+    @staticmethod
+    def load_function_tool(config: FunctionTool) -> Any:
+        """Load a function tool from configuration."""
+        try:
+            module = importlib.import_module(config.module_path)
+            return getattr(module, config.function_name)
+        except (ImportError, AttributeError) as e:
+            raise ValueError(f"Error loading function tool: {e}")
+
+    @staticmethod
+    def load_mcp_tool(config: McpTool) -> Any:
+        """Load an MCP tool from configuration."""
+
+        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
+                )
+            )
+        elif isinstance(config.mcp_config, McpTypeStdio):
+            command = config.mcp_config.command
+            args = config.mcp_config.args
+            env = expand_env_vars(config.mcp_config.env)
+
+            return MCPToolset(
+                connection_params=StdioConnectionParams(
+                    server_params=StdioServerParameters(
+                        command=command, args=args, env=env
+                    )
+                )
+            )
+
+    STRATEGIES = {
+        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.
+
+        Args:
+            tool: Tool configuration
+
+        Returns:
+            The created tool or None if creation failed
+
+        Raises:
+            ValueError: If tool type is not supported or config is invalid
+        """
+
+        return ToolGenerator.STRATEGIES[tool.type](tool)

aigency-0.0.1/aigency/utils/config_service.py

@@ -0,0 +1,68 @@
+"""Configuration service for loading and parsing agent configurations."""
+
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+
+from aigency.models.config import AgentConfig
+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.config = self._load_and_parse()
+
+    def _load_and_parse(self) -> AgentConfig:
+        """Carga los YAMLs, los mergea y parsea según AgentConfig."""
+
+        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")
+            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())}")
+                config = self._merge_configs(config, env_config)
+                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)
+
+    def _load_yaml(self, file_path: str) -> Dict[str, Any]:
+        """Carga un archivo YAML."""
+        try:
+            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}")
+        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}"
+        
+        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]:
+        """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):
+                result[key] = self._merge_configs(result[key], value)
+            else:
+                result[key] = value
+        return result

aigency-0.0.1/aigency/utils/logger.py

@@ -0,0 +1,101 @@
+import logging
+import sys
+from typing import Optional, Dict, Any
+from aigency.utils.singleton import Singleton
+
+
+class Logger(Singleton):
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        if hasattr(self, '_initialized'):
+            # Si ya está inicializado y se pasa nueva config, actualizar
+            if config and config != getattr(self, 'config', {}):
+                self.config.update(config)
+                self._setup_logger()
+            return
+        
+        self._initialized = True
+        self.config = config or {}
+        self._logger = None
+        self._setup_logger()
+    
+    def _setup_logger(self):
+        """Configura el logger con la configuración proporcionada"""
+        # Obtener configuración del logger
+        log_level = self.config.get('log_level', 'INFO').upper()
+        log_format = self.config.get('log_format', '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        log_file = self.config.get('log_file')
+        logger_name = self.config.get('logger_name', 'aigency')
+        
+        # Crear logger
+        self._logger = logging.getLogger(logger_name)
+        self._logger.setLevel(getattr(logging, log_level, logging.INFO))
+        
+        # Evitar duplicar handlers si ya existen
+        if self._logger.handlers:
+            return
+        
+        # Crear formatter
+        formatter = logging.Formatter(log_format)
+        
+        # Handler para consola
+        console_handler = logging.StreamHandler(sys.stdout)
+        console_handler.setLevel(getattr(logging, log_level, logging.INFO))
+        console_handler.setFormatter(formatter)
+        self._logger.addHandler(console_handler)
+        
+        # Handler para archivo si se especifica
+        if log_file:
+            file_handler = logging.FileHandler(log_file)
+            file_handler.setLevel(getattr(logging, log_level, logging.INFO))
+            file_handler.setFormatter(formatter)
+            self._logger.addHandler(file_handler)
+    
+    def debug(self, message: str, *args, **kwargs):
+        """Log a debug message"""
+        self._logger.debug(message, *args, **kwargs)
+    
+    def info(self, message: str, *args, **kwargs):
+        """Log an info message"""
+        self._logger.info(message, *args, **kwargs)
+    
+    def warning(self, message: str, *args, **kwargs):
+        """Log a warning message"""
+        self._logger.warning(message, *args, **kwargs)
+    
+    def error(self, message: str, *args, **kwargs):
+        """Log an error message"""
+        self._logger.error(message, *args, **kwargs)
+    
+    def critical(self, message: str, *args, **kwargs):
+        """Log a critical message"""
+        self._logger.critical(message, *args, **kwargs)
+    
+    def exception(self, message: str, *args, **kwargs):
+        """Log an exception with traceback"""
+        self._logger.exception(message, *args, **kwargs)
+    
+    def set_level(self, level: str):
+        """Cambiar el nivel de logging dinámicamente"""
+        log_level = level.upper()
+        self._logger.setLevel(getattr(logging, log_level, logging.INFO))
+        for handler in self._logger.handlers:
+            handler.setLevel(getattr(logging, log_level, logging.INFO))
+    
+    def get_logger(self):
+        """Obtener la instancia del logger interno"""
+        return self._logger
+
+
+# Función de conveniencia para obtener la instancia del logger
+def get_logger(config: Optional[Dict[str, Any]] = None) -> Logger:
+    """
+    Obtiene la instancia singleton del logger.
+    Si es la primera vez que se llama y se proporciona config, se usa esa configuración.
+    
+    Args:
+        config: Configuración opcional para el logger (solo se usa en la primera llamada)
+    
+    Returns:
+        Instancia singleton del Logger
+    """
+    return Logger(config)

aigency-0.0.1/aigency/utils/singleton.py

@@ -0,0 +1,12 @@
+class SingletonMeta(type):
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            instance = super().__call__(*args, **kwargs)
+            cls._instances[cls] = instance
+        return cls._instances[cls]
+
+
+class Singleton(metaclass=SingletonMeta):
+    pass

aigency-0.0.1/aigency/utils/utils.py

@@ -0,0 +1,96 @@
+"""Utility functions for type conversions and environment variable handling."""
+
+import asyncio
+import os
+import threading
+
+from a2a.types import FilePart, FileWithBytes, Part, TextPart
+from google.genai import types
+
+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.
+
+    Args:
+        part (Part): The A2A Part to convert.
+
+    Returns:
+        types.Part: The equivalent Google Gen AI Part.
+
+    Raises:
+        ValueError: If the part type is not supported.
+    """
+    part = part.root
+    if isinstance(part, TextPart):
+        return types.Part(text=part.text)
+    raise ValueError(f"Unsupported part type: {type(part)}")
+
+
+def convert_genai_part_to_a2a(part: types.Part) -> Part:
+    """Convert a single Google Gen AI Part type into an A2A Part type.
+
+    Args:
+        part (types.Part): The Google Gen AI Part to convert.
+
+    Returns:
+        Part: The equivalent A2A Part.
+
+    Raises:
+        ValueError: If the part type is not supported.
+    """
+    if part.text:
+        return TextPart(text=part.text)
+    if part.inline_data:
+        return Part(
+            root=FilePart(
+                file=FileWithBytes(
+                    bytes=part.inline_data.data,
+                    mime_type=part.inline_data.mime_type,
+                )
+            )
+        )
+    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.
+    Si la variable no existe en el entorno, deja el valor literal.
+    """
+    result = {}
+    for k, v in env_dict.items():
+        if isinstance(v, str) and v in os.environ:
+            result[k] = os.getenv(v)
+        else:
+            logger.warning(f"Environment variable {v} not found")
+    return result
+
+def safe_async_run(coro):
+    """Simple wrapper to safely run async code."""
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+
+            result = None
+            exception = None
+
+            def run_in_thread():
+                nonlocal result, exception
+                try:
+                    result = asyncio.run(coro)
+                except Exception as e:
+                    exception = e
+
+            thread = threading.Thread(target=run_in_thread)
+            thread.start()
+            thread.join()
+
+            if exception:
+                raise exception
+            return result
+        else:
+            return loop.run_until_complete(coro)
+    except RuntimeError:
+        return asyncio.run(coro)

aigency-0.0.1/aigency.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: aigency
+Version: 0.0.1
+Summary: Add your description here
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: google-adk>=1.11.0
+Requires-Dist: a2a-sdk==0.3.0
+Requires-Dist: litellm<1.73.0,>=1.72.6
+Requires-Dist: pyyaml==6.0.2
+Requires-Dist: PyJWT==2.10.1
+
+# aigency-lib
+
+
+aigency-lib/examples/simple_agents/hello_world_agent
+
+docker compose up

aigency-0.0.1/aigency.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+aigency/__init__.py
+aigency.egg-info/PKG-INFO
+aigency.egg-info/SOURCES.txt
+aigency.egg-info/dependency_links.txt
+aigency.egg-info/requires.txt
+aigency.egg-info/top_level.txt
+aigency/agents/executor.py
+aigency/agents/generator.py
+aigency/models/config.py
+aigency/models/core.py
+aigency/models/tools.py
+aigency/tools/generator.py
+aigency/utils/config_service.py
+aigency/utils/logger.py
+aigency/utils/singleton.py
+aigency/utils/utils.py

aigency-0.0.1/aigency.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aigency-0.0.1/aigency.egg-info/requires.txt

@@ -0,0 +1,5 @@
+google-adk>=1.11.0
+a2a-sdk==0.3.0
+litellm<1.73.0,>=1.72.6
+pyyaml==6.0.2
+PyJWT==2.10.1

aigency-0.0.1/aigency.egg-info/top_level.txt

@@ -0,0 +1 @@
+aigency

aigency-0.0.1/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "aigency"
+version = "0.0.1"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "google-adk>=1.11.0",
+    "a2a-sdk==0.3.0",
+    "litellm>=1.72.6,<1.73.0",
+    "pyyaml==6.0.2",
+    "PyJWT==2.10.1"
+]
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["aigency*"]

aigency-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+