daita-agents 0.1.0__py3-none-any.whl

daita/execution/exceptions.py

@@ -0,0 +1,92 @@
+"""
+Execution-specific exceptions for the autonomous execution system.
+
+These exceptions provide specific error handling for common issues that
+can occur during programmatic agent execution.
+"""
+
+from typing import Optional
+
+
+class ExecutionError(Exception):
+    """Base exception for execution-related errors."""
+
+    def __init__(
+        self,
+        message: str,
+        execution_id: Optional[str] = None,
+        status_code: Optional[int] = None
+    ):
+        self.message = message
+        self.execution_id = execution_id
+        self.status_code = status_code
+        super().__init__(message)
+
+    def __str__(self) -> str:
+        if self.execution_id:
+            return f"ExecutionError (ID: {self.execution_id}): {self.message}"
+        return f"ExecutionError: {self.message}"
+
+
+class AuthenticationError(ExecutionError):
+    """Raised when API key authentication fails."""
+
+    def __init__(self, message: str = "Invalid API key or insufficient permissions"):
+        super().__init__(message, status_code=401)
+
+
+class NotFoundError(ExecutionError):
+    """Raised when requested agent, workflow, or execution is not found."""
+
+    def __init__(self, message: str, resource_type: str = "resource"):
+        self.resource_type = resource_type
+        super().__init__(message, status_code=404)
+
+    def __str__(self) -> str:
+        return f"NotFoundError ({self.resource_type}): {self.message}"
+
+
+class ValidationError(ExecutionError):
+    """Raised when request validation fails."""
+
+    def __init__(self, message: str, field: Optional[str] = None):
+        self.field = field
+        super().__init__(message, status_code=400)
+
+    def __str__(self) -> str:
+        if self.field:
+            return f"ValidationError ({self.field}): {self.message}"
+        return f"ValidationError: {self.message}"
+
+
+class RateLimitError(ExecutionError):
+    """Raised when API rate limits are exceeded."""
+
+    def __init__(self, message: str = "Rate limit exceeded", retry_after: Optional[int] = None):
+        self.retry_after = retry_after
+        super().__init__(message, status_code=429)
+
+    def __str__(self) -> str:
+        if self.retry_after:
+            return f"RateLimitError: {self.message} (retry after {self.retry_after}s)"
+        return f"RateLimitError: {self.message}"
+
+
+class TimeoutError(ExecutionError):
+    """Raised when execution times out."""
+
+    def __init__(self, message: str = "Execution timeout", timeout_seconds: Optional[int] = None):
+        self.timeout_seconds = timeout_seconds
+        super().__init__(message, status_code=408)
+
+    def __str__(self) -> str:
+        if self.timeout_seconds:
+            return f"TimeoutError: {self.message} (timeout: {self.timeout_seconds}s)"
+        return f"TimeoutError: {self.message}"
+
+
+class ServerError(ExecutionError):
+    """Raised when server encounters an internal error."""
+
+    def __init__(self, message: str = "Internal server error"):
+        super().__init__(message, status_code=500)

daita/execution/models.py

