praisonaiagents 0.0.97__py3-none-any.whl → 0.0.99__py3-none-any.whl

praisonaiagents/__init__.py

@@ -12,6 +12,7 @@ from .knowledge.knowledge import Knowledge
 from .knowledge.chunking import Chunking
 from .mcp.mcp import MCP
 from .session import Session
+from .guardrails import GuardrailResult, LLMGuardrail
 from .main import (
     TaskOutput,
     ReflectionOutput,
@@ -55,5 +56,7 @@ __all__ = [
     'async_display_callbacks',
     'Knowledge',
     'Chunking',
-    'MCP'
+    'MCP',
+    'GuardrailResult',
+    'LLMGuardrail'
 ] 

praisonaiagents/agent/agent.py

@@ -3,7 +3,7 @@ import time
 import json
 import logging
 import asyncio
-from typing import List, Optional, Any, Dict, Union, Literal, TYPE_CHECKING
+from typing import List, Optional, Any, Dict, Union, Literal, TYPE_CHECKING, Callable, Tuple
 from rich.console import Console
 from rich.live import Live
 from openai import AsyncOpenAI
@@ -32,6 +32,7 @@ _shared_apps = {}  # Dict of port -> FastAPI app
 
 if TYPE_CHECKING:
     from ..task.task import Task
+    from ..main import TaskOutput
 
 @dataclass
 class ChatCompletionMessage:
@@ -368,7 +369,9 @@ class Agent:
         min_reflect: int = 1,
         reflect_llm: Optional[str] = None,
         user_id: Optional[str] = None,
-        reasoning_steps: bool = False
+        reasoning_steps: bool = False,
+        guardrail: Optional[Union[Callable[['TaskOutput'], Tuple[bool, Any]], str]] = None,
+        max_guardrail_retries: int = 3
     ):
         # Add check at start if memory is requested
         if memory is not None:
@@ -483,6 +486,12 @@ Your Goal: {self.goal}
         # Store user_id
         self.user_id = user_id or "praison"
         self.reasoning_steps = reasoning_steps
+        
+        # Initialize guardrail settings
+        self.guardrail = guardrail
+        self.max_guardrail_retries = max_guardrail_retries
+        self._guardrail_fn = None
+        self._setup_guardrail()
 
         # Check if knowledge parameter has any values
         if not knowledge:
@@ -512,6 +521,152 @@ Your Goal: {self.goal}
         except Exception as e:
             logging.error(f"Error processing knowledge item: {knowledge_item}, error: {e}")
 
+    def _setup_guardrail(self):
+        """Setup the guardrail function based on the provided guardrail parameter."""
+        if self.guardrail is None:
+            self._guardrail_fn = None
+            return
+            
+        if callable(self.guardrail):
+            # Validate function signature
+            sig = inspect.signature(self.guardrail)
+            positional_args = [
+                param for param in sig.parameters.values()
+                if param.default is inspect.Parameter.empty
+            ]
+            if len(positional_args) != 1:
+                raise ValueError("Agent guardrail function must accept exactly one parameter (TaskOutput)")
+            
+            # Check return annotation if present
+            from typing import get_args, get_origin
+            return_annotation = sig.return_annotation
+            if return_annotation != inspect.Signature.empty:
+                return_annotation_args = get_args(return_annotation)
+                if not (
+                    get_origin(return_annotation) is tuple
+                    and len(return_annotation_args) == 2
+                    and return_annotation_args[0] is bool
+                    and (
+                        return_annotation_args[1] is Any
+                        or return_annotation_args[1] is str
+                        or str(return_annotation_args[1]).endswith('TaskOutput')
+                        or str(return_annotation_args[1]).startswith('typing.Union')
+                    )
+                ):
+                    raise ValueError(
+                        "If return type is annotated, it must be Tuple[bool, Any] or Tuple[bool, Union[str, TaskOutput]]"
+                    )
+            
+            self._guardrail_fn = self.guardrail
+        elif isinstance(self.guardrail, str):
+            # Create LLM-based guardrail
+            from ..guardrails import LLMGuardrail
+            llm = getattr(self, 'llm', None) or getattr(self, 'llm_instance', None)
+            self._guardrail_fn = LLMGuardrail(description=self.guardrail, llm=llm)
+        else:
+            raise ValueError("Agent guardrail must be either a callable or a string description")
+
+    def _process_guardrail(self, task_output):
+        """Process the guardrail validation for a task output.
+        
+        Args:
+            task_output: The task output to validate
+            
+        Returns:
+            GuardrailResult: The result of the guardrail validation
+        """
+        from ..guardrails import GuardrailResult
+        
+        if not self._guardrail_fn:
+            return GuardrailResult(success=True, result=task_output)
+        
+        try:
+            # Call the guardrail function
+            result = self._guardrail_fn(task_output)
+            
+            # Convert the result to a GuardrailResult
+            return GuardrailResult.from_tuple(result)
+            
+        except Exception as e:
+            logging.error(f"Agent {self.name}: Error in guardrail validation: {e}")
+            # On error, return failure
+            return GuardrailResult(
+                success=False,
+                result=None,
+                error=f"Agent guardrail validation error: {str(e)}"
+            )
+
+    def _apply_guardrail_with_retry(self, response_text, prompt, temperature=0.2, tools=None):
+        """Apply guardrail validation with retry logic.
+        
+        Args:
+            response_text: The response to validate
+            prompt: Original prompt for regeneration if needed
+            temperature: Temperature for regeneration
+            tools: Tools for regeneration
+            
+        Returns:
+            str: The validated response text or None if validation fails after retries
+        """
+        if not self._guardrail_fn:
+            return response_text
+            
+        from ..main import TaskOutput
+        
+        retry_count = 0
+        current_response = response_text
+        
+        while retry_count <= self.max_guardrail_retries:
+            # Create TaskOutput object
+            task_output = TaskOutput(
+                raw=current_response,
+                output=current_response,
+                pydantic=None,
+                json_dict=None,
+                name=f"{self.name}_output",
+                description="Agent response output"
+            )
+            
+            # Process guardrail
+            guardrail_result = self._process_guardrail(task_output)
+            
+            if guardrail_result.success:
+                logging.info(f"Agent {self.name}: Guardrail validation passed")
+                # Return the potentially modified result
+                if guardrail_result.result and hasattr(guardrail_result.result, 'raw'):
+                    return guardrail_result.result.raw
+                elif guardrail_result.result:
+                    return str(guardrail_result.result)
+                else:
+                    return current_response
+            
+            # Guardrail failed
+            if retry_count >= self.max_guardrail_retries:
+                raise Exception(
+                    f"Agent {self.name} response failed guardrail validation after {self.max_guardrail_retries} retries. "
+                    f"Last error: {guardrail_result.error}"
+                )
+            
+            retry_count += 1
+            logging.warning(f"Agent {self.name}: Guardrail validation failed (retry {retry_count}/{self.max_guardrail_retries}): {guardrail_result.error}")
+            
+            # Regenerate response for retry
+            try:
+                retry_prompt = f"{prompt}\n\nNote: Previous response failed validation due to: {guardrail_result.error}. Please provide an improved response."
+                response = self._chat_completion([{"role": "user", "content": retry_prompt}], temperature, tools)
+                if response and response.choices:
+                    current_response = response.choices[0].message.content.strip()
+                else:
+                    raise Exception("Failed to generate retry response")
+            except Exception as e:
+                logging.error(f"Agent {self.name}: Error during guardrail retry: {e}")
+                # If we can't regenerate, fail the guardrail
+                raise Exception(
+                    f"Agent {self.name} guardrail retry failed: {e}"
+                )
+        
+        return current_response
+
     def generate_task(self) -> 'Task':
         """Generate a Task object from the agent's instructions"""
         from ..task.task import Task
