Error Handling

{
  "error": {
    "code": "policy_violation",
    "message": "Action blocked by policy: block-pii-sharing",
    "status": 403,
    "details": {
      "policy_name": "block-pii-sharing",
      "agent_id": "agent-123",
      "violation_type": "pii_detected"
    },
    "request_id": "req_abc123def456",
    "documentation_url": "https://docs.tork.network/errors/policy_violation"
  }
}

from tork_governance import TorkClient
from tork_governance.exceptions import (
    TorkAPIError,
    PolicyViolationError,
    BudgetExceededError,
    ApprovalRequiredError,
    RateLimitError
)

client = TorkClient()

try:
    result = client.policies.check(
        agent_id="agent-123",
        action_type="send_email",
        content="..."
    )
except PolicyViolationError as e:
    print(f"Policy blocked: {e.policy_name}")
    print(f"Reason: {e.message}")
    # Log for audit, notify user

except BudgetExceededError as e:
    print(f"Budget exceeded: {e.overage}")
    # Queue for later or request budget increase

except ApprovalRequiredError as e:
    print(f"Approval needed: {e.approval_id}")
    # Wait for approval or notify approvers

except RateLimitError as e:
    print(f"Rate limited, retry after: {e.retry_after}s")
    time.sleep(e.retry_after)
    # Retry the request

except TorkAPIError as e:
    print(f"API error: {e.code} - {e.message}")
    print(f"Request ID: {e.request_id}")
    # Log and handle gracefully

import time
from tork_governance.exceptions import TorkAPIError, RateLimitError

def with_retry(func, max_retries=3):
    """Execute function with exponential backoff."""
    for attempt in range(max_retries):
        try:
            return func()
        except RateLimitError as e:
            if attempt == max_retries - 1:
                raise
            wait = e.retry_after or (2 ** attempt)
            time.sleep(wait)
        except TorkAPIError as e:
            # Only retry on 5xx errors
            if e.status < 500 or attempt == max_retries - 1:
                raise
            time.sleep(2 ** attempt)

# Usage
result = with_retry(lambda: client.policies.check(...))