@@ -0,0 +1,317 @@
+"""
+Data models for the autonomous execution system.
+
+These models provide structured representations of execution results,
+scheduled tasks, and webhook triggers.
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Dict, Any, Optional, Union
+import json
+
+
+@dataclass
+class ExecutionResult:
+    """
+    Represents the result of an autonomous agent or workflow execution.
+
+    This class provides a structured way to access execution results
+    and metadata from programmatic agent executions.
+    """
+
+    execution_id: str
+    status: str  # queued, running, completed, failed, cancelled
+    target_type: str  # agent or workflow
+    target_name: str
+
+    # Result data
+    result: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+
+    # Timing information
+    created_at: Optional[datetime] = None
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    duration_ms: Optional[int] = None
+
+    # Resource usage
+    memory_used_mb: Optional[float] = None
+    cost_estimate: Optional[float] = None
+
+    # Monitoring and debugging
+    trace_id: Optional[str] = None
+    dashboard_url: Optional[str] = None
+
+    # Execution metadata
+    execution_source: str = "autonomous_sdk"
+    source_metadata: Dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def is_complete(self) -> bool:
+        """Check if execution is complete (success or failure)."""
+        return self.status in ['completed', 'success', 'failed', 'cancelled']
+
+    @property
+    def is_success(self) -> bool:
+        """Check if execution completed successfully."""
+        return self.status in ['completed', 'success']
+
+    @property
+    def is_running(self) -> bool:
+        """Check if execution is currently running."""
+        return self.status in ['queued', 'running']
+
+    @property
+    def duration_seconds(self) -> Optional[float]:
+        """Get duration in seconds."""
+        return self.duration_ms / 1000 if self.duration_ms else None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ExecutionResult":
+        """Create ExecutionResult from API response data."""
+
+        # Parse datetime fields
+        created_at = None
+        if data.get('created_at'):
+            created_at = datetime.fromisoformat(data['created_at'].replace('Z', '+00:00'))
+
+        started_at = None
+        if data.get('started_at'):
+            started_at = datetime.fromisoformat(data['started_at'].replace('Z', '+00:00'))
+
+        completed_at = None
+        if data.get('completed_at'):
+            completed_at = datetime.fromisoformat(data['completed_at'].replace('Z', '+00:00'))
+
+        # Parse result field - handle both string and dict formats
+        result = data.get('result')
+        if isinstance(result, str):
+            try:
+                result = json.loads(result)
+            except (json.JSONDecodeError, TypeError):
+                # If JSON parsing fails, keep as string or convert to dict with raw content
+                result = {"raw_output": result} if result else None
+
+        return cls(
+            execution_id=data['execution_id'],
+            status=data['status'],
+            target_type=data['target_type'],
+            target_name=data['target_name'],
+            result=result,
+            error=data.get('error'),
+            created_at=created_at,
+            started_at=started_at,
+            completed_at=completed_at,
+            duration_ms=data.get('duration_ms'),
+            memory_used_mb=data.get('memory_used_mb'),
+            cost_estimate=data.get('cost_estimate'),
+            trace_id=data.get('trace_id'),
+            dashboard_url=data.get('dashboard_url'),
+            execution_source=data.get('execution_source', 'autonomous_sdk'),
+            source_metadata=data.get('source_metadata', {})
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary representation."""
+        return {
+            'execution_id': self.execution_id,
+            'status': self.status,
+            'target_type': self.target_type,
+            'target_name': self.target_name,
+            'result': self.result,
+            'error': self.error,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'started_at': self.started_at.isoformat() if self.started_at else None,
+            'completed_at': self.completed_at.isoformat() if self.completed_at else None,
+            'duration_ms': self.duration_ms,
+            'memory_used_mb': self.memory_used_mb,
+            'cost_estimate': self.cost_estimate,
+            'trace_id': self.trace_id,
+            'dashboard_url': self.dashboard_url,
+            'execution_source': self.execution_source,
+            'source_metadata': self.source_metadata
+        }
+
+    def __repr__(self) -> str:
+        return f"ExecutionResult(id={self.execution_id[:8]}..., status={self.status}, target={self.target_name})"
+
+
+@dataclass
+class ScheduledTask:
+    """
+    Represents a scheduled agent or workflow execution.
+
+    This class provides information about scheduled tasks configured
+    through the YAML-based scheduling system.
+    """
+
+    # Required fields (no defaults)
+    task_id: str
+    organization_id: int
+    schedule: str  # cron expression
+
+    # Optional fields (with defaults)
+    deployment_id: Optional[str] = None
+    agent_name: Optional[str] = None
+    workflow_name: Optional[str] = None
+    data: Dict[str, Any] = field(default_factory=dict)
+    timezone: str = "UTC"
+    enabled: bool = True
+
+    # Timing information
+    next_run: Optional[datetime] = None
+    last_run: Optional[datetime] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+
+    # AWS EventBridge information
+    eventbridge_rule_arn: Optional[str] = None
+
+    @property
+    def target_name(self) -> str:
+        """Get the target name (agent or workflow)."""
+        return self.agent_name or self.workflow_name or "unknown"
+
+    @property
+    def target_type(self) -> str:
+        """Get the target type (agent or workflow)."""
+        return "agent" if self.agent_name else "workflow"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ScheduledTask":
+        """Create ScheduledTask from API response data."""
+
+        # Parse datetime fields
+        next_run = None
+        if data.get('next_run'):
+            next_run = datetime.fromisoformat(data['next_run'].replace('Z', '+00:00'))
+
+        last_run = None
+        if data.get('last_run'):
+            last_run = datetime.fromisoformat(data['last_run'].replace('Z', '+00:00'))
+
+        created_at = None
+        if data.get('created_at'):
+            created_at = datetime.fromisoformat(data['created_at'].replace('Z', '+00:00'))
+
+        updated_at = None
+        if data.get('updated_at'):
+            updated_at = datetime.fromisoformat(data['updated_at'].replace('Z', '+00:00'))
+
+        # Handle schedule_config if it's a nested object
+        schedule_config = data.get('schedule_config', {})
+        if isinstance(schedule_config, str):
+            schedule_config = json.loads(schedule_config)
+
+        return cls(
+            task_id=data['id'],
+            organization_id=data['organization_id'],
+            deployment_id=data.get('deployment_id'),
+            agent_name=data.get('agent_name'),
+            workflow_name=data.get('workflow_name'),
+            schedule=schedule_config.get('cron', data.get('schedule', '')),
+            data=schedule_config.get('data', {}),
+            timezone=schedule_config.get('timezone', 'UTC'),
+            enabled=data.get('enabled', True),
+            next_run=next_run,
+            last_run=last_run,
+            created_at=created_at,
+            updated_at=updated_at,
+            eventbridge_rule_arn=data.get('eventbridge_rule_arn')
+        )
+
+    def __repr__(self) -> str:
+        return f"ScheduledTask(id={self.task_id[:8]}..., target={self.target_name}, schedule={self.schedule})"
+
+
+@dataclass
+class WebhookTrigger:
+    """
+    Represents a webhook trigger for agent or workflow execution.
+
+    This class provides information about webhook configurations that
+    can trigger agent executions based on external events.
+    """
+
+    webhook_id: str
+    webhook_url: str
+    organization_id: int
+    deployment_id: Optional[str] = None
+
+    # Target information
+    agent_name: Optional[str] = None
+    workflow_name: Optional[str] = None
+
+    # Webhook configuration
+    data_template: Dict[str, Any] = field(default_factory=dict)
+    enabled: bool = True
+
+    # Timing information
+    created_at: Optional[datetime] = None
+
+    # Statistics
+    trigger_count: int = 0
+    last_triggered: Optional[datetime] = None
+
+    @property
+    def target_name(self) -> str:
+        """Get the target name (agent or workflow)."""
+        return self.agent_name or self.workflow_name or "unknown"
+
+    @property
+    def target_type(self) -> str:
+        """Get the target type (agent or workflow)."""
+        return "agent" if self.agent_name else "workflow"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "WebhookTrigger":
+        """Create WebhookTrigger from API response data."""
+
+        # Parse datetime fields
+        created_at = None
+        if data.get('created_at'):
+            created_at = datetime.fromisoformat(data['created_at'].replace('Z', '+00:00'))
+
+        last_triggered = None
+        if data.get('last_triggered'):
+            last_triggered = datetime.fromisoformat(data['last_triggered'].replace('Z', '+00:00'))
+
+        # Handle data_template if it's a string
+        data_template = data.get('data_template', {})
+        if isinstance(data_template, str):
+            data_template = json.loads(data_template)
+
+        return cls(
+            webhook_id=data['webhook_id'],
+            webhook_url=data['webhook_url'],
+            organization_id=data['organization_id'],
+            deployment_id=data.get('deployment_id'),
+            agent_name=data.get('agent_name'),
+            workflow_name=data.get('workflow_name'),
+            data_template=data_template,
+            enabled=data.get('enabled', True),
+            created_at=created_at,
+            trigger_count=data.get('trigger_count', 0),
+            last_triggered=last_triggered
+        )
+
+    def __repr__(self) -> str:
+        return f"WebhookTrigger(id={self.webhook_id[:8]}..., target={self.target_name}, enabled={self.enabled})"
+
+
+# Utility functions for working with models
+
+def parse_execution_response(response_data: Dict[str, Any]) -> ExecutionResult:
+    """Parse API response into ExecutionResult."""
+    return ExecutionResult.from_dict(response_data)
+
+
+def parse_schedule_list(response_data: list) -> list[ScheduledTask]:
+    """Parse API response list into ScheduledTask objects."""
+    return [ScheduledTask.from_dict(item) for item in response_data]
+
+
+def parse_webhook_list(response_data: list) -> list[WebhookTrigger]:
+    """Parse API response list into WebhookTrigger objects."""
+    return [WebhookTrigger.from_dict(item) for item in response_data]