@@ -788,69 +943,92 @@ Your Goal: {self.goal}
                     )
             else:
                 # Use the standard OpenAI client approach
-                if stream:
-                    # Process as streaming response with formatted tools
-                    final_response = self._process_stream_response(
-                        messages, 
-                        temperature, 
-                        start_time, 
-                        formatted_tools=formatted_tools if formatted_tools else None,
-                        reasoning_steps=reasoning_steps
-                    )
-                else:
-                    # Process as regular non-streaming response
-                    final_response = client.chat.completions.create(
-                        model=self.llm,
-                        messages=messages,
-                        temperature=temperature,
-                        tools=formatted_tools if formatted_tools else None,
-                        stream=False
-                    )
-
-            tool_calls = getattr(final_response.choices[0].message, 'tool_calls', None)
-
-            if tool_calls:
-                messages.append({
-                    "role": "assistant", 
-                    "content": final_response.choices[0].message.content,
-                    "tool_calls": tool_calls
-                })
+                # Continue tool execution loop until no more tool calls are needed
+                max_iterations = 10  # Prevent infinite loops
+                iteration_count = 0
+                
+                while iteration_count < max_iterations:
+                    if stream:
+                        # Process as streaming response with formatted tools
+                        final_response = self._process_stream_response(
+                            messages, 
+                            temperature, 
+                            start_time, 
+                            formatted_tools=formatted_tools if formatted_tools else None,
+                            reasoning_steps=reasoning_steps
+                        )
+                    else:
+                        # Process as regular non-streaming response
+                        final_response = client.chat.completions.create(
+                            model=self.llm,
+                            messages=messages,
+                            temperature=temperature,
+                            tools=formatted_tools if formatted_tools else None,
+                            stream=False
+                        )
 
-                for tool_call in tool_calls:
-                    function_name = tool_call.function.name
-                    arguments = json.loads(tool_call.function.arguments)
+                    tool_calls = getattr(final_response.choices[0].message, 'tool_calls', None)
 
-                    if self.verbose:
-                        display_tool_call(f"Agent {self.name} is calling function '{function_name}' with arguments: {arguments}")
+                    if tool_calls:
+                        messages.append({
+                            "role": "assistant", 
+                            "content": final_response.choices[0].message.content,
+                            "tool_calls": tool_calls
+                        })
 
-                    tool_result = self.execute_tool(function_name, arguments)
-                    results_str = json.dumps(tool_result) if tool_result else "Function returned an empty output"
+                        for tool_call in tool_calls:
+                            function_name = tool_call.function.name
+                            arguments = json.loads(tool_call.function.arguments)
 
-                    if self.verbose:
-                        display_tool_call(f"Function '{function_name}' returned: {results_str}")
+                            if self.verbose:
+                                display_tool_call(f"Agent {self.name} is calling function '{function_name}' with arguments: {arguments}")
 
-                    messages.append({
-                        "role": "tool",
-                        "tool_call_id": tool_call.id,
-                        "content": results_str
-                    })
+                            tool_result = self.execute_tool(function_name, arguments)
+                            results_str = json.dumps(tool_result) if tool_result else "Function returned an empty output"
 
