aiecs 1.0.1__py3-none-any.whl → 1.7.17__py3-none-any.whl

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,163 @@
+"""
+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)  # type: ignore[call-arg]
+        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
+        max_tokens = converted.get("max_tokens")
+        return AgentConfiguration(  # type: ignore[call-arg]
+            llm_model=converted.get("llm_model"),
+            temperature=converted.get("temperature", 0.7),
+            max_tokens=(max_tokens if max_tokens is not None and isinstance(max_tokens, int) else 4096),
+        )
+
+
+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: Dict[str, Any] = {
+        "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
+            errors_list = report["errors"]
+            if isinstance(errors_list, list):
+                errors_list.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,86 @@
+"""
+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__})"