genxai-framework 0.1.0__py3-none-any.whl

genxai/core/__init__.py

@@ -0,0 +1,37 @@
+"""Core components of GenXAI framework."""
+
+from genxai.core.agent import (
+    Agent,
+    AgentConfig,
+    AgentFactory,
+    AgentRegistry,
+    AgentRuntime,
+    AgentType,
+)
+from genxai.core.graph import (
+    Edge,
+    EnhancedGraph,
+    Graph,
+    Node,
+    NodeType,
+    WorkflowExecutor,
+    execute_workflow_sync,
+)
+from genxai.core.memory.manager import MemorySystem
+
+__all__ = [
+    "Agent",
+    "AgentConfig",
+    "AgentFactory",
+    "AgentRegistry",
+    "AgentRuntime",
+    "AgentType",
+    "Graph",
+    "EnhancedGraph",
+    "WorkflowExecutor",
+    "execute_workflow_sync",
+    "Node",
+    "NodeType",
+    "Edge",
+    "MemorySystem",
+]

genxai/core/agent/__init__.py

@@ -0,0 +1,32 @@
+"""Agent system for GenXAI."""
+
+from genxai.core.agent.base import Agent, AgentConfig, AgentType, AgentFactory
+from genxai.core.agent.config_io import (
+    agent_config_from_dict,
+    agent_config_to_dict,
+    agent_from_dict,
+    agent_to_dict,
+    export_agent_config_yaml,
+    export_agents_yaml,
+    import_agent_config_yaml,
+    import_agents_yaml,
+)
+from genxai.core.agent.runtime import AgentRuntime
+from genxai.core.agent.registry import AgentRegistry
+
+__all__ = [
+    "Agent",
+    "AgentConfig",
+    "AgentFactory",
+    "AgentType",
+    "AgentRuntime",
+    "AgentRegistry",
+    "agent_config_from_dict",
+    "agent_config_to_dict",
+    "agent_from_dict",
+    "agent_to_dict",
+    "export_agent_config_yaml",
+    "export_agents_yaml",
+    "import_agent_config_yaml",
+    "import_agents_yaml",
+]

genxai/core/agent/base.py

