ambivo-agents 1.0.1__py3-none-any.whl

ambivo_agents/__init__.py

@@ -0,0 +1,91 @@
+# 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
+from .agents.moderator import ModeratorAgent
+
+# 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",
+    "ModeratorAgent",
+
+    # Configuration
+    "load_config",
+    "ConfigurationError"
+]

ambivo_agents/agents/__init__.py

@@ -0,0 +1,21 @@
+# 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
+from .moderator import ModeratorAgent
+
+__all__ = [
+    "AssistantAgent",
+    "CodeExecutorAgent",
+    "KnowledgeBaseAgent",
+    "WebSearchAgent",
+    "WebScraperAgent",
+    "MediaEditorAgent",
+    "YouTubeDownloadAgent",
+    "ModeratorAgent"
+]
+

ambivo_agents/agents/assistant.py

@@ -0,0 +1,203 @@
+# AssistantAgent with BaseAgentHistoryMixin
+import json
+import uuid
+from typing import Dict, Any
+
+from ambivo_agents import BaseAgent, AgentRole, ExecutionContext, AgentMessage, MessageType
+from ambivo_agents.core.history import BaseAgentHistoryMixin
+
+
+class AssistantAgent(BaseAgent, BaseAgentHistoryMixin):
+    """General purpose assistant agent with conversation history"""
+
+    def __init__(self, agent_id: str = 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
+        )
+
+        # Initialize history mixin
+        self.setup_history_mixin()
+
+    async def _analyze_intent(self, user_message: str, conversation_context: str = "") -> Dict[str, Any]:
+        """Analyze user intent with conversation context"""
+        if not self.llm_service:
+            return self._keyword_based_analysis(user_message)
+
+        prompt = f"""
+        Analyze this user message in the context of general assistance:
+
+        Conversation Context:
+        {conversation_context}
+
+        Current User Message: {user_message}
+
+        Respond in JSON format:
+        {{
+            "primary_intent": "question|request|clarification|continuation|greeting|farewell",
+            "requires_context": true/false,
+            "context_reference": "what user is referring to",
+            "topic": "main subject area",
+            "confidence": 0.0-1.0
+        }}
+        """
+
+        try:
+            response = await self.llm_service.generate_response(prompt)
+            import re
+            json_match = re.search(r'\{.*\}', response, re.DOTALL)
+            if json_match:
+                return json.loads(json_match.group())
+            else:
+                # Fallback if LLM doesn't return JSON
+                return self._keyword_based_analysis(user_message)
+        except Exception as e:
+            return self._keyword_based_analysis(user_message)
+
+    def _keyword_based_analysis(self, user_message: str) -> Dict[str, Any]:
+        """Fallback keyword-based analysis"""
+        content_lower = user_message.lower()
+
+        if any(word in content_lower for word in ['hello', 'hi', 'hey']):
+            intent = 'greeting'
+        elif any(word in content_lower for word in ['bye', 'goodbye', 'thanks']):
+            intent = 'farewell'
+        elif any(word in content_lower for word in ['what', 'how', 'why', 'when', 'where']):
+            intent = 'question'
+        elif any(word in content_lower for word in ['can you', 'please', 'help me']):
+            intent = 'request'
+        elif any(word in content_lower for word in ['that', 'this', 'it', 'previous']):
+            intent = 'continuation'
+        else:
+            intent = 'question'
+
+        return {
+            "primary_intent": intent,
+            "requires_context": any(word in content_lower for word in ['that', 'this', 'it', 'previous']),
+            "context_reference": None,
+            "topic": "general",
+            "confidence": 0.7
+        }
+
+    def _get_conversation_context_summary(self) -> str:
+        """Get conversation context summary"""
+        try:
+            recent_history = self.get_conversation_history_with_context(limit=3)
+            context_summary = []
+
+            for msg in recent_history:
+                if msg.get('message_type') == 'user_input':
+                    content = msg.get('content', '')
+                    context_summary.append(f"User said: {content[:50]}...")
+                elif msg.get('message_type') == 'agent_response':
+                    content = msg.get('content', '')
+                    context_summary.append(f"I responded: {content[:50]}...")
+
+            return "\n".join(context_summary) if context_summary else "No previous conversation"
+        except:
+            return "No previous conversation"
+
+    async def _route_request(self, intent_analysis: Dict[str, Any], user_message: str,
+                             context: ExecutionContext) -> str:
+        """Route request based on intent analysis"""
+        primary_intent = intent_analysis.get("primary_intent", "question")
+        requires_context = intent_analysis.get("requires_context", False)
+
+        # Route based on primary intent
+        if primary_intent == "greeting":
+            return "Hello! How can I assist you today?"
+
+        elif primary_intent == "farewell":
+            return "Thank you for using the assistant. Have a great day!"
+
+        elif primary_intent == "continuation":
+            # Handle context references
+            conversation_context = self._get_conversation_context_summary()
+            if self.llm_service:
+                prompt = f"""The user is referring to our previous conversation. Provide a helpful response based on the context.
+
+Previous conversation:
+{conversation_context}
+
+Current user message: {user_message}
+
+Please provide a helpful, contextual response."""
+                return await self.llm_service.generate_response(prompt)
+            else:
+                return f"I understand you're referring to our previous conversation. Could you provide more specific details about what you'd like help with?"
+
+        elif primary_intent in ["question", "request"]:
+            # Build context-aware prompt for LLM
+            if requires_context:
+                conversation_context = self._get_conversation_context_summary()
+                context_prompt = f"\n\nConversation context:\n{conversation_context}\n\n"
+            else:
+                context_prompt = ""
+
+            if self.llm_service:
+                prompt = f"""You are a helpful assistant. Respond to this user message appropriately.{context_prompt}User message: {user_message}
+
+Please provide a helpful, accurate, and contextual response."""
+                return await self.llm_service.generate_response(prompt)
+            else:
+                if requires_context:
+                    return f"I understand you're asking about something related to our previous conversation. How can I help you with '{user_message}'?"
+                else:
+                    return f"I understand you said: '{user_message}'. How can I help you with that?"
+
+        else:
+            # Default handling
+            if self.llm_service:
+                prompt = f"""You are a helpful assistant. Respond to this user message: {user_message}"""
+                return await self.llm_service.generate_response(prompt)
+            else:
+                return f"I understand you said: '{user_message}'. How can I help you with that?"
+
+    async def process_message(self, message: AgentMessage, context: ExecutionContext = None) -> AgentMessage:
+        """Process user requests with conversation history"""
+        self.memory.store_message(message)
+
+        try:
+            user_message = message.content
+
+            # Update conversation state
+            self.update_conversation_state(user_message)
+
+            # Get conversation context for LLM analysis
+            conversation_context = self._get_conversation_context_summary()
+
+            # Use LLM to analyze intent
+            intent_analysis = await self._analyze_intent(user_message, conversation_context)
+
+            # Route request based on LLM analysis
+            response_content = await self._route_request(intent_analysis, user_message, context)
+
+            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:
+            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=None) -> 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

