🛡️ APPROVAL REQUIRED - HIGH RISK OPERATION
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Function: delete_file
Risk Level: HIGH

Arguments:
  filepath: /home/user/important.doc

Description: This operation will permanently delete the specified file.

Options:
[A]pprove  [D]eny  [M]odify arguments  [?]Help

Your choice:

from praisonaiagents.approval import require_approval

@require_approval(risk_level="critical")
def execute_sql(query: str, database: str):
    """Execute SQL query on database"""
    # Implementation
    pass

@require_approval(risk_level="medium")
def send_email(to: str, subject: str, body: str):
    """Send email to recipient"""
    # Implementation
    pass

from praisonaiagents.approval import add_approval_requirement

# Add approval to existing function
add_approval_requirement(
    function=existing_function,
    risk_level="high"
)

# Add approval by function name
add_approval_requirement(
    function_name="dangerous_operation",
    risk_level="critical"
)

def approval_callback(function_name: str, arguments: dict, risk_level: str):
    """
    Returns:
        - ApprovalDecision(approved=True/False, modified_args=dict)
        - None to use default console approval
    """
    pass

from praisonaiagents import Agent
from praisonaiagents.approval import require_approval

# Define dangerous tools
@require_approval(risk_level="high")
def modify_database(table: str, operation: str):
    # Database modification logic
    pass

@require_approval(risk_level="critical")
def system_command(command: str):
    # System command execution
    pass

# Create agent with approval-required tools
agent = Agent(
    name="System Administrator",
    instructions="You help with system administration tasks.",
    tools=[modify_database, system_command]
)

# Tools will request approval when used
response = agent.start("Delete old logs from the database")

from praisonaiagents.tools import Tool
from praisonaiagents.approval import require_approval

class FileManager(Tool):
    @require_approval(risk_level="medium")
    def delete_files(self, pattern: str):
        """Delete files matching pattern"""
        import glob
        import os
        
        files = glob.glob(pattern)
        for file in files:
            os.remove(file)
        return f"Deleted {len(files)} files"
    
    @require_approval(risk_level="high")
    def modify_permissions(self, path: str, mode: int):
        """Change file permissions"""
        import os
        os.chmod(path, mode)
        return f"Changed permissions for {path}"

from praisonaiagents import Agent
from praisonaiagents.tools import ShellTool

# Tools automatically require approval based on risk
agent = Agent(
    name="System Admin",
    tools=[ShellTool()]  # Shell commands are high-risk
)

# When agent tries to execute a command
agent.chat("Delete all temporary files in /tmp")
# User will be prompted for approval before execution

from praisonaiagents.agents.approval import require_approval

@require_approval("high")
def delete_user_data(user_id: str):
    """Delete all data for a user - requires approval"""
    # Dangerous operation
    pass

@require_approval("critical")
async def shutdown_server():
    """Shutdown the server - requires approval"""
    await perform_shutdown()

from praisonaiagents.agents.approval import console_approval_callback

# This is used by default, but you can customize it
def my_console_approval(tool_name, risk_level, args):
    # Custom console formatting
    response = input(f"Allow {tool_name}? (y/n): ")
    return ApprovalDecision(
        approved=response.lower() == 'y',
        reason="User input"
    )

from praisonaiagents.agents.approval import ApprovalDecision

def policy_based_approval(tool_name, risk_level, args):
    # Auto-approve low risk operations
    if risk_level == "low":
        return ApprovalDecision(approved=True, reason="Auto-approved: low risk")
    
    # Block certain patterns
    if "rm -rf /" in str(args):
        return ApprovalDecision(approved=False, reason="Dangerous command pattern")
    
    # Modify arguments
    if tool_name == "write_file" and args.get("path", "").startswith("/etc"):
        return ApprovalDecision(
            approved=True,
            modified_args={**args, "path": f"/tmp{args['path']}"},
            reason="Redirected to safe location"
        )
    
    # Delegate to human for others
    return console_approval_callback(tool_name, risk_level, args)

import tkinter as tk
from tkinter import messagebox

def gui_approval_callback(tool_name, risk_level, args):
    root = tk.Tk()
    root.withdraw()
    
    message = f"Approve {tool_name} ({risk_level} risk)?\nArgs: {args}"
    approved = messagebox.askyesno("Approval Required", message)
    
    root.destroy()
    
    return ApprovalDecision(
        approved=approved,
        reason="GUI approval"
    )

from praisonaiagents.agents.approval import add_approval_requirement

# Add custom tool to approval list
add_approval_requirement("custom_dangerous_tool", "high")

# Add with specific module
add_approval_requirement("api_delete", "critical", module_name="my_api_tools")

from praisonaiagents.agents.approval import remove_approval_requirement

# Remove approval requirement
remove_approval_requirement("read_file")  # Reading files no longer requires approval

from praisonaiagents.agents.approval import is_approval_required, get_risk_level

if is_approval_required("delete_file"):
    risk = get_risk_level("delete_file")
    print(f"delete_file requires approval (risk: {risk})")

from praisonaiagents import register_approval_callback

# Register globally
register_approval_callback(policy_based_approval)

# Now all agents will use this callback
agent = Agent(
    name="Admin Bot",
    tools=[ShellTool(), FileTools()]
)

# First call - requires approval
agent.chat("Run ls -la")  # Prompts for approval

# Within same context - already approved
agent.chat("Run ls -la again")  # No prompt, uses previous approval

from praisonaiagents import Agent, register_approval_callback
from praisonaiagents.tools import ShellTool, FileTools
from praisonaiagents.agents.approval import ApprovalDecision
import logging

# Set up logging
logging.basicConfig(level=logging.INFO)

# Custom approval callback with logging
def logged_approval(tool_name, risk_level, args):
    logging.info(f"Approval requested: {tool_name} ({risk_level})")
    
    # Auto-approve read operations
    if tool_name.startswith("read_"):
        return ApprovalDecision(approved=True, reason="Read operations allowed")
    
    # Require human approval for others
    print(f"\n🛡️ Approval Required")
    print(f"Tool: {tool_name}")
    print(f"Risk: {risk_level}")
    print(f"Arguments: {args}")
    
    response = input("Approve? (y/n/m to modify): ").lower()
    
    if response == 'y':
        return ApprovalDecision(approved=True, reason="User approved")
    elif response == 'm':
        # Allow argument modification
        new_args = {}
        for key, value in args.items():
            new_val = input(f"{key} [{value}]: ") or value
            new_args[key] = new_val
        return ApprovalDecision(
            approved=True,
            modified_args=new_args,
            reason="User approved with modifications"
        )
    else:
        return ApprovalDecision(approved=False, reason="User denied")

# Register the callback
register_approval_callback(logged_approval)

# Create agent with dangerous tools
agent = Agent(
    name="System Administrator",
    role="Server management",
    goal="Maintain system health",
    tools=[ShellTool(), FileTools()]
)

# Operations will require approval
response = agent.chat("Check disk usage and clean up if needed")