Integrate Runtime Guard
in 15 Minutes

import openai
from verisigil import VeriSigilGuard

client = openai.OpenAI()
guard  = VeriSigilGuard(agent_id="vsa_your_agent_id")

def handle_tool_call(tool_call):
    # Map OpenAI function name to action type
    action_map = {
        "send_payment":   "payment",
        "query_database": "data_access",
        "send_email":     "send_email",
        "delete_record":  "delete_records",
    }
    action_type = action_map.get(tool_call.function.name, "api_call")

    # Verify before executing
    result = guard.verify(
        action_type=action_type,
        action_details=tool_call.function.arguments,
        resource=tool_call.function.name
    )

    if result["decision"] != "ALLOW":
        return {"error": result["reason"], "decision": result["decision"]}

    # Approved — execute the function
    return execute_function(tool_call)

from crewai import Agent, Task, Crew
from verisigil import VeriSigilGuard

guard = VeriSigilGuard(agent_id="vsa_your_agent_id")

# Create a guarded tool wrapper
def guarded_database_write(data: dict) -> str:
    """Write data to database — verified by VeriSigil first."""
    guard.allow_or_raise(
        action_type="data_access",
        action_details={"contains_pii": False, "operation": "write"},
        resource="production_database"
    )
    # Verified — write to database
    return database_write(data)

# Attach to your CrewAI agent as a tool
finance_agent = Agent(
    role="Finance Analyst",
    goal="Process financial transactions safely",
    tools=[guarded_database_write],
    verbose=True
)

import autogen
from verisigil import VeriSigilGuard

guard = VeriSigilGuard(agent_id="vsa_your_agent_id")

class GuardedUserProxy(autogen.UserProxyAgent):
    """UserProxyAgent with VeriSigil Runtime Guard."""

    def execute_code_blocks(self, code_blocks):
        # Verify before any code execution
        guard.allow_or_raise(
            action_type="tool_use",
            action_details={
                "tool_name": "code_execution",
                "language": code_blocks[0][0] if code_blocks else "unknown"
            },
            resource="code_executor"
        )
        # Approved — execute normally
        return super().execute_code_blocks(code_blocks)

# Use in your AutoGen workflow
proxy = GuardedUserProxy(name="guarded_proxy")

import requests, os

API_KEY  = os.getenv("VERISIGIL_API_KEY")
BASE_URL = "https://verisigil-api-production.up.railway.app"

def verify_before_execution(agent_id, action_type, action_details, resource):
    resp = requests.post(
        f"{BASE_URL}/v1/guard/verify",
        headers={"x-api-key": API_KEY, "Content-Type": "application/json"},
        json={
            "agent_id":       agent_id,
            "action_type":   action_type,
            "action_details": action_details,
            "resource":      resource,
            "context":       "production"
        },
        timeout=10
    )
    return resp.json()

# Usage example
result = verify_before_execution(
    agent_id="vsa_your_agent_id",
    action_type="payment",
    action_details={"amount_usd": 5000, "recipient": "vendor@company.com"},
    resource="stripe_api"
)

if result["decision"] == "ALLOW":
    execute_payment()
elif result["decision"] == "REQUIRE_HUMAN_APPROVAL":
    notify_human(result["reason"])
else:
    block_and_log(result["reason"])