aiecs 1.5.1__py3-none-any.whl

aiecs/domain/agent/memory/conversation.py

@@ -0,0 +1,197 @@
+"""
+Conversation Memory
+
+Multi-turn conversation handling with session management.
+"""
+
+import logging
+from typing import Dict, List, Optional
+from datetime import datetime
+from dataclasses import dataclass, field
+
+from aiecs.llm import LLMMessage
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Session:
+    """Conversation session."""
+
+    session_id: str
+    agent_id: str
+    created_at: datetime = field(default_factory=datetime.utcnow)
+    last_activity: datetime = field(default_factory=datetime.utcnow)
+    messages: List[LLMMessage] = field(default_factory=list)
+    metadata: Dict = field(default_factory=dict)
+
+    def add_message(self, role: str, content: str) -> None:
+        """Add message to session."""
+        self.messages.append(LLMMessage(role=role, content=content))
+        self.last_activity = datetime.utcnow()
+
+    def get_recent_messages(self, limit: int) -> List[LLMMessage]:
+        """Get recent messages."""
+        return self.messages[-limit:] if limit else self.messages
+
+    def clear(self) -> None:
+        """Clear session messages."""
+        self.messages.clear()
+
+
+class ConversationMemory:
+    """
+    Manages multi-turn conversations with session isolation.
+
+    Example:
+        memory = ConversationMemory(agent_id="agent-1")
+        session_id = memory.create_session()
+        memory.add_message(session_id, "user", "Hello")
+        memory.add_message(session_id, "assistant", "Hi there!")
+        history = memory.get_history(session_id)
+    """
+
+    def __init__(self, agent_id: str, max_sessions: int = 100):
+        """
+        Initialize conversation memory.
+
+        Args:
+            agent_id: Agent identifier
+            max_sessions: Maximum number of sessions to keep
+        """
+        self.agent_id = agent_id
+        self.max_sessions = max_sessions
+        self._sessions: Dict[str, Session] = {}
+        logger.info(f"ConversationMemory initialized for agent {agent_id}")
+
+    def create_session(self, session_id: Optional[str] = None) -> str:
+        """
+        Create a new conversation session.
+
+        Args:
+            session_id: Optional custom session ID
+
+        Returns:
+            Session ID
+        """
+        if session_id is None:
+            session_id = f"session_{datetime.utcnow().timestamp()}"
+
+        if session_id in self._sessions:
+            logger.warning(f"Session {session_id} already exists")
+            return session_id
+
+        self._sessions[session_id] = Session(session_id=session_id, agent_id=self.agent_id)
+
+        # Cleanup old sessions if limit exceeded
+        if len(self._sessions) > self.max_sessions:
+            self._cleanup_old_sessions()
+
+        logger.debug(f"Session {session_id} created")
+        return session_id
+
+    def add_message(self, session_id: str, role: str, content: str) -> None:
+        """
+        Add message to session.
+
+        Args:
+            session_id: Session ID
+            role: Message role
+            content: Message content
+        """
+        if session_id not in self._sessions:
+            logger.warning(f"Session {session_id} not found, creating it")
+            self.create_session(session_id)
+
+        self._sessions[session_id].add_message(role, content)
+
+    def get_history(self, session_id: str, limit: Optional[int] = None) -> List[LLMMessage]:
+        """
+        Get conversation history for session.
+
+        Args:
+            session_id: Session ID
+            limit: Optional limit on number of messages
+
+        Returns:
+            List of messages
+        """
+        if session_id not in self._sessions:
+            return []
+
+        session = self._sessions[session_id]
+        return session.get_recent_messages(limit) if limit else session.messages.copy()
+
+    def format_history(self, session_id: str, limit: Optional[int] = None) -> str:
+        """
+        Format conversation history as string.
+
+        Args:
+            session_id: Session ID
+            limit: Optional limit on number of messages
+
+        Returns:
+            Formatted history string
+        """
+        history = self.get_history(session_id, limit)
+        lines = []
+        for msg in history:
+            lines.append(f"{msg.role.upper()}: {msg.content}")
+        return "\n".join(lines)
+
+    def clear_session(self, session_id: str) -> None:
+        """
+        Clear session messages.
+
+        Args:
+            session_id: Session ID
+        """
+        if session_id in self._sessions:
+            self._sessions[session_id].clear()
+            logger.debug(f"Session {session_id} cleared")
+
+    def delete_session(self, session_id: str) -> None:
+        """
+        Delete session.
+
+        Args:
+            session_id: Session ID
+        """
+        if session_id in self._sessions:
+            del self._sessions[session_id]
+            logger.debug(f"Session {session_id} deleted")
+
+    def get_session(self, session_id: str) -> Optional[Session]:
+        """
+        Get session object.
+
+        Args:
+            session_id: Session ID
+
+        Returns:
+            Session or None
+        """
+        return self._sessions.get(session_id)
+
+    def list_sessions(self) -> List[str]:
+        """List all session IDs."""
+        return list(self._sessions.keys())
+
+    def _cleanup_old_sessions(self) -> None:
+        """Remove oldest sessions to maintain limit."""
+        # Sort by last activity
+        sorted_sessions = sorted(self._sessions.items(), key=lambda x: x[1].last_activity)
+
+        # Remove oldest sessions
+        num_to_remove = len(self._sessions) - self.max_sessions
+        for session_id, _ in sorted_sessions[:num_to_remove]:
+            del self._sessions[session_id]
+            logger.debug(f"Removed old session {session_id}")
+
+    def get_stats(self) -> Dict:
+        """Get memory statistics."""
+        return {
+            "agent_id": self.agent_id,
+            "total_sessions": len(self._sessions),
+            "total_messages": sum(len(s.messages) for s in self._sessions.values()),
+        }