-                # Get final response after tool calls
-                if stream:
-                    final_response = self._process_stream_response(
-                        messages, 
-                        temperature, 
-                        start_time,
-                        formatted_tools=formatted_tools if formatted_tools else None,
-                        reasoning_steps=reasoning_steps
-                    )
-                else:
-                    final_response = client.chat.completions.create(
-                        model=self.llm,
-                        messages=messages,
-                        temperature=temperature,
-                        stream=False
-                    )
+                            if self.verbose:
+                                display_tool_call(f"Function '{function_name}' returned: {results_str}")
+
+                            messages.append({
+                                "role": "tool",
+                                "tool_call_id": tool_call.id,
+                                "content": results_str
+                            })
+
+                        # Check if we should continue (for tools like sequential thinking)
+                        should_continue = False
+                        for tool_call in tool_calls:
+                            function_name = tool_call.function.name
+                            arguments = json.loads(tool_call.function.arguments)
+                            
+                            # For sequential thinking tool, check if nextThoughtNeeded is True
+                            if function_name == "sequentialthinking" and arguments.get("nextThoughtNeeded", False):
+                                should_continue = True
+                                break
+
+                        if not should_continue:
+                            # Get final response after tool calls
+                            if stream:
+                                final_response = self._process_stream_response(
+                                    messages, 
+                                    temperature, 
+                                    start_time,
+                                    formatted_tools=formatted_tools if formatted_tools else None,
+                                    reasoning_steps=reasoning_steps
+                                )
+                            else:
+                                final_response = client.chat.completions.create(
+                                    model=self.llm,
+                                    messages=messages,
+                                    temperature=temperature,
+                                    stream=False
+                                )
+                            break
+                        
+                        iteration_count += 1
+                    else:
+                        # No tool calls, we're done
+                        break
 
             return final_response
 
@@ -944,7 +1122,13 @@ Your Goal: {self.goal}
                     total_time = time.time() - start_time
                     logging.debug(f"Agent.chat completed in {total_time:.2f} seconds")
 
-                return response_text
+                # Apply guardrail validation for custom LLM response
+                try:
+                    validated_response = self._apply_guardrail_with_retry(response_text, prompt, temperature, tools)
+                    return validated_response
+                except Exception as e:
+                    logging.error(f"Agent {self.name}: Guardrail validation failed for custom LLM: {e}")
+                    return None
             except Exception as e:
                 display_error(f"Error in LLM chat: {e}")
                 return None
