webagents 0.1.13__py3-none-any.whl → 0.2.2__py3-none-any.whl

webagents/__init__.py

@@ -1,5 +1,5 @@
 """
-Robutler V2.0 - AI Agent Framework
+WebAgents V2.0 - AI Agent Framework
 
 A comprehensive framework for building AI agents with skills, tools, handoffs, 
 and seamless integration with LLM providers.

webagents/__main__.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""
+WebAgents CLI Entry Point
+
+Command-line interface for the WebAgents framework.
+"""
+
+import sys
+import argparse
+from webagents.server.core.app import WebAgentsServer
+from webagents.utils.logging import setup_logging
+
+
+def main():
+    """Main entry point for the webagents CLI."""
+    parser = argparse.ArgumentParser(description="WebAgents - AI Agent Framework")
+    parser.add_argument(
+        "--server", 
+        action="store_true", 
+        help="Start the WebAgents server"
+    )
+    parser.add_argument(
+        "--port", 
+        type=int, 
+        default=8000, 
+        help="Port to run the server on (default: 8000)"
+    )
+    parser.add_argument(
+        "--host", 
+        default="0.0.0.0", 
+        help="Host to bind the server to (default: 0.0.0.0)"
+    )
+    parser.add_argument(
+        "--debug", 
+        action="store_true", 
+        help="Enable debug logging"
+    )
+    
+    args = parser.parse_args()
+    
+    # Setup logging
+    setup_logging(debug=args.debug)
+    
+    if args.server:
+        # Start the server
+        server = WebAgentsServer()
+        server.run(host=args.host, port=args.port)
+    else:
+        print("WebAgents - AI Agent Framework")
+        print("Use --server to start the server")
+        print("Use --help for more options")
+
+
+if __name__ == "__main__":
+    main()

webagents/agents/__init__.py

@@ -1,5 +1,5 @@
 """
-Robutler V2.0 Agents Module
+WebAgents V2.0 Agents Module
 
 Core agent system including BaseAgent, skills, tools, handoffs, and lifecycle management.
 """

webagents/agents/core/__init__.py

@@ -1,5 +1,5 @@
 """
-Robutler V2.0 Core Agent Module
+WebAgents V2.0 Core Agent Module
 
 Contains the core agent implementation and supporting systems:
 - BaseAgent: Main agent class with tool/hook/handoff registration  

webagents/agents/core/base_agent.py

@@ -1,5 +1,5 @@
 """
-BaseAgent - Robutler V2.0 Core Agent Implementation
+BaseAgent - WebAgents V2.0 Core Agent Implementation
 
 Central agent implementation with automatic decorator registration,
 unified context management, and comprehensive tool/hook/handoff execution.
@@ -158,7 +158,7 @@ class BaseAgent:
         level = getattr(logging, log_level, logging.INFO)
         # If using a LoggerAdapter (e.g., AgentContextAdapter), operate on the underlying logger
         base_logger = self.logger.logger if isinstance(self.logger, logging.LoggerAdapter) else self.logger
-        # Set desired level and let it propagate to 'robutler' logger configured by setup_logging
+        # Set desired level and let it propagate to 'webagents' logger configured by setup_logging
         base_logger.setLevel(level)
         base_logger.propagate = True
     
@@ -218,7 +218,7 @@ class BaseAgent:
                 # For agent-level tools, inheritance logic:
                 # - Decorated tools (@tool) keep their own scope (even default "all")
                 # - Undecorated tools inherit agent scopes
-                if hasattr(tool_func, '_robutler_is_tool') and tool_func._robutler_is_tool:
+                if hasattr(tool_func, '_webagents_is_tool') and tool_func._webagents_is_tool:
                     # Tool is decorated - keep its own scope
                     scope = tool_func._tool_scope
                 else:
@@ -253,7 +253,7 @@ class BaseAgent:
                     # Direct Handoff object
                     self.register_handoff(handoff_item, source="agent")
                     self.logger.debug(f"📨 Registered handoff target='{handoff_item.target}' type='{handoff_item.handoff_type}'")
