django-cfg 1.1.81__py3-none-any.whl → 1.2.0__py3-none-any.whl

django_cfg/apps/agents/models/registry.py

@@ -0,0 +1,220 @@
+"""
+Django models for agent registry and configuration.
+"""
+
+from django.db import models
+from django.conf import settings
+from django.core.exceptions import ValidationError
+import json
+
+
+class AgentDefinition(models.Model):
+    """Registry of available agents with their configurations."""
+    
+    name = models.CharField(max_length=100, unique=True, db_index=True)
+    display_name = models.CharField(max_length=200, blank=True)
+    description = models.TextField()
+    instructions = models.TextField(help_text="System prompt for the agent")
+    
+    # Type information
+    deps_type = models.CharField(max_length=100, help_text="Python class name for dependencies")
+    output_type = models.CharField(max_length=100, help_text="Python class name for output")
+    
+    # Model configuration
+    model = models.CharField(max_length=100, default='openai:gpt-4o-mini')
+    timeout = models.PositiveIntegerField(default=300, help_text="Timeout in seconds")
+    max_retries = models.PositiveIntegerField(default=3)
+    enable_caching = models.BooleanField(default=True)
+    
+    # Tools configuration
+    tools_config = models.JSONField(
+        default=dict, 
+        blank=True,
+        help_text="Configuration for agent tools"
+    )
+    
+    # Permissions and access control
+    is_active = models.BooleanField(default=True, db_index=True)
+    is_public = models.BooleanField(default=False, help_text="Available to all users")
+    allowed_users = models.ManyToManyField(
+        settings.AUTH_USER_MODEL, 
+        blank=True, 
+        related_name='allowed_agents',
+        help_text="Users allowed to use this agent"
+    )
+    allowed_groups = models.ManyToManyField(
+        'auth.Group',
+        blank=True,
+        related_name='allowed_agents',
+        help_text="Groups allowed to use this agent"
+    )
+    
+    # Metadata
+    category = models.CharField(max_length=50, blank=True, db_index=True)
+    tags = models.JSONField(default=list, blank=True, help_text="List of tags")
+    version = models.CharField(max_length=20, default='1.0.0')
+    
+    # Audit fields
+    created_by = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='created_agents')
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    
+    # Usage statistics
+    usage_count = models.PositiveIntegerField(default=0)
+    last_used_at = models.DateTimeField(null=True, blank=True)
+    
+    # Custom managers
+    from ..managers.registry import AgentDefinitionManager
+    objects = AgentDefinitionManager()
+    
+    class Meta:
+        db_table = 'orchestrator_agent_definitions'
+        indexes = [
+            models.Index(fields=['is_active', 'category']),
+            models.Index(fields=['created_by', '-created_at']),
+            models.Index(fields=['-usage_count']),
+        ]
+        ordering = ['name']
+    
+    def __str__(self):
+        return f"AgentDefinition({self.name})"
+    
+    def clean(self):
+        """Validate agent definition."""
+        super().clean()
+        
+        # Validate tools_config is valid JSON
+        if self.tools_config:
+            try:
+                if isinstance(self.tools_config, str):
+                    json.loads(self.tools_config)
+            except json.JSONDecodeError:
+                raise ValidationError({'tools_config': 'Invalid JSON format'})
+        
+        # Validate tags is a list
+        if self.tags and not isinstance(self.tags, list):
+            raise ValidationError({'tags': 'Tags must be a list'})
+        
+        # Validate timeout range
+        if self.timeout < 1 or self.timeout > 3600:
+            raise ValidationError({'timeout': 'Timeout must be between 1 and 3600 seconds'})
+        
+        # Validate max_retries range
+        if self.max_retries < 0 or self.max_retries > 10:
+            raise ValidationError({'max_retries': 'Max retries must be between 0 and 10'})
+    
+    def save(self, *args, **kwargs):
+        # Set display_name if not provided
+        if not self.display_name:
+            self.display_name = self.name.replace('_', ' ').title()
+        
+        # Clean and validate
+        self.full_clean()
+        
+        super().save(*args, **kwargs)
+    
+    def can_be_used_by(self, user) -> bool:
+        """Check if user can use this agent."""
+        if not self.is_active:
+            return False
+        
+        if self.is_public:
+            return True
+        
+        if user == self.created_by:
+            return True
+        
+        if self.allowed_users.filter(id=user.id).exists():
+            return True
+        
+        if self.allowed_groups.filter(user__id=user.id).exists():
+            return True
+        
+        return False
+    
+    def increment_usage(self):
+        """Increment usage count and update last used timestamp."""
+        from django.utils import timezone
+        self.usage_count += 1
+        self.last_used_at = timezone.now()
+        self.save(update_fields=['usage_count', 'last_used_at'])
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary for serialization."""
+        return {
+            'name': self.name,
+            'display_name': self.display_name,
+            'description': self.description,
+            'instructions': self.instructions,
+            'deps_type': self.deps_type,
+            'output_type': self.output_type,
+            'model': self.model,
+            'timeout': self.timeout,
+            'max_retries': self.max_retries,
+            'enable_caching': self.enable_caching,
+            'tools_config': self.tools_config,
+            'is_active': self.is_active,
+            'category': self.category,
+            'tags': self.tags,
+            'version': self.version,
+            'usage_count': self.usage_count,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None,
+        }
+    
+
+
+class AgentTemplate(models.Model):
+    """Templates for creating new agents."""
+    
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField()
+    
+    # Template configuration
+    template_config = models.JSONField(help_text="Template configuration")
+    default_instructions = models.TextField()
+    recommended_model = models.CharField(max_length=100, default='openai:gpt-4o-mini')
+    
+    # Categorization
+    category = models.CharField(max_length=50, db_index=True)
+    use_cases = models.JSONField(default=list, help_text="List of use cases")
+    
+    # Metadata
+    created_by = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    is_active = models.BooleanField(default=True)
+    
+    # Custom managers
+    from ..managers.registry import AgentTemplateManager
+    objects = AgentTemplateManager()
+    
+    class Meta:
+        db_table = 'orchestrator_agent_templates'
+        ordering = ['category', 'name']
+    
+    def __str__(self):
+        return f"AgentTemplate({self.name})"
+    
+    def create_agent_definition(
+        self, 
+        name: str, 
+        user, 
+        custom_instructions: str = None
+    ) -> AgentDefinition:
+        """Create agent definition from template."""
+        config = self.template_config.copy()
+        
+        return AgentDefinition.objects.create(
+            name=name,
+            description=self.description,
+            instructions=custom_instructions or self.default_instructions,
+            deps_type=config.get('deps_type', 'DjangoDeps'),
+            output_type=config.get('output_type', 'ProcessResult'),
+            model=config.get('model', self.recommended_model),
+            timeout=config.get('timeout', 300),
+            max_retries=config.get('max_retries', 3),
+            tools_config=config.get('tools_config', {}),
+            category=self.category,
+            created_by=user
+        )

django_cfg/apps/agents/models/toolsets.py

@@ -0,0 +1,305 @@
+"""
+Django models for toolset management and tool execution tracking.
+"""
+
+import uuid
+from django.db import models
+from django.conf import settings
+from django.utils import timezone
+
+
+class ToolExecution(models.Model):
+    """Track tool executions within agent runs."""
+    
+    class Status(models.TextChoices):
+        PENDING = 'pending', 'Pending'
+        RUNNING = 'running', 'Running'
+        COMPLETED = 'completed', 'Completed'
+        FAILED = 'failed', 'Failed'
+    
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    
+    # Context
+    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
+    agent_execution = models.ForeignKey(
+        'AgentExecution', 
+        on_delete=models.CASCADE,
+        related_name='tool_executions'
+    )
+    
+    # Tool information
+    tool_name = models.CharField(max_length=100, db_index=True)
+    toolset_name = models.CharField(max_length=100, blank=True)
+    
+    # Execution data
+    status = models.CharField(
+        max_length=20,
+        choices=Status.choices,
+        default=Status.PENDING,
+        db_index=True
+    )
+    arguments = models.JSONField(help_text="Tool arguments")
+    result = models.JSONField(null=True, blank=True, help_text="Tool execution result")
+    error_message = models.TextField(blank=True)
+    
+    # Metrics
+    execution_time = models.FloatField(null=True, blank=True)
+    retry_count = models.PositiveIntegerField(default=0)
+    
+    # Timestamps
+    created_at = models.DateTimeField(auto_now_add=True)
+    started_at = models.DateTimeField(null=True, blank=True)
+    completed_at = models.DateTimeField(null=True, blank=True)
+    
+    # Custom managers
+    from ..managers.toolsets import ToolExecutionManager
+    objects = ToolExecutionManager()
+    
+    class Meta:
+        db_table = 'orchestrator_tool_executions'
+        indexes = [
+            models.Index(fields=['tool_name', 'status']),
+            models.Index(fields=['user', '-created_at']),
+            models.Index(fields=['agent_execution', 'created_at']),
+        ]
+        ordering = ['-created_at']
+    
+    def __str__(self):
+        return f"ToolExecution({self.tool_name}, {self.status})"
+    
+    def save(self, *args, **kwargs):
+        # Auto-set timestamps based on status
+        if self.status == self.Status.RUNNING and not self.started_at:
+            self.started_at = timezone.now()
+        elif self.status in [self.Status.COMPLETED, self.Status.FAILED] and not self.completed_at:
+            self.completed_at = timezone.now()
+        
+        super().save(*args, **kwargs)
+    
+    @property
+    def duration(self):
+        """Calculate execution duration."""
+        if self.started_at and self.completed_at:
+            return (self.completed_at - self.started_at).total_seconds()
+        return None
+    
+    @property
+    def is_successful(self):
+        """Check if execution was successful."""
+        return self.status == self.Status.COMPLETED and not self.error_message
+
+
+class ApprovalLog(models.Model):
+    """Log approval decisions for tool executions."""
+    
+    class Status(models.TextChoices):
+        PENDING = 'pending', 'Pending'
+        APPROVED = 'approved', 'Approved'
+        REJECTED = 'rejected', 'Rejected'
+        EXPIRED = 'expired', 'Expired'
+    
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    approval_id = models.CharField(max_length=100, unique=True, db_index=True)
+    
+    # Request context
+    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='approval_requests')
+    tool_name = models.CharField(max_length=100)
+    tool_args = models.JSONField()
+    justification = models.TextField(blank=True)
+    
+    # Approval decision
+    status = models.CharField(
+        max_length=20,
+        choices=Status.choices,
+        default=Status.PENDING,
+        db_index=True
+    )
+    approved_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL, 
+        on_delete=models.SET_NULL, 
+        null=True, 
+        blank=True,
+        related_name='approvals_given'
+    )
+    rejected_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL, 
+        on_delete=models.SET_NULL, 
+        null=True, 
+        blank=True,
+        related_name='rejections_given'
+    )
+    rejection_reason = models.TextField(blank=True)
+    
+    # Timestamps
+    requested_at = models.DateTimeField(auto_now_add=True)
+    decided_at = models.DateTimeField(null=True, blank=True)
+    expires_at = models.DateTimeField(null=True, blank=True)
+    
+    # Custom managers
+    from ..managers.toolsets import ApprovalLogManager
+    objects = ApprovalLogManager()
+    
+    class Meta:
+        db_table = 'orchestrator_approval_logs'
+        indexes = [
+            models.Index(fields=['status', 'requested_at']),
+            models.Index(fields=['user', '-requested_at']),
+            models.Index(fields=['approved_by', '-decided_at']),
+        ]
+        ordering = ['-requested_at']
+    
+    def __str__(self):
+        return f"ApprovalLog({self.approval_id}, {self.status})"
+    
+    def save(self, *args, **kwargs):
+        # Auto-set decided_at timestamp
+        if self.status in [self.Status.APPROVED, self.Status.REJECTED] and not self.decided_at:
+            self.decided_at = timezone.now()
+        
+        super().save(*args, **kwargs)
+    
+    @property
+    def is_expired(self):
+        """Check if approval request has expired."""
+        if self.expires_at:
+            return timezone.now() > self.expires_at
+        return False
+    
+    @property
+    def time_to_decision(self):
+        """Calculate time from request to decision."""
+        if self.decided_at:
+            return (self.decided_at - self.requested_at).total_seconds()
+        return None
+    
+    def approve(self, approver):
+        """Approve the request."""
+        self.status = self.Status.APPROVED
+        self.approved_by = approver
+        self.decided_at = timezone.now()
+        self.save()
+    
+    def reject(self, rejector, reason: str = ""):
+        """Reject the request."""
+        self.status = self.Status.REJECTED
+        self.rejected_by = rejector
+        self.rejection_reason = reason
+        self.decided_at = timezone.now()
+        self.save()
+
+
+class ToolsetConfiguration(models.Model):
+    """Configuration for toolsets."""
+    
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField()
+    
+    # Configuration
+    toolset_class = models.CharField(max_length=200, help_text="Python class path")
+    config = models.JSONField(default=dict, help_text="Toolset configuration")
+    
+    # Access control
+    is_active = models.BooleanField(default=True)
+    allowed_users = models.ManyToManyField(settings.AUTH_USER_MODEL, blank=True, related_name='allowed_toolsets')
+    allowed_groups = models.ManyToManyField('auth.Group', blank=True, related_name='allowed_toolsets')
+    
+    # Metadata
+    created_by = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    
+    # Custom managers
+    from ..managers.toolsets import ToolsetConfigurationManager
+    objects = ToolsetConfigurationManager()
+    
+    class Meta:
+        db_table = 'orchestrator_toolset_configurations'
+        ordering = ['name']
+    
+    def __str__(self):
+        return f"ToolsetConfiguration({self.name})"
+    
+    def can_be_used_by(self, user) -> bool:
+        """Check if user can use this toolset."""
+        if not self.is_active:
+            return False
+        
+        if user == self.created_by:
+            return True
+        
+        if self.allowed_users.filter(id=user.id).exists():
+            return True
+        
+        if self.allowed_groups.filter(user__id=user.id).exists():
+            return True
+        
+        return False
+
+
+class ToolPermission(models.Model):
+    """Permissions for specific tools."""
+    
+    class Permission(models.TextChoices):
+        ALLOW = 'allow', 'Allow'
+        DENY = 'deny', 'Deny'
+        REQUIRE_APPROVAL = 'require_approval', 'Require Approval'
+    
+    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
+    tool_name = models.CharField(max_length=100, db_index=True)
+    permission = models.CharField(
+        max_length=20,
+        choices=Permission.choices,
+        default=Permission.ALLOW
+    )
+    
+    # Optional conditions
+    conditions = models.JSONField(
+        default=dict, 
+        blank=True,
+        help_text="Conditions for permission (e.g., argument limits)"
+    )
+    
+    # Metadata
+    created_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL, 
+        on_delete=models.CASCADE, 
+        related_name='tool_permissions_created'
+    )
+    created_at = models.DateTimeField(auto_now_add=True)
+    
+    # Custom managers
+    from ..managers.toolsets import ToolPermissionManager
+    objects = ToolPermissionManager()
+    
+    class Meta:
+        db_table = 'orchestrator_tool_permissions'
+        unique_together = ['user', 'tool_name']
+        indexes = [
+            models.Index(fields=['user', 'tool_name']),
+            models.Index(fields=['tool_name', 'permission']),
+        ]
+    
+    def __str__(self):
+        return f"ToolPermission({self.user.username}, {self.tool_name}, {self.permission})"
+    
+    def check_conditions(self, tool_args: dict) -> bool:
+        """Check if tool arguments meet permission conditions."""
+        if not self.conditions:
+            return True
+        
+        # Implement condition checking logic
+        # This is a simple example - extend as needed
+        for condition_key, condition_value in self.conditions.items():
+            if condition_key in tool_args:
+                arg_value = tool_args[condition_key]
+                
+                # Simple equality check
+                if isinstance(condition_value, dict):
+                    if 'max' in condition_value and arg_value > condition_value['max']:
+                        return False
+                    if 'min' in condition_value and arg_value < condition_value['min']:
+                        return False
+                elif arg_value != condition_value:
+                    return False
+        
+        return True

django_cfg/apps/agents/patterns/__init__.py

@@ -0,0 +1,24 @@
+"""
+Pre-built agent patterns for common use cases.
+"""
+
+from .content_agents import ContentAnalyzerAgent, ContentGeneratorAgent, ContentValidatorAgent
+from .data_agents import DataProcessorAgent, DataValidatorAgent, DataTransformerAgent
+from .business_agents import BusinessRuleAgent, WorkflowAgent, DecisionAgent
+
+__all__ = [
+    # Content patterns
+    "ContentAnalyzerAgent",
+    "ContentGeneratorAgent", 
+    "ContentValidatorAgent",
+    
+    # Data patterns
+    "DataProcessorAgent",
+    "DataValidatorAgent",
+    "DataTransformerAgent",
+    
+    # Business patterns
+    "BusinessRuleAgent",
+    "WorkflowAgent",
+    "DecisionAgent",
+]