@@ -0,0 +1,206 @@
+"""Base agent class and configuration."""
+
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field, ConfigDict
+from enum import Enum
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class AgentType(str, Enum):
+    """Types of agents."""
+
+    REACTIVE = "reactive"
+    DELIBERATIVE = "deliberative"
+    LEARNING = "learning"
+    COLLABORATIVE = "collaborative"
+    AUTONOMOUS = "autonomous"
+
+
+class AgentConfig(BaseModel):
+    """Configuration for an agent."""
+
+    model_config = ConfigDict(use_enum_values=True)
+
+    role: str = Field(..., description="Role of the agent")
+    goal: str = Field(..., description="Goal the agent should achieve")
+    backstory: str = Field(default="", description="Background story for the agent")
+    
+    # LLM configuration
+    llm_provider: str = Field(default="openai", description="LLM provider to use")
+    llm_model: str = Field(default="gpt-4", description="LLM model name")
+    llm_temperature: float = Field(default=0.7, ge=0.0, le=2.0)
+    llm_max_tokens: Optional[int] = Field(default=None, description="Max tokens for response")
+    
+    # Tools
+    tools: List[str] = Field(default_factory=list, description="List of tool names")
+    allow_tool_creation: bool = Field(default=False, description="Allow dynamic tool creation")
+    
+    # Memory
+    enable_memory: bool = Field(default=True, description="Enable memory system")
+    memory_type: str = Field(default="short_term", description="Type of memory to use")
+    
+    # Behavior
+    agent_type: AgentType = Field(default=AgentType.REACTIVE)
+    max_iterations: int = Field(default=10, description="Max iterations for agent execution")
+    verbose: bool = Field(default=False, description="Enable verbose logging")
+    
+    # Guardrails
+    max_execution_time: Optional[float] = Field(default=None, description="Max execution time in seconds")
+    allowed_domains: List[str] = Field(default_factory=list, description="Allowed domains for web access")
+    
+    # Metadata
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+
+
+class Agent(BaseModel):
+    """Base agent class."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow")
+
+    id: str = Field(..., description="Unique agent identifier")
+    config: AgentConfig
+    
+    # Runtime state
+    _execution_count: int = 0
+    _total_tokens: int = 0
+    _last_result: Optional[Any] = None
+
+
+    def __init__(self, id: str, config: AgentConfig, **kwargs: Any) -> None:
+        """Initialize agent.
+
+        Args:
+            id: Agent identifier
+            config: Agent configuration
+            **kwargs: Additional arguments
+        """
+        super().__init__(id=id, config=config, **kwargs)
+        logger.info(f"Agent initialized: {self.id} (role: {self.config.role})")
+
+    async def execute(self, task: str, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Execute a task.
+
+        This is a placeholder that will be implemented by AgentRuntime.
+
+        Args:
+            task: Task description
+            context: Execution context
+
+        Returns:
+            Execution result
+        """
+        self._execution_count += 1
+        
+        logger.info(f"Agent {self.id} executing task: {task}")
+        
+        # Placeholder implementation
+        result = {
+            "agent_id": self.id,
+            "task": task,
+            "status": "completed",
+            "output": f"Agent {self.config.role} processed: {task}",
+            "execution_count": self._execution_count,
+        }
+        
+        self._last_result = result
+        return result
+
+    async def reflect(self, result: Dict[str, Any]) -> Dict[str, Any]:
+        """Reflect on execution result.
+
+        Args:
+            result: Execution result to reflect on
+
+        Returns:
+            Reflection insights
+        """
+        logger.debug(f"Agent {self.id} reflecting on result")
+        
+        return {
+            "agent_id": self.id,
+            "reflection": "Reflection placeholder",
+            "improvements": [],
+        }
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get agent statistics.
+
+        Returns:
+            Agent statistics
+        """
+        return {
+            "id": self.id,
+            "role": self.config.role,
+            "execution_count": self._execution_count,
+            "total_tokens": self._total_tokens,
+            "agent_type": self.config.agent_type,
+        }
+
+    def reset_stats(self) -> None:
+        """Reset agent statistics."""
+        self._execution_count = 0
+        self._total_tokens = 0
+        self._last_result = None
+        logger.info(f"Agent {self.id} statistics reset")
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert agent to dictionary.
+
+        Returns:
+            Dictionary representation
+        """
+        return {
+            "id": self.id,
+            "config": self.config.dict(),
+            "stats": self.get_stats(),
+        }
+
+    def __repr__(self) -> str:
+        """String representation."""
+        return f"Agent(id={self.id}, role={self.config.role}, type={self.config.agent_type})"
+
+
+class AgentFactory:
+    """Factory for creating agents."""
+
+    @staticmethod
+    def create_agent(
+        id: str,
+        role: str,
+        goal: str,
+        **kwargs: Any,
+    ) -> Agent:
+        """Create an agent with given configuration.
+
+        Args:
+            id: Agent identifier
+            role: Agent role
+            goal: Agent goal
+            **kwargs: Additional configuration
+
+        Returns:
+            Configured agent
+        """
+        config = AgentConfig(
+            role=role,
+            goal=goal,
+            **kwargs,
+        )
+        
+        return Agent(id=id, config=config)
+
+    @staticmethod
+    def create_from_dict(data: Dict[str, Any]) -> Agent:
+        """Create agent from dictionary.
+
+        Args:
+            data: Agent data
+
+        Returns:
+            Agent instance
+        """
+        config = AgentConfig(**data.get("config", {}))
+        return Agent(id=data["id"], config=config)

genxai/core/agent/config_io.py

