webagents 0.1.12__py3-none-any.whl

webagents/api/types.py

@@ -0,0 +1,253 @@
+"""
+Robutler API Types - Robutler V2.0
+
+Data types and models for Robutler Platform API integration.
+Based on the Robutler Portal database schema.
+"""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Dict, Any, List, Optional
+from decimal import Decimal
+from enum import Enum
+
+
+class UserRole(Enum):
+    """User role enumeration"""
+    USER = "user"
+    ADMIN = "admin"
+
+
+class SubscriptionStatus(Enum):
+    """Subscription status enumeration"""
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+    CANCELED = "canceled"
+    TRIALING = "trialing"
+    PAST_DUE = "past_due"
+
+
+class IntegrationType(Enum):
+    """Integration type enumeration"""
+    AGENT = "agent"
+    MCP = "mcp"
+    API = "api"
+
+
+class IntegrationProtocol(Enum):
+    """Integration protocol enumeration"""
+    MCP = "mcp"
+    A2A = "a2a"
+    P2PMCP = "p2pmcp"
+    HTTP = "http"
+
+
+class TransactionType(Enum):
+    """Credit transaction type enumeration"""
+    ADDITION = "addition"
+    USAGE = "usage"
+    TRANSFER = "transfer"
+
+
+@dataclass
+class User:
+    """Robutler platform user"""
+    id: str
+    name: Optional[str] = None
+    email: str = ""
+    role: UserRole = UserRole.USER
+    google_id: Optional[str] = None
+    avatar_url: Optional[str] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+    # Stripe/Payment fields
+    stripe_customer_id: Optional[str] = None
+    stripe_subscription_id: Optional[str] = None
+    stripe_product_id: Optional[str] = None
+    plan_name: Optional[str] = None
+    subscription_status: Optional[SubscriptionStatus] = None
+    # Credits
+    total_credits: Decimal = Decimal('0')
+    used_credits: Decimal = Decimal('0')
+    # Referrals
+    referral_code: Optional[str] = None
+    referred_by: Optional[str] = None
+    referral_count: int = 0
+    
+    @property
+    def available_credits(self) -> Decimal:
+        """Calculate available credits"""
+        return self.total_credits - self.used_credits
+    
+    @property
+    def is_admin(self) -> bool:
+        """Check if user is admin"""
+        return self.role == UserRole.ADMIN
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary"""
+        return {
+            'id': self.id,
+            'name': self.name,
+            'email': self.email,
+            'role': self.role.value,
+            'avatar_url': self.avatar_url,
+            'total_credits': str(self.total_credits),
+            'used_credits': str(self.used_credits),
+            'available_credits': str(self.available_credits),
+            'subscription_status': self.subscription_status.value if self.subscription_status else None,
+            'plan_name': self.plan_name,
+            'referral_code': self.referral_code,
+            'is_admin': self.is_admin
+        }
+
+
+@dataclass
+class ApiKey:
+    """Robutler platform API key"""
+    id: str
+    user_id: str
+    name: str
+    key_hash: str
+    last_used: Optional[datetime] = None
+    expires_at: Optional[datetime] = None
+    is_active: bool = True
+    daily_rate_limit: Optional[int] = None
+    daily_credit_limit: Optional[Decimal] = None
+    session_credit_limit: Optional[Decimal] = None
+    spent_credits: Decimal = Decimal('0')
+    earned_credits: Decimal = Decimal('0')
+    permissions: Optional[Dict[str, Any]] = None
+    integration_id: Optional[str] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+    
+    @property
+    def is_expired(self) -> bool:
+        """Check if API key is expired"""
+        if not self.expires_at:
+            return False
+        return datetime.utcnow() > self.expires_at
+    
+    @property
+    def is_valid(self) -> bool:
+        """Check if API key is valid"""
+        return self.is_active and not self.is_expired
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary"""
+        return {
+            'id': self.id,
+            'user_id': self.user_id,
+            'name': self.name,
+            'is_active': self.is_active,
+            'is_expired': self.is_expired,
+            'is_valid': self.is_valid,
+            'expires_at': self.expires_at.isoformat() if self.expires_at else None,
+            'last_used': self.last_used.isoformat() if self.last_used else None,
+            'daily_credit_limit': str(self.daily_credit_limit) if self.daily_credit_limit else None,
+            'session_credit_limit': str(self.session_credit_limit) if self.session_credit_limit else None,
+            'spent_credits': str(self.spent_credits),
+            'permissions': self.permissions
+        }
+
+
+@dataclass
+class Integration:
+    """Robutler platform integration"""
+    id: str
+    user_id: str
+    agent_id: Optional[str] = None
+    name: Optional[str] = None
+    type: IntegrationType = IntegrationType.API
+    protocol: IntegrationProtocol = IntegrationProtocol.HTTP
+    secret: Optional[str] = None
+    api_key_id: Optional[str] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary"""
+        return {
+            'id': self.id,
+            'user_id': self.user_id,
+            'agent_id': self.agent_id,
+            'name': self.name,
+            'type': self.type.value,
+            'protocol': self.protocol.value,
+            'api_key_id': self.api_key_id,
+            'created_at': self.created_at.isoformat() if self.created_at else None
+        }
+
+
+@dataclass
+class CreditTransaction:
+    """Robutler platform credit transaction"""
+    id: str
+    user_id: str
+    integration_id: Optional[str] = None
+    api_key_id: Optional[str] = None
+    recipient_id: Optional[str] = None
+    amount: Decimal = Decimal('0')
+    type: TransactionType = TransactionType.USAGE
+    source: str = "api_usage"
+    description: Optional[str] = None
+    receipt: Optional[str] = None
+    created_at: Optional[datetime] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary"""
+        return {
+            'id': self.id,
+            'user_id': self.user_id,
+            'integration_id': self.integration_id,
+            'api_key_id': self.api_key_id,
+            'amount': str(self.amount),
+            'type': self.type.value,
+            'source': self.source,
+            'description': self.description,
+            'created_at': self.created_at.isoformat() if self.created_at else None
+        }
+
+
+@dataclass
+class AuthResponse:
+    """Authentication response from Robutler API"""
+    success: bool
+    user: Optional[User] = None
+    api_key: Optional[ApiKey] = None
+    error: Optional[str] = None
+    message: Optional[str] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary"""
+        result = {
+            'success': self.success,
+            'error': self.error,
+            'message': self.message
+        }
+        if self.user:
+            result['user'] = self.user.to_dict()
+        if self.api_key:
+            result['api_key'] = self.api_key.to_dict()
+        return result
+
+
+@dataclass
+class ApiResponse:
+    """Generic API response from Robutler Platform"""
+    success: bool
+    data: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+    message: Optional[str] = None
+    status_code: int = 200
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary"""
+        return {
+            'success': self.success,
+            'data': self.data,
+            'error': self.error,
+            'message': self.message,
+            'status_code': self.status_code
+        } 

