webagents 0.1.12__py3-none-any.whl

webagents/agents/skills/robutler/discovery/skill.py

@@ -0,0 +1,230 @@
+"""
+DiscoverySkill - Simplified Robutler Platform Integration
+
+Agent discovery skill for Robutler platform.
+Provides intent-based agent discovery and intent publishing capabilities.
+"""
+
+import os
+from typing import Dict, Any, List
+from dataclasses import dataclass
+
+from webagents.agents.skills.base import Skill
+from webagents.agents.tools.decorators import tool, prompt
+
+
+@dataclass
+class DiscoveryResult:
+    """Result from intent discovery operation"""
+    agent_id: str
+    intent: str
+    agent_description: str
+    similarity: float
+    url: str
+    rank: int
+
+
+class DiscoverySkill(Skill):
+    """
+    Simplified agent discovery skill for Robutler platform
+    
+    Key Features:
+    - Intent-based agent discovery via Portal API
+    - Intent publishing for agent registration
+    - Dynamic agent URL configuration for prompts
+    
+    Configuration hierarchy for robutler_api_key:
+    1. config.robutler_api_key (explicit configuration)
+    2. agent.api_key (agent's API key)
+    3. ROBUTLER_API_KEY environment variable
+    4. SERVICE_TOKEN environment variable
+    
+    Configuration hierarchy for agent_base_url:
+    1. AGENTS_BASE_URL environment variable
+    2. config.agent_base_url (explicit configuration)
+    3. 'http://localhost:2224' (default for local development)
+    """
+    
+    def __init__(self, config: Dict[str, Any] = None):
+        super().__init__(config, scope="all")
+        
+        # Configuration
+        self.config = config or {}
+        self.enable_discovery = self.config.get('enable_discovery', True)
+        
+        # Robutler platform configuration
+        self.robutler_api_url = (
+            os.getenv('ROBUTLER_INTERNAL_API_URL') or
+            os.getenv('ROBUTLER_API_URL') or 
+            self.config.get('robutler_api_url') or 
+            'https://robutler.ai'
+        )
+        
+        # Agent communication base URL configuration (for dynamic agent URLs in prompts)
+        self.agent_base_url = (
+            os.getenv('AGENTS_BASE_URL') or
+            self.config.get('agent_base_url') or 
+            'http://localhost:2224'  # Default for local development (agents server)
+        )
+        
+        # API key: config first (will be resolved in initialize)
+        self.robutler_api_key = self.config.get('robutler_api_key')
+    
+    async def initialize(self, agent) -> None:
+        """Initialize DiscoverySkill"""
+        from webagents.utils.logging import get_logger, log_skill_event
+        
+        self.agent = agent
+        self.logger = get_logger('skill.robutler.discovery', self.agent.name)
+        
+        # Resolve Robutler API key using hierarchy: config -> agent.api_key -> env
+        if not self.robutler_api_key:
+            if hasattr(self.agent, 'api_key') and self.agent.api_key:
+                self.robutler_api_key = self.agent.api_key
+                self.logger.debug(f"Using agent's API key for Robutler platform")
+            elif os.getenv('ROBUTLER_API_KEY'):
+                self.robutler_api_key = os.getenv('ROBUTLER_API_KEY')
+                self.logger.debug(f"Using ROBUTLER_API_KEY from environment")
+            elif os.getenv('SERVICE_TOKEN'):
+                self.robutler_api_key = os.getenv('SERVICE_TOKEN')
+                self.logger.debug(f"Using SERVICE_TOKEN from environment")
+            else:
+                self.logger.warning("No API key configured for discovery")
+        
+        log_skill_event(self.agent.name, 'discovery', 'initialized', {
+            'enable_discovery': self.enable_discovery,
+            'robutler_api_url': self.robutler_api_url,
+            'agent_base_url': self.agent_base_url,
+            'has_api_key': bool(self.robutler_api_key)
+        })
+    
+    # ===== DISCOVERY TOOLS =====
+    
+    @prompt(priority=20, scope="all")
+    def discovery_general_prompt(self, context: Any = None) -> str:
+        base_url = self.agent_base_url.rstrip('/')
+        return f"You are part of a network of AI agents working for their owners. Each agent has their own name and address. @agentname corresponds to {base_url}/agents/agentname. Use discovery_tool to discover other agents and their capabilities."
+
+    @tool(description="Discover agents and their capabilities across the Robutler network by intent. Make the intent as specific as possible. When presenting the results, make it simple and non-technical.", scope="all")
+    async def discovery_tool(self, 
+                            intent: str,
+                            top_k: int = 10,
+                            context=None) -> Dict[str, Any]:
+        """Discover agents by intent across the Robutler network"""
+        if not self.enable_discovery:
+            return {'success': False, 'error': 'Discovery disabled'}
+        
+        if not self.robutler_api_key:
+            return {'success': False, 'error': 'API key not configured for discovery'}
+        
+        try:
+            import aiohttp
+            
+            # Clamp top_k between 1-50
+            limited_top_k = max(1, min(50, top_k))
+            
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    f"{self.robutler_api_url}/api/intents/search",
+                    headers={
+                        'Authorization': f'Bearer {self.robutler_api_key}',
+                        'Content-Type': 'application/json',
+                    },
+                    json={
+                        'intent': intent.strip(),
+                        'top_k': limited_top_k,
+                    }
+                ) as response:
+                    
+                    if not response.ok:
+                        raise Exception(f"Discovery API error: {response.status}")
+                    
+                    result = await response.json()
+                    results = result.get('data', {}).get('results', [])
+                    
+                    return {
+                        'success': True,
+                        'intent': intent,
+                        'results_count': len(results),
+                        'results': [
+                            {
+                                'agent_id': r.get('agent_id'),
+                                'intent': r.get('intent'),
+                                'description': r.get('agent_description'),
+                                'similarity': r.get('similarity'),
+                                'url': r.get('url'),
+                                'rank': r.get('rank'),
+                            }
+                            for r in results
+                        ]
+                    }
+                    
+        except Exception as e:
+            self.logger.error(f"Agent discovery failed: {e}")
+            return {
+                'success': False,
+                'intent': intent,
+                'results_count': 0,
+                'results': [],
+                'error': str(e)
+            }
+    
+    @tool(description="Publish agent intents to the platform", scope="owner")
+    async def publish_intents_tool(self,
+                            intents: List[str],
+                            description: str,
+                            context=None) -> Dict[str, Any]:
+        """Publish agent intents to the Robutler platform"""
+        if not self.enable_discovery:
+            return {'success': False, 'error': 'Discovery disabled'}
+        
+        if not self.robutler_api_key:
+            return {'success': False, 'error': 'API key not configured for discovery'}
+        
+        try:
+            import aiohttp
+            
+            # Get agent information
+            agent_id = getattr(self.agent, 'name', 'unknown')
+            agent_url = self.config.get('agent_url', f"https://robutler.ai/agents/{agent_id}")
+            
+            # Prepare intent data
+            intents_data = [
+                {
+                    'intent': intent,
+                    'agent_id': agent_id,
+                    'description': description,
+                    'url': agent_url,
+                }
+                for intent in intents
+            ]
+            
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    f"{self.robutler_api_url}/api/intents/publish",
+                    headers={
+                        'Authorization': f'Bearer {self.robutler_api_key}',
+                        'Content-Type': 'application/json',
+                    },
+                    json={'intents': intents_data}
+                ) as response:
+                    
+                    if not response.ok:
+                        raise Exception(f"Publish API error: {response.status}")
+                    
+                    result = await response.json()
+                    
+                    return {
+                        'success': True,
+                        'agent_id': agent_id,
+                        'published_intents': intents,
+                        'results': result
+                    }
+                    
+        except Exception as e:
+            self.logger.error(f"Intent publishing failed: {e}")
+            return {'success': False, 'error': str(e)}
+    
+    def get_dependencies(self) -> List[str]:
+        """Get skill dependencies"""
+        return ['aiohttp']  # Required for HTTP client 