aiecs/domain/agent/migration/__init__.py

@@ -0,0 +1,14 @@
+"""
+Migration Utilities
+
+Tools for migrating from legacy agents and LangChain to BaseAIAgent.
+"""
+
+from .legacy_wrapper import LegacyAgentWrapper
+from .conversion import convert_langchain_prompt, convert_legacy_config
+
+__all__ = [
+    "LegacyAgentWrapper",
+    "convert_langchain_prompt",
+    "convert_legacy_config",
+]

aiecs/domain/agent/migration/conversion.py

@@ -0,0 +1,160 @@
+"""
+Conversion Utilities
+
+Convert legacy configurations and prompts to new format.
+"""
+
+import logging
+from typing import Dict, Any
+import re
+
+from ..models import AgentConfiguration
+from ..prompts import PromptTemplate, ChatPromptTemplate, MessageTemplate
+
+logger = logging.getLogger(__name__)
+
+
+def convert_legacy_config(legacy_config: Dict[str, Any]) -> AgentConfiguration:
+    """
+    Convert legacy agent configuration to AgentConfiguration.
+
+    Args:
+        legacy_config: Legacy configuration dictionary
+
+    Returns:
+        AgentConfiguration instance
+    """
+    # Map legacy fields to new fields
+    field_mapping = {
+        # Common legacy field names
+        "model": "llm_model",
+        "model_name": "llm_model",
+        "temp": "temperature",
+        "max_output_tokens": "max_tokens",
+        "enable_memory": "memory_enabled",
+        "verbose": "verbose",
+    }
+
+    converted = {}
+    for old_field, value in legacy_config.items():
+        new_field = field_mapping.get(old_field, old_field)
+        converted[new_field] = value
+
+    # Create AgentConfiguration
+    try:
+        config = AgentConfiguration(**converted)
+        logger.info("Legacy configuration converted successfully")
+        return config
+    except Exception as e:
+        logger.error(f"Failed to convert legacy config: {e}")
+        # Return default config with available fields
+        return AgentConfiguration(
+            llm_model=converted.get("llm_model"),
+            temperature=converted.get("temperature", 0.7),
+            max_tokens=converted.get("max_tokens"),
+        )
+
+
+def convert_langchain_prompt(langchain_prompt: str) -> PromptTemplate:
+    """
+    Convert LangChain prompt template to native PromptTemplate.
+
+    LangChain uses {variable} syntax, which is compatible with our format.
+
+    Args:
+        langchain_prompt: LangChain prompt string
+
+    Returns:
+        PromptTemplate instance
+    """
+    # LangChain and our template use same {variable} syntax
+    # Just need to extract variables
+    pattern = r"\{(\w+)\}"
+    variables = re.findall(pattern, langchain_prompt)
+
+    return PromptTemplate(template=langchain_prompt, required_variables=variables)
+
+
+def convert_langchain_chat_prompt(messages: list) -> ChatPromptTemplate:
+    """
+    Convert LangChain chat prompt to ChatPromptTemplate.
+
+    Args:
+        messages: List of (role, template) tuples
+
+    Returns:
+        ChatPromptTemplate instance
+    """
+    message_templates = []
+
+    for item in messages:
+        if isinstance(item, tuple):
+            role, template = item
+        elif isinstance(item, dict):
+            role = item.get("role", "user")
+            template = item.get("content", "")
+        else:
+            logger.warning(f"Unknown message format: {item}")
+            continue
+
+        message_templates.append(MessageTemplate(role=role, content=template))
+
+    return ChatPromptTemplate(messages=message_templates)
+
+
+def migrate_agent_state(legacy_state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Migrate legacy agent state to new format.
+
+    Args:
+        legacy_state: Legacy state dictionary
+
+    Returns:
+        New state dictionary
+    """
+    # Map legacy state fields
+    state_mapping = {
+        "status": "state",
+        "task_history": "interactions",
+        "memory": "memory",
+    }
+
+    migrated = {}
+    for old_field, value in legacy_state.items():
+        new_field = state_mapping.get(old_field, old_field)
+        migrated[new_field] = value
+
+    logger.info("Agent state migrated")
+    return migrated
+
+
+def validate_migration(legacy_agent: Any, new_agent: Any) -> Dict[str, Any]:
+    """
+    Validate migration by comparing legacy and new agent behavior.
+
+    Args:
+        legacy_agent: Legacy agent instance
+        new_agent: New agent instance
+
+    Returns:
+        Validation report
+    """
+    report = {
+        "compatible": True,
+        "warnings": [],
+        "errors": [],
+    }
+
+    # Check for required methods
+    required_methods = ["execute_task"]
+    for method in required_methods:
+        if not hasattr(new_agent, method):
+            report["compatible"] = False
+            report["errors"].append(f"Missing required method: {method}")
+
+    # Check configuration compatibility
+    if hasattr(legacy_agent, "config") and hasattr(new_agent, "_config"):
+        # Basic compatibility check
+        logger.info("Configuration validated")
+
+    return report

aiecs/domain/agent/migration/legacy_wrapper.py

@@ -0,0 +1,90 @@
+"""
+Legacy Agent Wrapper
+
+Compatibility wrapper for gradual migration from legacy agents.
+"""
+
+import logging
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class LegacyAgentWrapper:
+    """
+    Wrapper for legacy agents to work with BaseAIAgent interface.
+
+    This enables gradual migration without breaking existing code.
+
+    Example:
+        legacy_agent = SomeLegacyAgent()
+        wrapped = LegacyAgentWrapper(legacy_agent)
+        result = await wrapped.execute_task(task, context)
+    """
+
+    def __init__(self, legacy_agent: Any):
+        """
+        Initialize wrapper.
+
+        Args:
+            legacy_agent: Legacy agent instance
+        """
+        self.legacy_agent = legacy_agent
+        self._is_wrapped = True
+        logger.info(f"Legacy agent wrapped: {type(legacy_agent).__name__}")
+
+    async def execute_task(self, task: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Execute task using legacy agent.
+
+        Args:
+            task: Task specification
+            context: Execution context
+
+        Returns:
+            Result dictionary
+        """
+        # Try various legacy interfaces
+        if hasattr(self.legacy_agent, "execute_task"):
+            return await self.legacy_agent.execute_task(task, context)
+        elif hasattr(self.legacy_agent, "run"):
+            result = await self.legacy_agent.run(task.get("description", ""))
+            return {"output": result, "success": True}
+        elif hasattr(self.legacy_agent, "process"):
+            result = await self.legacy_agent.process(task)
+            return {"output": result, "success": True}
+        else:
+            raise NotImplementedError(
+                f"Legacy agent {type(self.legacy_agent).__name__} has no compatible interface"
+            )
+
+    async def process_message(
+        self, message: str, sender_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Process message using legacy agent.
+
+        Args:
+            message: Message content
+            sender_id: Optional sender ID
+
+        Returns:
+            Response dictionary
+        """
+        if hasattr(self.legacy_agent, "process_message"):
+            return await self.legacy_agent.process_message(message, sender_id)
+        elif hasattr(self.legacy_agent, "chat"):
+            response = await self.legacy_agent.chat(message)
+            return {"response": response}
+        else:
+            # Fallback to execute_task
+            task = {"description": message}
+            result = await self.execute_task(task, {"sender_id": sender_id})
+            return {"response": result.get("output")}
+
+    def __getattr__(self, name: str):
+        """Forward attribute access to legacy agent."""
+        return getattr(self.legacy_agent, name)
+
+    def __repr__(self) -> str:
+        return f"LegacyAgentWrapper({type(self.legacy_agent).__name__})"