daita/llm/__init__.py

@@ -0,0 +1,60 @@
+"""
+LLM provider integrations for Daita Agents.
+
+This module provides a unified interface for different LLM providers:
+- OpenAI (GPT-4, GPT-3.5-turbo, etc.)
+- Anthropic (Claude models)
+- Google Gemini
+- xAI Grok
+- Mock provider for testing
+
+The factory pattern allows easy switching between providers while maintaining
+a consistent interface for agents.
+
+Usage:
+    ```python
+    from daita.llm import create_llm_provider
+    
+    # Create OpenAI provider
+    llm = create_llm_provider("openai", "gpt-4", api_key="sk-...")
+    response = await llm.generate("Hello, world!")
+    
+    # Create Anthropic provider  
+    llm = create_llm_provider("anthropic", "claude-3-sonnet-20240229")
+    response = await llm.generate("Analyze this data...")
+    ```
+"""
+
+# Factory and registry functions
+from .factory import (
+    create_llm_provider,
+    register_llm_provider,
+    list_available_providers
+)
+
+# Base class for custom providers
+from .base import BaseLLMProvider
+
+# Concrete provider implementations
+from .openai import OpenAIProvider
+from .anthropic import AnthropicProvider
+from .grok import GrokProvider
+from .gemini import GeminiProvider
+from .mock import MockLLMProvider
+
+__all__ = [
+    # Factory functions
+    "create_llm_provider",
+    "register_llm_provider", 
+    "list_available_providers",
+    
+    # Base class
+    "BaseLLMProvider",
+    
+    # Provider implementations
+    "OpenAIProvider",
+    "AnthropicProvider",
+    "GrokProvider",
+    "GeminiProvider",
+    "MockLLMProvider",
+]

