Approval

from praisonaiagents import Agent

agent = Agent(
    name="Coder",
    instructions="Refactor safely",
    tools=["shell", "write_file"],
)
agent.start("Remove unused imports in utils.py")

from praisonaiagents import Agent

# All of these apply the full read-only deny set:
Agent(instructions="t", approval="read_only")
Agent(instructions="t", approval="read-only")
Agent(instructions="t", approval="READ_ONLY")
Agent(instructions="t", approval=" read-only ")

# Typo raises — no silent bypass:
Agent(instructions="t", approval="read_onl")
# ValueError: Unknown preset 'read_onl' for parameter 'approval'.
#             Did you mean 'read_only'? Valid presets: read_only, plan, ...

# Pass False explicitly if you want no approval:
Agent(instructions="t", approval=False)

from praisonaiagents import Agent, tool

@tool(approval=True)
def delete_account(user_id: str) -> str:
    """Permanently delete a user account."""
    return f"Deleted {user_id}"

agent = Agent(instructions="Help users.", tools=[delete_account])
agent.start("Delete account u_42")

from praisonaiagents import Agent

def execute_command(command: str) -> str:
    """Run a shell command."""
    ...

def read_file(path: str) -> str:
    """Read a file."""
    ...

agent = Agent(
    name="Reader",
    instructions="Help me explore the codebase",
    tools=[execute_command, read_file],
    approval="safe",   # blocks execute_command (dangerous)
)

agent.start("Show me what's in main.py")
# The model is offered ONLY read_file.
# execute_command is invisible — no denied-call loops, no wasted turns.

from praisonaiagents import Agent
from praisonaiagents.mcp import MCP

agent = Agent(
    name="Ops",
    instructions="Run ops tasks",
    tools=MCP("http://localhost:8000/sse"),
    approval={
        "permissions": {
            "tool:delete_*": "deny",   # MCP-namespaced tool names
        },
    },
)
# delete_* MCP tools never appear in the schema and are blocked at call time
# with {"permission_denied": True}.

from praisonaiagents import Agent
from praisonaiagents.approval.protocols import ApprovalConfig

# Configuration change (timeout only) — default denials PRESERVED
Agent(name="t", instructions="t", approval=ApprovalConfig(timeout=30))._perm_deny
# → includes execute_command, delete_file, kill_process, execute_code, …

# Dict form is symmetric
Agent(name="t", instructions="t", approval={"timeout": 30})._perm_deny
# → includes execute_command, …

# Explicit declarative policy — the policy owns denial, the preset does not shadow it
Agent(
    name="t",
    instructions="t",
    approval=ApprovalConfig(permissions={"bash:rm *": "deny"}),
)._perm_deny
# → frozenset()   (the PermissionManager holds the rule)

praisonai code --dangerously-skip-approval
# also sets PRAISONAI_TOOL_SAFETY=off for any subprocess tree

PRAISONAI_TOOL_SAFETY=off praisonai code

from praisonaiagents import Agent

Agent(tools=["shell", "write_file"], approval="bypass")   # silent allow
Agent(tools=["shell", "write_file"], approval=False)       # silent deny (no prompts)
Agent(tools=["shell", "write_file"], approval="safe")      # block all dangerous tools
Agent(tools=["shell", "write_file"], approval="read_only") # alias of "safe"
Agent(tools=["shell", "write_file"], approval="full")      # no restrictions

from praisonaiagents import Agent, require_approval

@require_approval(risk_level="critical")
def wipe_database(target: str) -> str:
    """Never runs unless a human says yes."""
    return f"wiped {target}"

agent = Agent(
    name="Ops",
    instructions="Only wipe when the operator approves.",
    tools=[wipe_database],
)
# If the operator denies, PermissionError is raised and wipe_database's body
# never runs. If the approval backend crashes, the same thing happens
# (fail-closed). If the operator approves with modified_args={"target": "sandbox"},
# the tool runs against 'sandbox' instead of the original argument.
agent.start("Wipe prod")

agents:
  admin:
    role: Server admin
    approval:
      enabled: true
      backend: slack
      timeout: 120
      approve_level: high
      default_policy: prompt
      approve_tools:
        shell: critical
        read_file: low

from praisonai._approval_spec import ApprovalSpec

spec = ApprovalSpec(
    enabled=True,
    default_policy="prompt",
    approve_tools={"shell": "critical"},
)
spec.install_hook()

praisonai "deploy" --approval slack --approval-timeout 120 --approve-level high

praisonai run workflow.yaml \
  --deny "bash:rm *" \
  --allow "bash:pytest *" \
  --approval console \
  --approval-timeout 60

from praisonaiagents import Agent
from praisonaiagents.approval import get_approval_registry, WebhookBackend

# Configure webhook backend for async compatibility
get_approval_registry().set_backend(
    WebhookBackend(url="http://localhost:8080/approve")
)

agent = Agent(
    name="AsyncBot",
    instructions="Process requests asynchronously",
    approval=True
)

# This now works with async agents
await agent.astart("Delete old files")

"{tool_name}:{sha256(json.dumps(arguments, sort_keys=True))[:16]}"

from praisonaiagents import Agent

agent = Agent(
    name="FileBot",
    instructions="Write files as requested",
    approval=True,
)

# First call — prompts for approval
agent.start("Write 'hello' to /tmp/a.txt")

# Second call with SAME path — no prompt (cached)
agent.start("Write 'hello again' to /tmp/a.txt")

# Third call with DIFFERENT path — prompts again
agent.start("Write 'world' to /tmp/b.txt")

mark_approved(tool_name: str, arguments: dict | None = None, agent_name: str | None = None) -> None
is_already_approved(tool_name: str, arguments: dict | None = None, agent_name: str | None = None) -> bool

approved /tmp/notes.txt: True
approved /etc/cron.d/evil: False   # was True before the fix

from praisonaiagents import Agent, require_approval

@require_approval(risk_level="high")
def write_file(path: str, content: str) -> str:
    """Write a file — a human must approve before each write."""
    with open(path, "w") as f:
        f.write(content)
    return f"wrote {path}"

agent = Agent(
    name="File Writer",
    instructions="Write user files on request.",
    tools=[write_file],
)
agent.start("Save 'hello' to notes.txt")
# → prompts, then writes notes.txt.
# A later write_file('/etc/passwd', ...) re-prompts — the earlier
# approval only covered notes.txt, not every write_file call.

from praisonaiagents.approval.registry import ApprovalRegistry

reg = ApprovalRegistry()
reg.mark_approved("write_file", {}, agent_name="permissive")
reg.is_already_approved("write_file", {}, agent_name="permissive")  # True
reg.is_already_approved("write_file", {}, agent_name="strict")      # False