praisonaiagents 0.0.127__py3-none-any.whl → 0.0.129__py3-none-any.whl

praisonaiagents/llm/model_capabilities.py

@@ -30,6 +30,16 @@ MODELS_SUPPORTING_STRUCTURED_OUTPUTS = {
     "gpt-4.1-mini",
     "o4-mini",
     "o3",
+    
+    # Gemini models that support structured outputs
+    "gemini-2.0-flash",
+    "gemini-2.0-flash-exp",
+    "gemini-1.5-pro",
+    "gemini-1.5-pro-latest",
+    "gemini-1.5-flash",
+    "gemini-1.5-flash-latest",
+    "gemini-1.5-flash-8b",
+    "gemini-1.5-flash-8b-latest",
 }
 
 # Models that explicitly DON'T support structured outputs
@@ -57,16 +67,23 @@ def supports_structured_outputs(model_name: str) -> bool:
     if not model_name:
         return False
     
+    # Strip provider prefixes (e.g., 'google/', 'openai/', etc.)
+    model_without_provider = model_name
+    for prefix in ['google/', 'openai/', 'anthropic/', 'gemini/', 'mistral/', 'deepseek/', 'groq/']:
+        if model_name.startswith(prefix):
+            model_without_provider = model_name[len(prefix):]
+            break
+    
     # First check if it's explicitly in the NOT supporting list
-    if model_name in MODELS_NOT_SUPPORTING_STRUCTURED_OUTPUTS:
+    if model_without_provider in MODELS_NOT_SUPPORTING_STRUCTURED_OUTPUTS:
         return False
     
     # Then check if it's in the supporting list
-    if model_name in MODELS_SUPPORTING_STRUCTURED_OUTPUTS:
+    if model_without_provider in MODELS_SUPPORTING_STRUCTURED_OUTPUTS:
         return True
     
     # For models with version suffixes, check the base model name
-    base_model = model_name.split('-2024-')[0].split('-2025-')[0]
+    base_model = model_without_provider.split('-2024-')[0].split('-2025-')[0]
     if base_model in MODELS_SUPPORTING_STRUCTURED_OUTPUTS:
         return True
     

praisonaiagents/llm/model_router.py

