intercept-ai 0.3.0

Runtime enforcement layer for autonomous AI agents — intercepts tool calls, classifies risk, enforces policies, and controls execution.

Interceptor

Runtime enforcement layer for autonomous AI agents.

Interceptor intercepts tool calls before execution and applies policy enforcement, risk classification, role-based approval, and execution control — so your AI agents never run unchecked.

Installation

pip install intercept-ai

Optional Integrations

# For LangChain support
pip install "intercept-ai[langchain]"

Or install from source:

git clone https://github.com/interceptor/interceptor.git
cd interceptor
pip install -e ".[dev]"

Quick Start

from interceptor import Interceptor

guard = Interceptor(mode="strict")

decision = guard.run(
    tool_name="delete_file",
    args={"path": "/tmp/data.csv"},
    user_role="user",
)

print(decision.allowed)       # False
print(decision.risk_level)    # HIGH
print(decision.decision)      # blocked

Console output:

┌──────────── INTERCEPTOR ────────────┐
│ Risk:     HIGH                      │
│ Mode:     strict                    │
│ Decision: blocked                   │
│ Intent:   Agent intends to call     │
│           delete_file with          │
│           path=/tmp/data.csv        │
│ Reason:   HIGH risk action requires │
│           admin approval.           │
└─────────────────────────────────────┘

Strict Mode

guard = Interceptor(mode="strict")

# HIGH  → blocked (unless admin)
# MEDIUM → confirmation required
# LOW   → allowed

Balanced Mode

guard = Interceptor(mode="balanced")

# HIGH   → confirmation required
# MEDIUM → allowed with warning
# LOW    → allowed

Observe Mode

guard = Interceptor(mode="observe")

# Never blocks — logs risk and intent only

YAML Policy

Create a policy.yaml:

tools:
  delete_file:
    risk: HIGH
  write_file:
    risk: MEDIUM

keywords:
  - drop
  - overwrite

Load it:

guard = Interceptor(mode="strict", policy_path="policy.yaml")

Role-Based Approval

# Blocked for regular users
decision = guard.run("delete_file", {"path": "/data"}, user_role="user")
assert not decision.allowed

# Allowed for admins
decision = guard.run("delete_file", {"path": "/data"}, user_role="admin")
assert decision.allowed

Override Tokens

token = guard.generate_override_token()

decision = guard.run(
    "delete_file",
    {"path": "/data"},
    user_role="user",
    override_token=token,
)
assert decision.allowed  # one-time bypass

LangChain Integration

Secure any LangChain tool in one line:

from langchain_core.tools import tool
from interceptor import Interceptor
from interceptor.integrations.langchain import InterceptedTool

@tool
def delete_database(db_name: str):
    """Deletes a database."""
    return f"Deleted {db_name}"

guard = Interceptor(mode="strict")
safe_tool = InterceptedTool(tool=delete_database, guard=guard)

# If an agent tries to call this without admin role:
# result = "Error: This action was BLOCKED by security policy..."

Async Support

Interceptor supports async def tool calls and asynchronous confirmation callbacks.

@intercept(guard)
async def async_tool(data: str):
    await some_io_operation(data)

# Or manually
decision = await guard.arun("tool_name", {"arg": "val"})

Session Reports

Get an intelligent summary of your agent's behavior at the end of a session:

guard.print_report()

This generates a colorful terminal dashboard with an Agent Score, threats caught, and smart tips to save LLM tokens.

License

MIT