Python SDK

pip install veto

pip install veto[openai]      # OpenAI support
pip install veto[anthropic]   # Anthropic support
pip install veto[gemini]      # Google Gemini support
pip install veto[all]         # All providers

from veto import protect

safe_tools = await protect(tools)

safe_tool = await protect(tool)

safe_tools = await protect(tools, pack="financial")
safe_tools_cloud = await protect(tools, api_key="veto_...")
safe_tools_log = await protect(tools, mode="log")
safe_tools_shadow = await protect(tools, mode="shadow")

from veto import Veto

veto = await Veto.init()

from veto import Veto, VetoOptions

veto = await Veto.init(VetoOptions(
    api_key="veto_abc123...",
    base_url="https://api.runveto.com",
    mode="strict",
    on_approval_required=my_approval_handler,
    approval_poll_interval=2.0,   # seconds
    approval_timeout=300.0,       # seconds
))

wrapped_tools = veto.wrap(my_tools)

safe_tool = veto.wrap_tool(my_tool)

from veto import Veto, GuardResult

veto = await Veto.init()

result: GuardResult = await veto.guard(
    "wire_transfer",
    {"amount": 25000, "recipient": "vendor-123"},
    session_id="session-42",
    agent_id="agent-7",
)

if result.decision == "deny":
    print(result.reason)

@dataclass
class GuardResult:
    decision: Literal["allow", "deny", "require_approval"]
    reason: str | None = None
    rule_id: str | None = None
    severity: Literal["critical", "high", "medium", "low", "info"] | None = None
    approval_id: str | None = None
    shadow: bool | None = None
    shadow_decision: str | None = None

stats = veto.get_history_stats()
# {"total_calls": 5, "allowed_calls": 4, "denied_calls": 1, ...}

veto.clear_history()

from veto.core.interceptor import ToolCallDeniedError

try:
    await wrapped_tool.ainvoke(args)
except ToolCallDeniedError as e:
    print(e.tool_name)   # "transfer_funds"
    print(e.reason)      # "Amount 5000 exceeds limit of 1000"
    print(e.call_id)     # "tc_abc123"

from veto.cloud.client import ApprovalTimeoutError

try:
    await wrapped_tool.ainvoke(args)
except ApprovalTimeoutError as e:
    print(e.approval_id)  # "apr_abc123"
    print(e.timeout)      # 300.0

async def handle_approval(context, approval_id):
    print(f"Tool '{context.tool_name}' needs approval: {approval_id}")

veto = await Veto.init(VetoOptions(
    on_approval_required=handle_approval,
))

# Auto-approve all future calls to "read_file"
veto.set_approval_preference("read_file", "approve_all")

# Auto-deny all future calls to "delete_database"
veto.set_approval_preference("delete_database", "deny_all")

# Check current preference
veto.get_approval_preference("read_file")  # "approve_all"

# Clear preference for one tool
veto.clear_approval_preferences("read_file")

# Clear all preferences
veto.clear_approval_preferences()

from veto.cloud.client import VetoCloudClient, VetoCloudConfig

client = VetoCloudClient(
    config=VetoCloudConfig(
        api_key="veto_abc123...",
        base_url="https://api.runveto.com",
        timeout=30000,
        retries=2,
    ),
)

result = await client.validate("send_email", {
    "to": "user@example.com",
    "subject": "Hello",
})
# ValidationResponse(decision="allow"|"deny"|"require_approval", reason=..., approval_id=...)

from veto.cloud.types import ApprovalPollOptions

approval = await client.poll_approval("apr_abc123", ApprovalPollOptions(
    poll_interval=2.0,  # seconds
    timeout=300.0,      # seconds
))
# ApprovalData(id=..., status="approved"|"denied"|"expired", resolved_by=...)

policy = await client.fetch_policy("send_email")
# dict with toolName, mode, constraints, etc.
# Returns None on error

client.log_decision({
    "tool_name": "send_email",
    "arguments": {"to": "user@example.com"},
    "decision": "allow",
    "mode": "deterministic",
    "latency_ms": 2,
    "source": "client",
})

from veto.cloud.types import ToolRegistration, ToolParameter

await client.register_tools([
    ToolRegistration(
        name="send_email",
        description="Send an email",
        parameters=[
            ToolParameter(name="to", type="string", required=True),
            ToolParameter(name="subject", type="string", required=True),
            ToolParameter(name="body", type="string", required=True),
        ],
    ),
])

json_data = veto.export_decisions()  # JSON by default
csv_data = veto.export_decisions(format="csv")