ambivo-agents 1.3.3__py3-none-any.whl

ambivo_agents/__init__.py

@@ -0,0 +1,89 @@
+# ambivo_agents/__init__.py
+"""
+Ambivo Agents Framework
+A minimalistic agent framework for building AI applications.
+"""
+
+__version__ = "1.0.0"
+
+# Core imports
+from .core.base import (
+    AgentRole,
+    MessageType,
+    AgentMessage,
+    AgentTool,
+    ExecutionContext,
+    BaseAgent,
+    ProviderConfig,
+    ProviderTracker,
+    AgentSession
+)
+
+from .core.memory import (
+    MemoryManagerInterface,
+    RedisMemoryManager,
+    create_redis_memory_manager
+)
+
+from .core.llm import (
+    LLMServiceInterface,
+    MultiProviderLLMService,
+    create_multi_provider_llm_service
+)
+
+# Service imports
+from .services.factory import AgentFactory
+from .services.agent_service import AgentService, create_agent_service
+
+# Agent imports
+from .agents.assistant import AssistantAgent
+from .agents.code_executor import CodeExecutorAgent
+from .agents.knowledge_base import KnowledgeBaseAgent
+from .agents.web_search import WebSearchAgent
+from .agents.web_scraper import WebScraperAgent
+from .agents.media_editor import MediaEditorAgent
+from .agents.youtube_download import YouTubeDownloadAgent
+
+# Configuration
+from .config.loader import load_config, ConfigurationError
+
+__all__ = [
+    # Core
+    "AgentRole",
+    "MessageType",
+    "AgentMessage",
+    "AgentTool",
+    "ExecutionContext",
+    "BaseAgent",
+    "ProviderConfig",
+    "ProviderTracker",
+    "AgentSession",
+
+    # Memory
+    "MemoryManagerInterface",
+    "RedisMemoryManager",
+    "create_redis_memory_manager",
+
+    # LLM
+    "LLMServiceInterface",
+    "MultiProviderLLMService",
+    "create_multi_provider_llm_service",
+
+    # Services
+    "AgentFactory",
+    "AgentService",
+    "create_agent_service",
+
+    # Agents
+    "AssistantAgent",
+    "CodeExecutorAgent",
+    "KnowledgeBaseAgent",
+    "WebSearchAgent",
+    "WebScraperAgent",
+    "MediaEditorAgent",
+    "YouTubeDownloadAgent",
+
+    # Configuration
+    "load_config",
+    "ConfigurationError"
+]

ambivo_agents/agents/__init__.py

@@ -0,0 +1,19 @@
+# ambivo_agents/agents/__init__.py
+from .assistant import AssistantAgent
+from .code_executor import CodeExecutorAgent
+from .knowledge_base import KnowledgeBaseAgent
+from .web_search import WebSearchAgent
+from .web_scraper import WebScraperAgent
+from .media_editor import MediaEditorAgent
+from .youtube_download import YouTubeDownloadAgent
+
+__all__ = [
+    "AssistantAgent",
+    "CodeExecutorAgent",
+    "KnowledgeBaseAgent",
+    "WebSearchAgent",
+    "WebScraperAgent",
+    "MediaEditorAgent",
+    "YouTubeDownloadAgent"
+]
+

ambivo_agents/agents/assistant.py

@@ -0,0 +1,79 @@
+# ambivo_agents/agents/assistant.py
+"""
+Assistant Agent for general purpose assistance.
+"""
+
+import logging
+import uuid
+from typing import Dict, Any
+
+from ..core.base import BaseAgent, AgentRole, AgentMessage, MessageType, ExecutionContext
+
+
+class AssistantAgent(BaseAgent):
+    """General purpose assistant agent"""
+
+    def __init__(self, agent_id: str| None = None, memory_manager=None, llm_service=None, **kwargs):
+        if agent_id is None:
+            agent_id = f"assistant_{str(uuid.uuid4())[:8]}"
+
+        super().__init__(
+            agent_id=agent_id,
+            role=AgentRole.ASSISTANT,
+            memory_manager=memory_manager,
+            llm_service=llm_service,
+            name="Assistant Agent",
+            description="General purpose assistant for user interactions",
+            **kwargs
+        )
+
+    async def process_message(self, message: AgentMessage, context: ExecutionContext) -> AgentMessage:
+        """Process user requests and provide assistance"""
+        self.memory.store_message(message)
+
+        try:
+            history = self.memory.get_recent_messages(limit=10, conversation_id=message.conversation_id)
+
+            conversation_context = "\n".join([
+                f"{msg.get('sender_id', 'unknown')}: {msg.get('content', '')}"
+                for msg in reversed(history[-5:]) if isinstance(msg, dict)
+            ])
+
+            if self.llm_service:
+                prompt = f"""You are an AI assistant. Based on the conversation context below, provide a helpful response.
+
+Conversation context:
+{conversation_context}
+
+Current user message: {message.content}
+
+Please provide a helpful, accurate, and contextual response."""
+
+                response_content = await self.llm_service.generate_response(
+                    prompt=prompt,
+                    context={'conversation_id': message.conversation_id, 'user_id': context.user_id}
+                )
+            else:
+                response_content = f"I understand you said: '{message.content}'. How can I help you with that?"
+
+            response = self.create_response(
+                content=response_content,
+                recipient_id=message.sender_id,
+                session_id=message.session_id,
+                conversation_id=message.conversation_id
+            )
+
+            self.memory.store_message(response)
+            return response
+
+        except Exception as e:
+            logging.error(f"Assistant agent error: {e}")
+            error_response = self.create_response(
+                content=f"I encountered an error processing your request: {str(e)}",
+                recipient_id=message.sender_id,
+                message_type=MessageType.ERROR,
+                session_id=message.session_id,
+                conversation_id=message.conversation_id
+            )
+            return error_response
+