-                elif callable(handoff_item) and hasattr(handoff_item, '_robutler_is_handoff'):
+                elif callable(handoff_item) and hasattr(handoff_item, '_webagents_is_handoff'):
                     # Function with @handoff decorator
                     handoff_config = Handoff(
                         target=getattr(handoff_item, '_handoff_name', handoff_item.__name__),
@@ -277,13 +277,13 @@ class BaseAgent:
             for capability_func in capabilities:
                 if callable(capability_func):
                     # Attempt to determine decorator type
-                    if hasattr(capability_func, '_robutler_is_tool') and capability_func._robutler_is_tool:
+                    if hasattr(capability_func, '_webagents_is_tool') and capability_func._webagents_is_tool:
                         self.register_tool(capability_func, source="agent")
-                    elif hasattr(capability_func, '_robutler_is_hook') and capability_func._robutler_is_hook:
+                    elif hasattr(capability_func, '_webagents_is_hook') and capability_func._webagents_is_hook:
                         priority = getattr(capability_func, '_hook_priority', 50)
                         scope = getattr(capability_func, '_hook_scope', self.scopes)
                         self.register_hook(getattr(capability_func, '_hook_event_type', 'on_request'), capability_func, priority, source="agent", scope=scope)
-                    elif hasattr(capability_func, '_robutler_is_handoff') and capability_func._robutler_is_handoff:
+                    elif hasattr(capability_func, '_webagents_is_handoff') and capability_func._webagents_is_handoff:
                         handoff_config = Handoff(
                             target=getattr(capability_func, '_handoff_name', capability_func.__name__),
                             handoff_type=getattr(capability_func, '_handoff_type', 'agent'),
@@ -292,7 +292,7 @@ class BaseAgent:
                         )
                         handoff_config.metadata = {'function': capability_func}
                         self.register_handoff(handoff_config, source="agent")
-                    elif hasattr(capability_func, '_robutler_is_http') and capability_func._robutler_is_http:
+                    elif hasattr(capability_func, '_webagents_is_http') and capability_func._webagents_is_http:
                         self.register_http_handler(capability_func)
                         self.logger.debug(f"🌐 Registered HTTP capability subpath='{getattr(capability_func, '_http_subpath', '<unknown>')}' method='{getattr(capability_func, '_http_method', 'get')}'")
     
@@ -360,25 +360,25 @@ class BaseAgent:
                 continue
             
             # Check for @hook decorator
-            if hasattr(attr, '_robutler_is_hook') and attr._robutler_is_hook:
+            if hasattr(attr, '_webagents_is_hook') and attr._webagents_is_hook:
                 event_type = attr._hook_event_type
                 priority = getattr(attr, '_hook_priority', 50)
                 scope = getattr(attr, '_hook_scope', None)
                 self.register_hook(event_type, attr, priority, source=skill_name, scope=scope)
             
             # Check for @tool decorator  
-            elif hasattr(attr, '_robutler_is_tool') and attr._robutler_is_tool:
+            elif hasattr(attr, '_webagents_is_tool') and attr._webagents_is_tool:
                 scope = getattr(attr, '_tool_scope', None)
                 self.register_tool(attr, source=skill_name, scope=scope)
             
             # Check for @prompt decorator
-            elif hasattr(attr, '_robutler_is_prompt') and attr._robutler_is_prompt:
+            elif hasattr(attr, '_webagents_is_prompt') and attr._webagents_is_prompt:
                 priority = getattr(attr, '_prompt_priority', 50)
                 scope = getattr(attr, '_prompt_scope', None)
                 self.register_prompt(attr, priority, source=skill_name, scope=scope)
             
             # Check for @handoff decorator
-            elif hasattr(attr, '_robutler_is_handoff') and attr._robutler_is_handoff:
+            elif hasattr(attr, '_webagents_is_handoff') and attr._webagents_is_handoff:
                 handoff_config = Handoff(
                     target=getattr(attr, '_handoff_name', attr_name),
                     handoff_type=getattr(attr, '_handoff_type', 'agent'),
@@ -389,7 +389,7 @@ class BaseAgent:
                 self.register_handoff(handoff_config, source=skill_name)
             
             # Check for @http decorator
-            elif hasattr(attr, '_robutler_is_http') and attr._robutler_is_http:
+            elif hasattr(attr, '_webagents_is_http') and attr._webagents_is_http:
                 self.register_http_handler(attr, source=skill_name)
     
     # Central registration methods (thread-safe)
@@ -402,7 +402,7 @@ class BaseAgent:
                 'scope': scope,
                 'name': getattr(tool_func, '_tool_name', tool_func.__name__),
                 'description': getattr(tool_func, '_tool_description', tool_func.__doc__ or ''),
-                'definition': getattr(tool_func, '_robutler_tool_definition', {})
+                'definition': getattr(tool_func, '_webagents_tool_definition', {})
             }
             self._registered_tools.append(tool_config)
         self.logger.debug(f"🛠️ Tool registered name='{tool_config['name']}' source='{source}' scope={scope}")
@@ -451,7 +451,7 @@ class BaseAgent:
     
     def register_http_handler(self, handler_func: Callable, source: str = "manual"):
         """Register an HTTP handler function with conflict detection"""
-        if not hasattr(handler_func, '_robutler_is_http'):
+        if not hasattr(handler_func, '_webagents_is_http'):
             raise ValueError(f"Function {handler_func.__name__} is not decorated with @http")
         
         subpath = getattr(handler_func, '_http_subpath')

webagents/agents/core/handoffs.py

@@ -1,5 +1,5 @@
 """
-Agent Handoffs - Robutler V2.0
+Agent Handoffs - WebAgents V2.0
 
 LocalAgentHandoff implementation for same-instance agent transfers.
 Provides basic agent-to-agent handoff functionality within a single server instance.

webagents/agents/skills/__init__.py

@@ -1,7 +1,7 @@
 """
-Robutler Agents Skills
+WebAgents Agents Skills
 
-This module provides the skill system for Robutler agents, including core skills,
+This module provides the skill system for WebAgents agents, including core skills,
 platform skills, and ecosystem skills. Skills are modular components that provide
 specific functionality to agents.
 """
@@ -16,10 +16,10 @@ CORE_SKILLS = {
     "litellm": LiteLLMSkill,
 }
 
-# Import Robutler platform skills
+# Import WebAgents platform skills
 from .robutler.crm import CRMAnalyticsSkill
 
-# Robutler platform skills - these integrate with Robutler services
+# WebAgents platform skills - these integrate with WebAgents services
 ROBUTLER_SKILLS = {
     "crm": CRMAnalyticsSkill,
     "analytics": CRMAnalyticsSkill,  # Alias for convenience
@@ -74,13 +74,13 @@ def get_skill(skill_name: str):
     
     # Lazy load ecosystem skills
     ecosystem_imports = {
-        "google": ("robutler.agents.skills.ecosystem.google", "GoogleSkill"),
-        "database": ("robutler.agents.skills.ecosystem.database", "DatabaseSkill"),
-        "filesystem": ("robutler.agents.skills.ecosystem.filesystem", "FilesystemSkill"),
-        "web": ("robutler.agents.skills.ecosystem.web", "WebSkill"),
-        "crewai": ("robutler.agents.skills.ecosystem.crewai", "CrewAISkill"),
-        "n8n": ("robutler.agents.skills.ecosystem.n8n", "N8nSkill"),
-        "zapier": ("robutler.agents.skills.ecosystem.zapier", "ZapierSkill"),
+        "google": ("webagents.agents.skills.ecosystem.google", "GoogleSkill"),
+        "database": ("webagents.agents.skills.ecosystem.database", "DatabaseSkill"),
+        "filesystem": ("webagents.agents.skills.ecosystem.filesystem", "FilesystemSkill"),
+        "web": ("webagents.agents.skills.ecosystem.web", "WebSkill"),
+        "crewai": ("webagents.agents.skills.ecosystem.crewai", "CrewAISkill"),
+        "n8n": ("webagents.agents.skills.ecosystem.n8n", "N8nSkill"),
+        "zapier": ("webagents.agents.skills.ecosystem.zapier", "ZapierSkill"),
     }
     
     if skill_name in ecosystem_imports:

webagents/agents/skills/base.py

@@ -1,5 +1,5 @@
 """
-Base Skill Interface - Robutler V2.0
+Base Skill Interface - WebAgents V2.0
 
 Core skill interface with unified context access, automatic registration support,
 and dependency resolution.

webagents/agents/skills/core/llm/litellm/__init__.py

@@ -1,5 +1,5 @@
 """
-LiteLLM Skill Package - Robutler V2.0
+LiteLLM Skill Package - WebAgents V2.0
 
 Cross-provider LLM routing with support for OpenAI, Anthropic, XAI/Grok, and more.
 Provides unified interface for multiple LLM providers with automatic fallbacks.

webagents/agents/skills/core/llm/litellm/skill.py

@@ -1,5 +1,5 @@
 """
-LiteLLM Skill - Robutler V2.0
+LiteLLM Skill - WebAgents V2.0
 
 Cross-provider LLM routing using LiteLLM for unified access to:
 - OpenAI (GPT-4, GPT-3.5, etc.)

webagents/agents/skills/core/mcp/README.md

@@ -63,8 +63,8 @@ The `MCPSkill` provides comprehensive **Model Context Protocol (MCP) integration
 ### Basic Configuration
 
 ```python
-from robutler.agents import BaseAgent
-from robutler.agents.skills.core.mcp import MCPSkill
+from webagents.agents import BaseAgent
+from webagents.agents.skills.core.mcp import MCPSkill
 
 # Configure MCP skill with servers
 mcp_config = {

webagents/agents/skills/core/mcp/skill.py

@@ -346,7 +346,7 @@ class MCPSkill(Skill):
             
             # Set tool attributes for registration
             dynamic_tool_func.__name__ = dynamic_tool_name
-            dynamic_tool_func._robutler_is_tool = True
+            dynamic_tool_func._webagents_is_tool = True
             dynamic_tool_func._tool_scope = "all"
             
             # Convert MCP tool schema to OpenAI format
@@ -362,7 +362,7 @@ class MCPSkill(Skill):
                 }
             }
             
-            dynamic_tool_func._robutler_tool_definition = openai_schema
+            dynamic_tool_func._webagents_tool_definition = openai_schema
             
             # Store and register the dynamic tool
             self.dynamic_tools[dynamic_tool_name] = dynamic_tool_func

webagents/agents/skills/core/memory/long_term_memory/memory_skill.py

@@ -2,7 +2,7 @@
 LongTermMemorySkill - Persistent Memory Management
 
 Automatically extracts and stores key facts, preferences, and context
-from conversations for future reference using Robutler portal storage
+from conversations for future reference using WebAgents portal storage
 via dependencies.
 """
 
@@ -37,7 +37,7 @@ class MemoryItem:
 
 class LongTermMemorySkill(Skill):
     """
-    Long-term memory management skill with robutler portal integration via dependencies.
+    Long-term memory management skill with webagents portal integration via dependencies.
     
     Features:
     - Automatic memory extraction from conversations
@@ -45,14 +45,14 @@ class LongTermMemorySkill(Skill):
     - Importance scoring and prioritization
     - Searchable memory retrieval
     - Memory cleanup and maintenance
-    - Integration with robutler portal storage via dependencies
+    - Integration with webagents portal storage via dependencies
     """
 
     def __init__(self, config: Optional[Dict[str, Any]] = None):
         super().__init__(config)
         self.max_memories = config.get('max_memories', 100) if config else 100
         self.auto_extract = config.get('auto_extract', True) if config else True
-        self.use_robutler_storage = config.get('use_robutler_storage', True) if config else True
+        self.use_webagents_storage = config.get('use_webagents_storage', True) if config else True
         self.fallback_file = config.get('fallback_file', '/tmp/agent_memory.json') if config else '/tmp/agent_memory.json'
         self.memories: Dict[str, MemoryItem] = {}
         self.agent_name = config.get('agent_name', 'default_agent') if config else 'default_agent'
@@ -71,8 +71,8 @@ class LongTermMemorySkill(Skill):
             self.agent_name = agent_reference.name
         
         # Get JSON storage from dependencies
-        if 'robutler.json_storage' in self.dependencies:
-            self.storage = self.dependencies['robutler.json_storage']
+        if 'webagents.json_storage' in self.dependencies:
+            self.storage = self.dependencies['webagents.json_storage']
         elif hasattr(agent_reference, 'skills') and 'json_storage' in agent_reference.skills:
             # Fallback to agent skills
             self.storage = agent_reference.skills['json_storage']
@@ -267,7 +267,7 @@ EXAMPLE TRIGGERS:
             # Sort by importance and access count
             filtered_memories.sort(key=lambda x: (x['importance'], x['access_count']), reverse=True)
             
-            storage_location = "robutler_json_storage" if self.storage else "local_file"
+            storage_location = "webagents_json_storage" if self.storage else "local_file"
             
             return json.dumps({
                 "total_memories": len(self.memories),
@@ -392,7 +392,7 @@ EXAMPLE TRIGGERS:
             JSON string with memory statistics
         """
         try:
-            storage_location = "robutler_json_storage" if self.storage else "local_file"
+            storage_location = "webagents_json_storage" if self.storage else "local_file"
             
             if not self.memories:
                 return json.dumps({
@@ -548,7 +548,7 @@ EXAMPLE TRIGGERS:
     async def _load_memories(self):
         """Load memories from storage"""
         try:
-            if self.use_robutler_storage and self.storage:
+            if self.use_webagents_storage and self.storage:
                 # Try to load from webagents JSON storage
                 result = await self.storage.retrieve_json_data(f"{self.agent_name}_memory.json")
                 result_data = json.loads(result)
@@ -584,8 +584,8 @@ EXAMPLE TRIGGERS:
                 }
             }
             
-            if self.use_robutler_storage and self.storage:
-                # Try to save to robutler JSON storage
+            if self.use_webagents_storage and self.storage:
+                # Try to save to webagents JSON storage
                 result = await self.storage.store_json_data(
                     f"{self.agent_name}_memory.json",
                     data,
@@ -608,7 +608,7 @@ EXAMPLE TRIGGERS:
         """Get comprehensive skill information"""
         return {
             "name": "LongTermMemorySkill",
-            "description": "Persistent long-term memory with robutler JSON storage via dependencies",
+            "description": "Persistent long-term memory with webagents JSON storage via dependencies",
             "version": "3.0.0",
             "capabilities": [
                 "Automatic memory extraction from conversations",
@@ -616,7 +616,7 @@ EXAMPLE TRIGGERS:
                 "Searchable memory retrieval",
                 "Importance-based prioritization",
                 "Memory cleanup and maintenance",
-                "Robutler JSON storage integration via dependencies"
+                "WebAgents JSON storage integration via dependencies"
             ],
             "tools": [
                 "extract_key_memories",
@@ -629,7 +629,7 @@ EXAMPLE TRIGGERS:
             "total_memories": len(self.memories),
             "categories": list(set(m.category for m in self.memories.values())) if self.memories else [],
             "config": {
-                "use_robutler_storage": self.use_robutler_storage,
+                "use_webagents_storage": self.use_webagents_storage,
                 "agent_name": self.agent_name,
                 "max_memories": self.max_memories,
                 "auto_extract": self.auto_extract,

webagents/agents/skills/core/memory/short_term_memory/__init__.py

@@ -1,5 +1,5 @@
 """
-Short-term Memory Skill Package - Robutler V2.0
+Short-term Memory Skill Package - WebAgents V2.0
 
 Manages message context, conversation filtering, and immediate memory operations.
 """

webagents/agents/skills/core/memory/short_term_memory/skill.py

@@ -1,5 +1,5 @@
 """
-Short-term Memory Skill - Robutler V2.0
+Short-term Memory Skill - WebAgents V2.0
 
 Manages conversation context, message filtering, and immediate memory operations.
 Handles recent message history, context windowing, and conversation summarization.

webagents/agents/skills/core/memory/vector_memory/skill.py

@@ -10,11 +10,11 @@ Env configuration:
 - MILVUS_HOST (e.g., https://in03)
 - MILVUS_PORT (e.g., 443)
 - MILVUS_TOKEN (if required by Milvus/Cosmos)
-- MILVUS_COLLECTION (default: robutler_memory)
+- MILVUS_COLLECTION (default: webagents_memory)
 - MILVUS_FORCE_RECREATE (truthy to recreate collection on init)
 - EMBEDDING_MODEL (default: text-embedding-3-small)
 - LITELLM_BASE_URL (default: http://localhost:2225)
-- LITELLM_API_KEY or ROBUTLER_API_KEY (bearer for embeddings)
+- LITELLM_API_KEY or WEBAGENTS_API_KEY (bearer for embeddings)
 """
 
 from __future__ import annotations
@@ -58,16 +58,16 @@ class VectorMemorySkill(Skill):
         self.milvus_host = _get_env_str("MILVUS_HOST", "http://localhost")
         self.milvus_port = int(os.getenv("MILVUS_PORT", "19530"))
         self.milvus_token = _get_env_str("MILVUS_TOKEN")
-        self.milvus_collection = _get_env_str("MILVUS_COLLECTION", "robutler_memory")
+        self.milvus_collection = _get_env_str("MILVUS_COLLECTION", "webagents_memory")
         self.milvus_force_recreate = _is_truthy(os.getenv("MILVUS_FORCE_RECREATE", "false"))
         # Embeddings config
         self.embed_model = _get_env_str("EMBEDDING_MODEL", "text-embedding-3-small")
         self.litellm_base = _get_env_str("LITELLM_BASE_URL", "http://localhost:2225")
-        self.litellm_key = _get_env_str("LITELLM_API_KEY") or _get_env_str("ROBUTLER_API_KEY")
+        self.litellm_key = _get_env_str("LITELLM_API_KEY") or _get_env_str("WEBAGENTS_API_KEY")
 
     async def initialize(self, agent) -> None:
         self.agent = agent
-        self.logger = get_logger('skill.robutler.vector_memory', agent.name)
+        self.logger = get_logger('skill.webagents.vector_memory', agent.name)
         if not _MILVUS_AVAILABLE:
             self.logger.warning("pymilvus not available; VectorMemorySkill disabled")
             return
@@ -96,7 +96,7 @@ class VectorMemorySkill(Skill):
                     FieldSchema(name="content", dtype=DataType.VARCHAR, max_length=8192),
                     FieldSchema(name="vector", dtype=DataType.FLOAT_VECTOR, dim=self.dim),
                 ]
-                schema = CollectionSchema(fields=fields, description="Robutler Vector Memory")
+                schema = CollectionSchema(fields=fields, description="WebAgents Vector Memory")
                 self.collection = Collection(name=self.milvus_collection, schema=schema)
                 try:
                     self.collection.create_index(

webagents/agents/skills/core/planning/__init__.py

@@ -1,5 +1,5 @@
 """
-Core Planning Skills - Robutler V2.0
+Core Planning Skills - WebAgents V2.0
 
 Advanced task planning and orchestration capabilities.
 """

webagents/agents/skills/ecosystem/crewai/__init__.py

@@ -1 +1,3 @@
-# TODO: Implement CrewAI skill
+from .skill import CrewAISkill
+
+__all__ = ['CrewAISkill']

webagents/agents/skills/ecosystem/crewai/skill.py

@@ -0,0 +1,158 @@
+"""
+Simplified CrewAI Skill for WebAgents
+
+This skill runs a pre-configured CrewAI crew with agents and tasks.
+The crew configuration is provided during skill initialization.
+
+Main use case: Execute a specific crew workflow on demand.
+"""
+
+import os
+import json
+from typing import Dict, Any, Optional, List, Union
+from datetime import datetime
+
+from webagents.agents.skills.base import Skill
+from webagents.agents.tools.decorators import tool, prompt
+
+try:
+    from crewai import Agent, Task, Crew, Process
+    CREWAI_AVAILABLE = True
+except ImportError:
+    CREWAI_AVAILABLE = False
+    Agent, Task, Crew, Process = None, None, None, None  # type: ignore
+
+
+class CrewAISkill(Skill):
+    """Simplified CrewAI skill for running pre-configured crews"""
+    
+    def __init__(self, crew_or_config: Optional[Union[Dict[str, Any], Any]] = None):
+        super().__init__({}, scope="all")
+        if not CREWAI_AVAILABLE:
+            raise ImportError("CrewAI is not installed. Install with: pip install crewai")
+        
+        # Handle both Crew object and configuration dictionary
+        if crew_or_config is None:
+            self.crew_config = {}
+            self.crew = None
+        elif hasattr(crew_or_config, 'agents') and hasattr(crew_or_config, 'tasks'):
+            # It's a Crew object
+            self.crew_config = {}
+            self.crew = crew_or_config
+        else:
+            # It's a configuration dictionary
+            self.crew_config = crew_or_config or {}
+            self.crew = None
+            self._setup_crew()
+    
+    def get_dependencies(self) -> List[str]:
+        """Skill dependencies"""
+        return []  # No dependencies needed for simple crew execution
+    
+    def _setup_crew(self):
+        """Set up the CrewAI crew from configuration"""
+        if not self.crew_config:
+            return
+        
+        try:
+            # Get agents configuration
+            agents_config = self.crew_config.get('agents', [])
+            tasks_config = self.crew_config.get('tasks', [])
+            process_type = self.crew_config.get('process', 'sequential')
+            
+            if not agents_config or not tasks_config:
+                return
+            
+            # Create agents
+            agents = []
+            for agent_config in agents_config:
+                agent = Agent(
+                    role=agent_config.get('role', 'Agent'),
+                    goal=agent_config.get('goal', 'Complete assigned tasks'),
+                    backstory=agent_config.get('backstory', 'An AI agent ready to help'),
+                    verbose=agent_config.get('verbose', True),
+                    allow_delegation=agent_config.get('allow_delegation', False)
+                )
+                agents.append(agent)
+            
+            # Create tasks
+            tasks = []
+            for i, task_config in enumerate(tasks_config):
+                # Assign agent to task (default to first agent if not specified)
+                agent_index = task_config.get('agent_index', 0)
+                if agent_index >= len(agents):
+                    agent_index = 0  # Fallback to first agent
+                
+                task = Task(
+                    description=task_config.get('description', f'Task {i+1}'),
+                    agent=agents[agent_index],
+                    expected_output=task_config.get('expected_output', 'Task completion')
+                )
+                tasks.append(task)
+            
+            # Create crew
+            process = Process.sequential
+            if process_type.lower() == 'hierarchical':
+                process = Process.hierarchical
+            
+            self.crew = Crew(
+                agents=agents,
+                tasks=tasks,
+                process=process,
+                verbose=self.crew_config.get('verbose', True)
+            )
+            
+            # CrewAI crew initialized successfully
+            
+        except Exception as e:
+            self.crew = None
+
+    @prompt(priority=40, scope=["owner", "all"])
+    def crewai_prompt(self) -> str:
+        """Prompt describing CrewAI capabilities"""
+        if not self.crew:
+            return """
+CrewAI skill is available but no crew is configured. 
+
+To use CrewAI, initialize the skill with either:
+1. A CrewAI Crew object: CrewAISkill(crew)
+2. A crew configuration dictionary with agents, tasks, and process settings
+"""
+        
+        agents_count = len(self.crew.agents) if self.crew else 0
+        tasks_count = len(self.crew.tasks) if self.crew else 0
+        
+        return f"""
+CrewAI multi-agent orchestration is ready. Available tool:
+
+• crewai_run(inputs) - Execute the configured crew with the given inputs
+
+Configured crew:
+- {agents_count} agents with specialized roles
+- {tasks_count} tasks in the workflow
+- Ready to process your requests through collaborative AI agents
+
+Provide inputs as a dictionary to run the crew workflow.
+"""
+
+    # Public tool
+    @tool(description="Execute the configured CrewAI crew with the given inputs")
+    async def crewai_run(self, inputs: Dict[str, Any]) -> str:
+        """Execute the configured CrewAI crew with the provided inputs"""
+        if not self.crew:
+            return "❌ No CrewAI crew configured. Please initialize the skill with a crew configuration."
+        
+        if not inputs:
+            return "❌ Inputs are required to run the crew"
+        
+        try:
+            # Execute the crew with inputs
+            result = self.crew.kickoff(inputs=inputs)
+            
+            agents_count = len(self.crew.agents)
+            tasks_count = len(self.crew.tasks)
+            
+            return f"✅ CrewAI execution completed successfully!\n👥 Agents: {agents_count}\n📝 Tasks: {tasks_count}\n\n📊 Result:\n{result}"
+            
+        except Exception as e:
+            return f"❌ CrewAI execution failed: {str(e)}"

webagents/agents/skills/ecosystem/database/__init__.py

@@ -1 +1,3 @@
-# TODO: Implement Database skill
+from .skill import SupabaseSkill
+
+__all__ = ['SupabaseSkill']