webagents/agents/skills/robutler/kv/__init__.py

@@ -0,0 +1,6 @@
+from .skill import KVSkill
+
+__all__ = ["KVSkill"]
+
+
+

webagents/agents/skills/robutler/kv/skill.py

@@ -0,0 +1,80 @@
+import os
+from typing import Any, Dict, Optional
+
+import httpx
+
+from webagents.agents.skills.base import Skill
+from webagents.agents.tools.decorators import tool
+from webagents.server.context.context_vars import get_context
+
+
+class KVSkill(Skill):
+    """Simple per-agent key-value storage via portal /api/kv.
+
+    Scope: owner-only tools to ensure only the agent owner can read/write.
+    """
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None) -> None:
+        super().__init__(config or {}, scope="all")
+        self.portal_url = os.getenv('ROBUTLER_INTERNAL_API_URL') or os.getenv('ROBUTLER_API_URL', 'http://localhost:3000')
+
+    async def _resolve_agent_and_user(self) -> Optional[Dict[str, str]]:
+        try:
+            ctx = get_context()
+            agent = getattr(ctx, 'agent', None)
+            auth = getattr(ctx, 'auth', None) or (ctx and ctx.get('auth'))
+            agent_id = getattr(agent, 'id', None)
+            user_id = getattr(auth, 'user_id', None)
+            if agent_id and user_id:
+                return {"agent_id": agent_id, "user_id": user_id}
+        except Exception:
+            pass
+        return None
+
+    async def _headers(self) -> Dict[str, str]:
+        # Prefer agent API key for auth
+        api_key = getattr(self.agent, 'api_key', None)
+        return {"X-API-Key": api_key} if api_key else {}
+
+    @tool(description="Set a key to a string value (owner-only)", scope="owner")
+    async def kv_set(self, key: str, value: str, namespace: Optional[str] = None) -> str:
+        ids = await self._resolve_agent_and_user()
+        if not ids:
+            return "❌ Missing agent/user context"
+        body = {"agentId": ids["agent_id"], "key": key, "value": value, "namespace": namespace}
+        async with httpx.AsyncClient(timeout=15) as client:
+            resp = await client.post(f"{self.portal_url}/api/kv", json=body, headers=await self._headers())
+            if resp.status_code >= 400:
+                return f"❌ KV set failed: {resp.text}"
+        return "✅ Saved"
+
+    @tool(description="Get a string value by key (owner-only)", scope="owner")
+    async def kv_get(self, key: str, namespace: Optional[str] = None) -> str:
+        ids = await self._resolve_agent_and_user()
+        if not ids:
+            return ""
+        params = {"agentId": ids["agent_id"], "key": key}
+        if namespace:
+            params["namespace"] = namespace
+        async with httpx.AsyncClient(timeout=15) as client:
+            resp = await client.get(f"{self.portal_url}/api/kv", params=params, headers=await self._headers())
+            if resp.status_code >= 400:
+                return ""
+            data = resp.json()
+            return data.get('value') or ""
+
+    @tool(description="Delete a key (owner-only)", scope="owner")
+    async def kv_delete(self, key: str, namespace: Optional[str] = None) -> str:
+        ids = await self._resolve_agent_and_user()
+        if not ids:
+            return ""
+        params = {"agentId": ids["agent_id"], "key": key}
+        if namespace:
+            params["namespace"] = namespace
+        async with httpx.AsyncClient(timeout=15) as client:
+            resp = await client.delete(f"{self.portal_url}/api/kv", params=params, headers=await self._headers())
+            if resp.status_code >= 400:
+                return ""
+        return "🗑️ Deleted"
+
+