daita/llm/anthropic.py

@@ -0,0 +1,166 @@
+"""
+Anthropic LLM provider implementation with integrated tracing.
+"""
+import os
+import logging
+from typing import Dict, Any, Optional
+
+from ..core.exceptions import LLMError
+from .base import BaseLLMProvider
+
+logger = logging.getLogger(__name__)
+
+class AnthropicProvider(BaseLLMProvider):
+    """Anthropic LLM provider implementation with automatic call tracing."""
+    
+    def __init__(
+        self,
+        model: str = "claude-3-sonnet-20240229",
+        api_key: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        Initialize Anthropic provider.
+        
+        Args:
+            model: Anthropic model name
+            api_key: Anthropic API key
+            **kwargs: Additional Anthropic-specific parameters
+        """
+        # Get API key from parameter or environment
+        api_key = api_key or os.getenv("ANTHROPIC_API_KEY")
+        
+        super().__init__(model=model, api_key=api_key, **kwargs)
+        
+        # Anthropic-specific default parameters
+        self.default_params.update({
+            'timeout': kwargs.get('timeout', 60)
+        })
+        
+        # Lazy-load Anthropic client
+        self._client = None
+    
+    @property
+    def client(self):
+        """Lazy-load Anthropic client."""
+        if self._client is None:
+            try:
+                import anthropic
+                self._validate_api_key()
+                self._client = anthropic.AsyncAnthropic(api_key=self.api_key)
+                logger.debug("Anthropic client initialized")
+            except ImportError:
+                raise LLMError(
+                    "Anthropic package not installed. Install with: pip install anthropic"
+                )
+        return self._client
+    
+    async def _generate_impl(self, prompt: str, **kwargs) -> str:
+        """
+        Provider-specific implementation of text generation for Anthropic.
+        
+        This method contains the actual Anthropic API call logic and is automatically
+        wrapped with tracing by the base class generate() method.
+        
+        Args:
+            prompt: Input prompt
+            **kwargs: Optional parameters
+            
+        Returns:
+            Generated text response
+        """
+        try:
+            # Merge parameters
+            params = self._merge_params(kwargs)
+            
+            # Make API call
+            response = await self.client.messages.create(
+                model=self.model,
+                max_tokens=params.get('max_tokens'),
+                temperature=params.get('temperature'),
+                messages=[
+                    {"role": "user", "content": prompt}
+                ],
+                timeout=params.get('timeout')
+            )
+            
+            # Store usage for base class token extraction
+            self._last_usage = response.usage
+            
+            return response.content[0].text
+            
+        except Exception as e:
+            logger.error(f"Anthropic generation failed: {str(e)}")
+            raise LLMError(f"Anthropic generation failed: {str(e)}")
+    
+    async def generate_with_system(self, prompt: str, system_message: str, **kwargs) -> str:
+        """
+        Generate text with a system message using Anthropic's system parameter.
+        
+        Note: This method bypasses automatic tracing since it's not part of the 
+        base interface. If you want tracing for system messages, call the base
+        generate() method with a formatted prompt instead.
+        
+        Args:
+            prompt: User prompt
+            system_message: System message to set context
+            **kwargs: Optional parameters
+            
+        Returns:
+            Generated text
+        """
+        try:
+            # Merge parameters
+            params = self._merge_params(kwargs)
+            
+            # Make API call with system parameter
+            response = await self.client.messages.create(
+                model=self.model,
+                max_tokens=params.get('max_tokens'),
+                temperature=params.get('temperature'),
+                system=system_message,
+                messages=[
+                    {"role": "user", "content": prompt}
+                ],
+                timeout=params.get('timeout')
+            )
+            
+            # Store usage for potential token extraction
+            self._last_usage = response.usage
+            
+            return response.content[0].text
+            
+        except Exception as e:
+            logger.error(f"Anthropic generation with system message failed: {str(e)}")
+            raise LLMError(f"Anthropic generation failed: {str(e)}")
+    
+    def _get_last_token_usage(self) -> Dict[str, int]:
+        """
+        Override base class method to handle Anthropic's token format.
+        
+        Anthropic uses input_tokens and output_tokens format, different from OpenAI.
+        """
+        if self._last_usage:
+            # Anthropic format: input_tokens + output_tokens
+            input_tokens = getattr(self._last_usage, 'input_tokens', 0)
+            output_tokens = getattr(self._last_usage, 'output_tokens', 0)
+            total_tokens = input_tokens + output_tokens
+            
+            return {
+                'total_tokens': total_tokens,
+                'prompt_tokens': input_tokens,  # Map input_tokens to prompt_tokens
+                'completion_tokens': output_tokens  # Map output_tokens to completion_tokens
+            }
+        
+        # Fallback to base class estimation
+        return super()._get_last_token_usage()
+    
+    @property
+    def info(self) -> Dict[str, Any]:
+        """Get information about the Anthropic provider."""
+        base_info = super().info
+        base_info.update({
+            'provider_name': 'Anthropic',
+            'api_compatible': 'Anthropic'
+        })
+        return base_info