praisonaiagents 0.0.96__py3-none-any.whl → 0.0.98__py3-none-any.whl

praisonaiagents/__init__.py

@@ -11,6 +11,8 @@ from .agents.autoagents import AutoAgents
 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,
@@ -40,6 +42,7 @@ __all__ = [
     'TaskOutput',
     'ReflectionOutput',
     'AutoAgents',
+    'Session',
     'display_interaction',
     'display_self_reflection',
     'display_instruction',
@@ -53,5 +56,7 @@ __all__ = [
     'async_display_callbacks',
     'Knowledge',
     'Chunking',
-    'MCP'
+    'MCP',
+    'GuardrailResult',
+    'LLMGuardrail'
 ] 

praisonaiagents/agent/agent.py

@@ -16,7 +16,8 @@ from ..main import (
     display_self_reflection,
     ReflectionOutput,
     client,
-    adisplay_instruction
+    adisplay_instruction,
+    approval_callback
 )
 import inspect
 import uuid
@@ -570,6 +571,35 @@ Your Goal: {self.goal}
         """
         logging.debug(f"{self.name} executing tool {function_name} with arguments: {arguments}")
 
+        # Check if approval is required for this tool
+        from ..approval import is_approval_required, console_approval_callback, get_risk_level, mark_approved, ApprovalDecision
+        if is_approval_required(function_name):
+            risk_level = get_risk_level(function_name)
+            logging.info(f"Tool {function_name} requires approval (risk level: {risk_level})")
+            
+            # Use global approval callback or default console callback
+            callback = approval_callback or console_approval_callback
+            
+            try:
+                decision = callback(function_name, arguments, risk_level)
+                if not decision.approved:
+                    error_msg = f"Tool execution denied: {decision.reason}"
+                    logging.warning(error_msg)
+                    return {"error": error_msg, "approval_denied": True}
+                
+                # Mark as approved in context to prevent double approval in decorator
+                mark_approved(function_name)
+                
+                # Use modified arguments if provided
+                if decision.modified_args:
+                    arguments = decision.modified_args
+                    logging.info(f"Using modified arguments: {arguments}")
+                    
+            except Exception as e:
+                error_msg = f"Error during approval process: {str(e)}"
+                logging.error(error_msg)
+                return {"error": error_msg, "approval_error": True}
+
         # Special handling for MCP tools
         # Check if tools is an MCP instance with the requested function name
         from ..mcp.mcp import MCP
@@ -758,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
-                    )
+                # 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
+                        )
 
-            tool_calls = getattr(final_response.choices[0].message, 'tool_calls', None)
+                    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
-                })
+                    if tool_calls:
+                        messages.append({
+                            "role": "assistant", 
+                            "content": final_response.choices[0].message.content,
+                            "tool_calls": tool_calls
+                        })
 
-                for tool_call in tool_calls:
-                    function_name = tool_call.function.name
-                    arguments = json.loads(tool_call.function.arguments)
+                        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"Agent {self.name} is calling function '{function_name}' with arguments: {arguments}")
+                            if self.verbose:
+                                display_tool_call(f"Agent {self.name} is calling function '{function_name}' with arguments: {arguments}")
 
-                    tool_result = self.execute_tool(function_name, arguments)
-                    results_str = json.dumps(tool_result) if tool_result else "Function returned an empty output"
+                            tool_result = self.execute_tool(function_name, arguments)
+                            results_str = json.dumps(tool_result) if tool_result else "Function returned an empty output"
 
-                    if self.verbose:
-                        display_tool_call(f"Function '{function_name}' returned: {results_str}")
+                            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
-                    })
+                            messages.append({
+                                "role": "tool",
+                                "tool_call_id": tool_call.id,
+                                "content": results_str
+                            })
 
-                # 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
-                    )
+                        # 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
 
@@ -982,43 +1035,7 @@ Your Goal: {self.goal}
                     if not response:
                         return None
 
-                    tool_calls = getattr(response.choices[0].message, 'tool_calls', None)
                     response_text = response.choices[0].message.content.strip()
-                    if tool_calls: ## TODO: Most likely this tool call is already called in _chat_completion, so maybe we can remove this.
-                        messages.append({
-                            "role": "assistant",
-                            "content": response_text,
-                            "tool_calls": tool_calls
-                        })
-                        
-                        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"Agent {self.name} is calling function '{function_name}' with arguments: {arguments}", console=self.console)
-
-                            tool_result = self.execute_tool(function_name, arguments)
-
-                            if tool_result:
-                                if self.verbose:
-                                    display_tool_call(f"Function '{function_name}' returned: {tool_result}", console=self.console)
-                                messages.append({
-                                    "role": "tool",
-                                    "tool_call_id": tool_call.id,
-                                    "content": json.dumps(tool_result)
-                                })
-                            else:
-                                messages.append({
-                                    "role": "tool",
-                                    "tool_call_id": tool_call.id,
-                                    "content": "Function returned an empty output"
-                                })
-                            
-                        response = self._chat_completion(messages, temperature=temperature, stream=stream)
-                        if not response:
-                            return None
-                        response_text = response.choices[0].message.content.strip()
 
                     # Handle output_json or output_pydantic if specified
                     if output_json or output_pydantic:
@@ -1418,6 +1435,21 @@ Your Goal: {self.goal}
         """Async version of execute_tool"""
         try:
             logging.info(f"Executing async tool: {function_name} with arguments: {arguments}")
+            
+            # Check if approval is required for this tool
+            from ..approval import is_approval_required, request_approval
+            if is_approval_required(function_name):
+                decision = await request_approval(function_name, arguments)
+                if not decision.approved:
+                    error_msg = f"Tool execution denied: {decision.reason}"
+                    logging.warning(error_msg)
+                    return {"error": error_msg, "approval_denied": True}
+                
+                # Use modified arguments if provided
+                if decision.modified_args:
+                    arguments = decision.modified_args
+                    logging.info(f"Using modified arguments: {arguments}")
+            
             # Try to find the function in the agent's tools list first
             func = None
             for tool in self.tools:
@@ -1661,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/agents/agents.py

@@ -63,7 +63,6 @@ def process_task_context(context_item, verbose=0, user_id=None):
     """
     Process a single context item for task execution.
     This helper function avoids code duplication between async and sync execution methods.
-    
     Args:
         context_item: The context item to process (can be string, list, task object, or dict)
         verbose: Verbosity level for logging
@@ -203,7 +202,6 @@ class PraisonAIAgents:
                 mem_cfg = memory_config
                 if not mem_cfg:
                     mem_cfg = next((t.config.get('memory_config') for t in tasks if hasattr(t, 'config') and t.config), None)
-                    
                 # Set default memory config if none provided
                 if not mem_cfg:
                     mem_cfg = {
@@ -215,7 +213,6 @@ class PraisonAIAgents:
                         },
                         "rag_db_path": "./.praison/chroma_db"
                     }
