praisonaiagents 0.0.97__py3-none-any.whl → 0.0.98__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

@@ -788,69 +788,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
 
@@ -1670,6 +1693,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/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.98.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.97
+Version: 0.0.98
 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.98.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=be5E_uEXxZo4xmRRoRQoCpZ964pzlakC_QCOOsG4rCA,88440
 praisonaiagents/agent/image_agent.py,sha256=-5MXG594HVwSpFMcidt16YBp7udtik-Cp7eXlzLE1fY,8696
 praisonaiagents/agents/__init__.py,sha256=_1d6Pqyk9EoBSo7E68sKyd1jDRlN1vxvVIRpoMc0Jcw,168
 praisonaiagents/agents/agents.py,sha256=C_yDdJB4XUuwKA9DrysAtAj3zSYT0IKtfCT4Pxo0oyI,63309
@@ -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.98.dist-info/METADATA,sha256=CGUF2azfrJRTc_js-tPZRX4-U2MIGe8v9wcCWa0pL6w,1452
+praisonaiagents-0.0.98.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+praisonaiagents-0.0.98.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.98.dist-info/RECORD,,