@@ -0,0 +1,348 @@
+"""
+Model Router for intelligent model selection based on task characteristics.
+
+This module provides functionality to automatically select the most appropriate
+LLM model/provider based on task complexity, cost considerations, and model capabilities.
+"""
+
+import os
+import logging
+from typing import Dict, List, Optional, Tuple
+from dataclasses import dataclass
+from enum import IntEnum
+
+logger = logging.getLogger(__name__)
+
+
+class TaskComplexity(IntEnum):
+    """Enum for task complexity levels"""
+    SIMPLE = 1          # Basic queries, math, factual questions
+    MODERATE = 2        # Summarization, basic analysis
+    COMPLEX = 3         # Code generation, deep reasoning
+    VERY_COMPLEX = 4    # Multi-step reasoning, complex analysis
+
+
+@dataclass
+class ModelProfile:
+    """Profile for an LLM model with its characteristics"""
+    name: str
+    provider: str
+    complexity_range: Tuple[TaskComplexity, TaskComplexity]
+    cost_per_1k_tokens: float  # Average of input/output costs
+    strengths: List[str]
+    capabilities: List[str]
+    context_window: int
+    supports_tools: bool = True
+    supports_streaming: bool = True
+
+
+class ModelRouter:
+    """
+    Intelligent model router that selects the best model based on task requirements.
+    
+    This router implements a strategy pattern for model selection, considering:
+    - Task complexity
+    - Cost optimization
+    - Model capabilities
+    - Specific strengths for different task types
+    """
+    
+    # Default model profiles - can be customized via configuration
+    DEFAULT_MODELS = [
+        # Lightweight/cheap models for simple tasks
+        ModelProfile(
+            name="gpt-4o-mini",
+            provider="openai",
+            complexity_range=(TaskComplexity.SIMPLE, TaskComplexity.MODERATE),
+            cost_per_1k_tokens=0.00075,  # Average of $0.00015 input, $0.0006 output
+            strengths=["speed", "cost-effective", "basic-reasoning"],
+            capabilities=["text", "function-calling"],
+            context_window=128000
+        ),
+        ModelProfile(
+            name="gemini/gemini-1.5-flash",
+            provider="google",
+            complexity_range=(TaskComplexity.SIMPLE, TaskComplexity.MODERATE),
+            cost_per_1k_tokens=0.000125,  # Very cost-effective
+            strengths=["speed", "cost-effective", "multimodal"],
+            capabilities=["text", "vision", "function-calling"],
+            context_window=1048576
+        ),
+        ModelProfile(
+            name="claude-3-haiku-20240307",
+            provider="anthropic",
+            complexity_range=(TaskComplexity.SIMPLE, TaskComplexity.MODERATE),
+            cost_per_1k_tokens=0.0008,  # Average of $0.00025 input, $0.00125 output
+            strengths=["speed", "instruction-following"],
+            capabilities=["text", "function-calling"],
+            context_window=200000
+        ),
+        
+        # Mid-tier models for moderate complexity
+        ModelProfile(
+            name="gpt-4o",
+            provider="openai",
+            complexity_range=(TaskComplexity.MODERATE, TaskComplexity.COMPLEX),
+            cost_per_1k_tokens=0.0075,  # Average of $0.0025 input, $0.01 output
+            strengths=["reasoning", "code-generation", "general-purpose"],
+            capabilities=["text", "vision", "function-calling"],
+            context_window=128000
+        ),
+        ModelProfile(
+            name="claude-3-5-sonnet-20241022",
+            provider="anthropic",
+            complexity_range=(TaskComplexity.MODERATE, TaskComplexity.VERY_COMPLEX),
+            cost_per_1k_tokens=0.009,  # Average of $0.003 input, $0.015 output
+            strengths=["reasoning", "code-generation", "analysis", "writing"],
+            capabilities=["text", "vision", "function-calling"],
+            context_window=200000
+        ),
+        
+        # High-end models for complex tasks
+        ModelProfile(
+            name="gemini/gemini-1.5-pro",
+            provider="google",
+            complexity_range=(TaskComplexity.COMPLEX, TaskComplexity.VERY_COMPLEX),
+            cost_per_1k_tokens=0.00625,  # Average of $0.00125 input, $0.005 output
+            strengths=["reasoning", "long-context", "multimodal"],
+            capabilities=["text", "vision", "function-calling"],
+            context_window=2097152  # 2M context
+        ),
+        ModelProfile(
+            name="claude-3-opus-20240229",
+            provider="anthropic",
+            complexity_range=(TaskComplexity.COMPLEX, TaskComplexity.VERY_COMPLEX),
+            cost_per_1k_tokens=0.045,  # Average of $0.015 input, $0.075 output
+            strengths=["deep-reasoning", "complex-analysis", "creative-writing"],
+            capabilities=["text", "vision", "function-calling"],
+            context_window=200000
+        ),
+        ModelProfile(
+            name="deepseek-chat",
+            provider="deepseek",
+            complexity_range=(TaskComplexity.COMPLEX, TaskComplexity.VERY_COMPLEX),
+            cost_per_1k_tokens=0.0014,  # Very cost-effective for capability
+            strengths=["reasoning", "code-generation", "mathematics"],
+            capabilities=["text", "function-calling"],
+            context_window=128000
+        ),
+    ]
+    
+    def __init__(
+        self,
+        models: Optional[List[ModelProfile]] = None,
+        default_model: Optional[str] = None,
+        cost_threshold: Optional[float] = None,
+        preferred_providers: Optional[List[str]] = None
+    ):
+        """
+        Initialize the ModelRouter.
+        
+        Args:
+            models: Custom list of model profiles to use
+            default_model: Default model to use if no suitable model found
+            cost_threshold: Maximum cost per 1k tokens to consider
+            preferred_providers: List of preferred providers in order
+        """
+        self.models = models or self.DEFAULT_MODELS
+        self.default_model = default_model or os.getenv('OPENAI_MODEL_NAME', 'gpt-4o')
+        self.cost_threshold = cost_threshold
+        self.preferred_providers = preferred_providers or []
+        
+        # Build lookup indices for efficient access
+        self._model_by_name = {m.name: m for m in self.models}
+        self._models_by_complexity = self._build_complexity_index()
+        
+    def _build_complexity_index(self) -> Dict[TaskComplexity, List[ModelProfile]]:
+        """Build an index of models by complexity level"""
+        index = {level: [] for level in TaskComplexity}
+        
+        for model in self.models:
+            min_complexity, max_complexity = model.complexity_range
+            for level in TaskComplexity:
+                if min_complexity.value <= level.value <= max_complexity.value:
+                    index[level].append(model)
+        
+        return index
+    
+    def analyze_task_complexity(
+        self,
+        task_description: str,
+        tools_required: Optional[List[str]] = None,
+        context_size: Optional[int] = None
+    ) -> TaskComplexity:
+        """
+        Analyze task description to determine complexity level.
+        
+        This is a simple heuristic-based approach. In production, this could be
+        replaced with a more sophisticated ML-based classifier.
+        """
+        description_lower = task_description.lower()
+        
+        # Keywords indicating different complexity levels
+        simple_keywords = [
+            "calculate", "compute", "what is", "define", "list", "count",
+            "simple", "basic", "check", "verify", "yes or no", "true or false"
+        ]
+        
+        moderate_keywords = [
+            "summarize", "explain", "compare", "describe", "analyze briefly",
+            "find", "search", "extract", "classify", "categorize"
+        ]
+        
+        complex_keywords = [
+            "implement", "code", "develop", "design", "create algorithm",
+            "optimize", "debug", "refactor", "architect", "solve"
+        ]
+        
+        very_complex_keywords = [
+            "multi-step", "comprehensive analysis", "deep dive", "research",
+            "strategic", "framework", "system design", "proof", "theorem"
+        ]
+        
+        # Check for keyword matches
+        if any(keyword in description_lower for keyword in very_complex_keywords):
+            return TaskComplexity.VERY_COMPLEX
+        elif any(keyword in description_lower for keyword in complex_keywords):
+            return TaskComplexity.COMPLEX
+        elif any(keyword in description_lower for keyword in moderate_keywords):
+            return TaskComplexity.MODERATE
+        elif any(keyword in description_lower for keyword in simple_keywords):
+            return TaskComplexity.SIMPLE
+        
+        # Consider tool requirements
+        if tools_required and len(tools_required) > 3:
+            return TaskComplexity.COMPLEX
+        
+        # Consider context size requirements
+        if context_size and context_size > 50000:
+            return TaskComplexity.COMPLEX
+        
+        # Default to moderate
+        return TaskComplexity.MODERATE
+    
+    def select_model(
+        self,
+        task_description: str,
+        required_capabilities: Optional[List[str]] = None,
+        tools_required: Optional[List[str]] = None,
+        context_size: Optional[int] = None,
+        budget_conscious: bool = True
+    ) -> str:
+        """
+        Select the most appropriate model for a given task.
+        
+        Args:
+            task_description: Description of the task to perform
+            required_capabilities: List of required capabilities (e.g., ["vision", "function-calling"])
+            tools_required: List of tools that will be used
+            context_size: Estimated context size needed
+            budget_conscious: Whether to optimize for cost
+            
+        Returns:
+            Model name string to use
+        """
+        # Analyze task complexity
+        complexity = self.analyze_task_complexity(task_description, tools_required, context_size)
+        
+        # Get candidate models for this complexity level
+        candidates = self._models_by_complexity.get(complexity, [])
+        
+        if not candidates:
+            logger.warning(f"No models found for complexity {complexity}, using default")
+            return self.default_model
+        
+        # Filter by required capabilities
+        if required_capabilities:
+            candidates = [
+                m for m in candidates
+                if all(cap in m.capabilities for cap in required_capabilities)
+            ]
+        
+        # Filter by tool support if needed
+        if tools_required:
+            candidates = [m for m in candidates if m.supports_tools]
+        
+        # Filter by context window if specified
+        if context_size:
+            candidates = [m for m in candidates if m.context_window >= context_size]
+        
+        # Filter by cost threshold if specified
+        if self.cost_threshold:
+            candidates = [m for m in candidates if m.cost_per_1k_tokens <= self.cost_threshold]
+        
+        if not candidates:
+            logger.warning("No models meet all criteria, using default")
+            return self.default_model
+        
+        # Sort by selection criteria
+        if budget_conscious:
+            # Sort by cost (ascending)
+            candidates.sort(key=lambda m: m.cost_per_1k_tokens)
+        else:
+            # Sort by capability (descending complexity)
+            candidates.sort(key=lambda m: m.complexity_range[1].value, reverse=True)
+        
+        # Apply provider preferences
+        if self.preferred_providers:
+            for provider in self.preferred_providers:
+                for model in candidates:
+                    if model.provider == provider:
+                        logger.info(f"Selected model: {model.name} (complexity: {complexity}, cost: ${model.cost_per_1k_tokens}/1k tokens)")
+                        return model.name
+        
+        # Return the best candidate
+        selected = candidates[0]
+        logger.info(f"Selected model: {selected.name} (complexity: {complexity}, cost: ${selected.cost_per_1k_tokens}/1k tokens)")
+        return selected.name
+    
+    def get_model_info(self, model_name: str) -> Optional[ModelProfile]:
+        """Get profile information for a specific model"""
+        return self._model_by_name.get(model_name)
+    
+    def estimate_cost(self, model_name: str, estimated_tokens: int) -> float:
+        """Estimate the cost for a given model and token count"""
+        model = self._model_by_name.get(model_name)
+        if not model:
+            return 0.0
+        return (model.cost_per_1k_tokens * estimated_tokens) / 1000
+
+
+def create_routing_agent(
+    models: Optional[List[str]] = None,
+    router: Optional[ModelRouter] = None,
+    **agent_kwargs
+) -> 'Agent':
+    """
+    Create a specialized routing agent that can select models dynamically.
+    
+    Args:
+        models: List of model names to route between
+        router: Custom ModelRouter instance
+        **agent_kwargs: Additional arguments to pass to Agent constructor
+        
+    Returns:
+        Agent configured for model routing
+    """
+    from ..agent import Agent
+    
+    if not router:
+        router = ModelRouter()
+    
+    routing_agent = Agent(
+        name=agent_kwargs.pop('name', 'ModelRouter'),
+        role=agent_kwargs.pop('role', 'Intelligent Model Router'),
+        goal=agent_kwargs.pop('goal', 'Select the most appropriate AI model based on task requirements'),
+        backstory=agent_kwargs.pop('backstory', 
+            'I analyze tasks and route them to the most suitable AI model, '
+            'optimizing for performance, cost, and capability requirements.'
+        ),
+        **agent_kwargs
+    )
+    
+    # TODO: Consider creating a proper RoutingAgent subclass instead of setting private attributes
+    # For now, store the router on the agent for use in execution
+    routing_agent._model_router = router
+    routing_agent._available_models = models or [m.name for m in router.models]
+    
+    return routing_agent