-                
                 # Add embedder config if provided
                 if embedder:
                     if isinstance(embedder, dict):
@@ -231,17 +228,14 @@ class PraisonAIAgents:
                     self.shared_memory = Memory(config=mem_cfg, verbose=verbose)
                     if verbose >= 5:
                         logger.info("Initialized shared memory for PraisonAIAgents")
-                    
                     # Distribute memory to tasks
                     for task in tasks:
                         if not task.memory:
                             task.memory = self.shared_memory
                             if verbose >= 5:
                                 logger.info(f"Assigned shared memory to task {task.id}")
-                            
             except Exception as e:
                 logger.error(f"Failed to initialize shared memory: {e}")
-            
         # Update tasks with shared memory
         if self.shared_memory:
             for task in tasks:
@@ -898,6 +892,105 @@ Context:
     def clear_state(self) -> None:
         """Clear all state values"""
         self._state.clear()
+    
+    # Convenience methods for enhanced state management
+    def has_state(self, key: str) -> bool:
+        """Check if a state key exists"""
+        return key in self._state
+    
+    def get_all_state(self) -> Dict[str, Any]:
+        """Get a copy of the entire state dictionary"""
+        return self._state.copy()
+    
+    def delete_state(self, key: str) -> bool:
+        """Delete a state key if it exists. Returns True if deleted, False if key didn't exist."""
+        if key in self._state:
+            del self._state[key]
+            return True
+        return False
+    
+    def increment_state(self, key: str, amount: float = 1, default: float = 0) -> float:
+        """Increment a numeric state value. Creates the key with default if it doesn't exist."""
+        current = self._state.get(key, default)
+        if not isinstance(current, (int, float)):
+            raise TypeError(f"Cannot increment non-numeric value at key '{key}': {type(current).__name__}")
+        new_value = current + amount
+        self._state[key] = new_value
+        return new_value
+    
+    def append_to_state(self, key: str, value: Any, max_length: Optional[int] = None) -> List[Any]:
+        """Append a value to a list state. Creates the list if it doesn't exist.
+        
+        Args:
+            key: State key
+            value: Value to append
+            max_length: Optional maximum length for the list
+            
+        Returns:
+            The updated list
+            
+        Raises:
+            TypeError: If the existing value is not a list and convert_to_list=False
+        """
+        if key not in self._state:
+            self._state[key] = []
+        elif not isinstance(self._state[key], list):
+            # Be explicit about type conversion for better user experience
+            current_value = self._state[key]
+            self._state[key] = [current_value]
+        
+        self._state[key].append(value)
+        
+        # Trim list if max_length is specified
+        if max_length and len(self._state[key]) > max_length:
+            self._state[key] = self._state[key][-max_length:]
+        
+        return self._state[key]
+    
+    def save_session_state(self, session_id: str, include_memory: bool = True) -> None:
+        """Save current state to memory for session persistence"""
+        if self.shared_memory and include_memory:
+            state_data = {
+                "session_id": session_id,
+                "user_id": self.user_id,
+                "run_id": self.run_id,
+                "state": self._state,
+                "agents": [agent.name for agent in self.agents],
+                "process": self.process
+            }
+            self.shared_memory.store_short_term(
+                text=f"Session state for {session_id}",
+                metadata={
+                    "type": "session_state",
+                    "session_id": session_id,
+                    "user_id": self.user_id,
+                    "state_data": state_data
+                }
+            )
+    
+    def restore_session_state(self, session_id: str) -> bool:
+        """Restore state from memory for session persistence. Returns True if restored."""
+        if not self.shared_memory:
+            return False
+        
+        # Use metadata-based search for better SQLite compatibility
+        results = self.shared_memory.search_short_term(
+            query=f"type:session_state",
+            limit=10  # Get more results to filter by session_id
+        )
+        
+        # Filter results by session_id in metadata
+        for result in results:
+            metadata = result.get("metadata", {})
+            if (metadata.get("type") == "session_state" and 
+                metadata.get("session_id") == session_id):
+                state_data = metadata.get("state_data", {})
+                if "state" in state_data:
+                    # Merge with existing state instead of replacing
+                    self._state.update(state_data["state"])
+                    return True
+        
+        return False
         
     def launch(self, path: str = '/agents', port: int = 8000, host: str = '0.0.0.0', debug: bool = False, protocol: str = "http"):
         """