# Example: Python integration with Anthropic SDK
import anthropic
import requests

client = anthropic.Anthropic()
GUARDRAIL_URL = "http://localhost:9090/check"

def check_with_guardrail(tool_name, target, params=None):
    """Send a tool call to the guardrail and return verdict."""
    response = requests.post(GUARDRAIL_URL, json={
        "tool_name": tool_name,
        "target": target,
        "params": params or {}
    })
    response.raise_for_status()
    return response.json()

# In your tool use loop:
def handle_tool_call(tool_name, tool_input):
    target = tool_input.get("command", "") if tool_name == "Bash" else str(tool_input)
    result = check_with_guardrail(tool_name, target, tool_input)

    if result["verdict"] == "allow":
        # Execute the tool call normally
        return execute_tool(tool_name, tool_input)
    elif result["verdict"] == "deny":
        return f"Guardrail blocked this operation: {result['reason']}"
    else:  # escalate
        return f"Guardrail escalated for review: {result['reason']}"

# Example: Integration with OpenAI function calling
from openai import OpenAI
import requests

client = OpenAI()
GUARDRAIL_URL = "http://localhost:9090/check"

def guardrail_check(tool_name, target, params=None):
    resp = requests.post(GUARDRAIL_URL, json={
        "tool_name": tool_name,
        "target": target,
        "params": params or {}
    })
    return resp.json()

# Wrapper around tool execution:
def guarded_function_call(name, arguments):
    # Map OpenAI tool name to guardrail tool name
    guardrail_name = name

    # Determine target based on tool
    if "command" in arguments:
        target = arguments["command"]
    elif "path" in arguments:
        target = arguments["path"]
    elif "url" in arguments:
        target = arguments["url"]
    else:
        target = json.dumps(arguments)

    result = guardrail_check(guardrail_name, target, arguments)

    if result["verdict"] == "allow":
        return execute_function(name, arguments)
    elif result["verdict"] == "deny":
        return json.dumps({"error": "blocked", "reason": result["reason"]})
    else:
        return json.dumps({"error": "escalated", "reason": result["reason"]})

# Example: Custom LangChain callback that checks with guardrail
from langchain.tools import BaseTool
from langchain.callbacks.base import BaseCallbackHandler
import requests

GUARDRAIL_URL = "http://localhost:9090/check"

class GuardrailCallback(BaseCallbackHandler):
    """LangChain callback handler that checks tool calls against guardrail."""

    def on_tool_start(self, tool_name, tool_input, **kwargs):
        # Determine target
        if isinstance(tool_input, dict):
            target = tool_input.get("command") or tool_input.get("path") or str(tool_input)
            params = tool_input
        else:
            target = str(tool_input)
            params = {"input": tool_input}

        response = requests.post(GUARDRAIL_URL, json={
            "tool_name": tool_name,
            "target": target,
            "params": params
        })
        result = response.json()

        if result["verdict"] == "deny":
            raise ValueError(f"Guardrail denied: {result['reason']}")
        elif result["verdict"] == "escalate":
            # Log escalation — in production, escalate to human
            print(f"Guardrail escalated: {result['reason']}")

        return result["verdict"] == "allow"

# Usage:
# agent = create_react_agent(llm, tools, callbacks=[GuardrailCallback()])

# Example: MCP server with guardrail middleware
from mcp.server.fastmcp import FastMCP
import requests

GUARDRAIL_URL = "http://localhost:9090/check"

mcp = FastMCP("MyServer")

# Guardrail middleware for MCP tools
def guardrail_wrapper(func):
    async def wrapper(name, arguments):
        result = requests.post(GUARDRAIL_URL, json={
            "tool_name": f"mcp__{name}",
            "target": arguments.get("path") or arguments.get("url") or str(arguments),
            "params": arguments
        }).json()

        if result["verdict"] == "deny":
            raise PermissionError(f"Guardrail blocked: {result['reason']}")
        elif result["verdict"] == "escalate":
            print(f"Guardrail escalated: {result['reason']}")

        return await func(name, arguments)
    return wrapper

# Decorate tools with guardrail
@mcp.tool()
@guardrail_wrapper
async def read_file(name, arguments):
    # Original tool implementation
    pass

use ellm_guardrail::pipeline::GuardrailPipeline;

let mut pipeline = GuardrailPipeline::deterministic_only();

// Check a Read tool call
let result = pipeline.check("Read", "src/main.rs", &[]);
assert_eq!(result.verdict, Verdict::Allow);

// Check a Bash tool call
let result = pipeline.check("Bash", "rm -rf /", &[]);
assert_eq!(result.verdict, Verdict::Deny);

// Check with parameters — param-trap triggered
let result = pipeline.check("Read", "id_rsa", &[
    ("cmd".into(), "rm -rf /".into()),
]);
assert_eq!(result.verdict, Verdict::Deny);

{
  "tool_name": "Bash",
  "target": "rm -rf /",
  "params": {
    "timeout": "60000",
    "description": "cleanup temp files"
  }
}

{
  "verdict": "deny",
  "tier": "deterministic",
  "action": "rm_rf",
  "confidence": "high",
  "strategy": "exact_command",
  "reason": "rm with destructive flags",
  "ellm_trace": ["rm_rf --rel1--> destructive_op", "destructive_op --rel225--> rm_rf"],
  "llm_outcome": null,
  "latencies": {
    "mapper_us": 6,
    "ellm_us": 9,
    "llm_us": 0,
    "total_us": 15
  },
  "service_wall_us": 45
}

{
  "error": "invalid JSON: missing field `tool_name`"
}

{
  "status": "ok"
}

{
  "total_checks": 12345,
  "allow_count": 11000,
  "deny_count": 1000,
  "escalate_count": 345,
  "avg_latency_us": 19
}

{
  "service": "ellm-guardrail",
  "version": "0.1.0",
  "endpoints": ["POST /check", "GET /health", "GET /metrics"]
}