praisonaiagents/process/process.py

@@ -6,9 +6,9 @@ from pydantic import BaseModel, ConfigDict
 from ..agent.agent import Agent
 from ..task.task import Task
 from ..main import display_error
+from ..llm import LLM
 import csv
 import os
-from openai import AsyncOpenAI, OpenAI
 
 class LoopItems(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
@@ -34,6 +34,29 @@ class Process:
         self.task_retry_counter: Dict[str, int] = {} # Initialize retry counter
         self.workflow_finished = False # ADDED: Workflow finished flag
 
+    def _create_llm_instance(self):
+        """Create and return a configured LLM instance for manager tasks."""
+        return LLM(model=self.manager_llm, temperature=0.7)
+
+    def _parse_manager_instructions(self, response, ManagerInstructions):
+        """Parse LLM response and return ManagerInstructions instance.
+        
+        Args:
+            response: String response from LLM
+            ManagerInstructions: Pydantic model class for validation
+            
+        Returns:
+            ManagerInstructions instance
+            
+        Raises:
+            Exception: If parsing fails
+        """
+        try:
+            parsed_json = json.loads(response)
+            return ManagerInstructions(**parsed_json)
+        except (json.JSONDecodeError, ValueError, TypeError) as e:
+            raise Exception(f"Failed to parse response: {response}") from e
+
     def _create_loop_subtasks(self, loop_task: Task):
         """Create subtasks for a loop task from input file."""
         logging.warning(f"_create_loop_subtasks called for {loop_task.name} but method not fully implemented")
@@ -167,24 +190,24 @@ class Process:
 
     def _get_manager_instructions_with_fallback(self, manager_task, manager_prompt, ManagerInstructions):
         """Sync version of getting manager instructions with fallback"""
-        # Create OpenAI client
-        client = OpenAI()
+        # Create LLM instance with the manager_llm
+        llm = self._create_llm_instance()
+        
         try:
-            # First try structured output (OpenAI compatible)
+            # Use LLM with output_pydantic for structured output
             logging.info("Attempting structured output...")
-            manager_response = client.beta.chat.completions.parse(
-                model=self.manager_llm,
-                messages=[
-                    {"role": "system", "content": manager_task.description},
-                    {"role": "user", "content": manager_prompt}
-                ],
-                temperature=0.7,
-                response_format=ManagerInstructions
+            response = llm.get_response(
+                prompt=manager_prompt,
+                system_prompt=manager_task.description,
+                output_pydantic=ManagerInstructions
             )
-            return manager_response.choices[0].message.parsed
+            
+            # Parse the response and validate with Pydantic
+            return self._parse_manager_instructions(response, ManagerInstructions)
+                
         except Exception as e:
             logging.info(f"Structured output failed: {e}, falling back to JSON mode...")
-            # Fallback to regular JSON mode
+            # Fallback to regular JSON mode with explicit JSON instructions
             try:
                 # Generate JSON structure description from Pydantic model
                 try:
@@ -200,23 +223,14 @@ class Process:
                     # Fallback to hardcoded prompt if schema generation fails
                     enhanced_prompt = manager_prompt + "\n\nIMPORTANT: Respond with valid JSON only, using this exact structure: {\"task_id\": <int>, \"agent_name\": \"<string>\", \"action\": \"<execute or stop>\"}"
                 
-                manager_response = client.chat.completions.create(
-                    model=self.manager_llm,
-                    messages=[
-                        {"role": "system", "content": manager_task.description},
-                        {"role": "user", "content": enhanced_prompt}
-                    ],
-                    temperature=0.7,
-                    response_format={"type": "json_object"}
+                response = llm.get_response(
+                    prompt=enhanced_prompt,
+                    system_prompt=manager_task.description,
+                    output_json=True
                 )
                 
                 # Parse JSON and validate with Pydantic
-                try:
-                    json_content = manager_response.choices[0].message.content
-                    parsed_json = json.loads(json_content)
-                    return ManagerInstructions(**parsed_json)
-                except (json.JSONDecodeError, ValueError) as e:
-                    raise Exception(f"Failed to parse JSON response: {json_content}") from e
+                return self._parse_manager_instructions(response, ManagerInstructions)
             except Exception as fallback_error:
                 error_msg = f"Both structured output and JSON fallback failed: {fallback_error}"
                 logging.error(error_msg, exc_info=True)
@@ -224,40 +238,32 @@ class Process:
 
     async def _get_structured_response_async(self, manager_task, manager_prompt, ManagerInstructions):
         """Async version of structured response"""
-        # Create an async client instance for this async method
-        async_client = AsyncOpenAI()
-        manager_response = await async_client.beta.chat.completions.parse(
-            model=self.manager_llm,
-            messages=[
-                {"role": "system", "content": manager_task.description},
-                {"role": "user", "content": manager_prompt}
-            ],
-            temperature=0.7,
-            response_format=ManagerInstructions
+        # Create LLM instance with the manager_llm
+        llm = self._create_llm_instance()
+        
+        # Use async get_response with output_pydantic
+        response = await llm.get_response_async(
+            prompt=manager_prompt,
+            system_prompt=manager_task.description,
+            output_pydantic=ManagerInstructions
         )
-        return manager_response.choices[0].message.parsed
+        
+        # Parse the response and validate with Pydantic
+        return self._parse_manager_instructions(response, ManagerInstructions)
 
     async def _get_json_response_async(self, manager_task, enhanced_prompt, ManagerInstructions):
         """Async version of JSON fallback response"""
-        # Create an async client instance for this async method
-        async_client = AsyncOpenAI()
-        manager_response = await async_client.chat.completions.create(
-            model=self.manager_llm,
-            messages=[
-                {"role": "system", "content": manager_task.description},
-                {"role": "user", "content": enhanced_prompt}
-            ],
-            temperature=0.7,
-            response_format={"type": "json_object"}
+        # Create LLM instance with the manager_llm
+        llm = self._create_llm_instance()
+        
+        response = await llm.get_response_async(
+            prompt=enhanced_prompt,
+            system_prompt=manager_task.description,
+            output_json=True
         )
         
         # Parse JSON and validate with Pydantic
-        try:
-            json_content = manager_response.choices[0].message.content
-            parsed_json = json.loads(json_content)
-            return ManagerInstructions(**parsed_json)
-        except (json.JSONDecodeError, ValueError) as e:
-            raise Exception(f"Failed to parse JSON response: {json_content}") from e
+        return self._parse_manager_instructions(response, ManagerInstructions)
 
 
     async def aworkflow(self) -> AsyncGenerator[str, None]:
@@ -469,16 +475,18 @@ Subtask: {st.name}
                 logging.debug(f"Task type: {task_to_check.task_type}")
                 logging.debug(f"Task status before reset check: {task_to_check.status}")
                 logging.debug(f"Task rerun: {getattr(task_to_check, 'rerun', True)}") # default to True if not set
+                logging.debug(f"Task async_execution: {task_to_check.async_execution}")
 
                 if (getattr(task_to_check, 'rerun', True) and # Corrected condition - reset only if rerun is True (or default True)
                     task_to_check.task_type != "loop" and # Removed "decision" from exclusion
                     not any(t.task_type == "loop" and subtask_name.startswith(t.name + "_")
-                           for t in self.tasks.values())):
-                    logging.debug(f"=== Resetting non-loop, non-decision task {subtask_name} to 'not started' ===")
+                           for t in self.tasks.values()) and
+                    not task_to_check.async_execution):  # Don't reset async parallel tasks
+                    logging.debug(f"=== Resetting non-loop, non-decision, non-parallel task {subtask_name} to 'not started' ===")
                     self.tasks[task_id].status = "not started"
                     logging.debug(f"Task status after reset: {self.tasks[task_id].status}")
                 else:
-                    logging.debug(f"=== Skipping reset for loop/decision/subtask or rerun=False: {subtask_name} ===")
+                    logging.debug(f"=== Skipping reset for loop/decision/subtask/parallel or rerun=False: {subtask_name} ===")
                     logging.debug(f"Keeping status as: {self.tasks[task_id].status}")
 
             # Handle loop progression
@@ -1099,16 +1107,18 @@ Subtask: {st.name}
                 logging.debug(f"Task type: {task_to_check.task_type}")
                 logging.debug(f"Task status before reset check: {task_to_check.status}")
                 logging.debug(f"Task rerun: {getattr(task_to_check, 'rerun', True)}") # default to True if not set
+                logging.debug(f"Task async_execution: {task_to_check.async_execution}")
 
                 if (getattr(task_to_check, 'rerun', True) and # Corrected condition - reset only if rerun is True (or default True)
                     task_to_check.task_type != "loop" and # Removed "decision" from exclusion
                     not any(t.task_type == "loop" and subtask_name.startswith(t.name + "_")
-                           for t in self.tasks.values())):
-                    logging.debug(f"=== Resetting non-loop, non-decision task {subtask_name} to 'not started' ===")
+                           for t in self.tasks.values()) and
+                    not task_to_check.async_execution):  # Don't reset async parallel tasks
+                    logging.debug(f"=== Resetting non-loop, non-decision, non-parallel task {subtask_name} to 'not started' ===")
                     self.tasks[task_id].status = "not started"
                     logging.debug(f"Task status after reset: {self.tasks[task_id].status}")
                 else:
-                    logging.debug(f"=== Skipping reset for loop/decision/subtask or rerun=False: {subtask_name} ===")
+                    logging.debug(f"=== Skipping reset for loop/decision/subtask/parallel or rerun=False: {subtask_name} ===")
                     logging.debug(f"Keeping status as: {self.tasks[task_id].status}")
 
 

praisonaiagents/task/task.py

@@ -172,8 +172,15 @@ class Task:
             # Check return annotation if present
             return_annotation = sig.return_annotation
             if return_annotation != inspect.Signature.empty:
+                # Import GuardrailResult for checking
+                from ..guardrails import GuardrailResult
+                
+                # Check if it's a GuardrailResult type
+                is_guardrail_result = return_annotation is GuardrailResult
+                
+                # Check for tuple return type
                 return_annotation_args = get_args(return_annotation)
-                if not (
+                is_tuple = (
                     get_origin(return_annotation) is tuple
                     and len(return_annotation_args) == 2
                     and return_annotation_args[0] is bool
@@ -183,9 +190,11 @@ class Task:
                         or return_annotation_args[1] is TaskOutput
                         or return_annotation_args[1] == Union[str, TaskOutput]
                     )
-                ):
+                )
+                
+                if not (is_guardrail_result or is_tuple):
                     raise ValueError(
-                        "If return type is annotated, it must be Tuple[bool, Any]"
+                        "If return type is annotated, it must be GuardrailResult or Tuple[bool, Any]"
                     )
             
             self._guardrail_fn = self.guardrail
@@ -447,7 +456,11 @@ Context:
             # Call the guardrail function
             result = self._guardrail_fn(task_output)
             
-            # Convert the result to a GuardrailResult
+            # Check if result is already a GuardrailResult
+            if isinstance(result, GuardrailResult):
+                return result
+            
+            # Otherwise, convert the tuple result to a GuardrailResult
             return GuardrailResult.from_tuple(result)
             
         except Exception as e:

{praisonaiagents-0.0.127.dist-info → praisonaiagents-0.0.129.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.127
+Version: 0.0.129
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Python: >=3.10