webagents 0.1.12__py3-none-any.whl → 0.2.0__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/google/calendar/skill.py

@@ -178,7 +178,7 @@ class GoogleCalendarSkill(Skill):
   <head>
     <meta charset=\"utf-8\" />
     <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />
-    <title>Robutler – Google Calendar</title>
+    <title>WebAgents – Google Calendar</title>
     <style>
       :root { color-scheme: light dark; }
       html, body { height: 100%; margin: 0; font-family: ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, Helvetica, Arial, "Apple Color Emoji", "Segoe UI Emoji"; }

webagents/agents/skills/robutler/__init__.py

@@ -1,7 +1,7 @@
 """
-Robutler Platform Skills
+WebAgents Platform Skills
 
-Skills that integrate with Robutler platform services.
+Skills that integrate with WebAgents platform services.
 """
 
 from .crm import CRMAnalyticsSkill

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

@@ -1,9 +1,9 @@
 """
-AuthSkill Package - Robutler V2.0
+AuthSkill Package - WebAgents V2.0
 
-Authentication and authorization skill for Robutler platform.
+Authentication and authorization skill for WebAgents platform.
 Provides user authentication, API key validation, role-based access control,
-and integration with Robutler platform services.
+and integration with WebAgents platform services.
 """
 
 from .skill import AuthSkill, AuthScope, AuthContext, AuthenticationError, AuthorizationError

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

@@ -1,8 +1,8 @@
 """
-AuthSkill - Robutler V2.0 Platform Integration
+AuthSkill - WebAgents V2.0 Platform Integration
 
-Authentication and authorization skill for Robutler platform.
-Integrates with Robutler Portal APIs for user authentication, API key validation,
+Authentication and authorization skill for WebAgents platform.
+Integrates with WebAgents Portal APIs for user authentication, API key validation,
 and platform service integration.
 """
 
@@ -13,8 +13,8 @@ from enum import Enum
 
 from webagents.agents.skills.base import Skill
 from webagents.agents.tools.decorators import tool, hook
-from webagents.api import RobutlerClient
-from webagents.api.types import User, ApiKey, AuthResponse
+from robutler.api import RobutlerClient
+from robutler.api.types import User, ApiKey, AuthResponse
 from typing import Any as _Any
 try:
     from jose import jwt as jose_jwt  # python-jose
@@ -49,10 +49,10 @@ class AuthContext:
 
 class AuthSkill(Skill):
     """
-    Authentication and authorization skill for Robutler platform
+    Authentication and authorization skill for WebAgents platform
     
     Features:
-    - Platform integration with Robutler Portal APIs
+    - Platform integration with WebAgents Portal APIs
     - API key authentication and validation
     - User information retrieval
     - Credit tracking and usage management
@@ -82,13 +82,13 @@ class AuthSkill(Skill):
         self.client: Optional[RobutlerClient] = None
         
     async def initialize(self, agent) -> None:
-        """Initialize AuthSkill with Robutler Platform client"""
+        """Initialize AuthSkill with WebAgents Platform client"""
         from webagents.utils.logging import get_logger, log_skill_event
         
         self.agent = agent
-        self.logger = get_logger('skill.robutler.auth', agent.name)
+        self.logger = get_logger('skill.webagents.auth', agent.name)
         
-        # Initialize Robutler Platform client
+        # Initialize WebAgents Platform client
         try:
             # Use api_key as priority, fallback to agent's API key
             final_api_key = self.api_key or getattr(agent, 'api_key', None)
@@ -101,12 +101,12 @@ class AuthSkill(Skill):
             # Test connection
             health_response = await self.client.health_check()
             if health_response.success:
-                self.logger.info(f"Connected to Robutler Platform: {self.platform_api_url}")
+                self.logger.info(f"Connected to WebAgents Platform: {self.platform_api_url}")
             else:
                 self.logger.warning(f"Platform health check failed: {health_response.message}")
             
         except Exception as e:
-            self.logger.error(f"Failed to initialize Robutler Platform client: {e}")
+            self.logger.error(f"Failed to initialize WebAgents Platform client: {e}")
             # Continue without platform integration for testing
             self.client = None
         
@@ -121,7 +121,7 @@ class AuthSkill(Skill):
     
     @hook("on_connection", priority=0, scope="all")
     async def validate_request_auth(self, context) -> Any:
-        """Validate authentication for incoming requests using Robutler Platform"""
+        """Validate authentication for incoming requests using WebAgents Platform"""
         if not self.require_auth:
             return context
 
@@ -241,7 +241,7 @@ class AuthSkill(Skill):
                 assertion_token,
                 selected_key,
                 algorithms=['RS256'],
-                audience=f"robutler-agent:{getattr(self.agent, 'id', '')}",
+                audience=f"webagents-agent:{getattr(self.agent, 'id', '')}",
             )
             if claims.get('agent_id') and getattr(self.agent, 'id', None) and claims['agent_id'] != getattr(self.agent, 'id'):
                 raise Exception('Owner assertion agent_id mismatch')
@@ -265,7 +265,7 @@ class AuthSkill(Skill):
             return None
     
     async def _authenticate_api_key(self, api_key: str) -> Optional[AuthContext]:
-        """Authenticate API key with Robutler Platform and merge optional owner assertion (JWT)."""
+        """Authenticate API key with WebAgents Platform and merge optional owner assertion (JWT)."""
         
         if not self.client:
             self.logger.warning("Platform client not available for authentication")
@@ -321,7 +321,7 @@ class AuthSkill(Skill):
                             assertion_token,
                             selected_key,
                             algorithms=['RS256'],
-                            audience=f"robutler-agent:{getattr(self.agent, 'id', '')}",
+                            audience=f"webagents-agent:{getattr(self.agent, 'id', '')}",
                         )
                         # Enforce agent binding if claim present
                         if claims.get('agent_id') and getattr(self.agent, 'id', None) and claims['agent_id'] != getattr(self.agent, 'id'):

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

@@ -1,7 +1,7 @@
 """
-CRM & Analytics Skill Package - Robutler Platform Integration
+CRM & Analytics Skill Package - WebAgents Platform Integration
 
-CRM and analytics skill for Robutler platform.
+CRM and analytics skill for WebAgents platform.
 Provides contact management and event tracking capabilities.
 """