@@ -1032,8 +1216,20 @@ Your Goal: {self.goal}
                         display_interaction(original_prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
                         # Return only reasoning content if reasoning_steps is True
                         if reasoning_steps and hasattr(response.choices[0].message, 'reasoning_content'):
-                            return response.choices[0].message.reasoning_content
-                        return response_text
+                            # Apply guardrail to reasoning content
+                            try:
+                                validated_reasoning = self._apply_guardrail_with_retry(response.choices[0].message.reasoning_content, original_prompt, temperature, tools)
+                                return validated_reasoning
+                            except Exception as e:
+                                logging.error(f"Agent {self.name}: Guardrail validation failed for reasoning content: {e}")
+                                return None
+                        # Apply guardrail to regular response
+                        try:
+                            validated_response = self._apply_guardrail_with_retry(response_text, original_prompt, temperature, tools)
+                            return validated_response
+                        except Exception as e:
+                            logging.error(f"Agent {self.name}: Guardrail validation failed: {e}")
+                            return None
 
                     reflection_prompt = f"""
 Reflect on your previous response: '{response_text}'.
@@ -1066,7 +1262,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             self.chat_history.append({"role": "user", "content": prompt})
                             self.chat_history.append({"role": "assistant", "content": response_text})
                             display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
-                            return response_text
+                            # Apply guardrail validation after satisfactory reflection
+                            try:
+                                validated_response = self._apply_guardrail_with_retry(response_text, prompt, temperature, tools)
+                                return validated_response
+                            except Exception as e:
+                                logging.error(f"Agent {self.name}: Guardrail validation failed after reflection: {e}")
+                                return None
 
                         # Check if we've hit max reflections
                         if reflection_count >= self.max_reflect - 1:
@@ -1075,7 +1277,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             self.chat_history.append({"role": "user", "content": prompt})
                             self.chat_history.append({"role": "assistant", "content": response_text})
                             display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
-                            return response_text
+                            # Apply guardrail validation after max reflections
+                            try:
+                                validated_response = self._apply_guardrail_with_retry(response_text, prompt, temperature, tools)
+                                return validated_response
+                            except Exception as e:
+                                logging.error(f"Agent {self.name}: Guardrail validation failed after max reflections: {e}")
+                                return None
 
                         logging.debug(f"{self.name} reflection count {reflection_count + 1}, continuing reflection process")
                         messages.append({"role": "user", "content": "Now regenerate your response using the reflection you made"})
@@ -1099,8 +1307,16 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
         if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
             total_time = time.time() - start_time
             logging.debug(f"Agent.chat completed in {total_time:.2f} seconds")
-            
-        return response_text
+        
+        # Apply guardrail validation before returning    
+        try:
+            validated_response = self._apply_guardrail_with_retry(response_text, prompt, temperature, tools)
+            return validated_response
+        except Exception as e:
+            logging.error(f"Agent {self.name}: Guardrail validation failed: {e}")
+            if self.verbose:
+                display_error(f"Guardrail validation failed: {e}", console=self.console)
+            return None
 
     def clean_json_output(self, output: str) -> str:
         """Clean and extract JSON from response text."""
@@ -1670,6 +1886,7 @@ Your Goal: {self.goal}
                 import threading
                 import time
                 import inspect
+                import asyncio  # Import asyncio in the MCP scope
                 # logging is already imported at the module level
                 
             except ImportError as e:

praisonaiagents/llm/llm.py

@@ -413,24 +413,30 @@ class LLM:
             start_time = time.time()
             reflection_count = 0
 
-            while True:
-                try:
-                    if verbose:
-                        display_text = prompt
-                        if isinstance(prompt, list):
-                            display_text = next((item["text"] for item in prompt if item["type"] == "text"), "")
-                        
-                        if display_text and str(display_text).strip():
-                            display_instruction(
-                                f"Agent {agent_name} is processing prompt: {display_text}",
-                                console=console,
-                                agent_name=agent_name,
-                                agent_role=agent_role,
-                                agent_tools=agent_tools
-                            )
+            # Display initial instruction once
+            if verbose:
+                display_text = prompt
+                if isinstance(prompt, list):
+                    display_text = next((item["text"] for item in prompt if item["type"] == "text"), "")
+                
+                if display_text and str(display_text).strip():
+                    display_instruction(
+                        f"Agent {agent_name} is processing prompt: {display_text}",
+                        console=console,
+                        agent_name=agent_name,
+                        agent_role=agent_role,
+                        agent_tools=agent_tools
+                    )
 
+            # Sequential tool calling loop - similar to agent.py
+            max_iterations = 10  # Prevent infinite loops
+            iteration_count = 0
+            final_response_text = ""
+
+            while iteration_count < max_iterations:
+                try:
                     # Get response from LiteLLM
-                    start_time = time.time()
+                    current_time = time.time()
 
                     # If reasoning_steps is True, do a single non-streaming call
                     if reasoning_steps:
@@ -445,6 +451,7 @@ class LLM:
                         )
                         reasoning_content = resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
                         response_text = resp["choices"][0]["message"]["content"]
+                        final_response = resp
                         
                         # Optionally display reasoning if present
                         if verbose and reasoning_content:
@@ -452,7 +459,7 @@ class LLM:
                                 original_prompt,
                                 f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
                                 markdown=markdown,
-                                generation_time=time.time() - start_time,
+                                generation_time=time.time() - current_time,
                                 console=console
                             )
                         else:
@@ -460,14 +467,14 @@ class LLM:
                                 original_prompt,
                                 response_text,
                                 markdown=markdown,
-                                generation_time=time.time() - start_time,
+                                generation_time=time.time() - current_time,
                                 console=console
                             )
                     
                     # Otherwise do the existing streaming approach
                     else:
                         if verbose:
-                            with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
+                            with Live(display_generating("", current_time), console=console, refresh_per_second=4) as live:
                                 response_text = ""
                                 for chunk in litellm.completion(
                                     **self._build_completion_params(
@@ -481,7 +488,7 @@ class LLM:
                                     if chunk and chunk.choices and chunk.choices[0].delta.content:
                                         content = chunk.choices[0].delta.content
                                         response_text += content
-                                        live.update(display_generating(response_text, start_time))
+                                        live.update(display_generating(response_text, current_time))
                         else:
                             # Non-verbose mode, just collect the response
                             response_text = ""
@@ -499,20 +506,20 @@ class LLM:
 
                         response_text = response_text.strip()
 
-                    # Get final completion to check for tool calls
-                    final_response = litellm.completion(
-                        **self._build_completion_params(
-                            messages=messages,
-                            tools=formatted_tools,
-                            temperature=temperature,
-                            stream=False,  # No streaming for tool call check
-                            **kwargs
+                        # Get final completion to check for tool calls
+                        final_response = litellm.completion(
+                            **self._build_completion_params(
+                                messages=messages,
+                                tools=formatted_tools,
+                                temperature=temperature,
+                                stream=False,  # No streaming for tool call check
+                                **kwargs
+                            )
                         )
-                    )
                     
                     tool_calls = final_response["choices"][0]["message"].get("tool_calls")
                     
-                    # Handle tool calls
+                    # Handle tool calls - Sequential tool calling logic
                     if tool_calls and execute_tool_fn:
                         # Convert tool_calls to a serializable format for all providers
                         serializable_tool_calls = []
@@ -535,6 +542,7 @@ class LLM:
                             "tool_calls": serializable_tool_calls
                         })
                         
+                        should_continue = False
                         for tool_call in tool_calls:
                             # Handle both object and dict access patterns
                             if isinstance(tool_call, dict):
@@ -574,6 +582,18 @@ class LLM:
                                 "content": json.dumps(tool_result) if tool_result is not None else "Function returned an empty output"
                             })
 
+                            # Check if we should continue (for tools like sequential thinking)
+                            # This mimics the logic from agent.py lines 1004-1007
+                            if function_name == "sequentialthinking" and arguments.get("nextThoughtNeeded", False):
+                                should_continue = True
+                        
+                        # If we should continue, increment iteration and continue loop
+                        if should_continue:
+                            iteration_count += 1
+                            continue
+
+                        # If we reach here, no more tool calls needed - get final response
+                        # Make one more call to get the final summary response
                         # Special handling for Ollama models that don't automatically process tool results
                         if self.model and self.model.startswith("ollama/") and tool_result:
                             # For Ollama models, we need to explicitly ask the model to process the tool results
@@ -666,115 +686,141 @@ class LLM:
                         else:
                             # Get response after tool calls with streaming
                             if verbose:
-                                with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
-                                    response_text = ""
+                                with Live(display_generating("", current_time), console=console, refresh_per_second=4) as live:
+                                    final_response_text = ""
                                     for chunk in litellm.completion(
                                         **self._build_completion_params(
                                             messages=messages,
+                                            tools=formatted_tools,
                                             temperature=temperature,
-                                            stream=True
+                                            stream=True,
+                                            **kwargs
                                         )
                                     ):
                                         if chunk and chunk.choices and chunk.choices[0].delta.content:
                                             content = chunk.choices[0].delta.content
-                                            response_text += content
-                                            live.update(display_generating(response_text, start_time))
+                                            final_response_text += content
+                                            live.update(display_generating(final_response_text, current_time))
                             else:
-                                response_text = ""
+                                final_response_text = ""
                                 for chunk in litellm.completion(
                                     **self._build_completion_params(
                                         messages=messages,
+                                        tools=formatted_tools,
                                         temperature=temperature,
-                                        stream=True
+                                        stream=True,
+                                        **kwargs
                                     )
                                 ):
                                     if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                        response_text += chunk.choices[0].delta.content
-
-                            response_text = response_text.strip()
-
-                    # Handle output formatting
-                    if output_json or output_pydantic:
-                        self.chat_history.append({"role": "user", "content": original_prompt})
-                        self.chat_history.append({"role": "assistant", "content": response_text})
+                                        final_response_text += chunk.choices[0].delta.content
+                            
+                            final_response_text = final_response_text.strip()
+                        
+                        # Display final response
                         if verbose:
-                            display_interaction(original_prompt, response_text, markdown=markdown,
-                                             generation_time=time.time() - start_time, console=console)
-                        return response_text
+                            display_interaction(
+                                original_prompt,
+                                final_response_text,
+                                markdown=markdown,
+                                generation_time=time.time() - start_time,
+                                console=console
+                            )
+                        
+                        return final_response_text
+                    else:
+                        # No tool calls, we're done with this iteration
+                        break
+                        
+                except Exception as e:
+                    logging.error(f"Error in LLM iteration {iteration_count}: {e}")
+                    break
+                    
+            # End of while loop - return final response
+            if final_response_text:
+                return final_response_text
+            
+            # No tool calls were made in this iteration, return the response
+            if verbose:
+                display_interaction(
+                    original_prompt,
+                    response_text,
+                    markdown=markdown,
+                    generation_time=time.time() - start_time,
+                    console=console
+                )
+            
+            response_text = response_text.strip()
+            
+            # Handle output formatting
+            if output_json or output_pydantic:
+                self.chat_history.append({"role": "user", "content": original_prompt})
+                self.chat_history.append({"role": "assistant", "content": response_text})
+                if verbose:
+                    display_interaction(original_prompt, response_text, markdown=markdown,
+                                     generation_time=time.time() - start_time, console=console)
+                return response_text
 
-                    if not self_reflect:
-                        if verbose:
-                            display_interaction(original_prompt, response_text, markdown=markdown,
-                                             generation_time=time.time() - start_time, console=console)
-                        # Return reasoning content if reasoning_steps is True
-                        if reasoning_steps and reasoning_content:
-                            return reasoning_content
-                        return response_text
+            if not self_reflect:
+                if verbose:
+                    display_interaction(original_prompt, response_text, markdown=markdown,
+                                     generation_time=time.time() - start_time, console=console)
+                # Return reasoning content if reasoning_steps is True
+                if reasoning_steps and reasoning_content:
+                    return reasoning_content
+                return response_text
 
-                    # Handle self-reflection
-                    reflection_prompt = f"""
+            # Handle self-reflection loop
+            while reflection_count < max_reflect:
+                # Handle self-reflection
+                reflection_prompt = f"""
 Reflect on your previous response: '{response_text}'.
 Identify any flaws, improvements, or actions.
 Provide a "satisfactory" status ('yes' or 'no').
 Output MUST be JSON with 'reflection' and 'satisfactory'.
-                    """
-                    
-                    reflection_messages = messages + [
-                        {"role": "assistant", "content": response_text},
-                        {"role": "user", "content": reflection_prompt}
-                    ]
-
-                    # If reasoning_steps is True, do a single non-streaming call to capture reasoning
-                    if reasoning_steps:
-                        reflection_resp = litellm.completion(
-                            **self._build_completion_params(
-                                messages=reflection_messages,
-                                temperature=temperature,
-                                stream=False,  # Force non-streaming
-                                response_format={"type": "json_object"},
-                                **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
-                            )
+                """
+                
+                reflection_messages = messages + [
+                    {"role": "assistant", "content": response_text},
+                    {"role": "user", "content": reflection_prompt}
+                ]
+
+                # If reasoning_steps is True, do a single non-streaming call to capture reasoning
+                if reasoning_steps:
+                    reflection_resp = litellm.completion(
+                        **self._build_completion_params(
+                            messages=reflection_messages,
+                            temperature=temperature,
+                            stream=False,  # Force non-streaming
+                            response_format={"type": "json_object"},
+                            **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                         )
-                        # Grab reflection text and optional reasoning
-                        reasoning_content = reflection_resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
-                        reflection_text = reflection_resp["choices"][0]["message"]["content"]
-
-                        # Optionally display reasoning if present
-                        if verbose and reasoning_content:
-                            display_interaction(
-                                "Reflection reasoning:",
-                                f"{reasoning_content}\n\nReflection result:\n{reflection_text}",
-                                markdown=markdown,
-                                generation_time=time.time() - start_time,
-                                console=console
-                            )
-                        elif verbose:
-                            display_interaction(
-                                "Self-reflection (non-streaming):",
-                                reflection_text,
-                                markdown=markdown,
-                                generation_time=time.time() - start_time,
-                                console=console
-                            )
-                    else:
-                        # Existing streaming approach
-                        if verbose:
-                            with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
-                                reflection_text = ""
-                                for chunk in litellm.completion(
-                                    **self._build_completion_params(
-                                        messages=reflection_messages,
-                                        temperature=temperature,
-                                        stream=True,
-                                        response_format={"type": "json_object"},
-                                        **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
-                                    )
-                                ):
-                                    if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                        content = chunk.choices[0].delta.content
-                                        reflection_text += content
-                                        live.update(display_generating(reflection_text, start_time))
-                        else:
+                    )
+                    # Grab reflection text and optional reasoning
+                    reasoning_content = reflection_resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
+                    reflection_text = reflection_resp["choices"][0]["message"]["content"]
+
+                    # Optionally display reasoning if present
+                    if verbose and reasoning_content:
+                        display_interaction(
+                            "Reflection reasoning:",
+                            f"{reasoning_content}\n\nReflection result:\n{reflection_text}",
+                            markdown=markdown,
+                            generation_time=time.time() - start_time,
+                            console=console
+                        )
+                    elif verbose:
+                        display_interaction(
+                            "Self-reflection (non-streaming):",
+                            reflection_text,
+                            markdown=markdown,
+                            generation_time=time.time() - start_time,
+                            console=console
+                        )
+                else:
+                    # Existing streaming approach
+                    if verbose:
+                        with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
                             reflection_text = ""
                             for chunk in litellm.completion(
                                 **self._build_completion_params(
@@ -786,48 +832,102 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 )
                             ):
                                 if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                    reflection_text += chunk.choices[0].delta.content
+                                    content = chunk.choices[0].delta.content
+                                    reflection_text += content
+                                    live.update(display_generating(reflection_text, start_time))
+                    else:
+                        reflection_text = ""
+                        for chunk in litellm.completion(
+                            **self._build_completion_params(
+                                messages=reflection_messages,
+                                temperature=temperature,
+                                stream=True,
+                                response_format={"type": "json_object"},
+                                **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
+                            )
+                        ):
+                            if chunk and chunk.choices and chunk.choices[0].delta.content:
+                                reflection_text += chunk.choices[0].delta.content
 
-                    try:
-                        reflection_data = json.loads(reflection_text)
-                        satisfactory = reflection_data.get("satisfactory", "no").lower() == "yes"
+                try:
+                    reflection_data = json.loads(reflection_text)
+                    satisfactory = reflection_data.get("satisfactory", "no").lower() == "yes"
+
+                    if verbose:
+                        display_self_reflection(
+                            f"Agent {agent_name} self reflection: reflection='{reflection_data['reflection']}' satisfactory='{reflection_data['satisfactory']}'",
+                            console=console
+                        )
 
+                    if satisfactory and reflection_count >= min_reflect - 1:
                         if verbose:
-                            display_self_reflection(
-                                f"Agent {agent_name} self reflection: reflection='{reflection_data['reflection']}' satisfactory='{reflection_data['satisfactory']}'",
-                                console=console
-                            )
+                            display_interaction(prompt, response_text, markdown=markdown,
+                                             generation_time=time.time() - start_time, console=console)
+                        return response_text
 
-                        if satisfactory and reflection_count >= min_reflect - 1:
-                            if verbose:
-                                display_interaction(prompt, response_text, markdown=markdown,
-                                                 generation_time=time.time() - start_time, console=console)
-                            return response_text
+                    if reflection_count >= max_reflect - 1:
+                        if verbose:
+                            display_interaction(prompt, response_text, markdown=markdown,
+                                             generation_time=time.time() - start_time, console=console)
+                        return response_text
 
-                        if reflection_count >= max_reflect - 1:
-                            if verbose:
-                                display_interaction(prompt, response_text, markdown=markdown,
-                                                 generation_time=time.time() - start_time, console=console)
-                            return response_text
-
-                        reflection_count += 1
-                        messages.extend([
-                            {"role": "assistant", "content": response_text},
-                            {"role": "user", "content": reflection_prompt},
-                            {"role": "assistant", "content": reflection_text},
-                            {"role": "user", "content": "Now regenerate your response using the reflection you made"}
-                        ])
-                        continue
-
-                    except json.JSONDecodeError:
-                        reflection_count += 1
-                        if reflection_count >= max_reflect:
-                            return response_text
-                        continue
+                    reflection_count += 1
+                    messages.extend([
+                        {"role": "assistant", "content": response_text},
+                        {"role": "user", "content": reflection_prompt},
+                        {"role": "assistant", "content": reflection_text},
+                        {"role": "user", "content": "Now regenerate your response using the reflection you made"}
+                    ])
+                    
+                    # Get new response after reflection
+                    if verbose:
+                        with Live(display_generating("", time.time()), console=console, refresh_per_second=4) as live:
+                            response_text = ""
+                            for chunk in litellm.completion(
+                                **self._build_completion_params(
+                                    messages=messages,
+                                    temperature=temperature,
+                                    stream=True,
+                                    **kwargs
+                                )
+                            ):
+                                if chunk and chunk.choices and chunk.choices[0].delta.content:
+                                    content = chunk.choices[0].delta.content
+                                    response_text += content
+                                    live.update(display_generating(response_text, time.time()))
+                    else:
+                        response_text = ""
+                        for chunk in litellm.completion(
+                            **self._build_completion_params(
+                                messages=messages,
+                                temperature=temperature,
+                                stream=True,
+                                **kwargs
+                            )
+                        ):
+                            if chunk and chunk.choices and chunk.choices[0].delta.content:
+                                response_text += chunk.choices[0].delta.content
+                    
+                    response_text = response_text.strip()
+                    continue
 
+                except json.JSONDecodeError:
+                    reflection_count += 1
+                    if reflection_count >= max_reflect:
+                        if verbose:
+                            display_interaction(prompt, response_text, markdown=markdown,
+                                             generation_time=time.time() - start_time, console=console)
+                        return response_text
+                    continue
                 except Exception as e:
                     display_error(f"Error in LLM response: {str(e)}")
                     return None
+            
+            # If we've exhausted reflection attempts
+            if verbose:
+                display_interaction(prompt, response_text, markdown=markdown,
+                                 generation_time=time.time() - start_time, console=console)
+            return response_text
 
         except Exception as error:
             display_error(f"Error in get_response: {str(error)}")

praisonaiagents/task/task.py

@@ -1,6 +1,7 @@
 import logging
 import asyncio
-from typing import List, Optional, Dict, Any, Type, Callable, Union, Coroutine, Literal
+import inspect
+from typing import List, Optional, Dict, Any, Type, Callable, Union, Coroutine, Literal, Tuple, get_args, get_origin
 from pydantic import BaseModel
 from ..main import TaskOutput
 from ..agent.agent import Agent
@@ -40,7 +41,10 @@ class Task:
         quality_check=True,
         input_file: Optional[str] = None,
         rerun: bool = False, # Renamed from can_rerun and logic inverted, default True for backward compatibility
-        retain_full_context: bool = False # By default, only use previous task output, not all previous tasks
+        retain_full_context: bool = False, # By default, only use previous task output, not all previous tasks
+        guardrail: Optional[Union[Callable[[TaskOutput], Tuple[bool, Any]], str]] = None,
+        max_retries: int = 3,
+        retry_count: int = 0
     ):
         # Add check if memory config is provided
         if memory is not None or (config and config.get('memory_config')):
@@ -80,6 +84,10 @@ class Task:
         self.quality_check = quality_check
         self.rerun = rerun # Assigning the rerun parameter
         self.retain_full_context = retain_full_context
+        self.guardrail = guardrail
+        self.max_retries = max_retries
+        self.retry_count = retry_count
+        self._guardrail_fn = None
 
         # Set logger level based on config verbose level
         verbose = self.config.get("verbose", 0)
@@ -141,6 +149,55 @@ class Task:
 
             self.output_pydantic = LoopModel
 
+        # Initialize guardrail
+        self._setup_guardrail()
+
+    def _setup_guardrail(self):
+        """Setup the guardrail function based on the provided guardrail parameter."""
+        if self.guardrail is None:
+            self._guardrail_fn = None
+            return
+            
+        if callable(self.guardrail):
+            # Validate function signature
+            sig = inspect.signature(self.guardrail)
+            positional_args = [
+                param for param in sig.parameters.values()
+                if param.default is inspect.Parameter.empty
+            ]
+            if len(positional_args) != 1:
+                raise ValueError("Guardrail function must accept exactly one parameter (TaskOutput)")
+            
+            # Check return annotation if present
+            return_annotation = sig.return_annotation
+            if return_annotation != inspect.Signature.empty:
+                return_annotation_args = get_args(return_annotation)
+                if not (
+                    get_origin(return_annotation) is tuple
+                    and len(return_annotation_args) == 2
+                    and return_annotation_args[0] is bool
+                    and (
+                        return_annotation_args[1] is Any
+                        or return_annotation_args[1] is str
+                        or return_annotation_args[1] is TaskOutput
+                        or return_annotation_args[1] == Union[str, TaskOutput]
+                    )
+                ):
+                    raise ValueError(
+                        "If return type is annotated, it must be Tuple[bool, Any]"
+                    )
+            
+            self._guardrail_fn = self.guardrail
+        elif isinstance(self.guardrail, str):
+            # Create LLM-based guardrail
+            from ..guardrails import LLMGuardrail
+            if not self.agent:
+                raise ValueError("Agent is required for string-based guardrails")
+            llm = getattr(self.agent, 'llm', None) or getattr(self.agent, 'llm_instance', None)
+            self._guardrail_fn = LLMGuardrail(description=self.guardrail, llm=llm)
+        else:
+            raise ValueError("Guardrail must be either a callable or a string description")
+
     def __str__(self):
         return f"Task(name='{self.name if self.name else 'None'}', description='{self.description}', agent='{self.agent.name if self.agent else 'None'}', status='{self.status}')"
 
@@ -187,6 +244,37 @@ class Task:
         logger.info(f"Task {self.id}: execute_callback called")
         logger.info(f"Quality check enabled: {self.quality_check}")
 
+        # Process guardrail if configured
+        if self._guardrail_fn:
+            try:
+                guardrail_result = self._process_guardrail(task_output)
+                if not guardrail_result.success:
+                    if self.retry_count >= self.max_retries:
+                        raise Exception(
+                            f"Task failed guardrail validation after {self.max_retries} retries. "
+                            f"Last error: {guardrail_result.error}"
+                        )
+                    
+                    self.retry_count += 1
+                    logger.warning(f"Task {self.id}: Guardrail validation failed (retry {self.retry_count}/{self.max_retries}): {guardrail_result.error}")
+                    # Note: In a real execution, this would trigger a retry, but since this is a callback
+                    # the retry logic would need to be handled at the agent/execution level
+                    return
+                
+                # If guardrail passed and returned a modified result
+                if guardrail_result.result is not None:
+                    if isinstance(guardrail_result.result, str):
+                        # Update the task output with the modified result
+                        task_output.raw = guardrail_result.result
+                    elif isinstance(guardrail_result.result, TaskOutput):
+                        # Replace with the new task output
+                        task_output = guardrail_result.result
+                
+                logger.info(f"Task {self.id}: Guardrail validation passed")
+            except Exception as e:
+                logger.error(f"Task {self.id}: Error in guardrail processing: {e}")
+                # Continue execution even if guardrail fails to avoid breaking the task
+
         # Initialize memory if not already initialized
         if not self.memory:
             self.memory = self.initialize_memory()
@@ -334,4 +422,34 @@ Context:
                 loop.run_until_complete(self.execute_callback(task_output))
         except RuntimeError:
             # If no loop is running in this context
-            asyncio.run(self.execute_callback(task_output))
+            asyncio.run(self.execute_callback(task_output))
+
+    def _process_guardrail(self, task_output: TaskOutput):
+        """Process the guardrail validation for a task output.
+        
+        Args:
+            task_output: The task output to validate
+            
+        Returns:
+            GuardrailResult: The result of the guardrail validation
+        """
+        from ..guardrails import GuardrailResult
+        
+        if not self._guardrail_fn:
+            return GuardrailResult(success=True, result=task_output)
+        
+        try:
+            # Call the guardrail function
+            result = self._guardrail_fn(task_output)
+            
+            # Convert the result to a GuardrailResult
+            return GuardrailResult.from_tuple(result)
+            
+        except Exception as e:
+            logger.error(f"Task {self.id}: Error in guardrail validation: {e}")
+            # On error, return failure
+            return GuardrailResult(
+                success=False,
+                result=None,
+                error=f"Guardrail validation error: {str(e)}"
+            )

{praisonaiagents-0.0.97.dist-info → praisonaiagents-0.0.99.dist-info}/METADATA

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

{praisonaiagents-0.0.97.dist-info → praisonaiagents-0.0.99.dist-info}/RECORD

@@ -1,9 +1,9 @@
-praisonaiagents/__init__.py,sha256=jd2-rTrVQRH7fY8gO70UZBvV0Sq6FyijUMokQHJa-q0,1368
+praisonaiagents/__init__.py,sha256=GmTiMNta4iwmfarh_6cTUpry50hpqFE8YqolrYfZ_7U,1465
 praisonaiagents/approval.py,sha256=UJ4OhfihpFGR5CAaMphqpSvqdZCHi5w2MGw1MByZ1FQ,9813
 praisonaiagents/main.py,sha256=_-XE7_Y7ChvtLQMivfNFrrnAhv4wSSDhH9WJMWlkS0w,16315
 praisonaiagents/session.py,sha256=CI-ffCiOfmgB-1zFFik9daKCB5Sm41Q9ZOaq1-oSLW8,9250
 praisonaiagents/agent/__init__.py,sha256=j0T19TVNbfZcClvpbZDDinQxZ0oORgsMrMqx16jZ-bA,128
-praisonaiagents/agent/agent.py,sha256=irU4M5n23LD57hHtB5K6FHXrWgE_p0HeCX6UuIvhMlQ,86753
+praisonaiagents/agent/agent.py,sha256=gWTkPOhNHLosZbeZSWXp9sk4H9AN531EgclHmWeZVXk,97881
 praisonaiagents/agent/image_agent.py,sha256=-5MXG594HVwSpFMcidt16YBp7udtik-Cp7eXlzLE1fY,8696
 praisonaiagents/agents/__init__.py,sha256=_1d6Pqyk9EoBSo7E68sKyd1jDRlN1vxvVIRpoMc0Jcw,168
 praisonaiagents/agents/agents.py,sha256=C_yDdJB4XUuwKA9DrysAtAj3zSYT0IKtfCT4Pxo0oyI,63309
@@ -12,7 +12,7 @@ praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9b
 praisonaiagents/knowledge/chunking.py,sha256=G6wyHa7_8V0_7VpnrrUXbEmUmptlT16ISJYaxmkSgmU,7678
 praisonaiagents/knowledge/knowledge.py,sha256=OKPar-XGyAp1ndmbOOdCgqFnTCqpOThYVSIZRxZyP58,15683
 praisonaiagents/llm/__init__.py,sha256=ttPQQJQq6Tah-0updoEXDZFKWtJAM93rBWRoIgxRWO8,689
-praisonaiagents/llm/llm.py,sha256=SzD_qoUqQnC9FpY-d1HHqKQGkIGPR5wEmE1OcqVEPFY,93577
+praisonaiagents/llm/llm.py,sha256=hoIxHzo9aNygeOiw9RtoPhpuSCVTUrKPe3OPvsT5qLc,98212
 praisonaiagents/mcp/__init__.py,sha256=ibbqe3_7XB7VrIcUcetkZiUZS1fTVvyMy_AqCSFG8qc,240
 praisonaiagents/mcp/mcp.py,sha256=_gfp8hrSVT9aPqEDDfU8MiCdg0-3dVQpEQUE6AbrJlo,17243
 praisonaiagents/mcp/mcp_sse.py,sha256=DLh3F_aoVRM1X-7hgIOWOw4FQ1nGmn9YNbQTesykzn4,6792
@@ -20,7 +20,7 @@ praisonaiagents/memory/memory.py,sha256=6tvsLWkpvyNU-t-8d6XpW7vOFUm1pNReW5B7rA8c
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
 praisonaiagents/process/process.py,sha256=gxhMXG3s4CzaREyuwE5zxCMx2Wp_b_Wd53tDfkj8Qk8,66567
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
-praisonaiagents/task/task.py,sha256=03Vcz3TaKIYnryFnKAuuQ7Ly5nTaxysFpem6sgn4gJA,15112
+praisonaiagents/task/task.py,sha256=60JE07JPpRowbEO420f4Ol49e_1AK856wSJDi_ricbg,20531
 praisonaiagents/tools/__init__.py,sha256=Rrgi7_3-yLHpfBB81WUi0-wD_wb_BsukwHVdjDYAF-0,9316
 praisonaiagents/tools/arxiv_tools.py,sha256=1stb31zTjLTon4jCnpZG5de9rKc9QWgC0leLegvPXWo,10528
 praisonaiagents/tools/calculator_tools.py,sha256=S1xPT74Geurvjm52QMMIG29zDXVEWJmM6nmyY7yF298,9571
@@ -42,7 +42,7 @@ praisonaiagents/tools/xml_tools.py,sha256=iYTMBEk5l3L3ryQ1fkUnNVYK-Nnua2Kx2S0dxN
 praisonaiagents/tools/yaml_tools.py,sha256=uogAZrhXV9O7xvspAtcTfpKSQYL2nlOTvCQXN94-G9A,14215
 praisonaiagents/tools/yfinance_tools.py,sha256=s2PBj_1v7oQnOobo2fDbQBACEHl61ftG4beG6Z979ZE,8529
 praisonaiagents/tools/train/data/generatecot.py,sha256=H6bNh-E2hqL5MW6kX3hqZ05g9ETKN2-kudSjiuU_SD8,19403
-praisonaiagents-0.0.97.dist-info/METADATA,sha256=8vBs0ezuT_KyidSMGofmM_YJTr4p9z5dUT-5o4LpohA,1452
-praisonaiagents-0.0.97.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-praisonaiagents-0.0.97.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.97.dist-info/RECORD,,
+praisonaiagents-0.0.99.dist-info/METADATA,sha256=nwlbhRlDcuelH3q-qUQS1jaEPb_CeGL849Epd6NonJM,1452
+praisonaiagents-0.0.99.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+praisonaiagents-0.0.99.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.99.dist-info/RECORD,,