ambivo_agents/agents/code_executor2.py

@@ -0,0 +1,222 @@
+# CodeExecutorAgent with BaseAgentHistoryMixin
+import re
+import uuid
+
+import json
+import uuid
+from typing import Dict, Any
+
+from ambivo_agents import BaseAgent, AgentRole, ExecutionContext, AgentMessage, MessageType, load_config
+from ambivo_agents.core.history import BaseAgentHistoryMixin, ContextType
+from ambivo_agents.executors import DockerCodeExecutor
+
+
+class CodeExecutorAgent(BaseAgent, BaseAgentHistoryMixin):
+    """Agent specialized in code execution with execution history"""
+
+    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
+        )
+
+        # Initialize history mixin
+        self.setup_history_mixin()
+
+        # Load Docker configuration from YAML
+        try:
+            config = load_config()
+            docker_config = config.get('docker', {})
+        except Exception as e:
+            docker_config = {}
+
+        self.docker_executor = DockerCodeExecutor(docker_config)
+        self._add_code_tools()
+
+        # Add code-specific context extractors
+        self.register_context_extractor(
+            ContextType.CODE_REFERENCE,
+            lambda text: re.findall(r'```(?:python|bash|javascript)?\n?(.*?)\n?```', text, re.DOTALL)
+        )
+
+    async def _analyze_intent(self, user_message: str, conversation_context: str = "") -> Dict[str, Any]:
+        """Analyze code execution intent with previous execution context"""
+        if not self.llm_service:
+            return self._keyword_based_analysis(user_message)
+
+        prompt = f"""
+        Analyze this user message in the context of code execution:
+
+        Previous Execution Context:
+        {conversation_context}
+
+        Current User Message: {user_message}
+
+        Respond in JSON format:
+        {{
+            "primary_intent": "execute_code|modify_code|debug_code|explain_code|continue_execution",
+            "language": "python|bash|javascript",
+            "references_previous": true/false,
+            "code_blocks": ["extracted code"],
+            "execution_type": "new|modification|continuation",
+            "confidence": 0.0-1.0
+        }}
+        """
+
+        try:
+            response = await self.llm_service.generate_response(prompt)
+            import re
+            json_match = re.search(r'\{.*\}', response, re.DOTALL)
+            if json_match:
+                return json.loads(json_match.group())
+            else:
+                return self._extract_intent_from_llm_response(response, user_message)
+        except Exception as e:
+            return self._keyword_based_analysis(user_message)
+
+    def _keyword_based_analysis(self, user_message: str) -> Dict[str, Any]:
+        """Fallback keyword-based analysis for code execution"""
+        content_lower = user_message.lower()
+
+        if "```python" in user_message:
+            intent = 'execute_code'
+            language = 'python'
+        elif "```bash" in user_message:
+            intent = 'execute_code'
+            language = 'bash'
+        elif any(word in content_lower for word in ['run', 'execute', 'test']):
+            intent = 'execute_code'
+            language = 'python'
+        elif any(word in content_lower for word in ['modify', 'change', 'update']):
+            intent = 'modify_code'
+            language = 'python'
+        elif any(word in content_lower for word in ['debug', 'fix', 'error']):
+            intent = 'debug_code'
+            language = 'python'
+        else:
+            intent = 'execute_code'
+            language = 'python'
+
+        # Extract code blocks
+        code_blocks = re.findall(r'```(?:python|bash)?\n?(.*?)\n?```', user_message, re.DOTALL)
+
+        return {
+            "primary_intent": intent,
+            "language": language,
+            "references_previous": any(word in content_lower for word in ['that', 'previous', 'last', 'again']),
+            "code_blocks": code_blocks,
+            "execution_type": "new",
+            "confidence": 0.8
+        }
+
+    def _get_conversation_context_summary(self) -> str:
+        """Get code execution context summary"""
+        try:
+            recent_history = self.get_conversation_history_with_context(
+                limit=3,
+                context_types=[ContextType.CODE_REFERENCE]
+            )
+
+            context_summary = []
+            for msg in recent_history:
+                if msg.get('message_type') == 'user_input':
+                    extracted_context = msg.get('extracted_context', {})
+                    code_refs = extracted_context.get('code_reference', [])
+
+                    if code_refs:
+                        context_summary.append(f"Previous code: {code_refs[0][:100]}...")
+                elif msg.get('message_type') == 'agent_response':
+                    content = msg.get('content', '')
+                    if 'executed successfully' in content.lower():
+                        context_summary.append("Previous execution: successful")
+                    elif 'failed' in content.lower():
+                        context_summary.append("Previous execution: failed")
+
+            return "\n".join(context_summary) if context_summary else "No previous code execution"
+        except:
+            return "No previous code execution"
+
+    async def _route_request(self, intent_analysis: Dict[str, Any], user_message: str,
+                             context: ExecutionContext) -> str:
+        """Route code execution request based on intent analysis"""
+        primary_intent = intent_analysis.get("primary_intent", "execute_code")
+        language = intent_analysis.get("language", "python")
+        code_blocks = intent_analysis.get("code_blocks", [])
+        references_previous = intent_analysis.get("references_previous", False)
+
+        if primary_intent == "execute_code":
+            if code_blocks:
+                # Execute the provided code
+                code = code_blocks[0]
+                if language == "python":
+                    result = await self._execute_python_code(code)
+                elif language == "bash":
+                    result = await self._execute_bash_code(code)
+                else:
+                    return f"Unsupported language: {language}"
+
+                if result['success']:
+                    return f"Code executed successfully:\n\n```\n{result['output']}\n```\n\nExecution time: {result['execution_time']:.2f}s"
+                else:
+                    return f"Code execution failed:\n\n```\n{result['error']}\n```"
+            else:
+                return "Please provide code wrapped in ```python or ```bash code blocks for execution."
+
+        elif primary_intent == "modify_code":
+            if references_previous:
+                return "I can help modify code. Please provide the specific changes you want to make or show me the modified code."
+            else:
+                return "Please provide the code you want to modify."
+
+        elif primary_intent == "debug_code":
+            return "I can help debug code. Please provide the code that's having issues and describe the problem."
+
+        else:
+            return "Please provide code wrapped in ```python or ```bash code blocks for execution."
+
+    async def process_message(self, message: AgentMessage, context: ExecutionContext = None) -> AgentMessage:
+        """Process code execution requests with execution history"""
+        self.memory.store_message(message)
+
+        try:
+            user_message = message.content
+
+            # Update conversation state
+            self.update_conversation_state(user_message)
+
+            # Get conversation context for analysis
+            conversation_context = self._get_conversation_context_summary()
+
+            # Use LLM to analyze intent
+            intent_analysis = await self._analyze_intent(user_message, conversation_context)
+
+            # Route request based on analysis
+            response_content = await self._route_request(intent_analysis, user_message, context)
+
+            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:
+            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