webagents/server/__init__.py

@@ -0,0 +1,28 @@
+"""
+Robutler V2.0 Server Package
+
+FastAPI server implementation with OpenAI compatibility,
+streaming support, and comprehensive agent management.
+"""
+
+# Import moved to avoid circular dependency
+# from .core.app import RobutlerServer, create_server
+from .models import (
+    ChatCompletionRequest,
+    OpenAIResponse, 
+    OpenAIStreamChunk,
+    AgentInfoResponse,
+    ServerInfo,
+    HealthResponse
+)
+
+__all__ = [
+    # 'RobutlerServer',
+    # 'create_server', 
+    'ChatCompletionRequest',
+    'OpenAIResponse',
+    'OpenAIStreamChunk', 
+    'AgentInfoResponse',
+    'ServerInfo',
+    'HealthResponse'
+]

webagents/server/context/context_vars.py

@@ -0,0 +1,121 @@
+"""
+Context Variables and Unified Context - Robutler V2.0
+
+Unified context management using Python's contextvars for thread-safe,
+async-compatible context handling.
+"""
+
+import time
+import uuid
+from contextvars import ContextVar
+from dataclasses import dataclass, field
+from typing import Dict, Any, List, Optional, Union
+from datetime import datetime
+
+
+# Single ContextVar for unified context
+CONTEXT: ContextVar['Context'] = ContextVar('robutler_context')
+
+
+@dataclass
+class Context:
+    """Unified Context containing ALL request data AND agent capabilities
+    
+    This replaces the previous multiple context variables with a single,
+    comprehensive context object that contains everything skills and
+    tools need access to.
+    """
+    
+    # Request identification
+    request_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    start_time: float = field(default_factory=time.time)
+    
+    # Request data
+    messages: List[Dict[str, Any]] = field(default_factory=list)
+    stream: bool = False
+    
+    agent: Optional[Any] = None  # BaseAgent instance
+    request: Optional[Any] = None  # Incoming HTTP request wrapper
+
+    # Authentication namespace (populated by AuthSkill)
+    auth: Optional[Any] = None
+
+    # Usage data
+    usage: List[Dict[str, Any]] = field(default_factory=list)
+    
+    # Custom data storage (for skills/tools to store temporary data)
+    custom_data: Dict[str, Any] = field(default_factory=dict)
+    
+    # --- Properties for clean access ---
+    
+    @property
+    def skills(self) -> Dict[str, Any]:
+        """Access to agent's skills"""
+        return self.agent.skills if self.agent else {}
+
+    @property
+    def tools(self) -> List[Dict[str, Any]]:
+        """Access to agent's registered tools"""
+        return self.agent.get_all_tools() if self.agent else []
+    
+    @property
+    def handoffs(self) -> List[Dict[str, Any]]:
+        """Access to agent's registered handoffs"""  
+        return self.agent.get_all_handoffs() if self.agent else []
+    
+    @property
+    def auth_scope(self) -> str:
+        """Determine user scope based on user context"""
+        return self.auth.scope.value if self.auth else 'all'
+    
+    # --- Methods for data manipulation ---
+    
+    def set(self, key: str, value: Any) -> None:
+        """Store custom data"""
+        self.custom_data[key] = value
+    
+    def get(self, key: str, default: Any = None) -> Any:
+        """Retrieve custom data"""
+        return self.custom_data.get(key, default)
+    
+    
+    def add_message(self, message: Dict[str, Any]) -> None:
+        """Add message to context"""
+        self.messages.append(message)
+    
+    def update_agent_context(self, agent: Any, agent_name: str) -> None:
+        """Update agent-related context"""
+        self.agent = agent
+        self.agent_name_resolved = agent_name
+
+
+# Context management functions
+def get_context() -> Optional[Context]:
+    """Get current context from context variable"""
+    try:
+        return CONTEXT.get()
+    except LookupError:
+        return None
+
+
+def set_context(context: Context) -> None:
+    """Set current context in context variable"""
+    CONTEXT.set(context)
+
+
+def create_context(
+    request_id: Optional[str] = None,
+    messages: Optional[List[Dict[str, Any]]] = None,
+    stream: bool = False,
+    request: Any = None,
+    agent: Any = None
+) -> Context:
+    """Create new context with provided data"""
+    context = Context(
+        request_id=request_id or str(uuid.uuid4()),
+        messages=messages or [],
+        stream=stream,
+        agent=agent,
+        request=request
+    )
+    return context