@@ -0,0 +1,59 @@
+"""YAML import/export utilities for agent configuration."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Iterable, List
+import yaml
+
+from genxai.core.agent.base import Agent, AgentConfig
+
+
+def agent_config_to_dict(config: AgentConfig) -> Dict[str, Any]:
+    """Serialize AgentConfig to a dictionary."""
+    return config.model_dump(mode="json")
+
+
+def agent_config_from_dict(data: Dict[str, Any]) -> AgentConfig:
+    """Load AgentConfig from a dictionary."""
+    return AgentConfig(**data)
+
+
+def agent_to_dict(agent: Agent) -> Dict[str, Any]:
+    """Serialize Agent to a dictionary."""
+    return {"id": agent.id, "config": agent_config_to_dict(agent.config)}
+
+
+def agent_from_dict(data: Dict[str, Any]) -> Agent:
+    """Load Agent from a dictionary."""
+    return Agent(id=data["id"], config=agent_config_from_dict(data["config"]))
+
+
+def export_agent_config_yaml(agent: Agent, path: Path) -> None:
+    """Export an agent configuration to a YAML file."""
+    payload = agent_to_dict(agent)
+    path.write_text(yaml.safe_dump(payload, sort_keys=False))
+
+
+def import_agent_config_yaml(path: Path) -> Agent:
+    """Import an agent configuration from a YAML file."""
+    data = yaml.safe_load(path.read_text())
+    if not isinstance(data, dict):
+        raise ValueError("Invalid YAML format for agent config")
+    return agent_from_dict(data)
+
+
+def export_agents_yaml(agents: Iterable[Agent], path: Path) -> None:
+    """Export a list of agents to YAML."""
+    payload = {"agents": [agent_to_dict(agent) for agent in agents]}
+    path.write_text(yaml.safe_dump(payload, sort_keys=False))
+
+
+def import_agents_yaml(path: Path) -> List[Agent]:
+    """Import a list of agents from YAML."""
+    data = yaml.safe_load(path.read_text())
+    if not isinstance(data, dict) or "agents" not in data:
+        raise ValueError("Invalid YAML format for agents list")
+    if not isinstance(data["agents"], list):
+        raise ValueError("Invalid YAML format for agents list")
+    return [agent_from_dict(item) for item in data["agents"]]

genxai/core/agent/registry.py

@@ -0,0 +1,98 @@
+"""Agent registry for managing agent instances."""
+
+from typing import Dict, Optional, List
+import logging
+
+from genxai.core.agent.base import Agent
+
+logger = logging.getLogger(__name__)
+
+
+class AgentRegistry:
+    """Global registry for managing agent instances."""
+
+    _agents: Dict[str, Agent] = {}
+
+    @classmethod
+    def register(cls, agent: Agent) -> None:
+        """Register an agent.
+
+        Args:
+            agent: Agent instance to register
+
+        Raises:
+            ValueError: If agent with same ID already exists
+        """
+        if agent.id in cls._agents:
+            logger.warning(f"Agent '{agent.id}' already registered, overwriting")
+        
+        cls._agents[agent.id] = agent
+        logger.info(f"Registered agent: {agent.id} (role: {agent.config.role})")
+
+    @classmethod
+    def get(cls, agent_id: str) -> Optional[Agent]:
+        """Get an agent by ID.
+
+        Args:
+            agent_id: Agent identifier
+
+        Returns:
+            Agent instance if found, None otherwise
+        """
+        agent = cls._agents.get(agent_id)
+        if agent is None:
+            logger.warning(f"Agent '{agent_id}' not found in registry")
+        return agent
+
+    @classmethod
+    def unregister(cls, agent_id: str) -> bool:
+        """Unregister an agent.
+
+        Args:
+            agent_id: Agent identifier
+
+        Returns:
+            True if agent was unregistered, False if not found
+        """
+        if agent_id in cls._agents:
+            del cls._agents[agent_id]
+            logger.info(f"Unregistered agent: {agent_id}")
+            return True
+        return False
+
+    @classmethod
+    def list_all(cls) -> List[str]:
+        """List all registered agent IDs.
+
+        Returns:
+            List of agent IDs
+        """
+        return list(cls._agents.keys())
+
+    @classmethod
+    def get_all(cls) -> Dict[str, Agent]:
+        """Get all registered agents.
+
+        Returns:
+            Dictionary of agent ID to agent instance
+        """
+        return cls._agents.copy()
+
+    @classmethod
+    def clear(cls) -> None:
+        """Clear all registered agents."""
+        count = len(cls._agents)
+        cls._agents.clear()
+        logger.info(f"Cleared {count} agents from registry")
+
+    @classmethod
+    def get_stats(cls) -> Dict[str, int]:
+        """Get registry statistics.
+
+        Returns:
+            Dictionary with registry stats
+        """
+        return {
+            "total_agents": len(cls._agents),
+            "agent_ids": cls.list_all(),
+        }