webagents/agents/skills/robutler/message_history/__init__.py

@@ -0,0 +1,9 @@
+"""
+Message History Skill for Robutler Agents
+
+Enables agents to save conversation messages to persistent storage in Robutler Portal.
+"""
+
+from .skill import MessageHistorySkill
+
+__all__ = ['MessageHistorySkill'] 

webagents/agents/skills/robutler/message_history/skill.py

@@ -0,0 +1,270 @@
+"""
+MessageHistorySkill - Save agent conversation messages to Robutler Portal
+
+This skill enables agents to:
+- Automatically save conversation messages on connection finalization
+- Create and manage conversation threads
+- Retrieve conversation history for context
+- Support agent-to-agent and user-to-agent conversations
+"""
+
+import os
+import json
+import asyncio
+from typing import Dict, Any, List, Optional
+from webagents.agents.skills.base import Skill
+from webagents.agents.tools.decorators import tool, hook
+from webagents.utils.logging import get_logger, log_skill_event
+
+
+class MessageHistorySkill(Skill):
+    """
+    Skill for automatically saving agent conversation history in Robutler Portal
+    
+    Features:
+    - Automatic message saving on connection finalization
+    - Create and manage conversation threads
+    - Support for agent-to-agent and user-to-agent conversations
+    - Retrieve conversation history for context
+    """
+    
+    def __init__(self, config: Dict[str, Any] = None):
+        super().__init__(config, scope="all")
+        
+        # Configuration
+        self.portal_url = config.get('portal_url') if config else None
+        self.api_key = config.get('api_key') if config else None
+        
+        # Runtime state
+        self.current_conversation_id = None
+        self.agent_id = None
+        self.api_client = None
+        self.session_messages = []
+        
+    async def initialize(self, agent: 'BaseAgent') -> None:
+        """Initialize the message history skill"""
+        from webagents.utils.logging import get_logger, log_skill_event
+        
+        self.agent = agent
+        self.agent_id = getattr(agent, 'id', None) or getattr(agent, 'name', 'unknown')
+        self.logger = get_logger('skill.message_history', agent.name)
+        
+        # Initialize API client
+        try:
+            from webagents.api.client import RobutlerClient
+            
+            # Get API key from agent config, skill config, or environment
+            api_key = (
+                self.api_key or 
+                getattr(agent, 'api_key', None) or
+                os.getenv('ROBUTLER_API_KEY')
+            )
+            
+            if not api_key:
+                self.logger.warning("No API key available for MessageHistorySkill")
+                return
+                
+            self.api_client = RobutlerClient(
+                api_key=api_key,
+                base_url=self.portal_url or os.getenv('ROBUTLER_API_URL', 'https://robutler.ai')
+            )
+            
+            log_skill_event(agent.name, 'message_history', 'initialized', {
+                'agent_id': self.agent_id
+            })
+            
+        except ImportError:
+            self.logger.warning("RobutlerClient not available - MessageHistorySkill disabled")
+        except Exception as e:
+            self.logger.error(f"Failed to initialize MessageHistorySkill: {e}")
+
+    @tool(description="Create a new conversation thread for organizing messages")
+    async def create_conversation(
+        self, 
+        title: str,
+        other_party_id: str,
+        other_party_type: str = "user",
+        visibility: str = "private"
+    ) -> str:
+        """Create a new conversation thread"""
+        if not self.api_client:
+            return "❌ Error: API client not initialized"
+            
+        try:
+            import aiohttp
+            
+            async with aiohttp.ClientSession() as session:
+                headers = {
+                    'Authorization': f'Bearer {self.api_client.api_key}',
+                    'Content-Type': 'application/json'
+                }
+                
+                payload = {
+                    'operation': 'createChat',
+                    'agentId': self.agent_id,
+                    'title': title,
+                    'visibility': visibility,
+                    'otherPartyId': other_party_id,
+                    'otherPartyType': other_party_type
+                }
+                
+                async with session.post(
+                    f"{self.api_client.base_url}/api/chat",
+                    headers=headers,
+                    json=payload
+                ) as response:
+                    if response.status == 200:
+                        data = await response.json()
+                        conversation_id = data.get('id')
+                        self.current_conversation_id = conversation_id
+                        return f"✅ Created conversation: {conversation_id}"
+                    else:
+                        error_text = await response.text()
+                        return f"❌ Failed to create conversation: {response.status} - {error_text}"
+                        
+        except Exception as e:
+            self.logger.error(f"Error creating conversation: {e}")
+            return f"❌ Error creating conversation: {str(e)}"
+
+    @tool(description="Retrieve conversation history for context")
+    async def get_conversation_history(
+        self,
+        conversation_id: str = None,
+        limit: int = 50
+    ) -> str:
+        """Retrieve conversation history"""
+        if not self.api_client:
+            return "❌ Error: API client not initialized"
+            
+        try:
+            chat_id = conversation_id or self.current_conversation_id
+            if not chat_id:
+                return "❌ Error: No conversation ID provided and no current conversation"
+                
+            import aiohttp
+            
+            async with aiohttp.ClientSession() as session:
+                headers = {
+                    'Authorization': f'Bearer {self.api_client.api_key}',
+                    'Content-Type': 'application/json'
+                }
+                
+                params = {
+                    'operation': 'getMessagesByChatId',
+                    'chatId': chat_id
+                }
+                
+                async with session.get(
+                    f"{self.api_client.base_url}/api/messages",
+                    headers=headers,
+                    params=params
+                ) as response:
+                    if response.status == 200:
+                        data = await response.json()
+                        messages = data.get('messages', [])
+                        
+                        # Format messages for context
+                        formatted_messages = []
+                        for msg in messages[-limit:]:  # Get last N messages
+                            sender_info = f"{msg.get('senderType', 'unknown')}:{msg.get('senderId', 'unknown')}"
+                            content = msg.get('parts', '')
+                            if isinstance(content, list):
+                                content = ' '.join(str(part) for part in content)
+                            formatted_messages.append(f"[{sender_info}] {content}")
+                        
+                        return "\n".join(formatted_messages)
+                    else:
+                        error_text = await response.text()
+                        return f"❌ Failed to get conversation history: {response.status} - {error_text}"
+                        
+        except Exception as e:
+            self.logger.error(f"Error getting conversation history: {e}")
+            return f"❌ Error getting conversation history: {str(e)}"
+
+    @tool(description="Set the current active conversation")
+    async def set_current_conversation(self, conversation_id: str) -> str:
+        """Set the current active conversation"""
+        self.current_conversation_id = conversation_id
+        return f"✅ Set current conversation to: {conversation_id}"
+
+    @hook("on_message")
+    async def capture_session_messages(self, context):
+        """Capture messages during the session for later saving"""
+        try:
+            # Extract message information from context
+            messages = getattr(context, 'messages', [])
+            if messages:
+                # Store the full message exchange for this session
+                self.session_messages = messages.copy()
+                self.logger.debug(f"Captured {len(messages)} messages for session")
+                
+        except Exception as e:
+            self.logger.warning(f"Failed to capture session messages: {e}")
+            
+        return context
+
+    @hook("finalize_connection")
+    async def save_session_messages(self, context):
+        """Automatically save all session messages when connection finalizes"""
+        if not self.api_client or not self.session_messages or not self.current_conversation_id:
+            return context
+            
+        try:
+            # Prepare messages for saving
+            messages_to_save = []
+            
+            for i, msg in enumerate(self.session_messages):
+                # Determine sender info based on message role
+                if msg.get('role') == 'user':
+                    sender_id = "user_session"  # Default user ID - could be enhanced
+                    sender_type = "user"
+                elif msg.get('role') == 'assistant':
+                    sender_id = self.agent_id
+                    sender_type = "agent"
+                else:
+                    continue  # Skip system messages
+                
+                message_data = {
+                    'id': f"msg_{self.current_conversation_id}_{i}_{hash(str(msg))}",
+                    'chatId': self.current_conversation_id,
+                    'role': msg.get('role'),
+                    'parts': msg.get('content', ''),
+                    'attachments': json.dumps([]),
+                    'senderId': sender_id,
+                    'senderType': sender_type
+                }
+                messages_to_save.append(message_data)
+            
+            if messages_to_save:
+                # Save messages via API
+                import aiohttp
+                
+                async with aiohttp.ClientSession() as session:
+                    headers = {
+                        'Authorization': f'Bearer {self.api_client.api_key}',
+                        'Content-Type': 'application/json'
+                    }
+                    
+                    payload = {
+                        'operation': 'saveMessages',
+                        'messages': messages_to_save
+                    }
+                    
+                    async with session.post(
+                        f"{self.api_client.base_url}/api/messages",
+                        headers=headers,
+                        json=payload
+                    ) as response:
+                        if response.status == 200:
+                            self.logger.info(f"Successfully saved {len(messages_to_save)} messages to conversation {self.current_conversation_id}")
+                        else:
+                            error_text = await response.text()
+                            self.logger.error(f"Failed to save messages: {response.status} - {error_text}")
+            
+            # Clear session messages after saving
+            self.session_messages = []
+                    
+        except Exception as e:
+            self.logger.error(f"Error saving session messages: {e}")
+            
+        return context 

webagents/agents/skills/robutler/nli/__init__.py

@@ -0,0 +1,13 @@
+"""
+NLI Skill - Natural Language Interface for Agent-to-Agent Communication
+
+Provides HTTP-based communication between Robutler agents with natural language messages.
+"""
+
+from .skill import NLISkill, NLICommunication, AgentEndpoint
+
+__all__ = [
+    'NLISkill',
+    'NLICommunication', 
+    'AgentEndpoint'
+]