ambivo_agents/agents/code_executor.py

@@ -0,0 +1,133 @@
+# ambivo_agents/agents/code_executor.py
+"""
+Code Executor Agent for running code in secure Docker containers.
+"""
+
+import logging
+import uuid
+from typing import Dict, Any
+
+from ..core.base import BaseAgent, AgentRole, AgentMessage, MessageType, ExecutionContext, AgentTool, DockerCodeExecutor
+from ..config.loader import load_config, get_config_section
+
+
+class CodeExecutorAgent(BaseAgent):
+    """Agent specialized in code execution"""
+
+    def __init__(self, agent_id: str=None, memory_manager=None, llm_service=None, **kwargs):
+        if agent_id is None:
+            agent_id = f"code_executor_{str(uuid.uuid4())[:8]}"
+
+        super().__init__(
+            agent_id=agent_id,
+            role=AgentRole.CODE_EXECUTOR,
+            memory_manager=memory_manager,
+            llm_service=llm_service,
+            name="Code Executor Agent",
+            description="Agent for secure code execution using Docker containers",
+            **kwargs
+        )
+
+        # Load Docker configuration from YAML
+        try:
+            config = load_config()
+            docker_config = config.get('docker', {})
+        except Exception as e:
+            logging.warning(f"Could not load Docker config from YAML: {e}")
+            docker_config = {}
+
+        self.docker_executor = DockerCodeExecutor(docker_config)
+        self._add_code_tools()
+
+    def _add_code_tools(self):
+        """Add code execution tools"""
+        self.add_tool(AgentTool(
+            name="execute_python",
+            description="Execute Python code in a secure Docker container",
+            function=self._execute_python_code,
+            parameters_schema={
+                "type": "object",
+                "properties": {
+                    "code": {"type": "string", "description": "Python code to execute"},
+                    "files": {"type": "object", "description": "Additional files needed"}
+                },
+                "required": ["code"]
+            }
+        ))
+
+        self.add_tool(AgentTool(
+            name="execute_bash",
+            description="Execute bash commands in a secure Docker container",
+            function=self._execute_bash_code,
+            parameters_schema={
+                "type": "object",
+                "properties": {
+                    "code": {"type": "string", "description": "Bash commands to execute"},
+                    "files": {"type": "object", "description": "Additional files needed"}
+                },
+                "required": ["code"]
+            }
+        ))
+
+    async def _execute_python_code(self, code: str, files: Dict[str, str] = None) -> Dict[str, Any]:
+        """Execute Python code safely"""
+        return self.docker_executor.execute_code(code, "python", files)
+
+    async def _execute_bash_code(self, code: str, files: Dict[str, str] = None) -> Dict[str, Any]:
+        """Execute bash commands safely"""
+        return self.docker_executor.execute_code(code, "bash", files)
+
+    async def process_message(self, message: AgentMessage, context: ExecutionContext) -> AgentMessage:
+        """Process code execution requests"""
+        self.memory.store_message(message)
+
+        try:
+            content = message.content
+
+            if "```python" in content:
+                code_start = content.find("```python") + 9
+                code_end = content.find("```", code_start)
+                code = content[code_start:code_end].strip()
+
+                result = await self._execute_python_code(code)
+
+                if result['success']:
+                    response_content = f"Code executed successfully:\n\n```\n{result['output']}\n```\n\nExecution time: {result['execution_time']:.2f}s"
+                else:
+                    response_content = f"Code execution failed:\n\n```\n{result['error']}\n```"
+
+            elif "```bash" in content:
+                code_start = content.find("```bash") + 7
+                code_end = content.find("```", code_start)
+                code = content[code_start:code_end].strip()
+
+                result = await self._execute_bash_code(code)
+
+                if result['success']:
+                    response_content = f"Commands executed successfully:\n\n```\n{result['output']}\n```\n\nExecution time: {result['execution_time']:.2f}s"
+                else:
+                    response_content = f"Command execution failed:\n\n```\n{result['error']}\n```"
+
+            else:
+                response_content = "Please provide code wrapped in ```python or ```bash code blocks for execution."
+
+            response = self.create_response(
+                content=response_content,
+                recipient_id=message.sender_id,
+                session_id=message.session_id,
+                conversation_id=message.conversation_id
+            )
+
+            self.memory.store_message(response)
+            return response
+
+        except Exception as e:
+            logging.error(f"Code executor error: {e}")
+            error_response = self.create_response(
+                content=f"Error in code execution: {str(e)}",
+                recipient_id=message.sender_id,
+                message_type=MessageType.ERROR,
+                session_id=message.session_id,
+                conversation_id=message.conversation_id
+            )
+            return error_response