driftrail 2.0.0__py3-none-any.whl

driftrail/__init__.py

@@ -0,0 +1,19 @@
+"""
+DriftRail Python SDK
+AI Safety & Observability Platform
+"""
+
+from .client import DriftRail, DriftRailAsync, DriftRailEnterprise
+from .types import IngestPayload, IngestResponse, Provider, GuardResult, GuardBlockedError
+
+__version__ = "2.0.0"
+__all__ = [
+    "DriftRail", 
+    "DriftRailAsync", 
+    "DriftRailEnterprise",
+    "IngestPayload", 
+    "IngestResponse", 
+    "Provider",
+    "GuardResult",
+    "GuardBlockedError",
+]

driftrail/client.py

@@ -0,0 +1,478 @@
+"""
+DriftRail Client - Sync and Async implementations
+"""
+
+import json
+from typing import Optional, Dict, Any, Union
+from urllib.request import Request, urlopen
+from urllib.error import HTTPError, URLError
+from concurrent.futures import ThreadPoolExecutor
+
+from .types import (
+    IngestPayload, IngestResponse, InputPayload, OutputPayload, 
+    Metadata, Provider, GuardResult, GuardBlockedError
+)
+
+DEFAULT_BASE_URL = "https://api.driftrail.com"
+
+
+class DriftRail:
+    """
+    Synchronous DriftRail client.
+    
+    Usage:
+        client = DriftRail(api_key="dr_live_...", app_id="my-app")
+        
+        response = client.ingest(
+            model="gpt-5",
+            provider="openai",
+            input={"prompt": "Hello"},
+            output={"text": "Hi there!"}
+        )
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        app_id: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: int = 30,
+        fail_open: bool = True,
+        guard_mode: str = "fail_open",
+    ):
+        """
+        Initialize DriftRail client.
+        
+        Args:
+            api_key: Your DriftRail API key (dr_live_... or dr_test_...)
+            app_id: Your application identifier
+            base_url: API base URL (default: https://api.driftrail.com)
+            timeout: Request timeout in seconds
+            fail_open: If True, errors are logged but don't raise exceptions
+            guard_mode: "fail_open" (default) or "fail_closed" for guard() calls
+        """
+        self.api_key = api_key
+        self.app_id = app_id
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.fail_open = fail_open
+        self.guard_mode = guard_mode
+        self._executor = ThreadPoolExecutor(max_workers=4)
+
+    def ingest(
+        self,
+        model: str,
+        provider: Provider,
+        input: Union[InputPayload, Dict[str, Any]],
+        output: Union[OutputPayload, Dict[str, Any]],
+        metadata: Optional[Union[Metadata, Dict[str, Any]]] = None,
+    ) -> IngestResponse:
+        """
+        Ingest an LLM interaction for classification.
+        
+        Args:
+            model: Model name (e.g., "gpt-5", "claude-3")
+            provider: Provider name ("openai", "google", "anthropic", "other")
+            input: Input payload with prompt and optional messages/sources
+            output: Output payload with text and optional tool calls
+            metadata: Optional metadata (latency, tokens, temperature)
+            
+        Returns:
+            IngestResponse with event_id and job_id on success
+        """
+        # Build payload
+        if isinstance(input, dict):
+            input_payload = InputPayload(
+                prompt=input.get("prompt", ""),
+                messages=input.get("messages"),
+                retrieved_sources=input.get("retrievedSources") or input.get("retrieved_sources"),
+            )
+        else:
+            input_payload = input
+
+        if isinstance(output, dict):
+            output_payload = OutputPayload(
+                text=output.get("text", ""),
+                tool_calls=output.get("toolCalls") or output.get("tool_calls"),
+            )
+        else:
+            output_payload = output
+
+        metadata_payload = None
+        if metadata:
+            if isinstance(metadata, dict):
+                metadata_payload = Metadata(
+                    latency_ms=metadata.get("latencyMs") or metadata.get("latency_ms"),
+                    tokens_in=metadata.get("tokensIn") or metadata.get("tokens_in"),
+                    tokens_out=metadata.get("tokensOut") or metadata.get("tokens_out"),
+                    temperature=metadata.get("temperature"),
+                )
+            else:
+                metadata_payload = metadata
+
+        payload = IngestPayload(
+            model=model,
+            provider=provider,
+            input=input_payload,
+            output=output_payload,
+            metadata=metadata_payload,
+        )
+
+        return self._send_ingest(payload)
+
+    def ingest_async(
+        self,
+        model: str,
+        provider: Provider,
+        input: Union[InputPayload, Dict[str, Any]],
+        output: Union[OutputPayload, Dict[str, Any]],
+        metadata: Optional[Union[Metadata, Dict[str, Any]]] = None,
+    ) -> None:
+        """
+        Ingest asynchronously (fire-and-forget).
+        Does not block the main thread.
+        """
+        self._executor.submit(self.ingest, model, provider, input, output, metadata)
+
+    def guard(
+        self,
+        output: str,
+        input: Optional[str] = None,
+        mode: str = "strict",
+        timeout_ms: int = 100,
+    ) -> GuardResult:
+        """
+        Inline guardrail check - blocks dangerous outputs before they reach users.
+        
+        Args:
+            output: The LLM output text to check
+            input: Optional user input/prompt for context
+            mode: "strict" (block on medium+ risk) or "permissive" (block on high only)
+            timeout_ms: Classification timeout in ms (default 100, max 500)
+            
+        Returns:
+            GuardResult with allowed, action, output (possibly redacted), triggered
+            
+        Raises:
+            GuardBlockedError: If guard_mode="fail_closed" and content is blocked
+        """
+        url = f"{self.base_url}/api/guard"
+        
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+            "X-App-Id": self.app_id,
+        }
+        
+        payload = {
+            "output": output,
+            "input": input or "",
+            "mode": mode,
+            "timeout_ms": min(timeout_ms, 500),
+            "app_id": self.app_id,
+        }
+
+        try:
+            data = json.dumps(payload).encode("utf-8")
+            req = Request(url, data=data, headers=headers, method="POST")
+            guard_timeout = max(1, timeout_ms / 1000 + 1)
+            
+            with urlopen(req, timeout=guard_timeout) as response:
+                result_data = json.loads(response.read().decode("utf-8"))
+                result = GuardResult.from_dict(result_data)
+                
+                if self.guard_mode == "fail_closed" and not result.allowed:
+                    raise GuardBlockedError(result)
+                
+                return result
+
+        except GuardBlockedError:
+            raise
+            
+        except HTTPError as e:
+            error_body = e.read().decode("utf-8") if e.fp else str(e)
+            if self.guard_mode == "fail_closed":
+                raise Exception(f"Guard API error: HTTP {e.code}: {error_body}")
+            return GuardResult(
+                allowed=True, action="allow", output=output, triggered=[],
+                latency_ms=0, fallback=True, error=f"HTTP {e.code}: {error_body}",
+            )
+
+        except (URLError, Exception) as e:
+            if self.guard_mode == "fail_closed":
+                raise Exception(f"Guard API error: {e}")
+            return GuardResult(
+                allowed=True, action="allow", output=output, triggered=[],
+                latency_ms=0, fallback=True, error=str(e),
+            )
+
+    def _send_ingest(self, payload: IngestPayload) -> IngestResponse:
+        """Send ingest request to API."""
+        url = f"{self.base_url}/ingest"
+        
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+            "X-App-Id": self.app_id,
+        }
+
+        try:
+            data = json.dumps(payload.to_dict()).encode("utf-8")
+            req = Request(url, data=data, headers=headers, method="POST")
+            
+            with urlopen(req, timeout=self.timeout) as response:
+                result = json.loads(response.read().decode("utf-8"))
+                return IngestResponse(
+                    success=result.get("success", False),
+                    event_id=result.get("event_id"),
+                    job_id=result.get("job_id"),
+                    duplicate=result.get("duplicate", False),
+                )
+
+        except HTTPError as e:
+            error_body = e.read().decode("utf-8") if e.fp else str(e)
+            if self.fail_open:
+                return IngestResponse(success=False, error=f"HTTP {e.code}: {error_body}")
+            raise
+
+        except URLError as e:
+            if self.fail_open:
+                return IngestResponse(success=False, error=f"Network error: {e.reason}")
+            raise
+
+        except Exception as e:
+            if self.fail_open:
+                return IngestResponse(success=False, error=str(e))
+            raise
+
+    def close(self) -> None:
+        """Shutdown the thread pool executor."""
+        self._executor.shutdown(wait=False)
+
+    def __enter__(self) -> "DriftRail":
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        self.close()
+
+
+
+class DriftRailAsync:
+    """
+    Async DriftRail client using aiohttp.
+    
+    Usage:
+        async with DriftRailAsync(api_key="...", app_id="my-app") as client:
+            response = await client.ingest(...)
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        app_id: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: int = 30,
+        fail_open: bool = True,
+    ):
+        self.api_key = api_key
+        self.app_id = app_id
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.fail_open = fail_open
+        self._session: Any = None
+
+    async def _get_session(self) -> Any:
+        if self._session is None:
+            try:
+                import aiohttp
+                self._session = aiohttp.ClientSession()
+            except ImportError:
+                raise ImportError("aiohttp is required for async client: pip install driftrail[async]")
+        return self._session
+
+    async def ingest(
+        self,
+        model: str,
+        provider: Provider,
+        input: Union[InputPayload, Dict[str, Any]],
+        output: Union[OutputPayload, Dict[str, Any]],
+        metadata: Optional[Union[Metadata, Dict[str, Any]]] = None,
+    ) -> IngestResponse:
+        """Async ingest - see DriftRail.ingest for documentation."""
+        import aiohttp
+
+        if isinstance(input, dict):
+            input_payload = InputPayload(
+                prompt=input.get("prompt", ""),
+                messages=input.get("messages"),
+                retrieved_sources=input.get("retrievedSources") or input.get("retrieved_sources"),
+            )
+        else:
+            input_payload = input
+
+        if isinstance(output, dict):
+            output_payload = OutputPayload(
+                text=output.get("text", ""),
+                tool_calls=output.get("toolCalls") or output.get("tool_calls"),
+            )
+        else:
+            output_payload = output
+
+        metadata_payload = None
+        if metadata:
+            if isinstance(metadata, dict):
+                metadata_payload = Metadata(
+                    latency_ms=metadata.get("latencyMs") or metadata.get("latency_ms"),
+                    tokens_in=metadata.get("tokensIn") or metadata.get("tokens_in"),
+                    tokens_out=metadata.get("tokensOut") or metadata.get("tokens_out"),
+                    temperature=metadata.get("temperature"),
+                )
+            else:
+                metadata_payload = metadata
+
+        payload = IngestPayload(
+            model=model,
+            provider=provider,
+            input=input_payload,
+            output=output_payload,
+            metadata=metadata_payload,
+        )
+
+        url = f"{self.base_url}/ingest"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+            "X-App-Id": self.app_id,
+        }
+
+        try:
+            session = await self._get_session()
+            async with session.post(
+                url,
+                json=payload.to_dict(),
+                headers=headers,
+                timeout=aiohttp.ClientTimeout(total=self.timeout),
+            ) as response:
+                result = await response.json()
+                if response.status >= 400:
+                    if self.fail_open:
+                        return IngestResponse(
+                            success=False,
+                            error=f"HTTP {response.status}: {result.get('error', 'Unknown error')}",
+                        )
+                    raise Exception(f"HTTP {response.status}: {result}")
+
+                return IngestResponse(
+                    success=result.get("success", False),
+                    event_id=result.get("event_id"),
+                    job_id=result.get("job_id"),
+                    duplicate=result.get("duplicate", False),
+                )
+
+        except Exception as e:
+            if self.fail_open:
+                return IngestResponse(success=False, error=str(e))
+            raise
+
+    async def close(self) -> None:
+        if self._session:
+            await self._session.close()
+            self._session = None
+
+    async def __aenter__(self) -> "DriftRailAsync":
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        await self.close()
+
+
+class DriftRailEnterprise(DriftRail):
+    """
+    Enterprise DriftRail client with monitoring features.
+    
+    Includes: Incidents, Compliance, Model Comparison, Exports, Brand Safety
+    """
+
+    def _api_request(self, endpoint: str, method: str = "GET", data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make an API request."""
+        url = f"{self.base_url}{endpoint}"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        try:
+            body = json.dumps(data).encode("utf-8") if data else None
+            req = Request(url, data=body, headers=headers, method=method)
+            
+            with urlopen(req, timeout=self.timeout) as response:
+                return json.loads(response.read().decode("utf-8"))
+
+        except HTTPError as e:
+            error_body = e.read().decode("utf-8") if e.fp else str(e)
+            raise Exception(f"HTTP {e.code}: {error_body}")
+
+    def list_incidents(
+        self,
+        status: Optional[list] = None,
+        severity: Optional[list] = None,
+        limit: int = 50,
+    ) -> Dict[str, Any]:
+        """List incidents with optional filters."""
+        params = []
+        if status:
+            params.append(f"status={','.join(status)}")
+        if severity:
+            params.append(f"severity={','.join(severity)}")
+        params.append(f"limit={limit}")
+        query = "&".join(params)
+        return self._api_request(f"/api/incidents?{query}")
+
+    def create_incident(
+        self,
+        title: str,
+        severity: str,
+        incident_type: str,
+        description: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Create a new incident."""
+        return self._api_request("/api/incidents", "POST", {
+            "title": title,
+            "severity": severity,
+            "incident_type": incident_type,
+            "description": description,
+        })
+
+    def get_incident_stats(self) -> Dict[str, Any]:
+        """Get incident statistics."""
+        return self._api_request("/api/incidents/stats")
+
+    def get_compliance_status(self) -> Dict[str, Any]:
+        """Get compliance framework status."""
+        return self._api_request("/api/compliance/status")
+
+    def get_model_leaderboard(self, metric: str = "avg_risk_score") -> Dict[str, Any]:
+        """Get model performance leaderboard."""
+        return self._api_request(f"/api/models/leaderboard?metric={metric}")
+
+    def create_export(
+        self,
+        export_type: str,
+        format: str = "json",
+        date_from: Optional[str] = None,
+        date_to: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Create a data export job."""
+        return self._api_request("/api/exports", "POST", {
+            "export_type": export_type,
+            "format": format,
+            "date_from": date_from,
+            "date_to": date_to,
+        })
+
+    def check_brand_safety(self, text: str, location: str = "output") -> Dict[str, Any]:
+        """Check text against brand safety rules."""
+        return self._api_request("/api/brand-safety/check", "POST", {
+            "text": text,
+            "location": location,
+        })

driftrail/types.py

@@ -0,0 +1,187 @@
+"""
+DriftRail Type Definitions
+"""
+
+from typing import Optional, List, Dict, Any, Literal
+from dataclasses import dataclass, field, asdict
+
+Provider = Literal["openai", "google", "anthropic", "other"]
+
+
+@dataclass
+class Message:
+    role: Literal["system", "user", "assistant", "tool"]
+    content: str
+    name: Optional[str] = None
+    tool_call_id: Optional[str] = None
+
+
+@dataclass
+class SourceRef:
+    id: str
+    type: Optional[str] = None
+    content: Optional[str] = None
+    url: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class ToolCall:
+    id: str
+    type: Literal["function"] = "function"
+    function: Dict[str, str] = field(default_factory=dict)
+
+
+@dataclass
+class InputPayload:
+    prompt: str
+    messages: Optional[List[Message]] = None
+    retrieved_sources: Optional[List[SourceRef]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d: Dict[str, Any] = {"prompt": self.prompt}
+        if self.messages:
+            d["messages"] = [asdict(m) for m in self.messages]
+        if self.retrieved_sources:
+            d["retrievedSources"] = [asdict(s) for s in self.retrieved_sources]
+        return d
+
+
+@dataclass
+class OutputPayload:
+    text: str
+    tool_calls: Optional[List[ToolCall]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d: Dict[str, Any] = {"text": self.text}
+        if self.tool_calls:
+            d["toolCalls"] = [asdict(t) for t in self.tool_calls]
+        return d
+
+
+@dataclass
+class Metadata:
+    latency_ms: Optional[int] = None
+    tokens_in: Optional[int] = None
+    tokens_out: Optional[int] = None
+    temperature: Optional[float] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d: Dict[str, Any] = {}
+        if self.latency_ms is not None:
+            d["latencyMs"] = self.latency_ms
+        if self.tokens_in is not None:
+            d["tokensIn"] = self.tokens_in
+        if self.tokens_out is not None:
+            d["tokensOut"] = self.tokens_out
+        if self.temperature is not None:
+            d["temperature"] = self.temperature
+        return d
+
+
+@dataclass
+class IngestPayload:
+    model: str
+    provider: Provider
+    input: InputPayload
+    output: OutputPayload
+    metadata: Optional[Metadata] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d: Dict[str, Any] = {
+            "model": self.model,
+            "provider": self.provider,
+            "input": self.input.to_dict(),
+            "output": self.output.to_dict(),
+        }
+        if self.metadata:
+            d["metadata"] = self.metadata.to_dict()
+        return d
+
+
+@dataclass
+class IngestResponse:
+    success: bool
+    event_id: Optional[str] = None
+    job_id: Optional[str] = None
+    error: Optional[str] = None
+    duplicate: bool = False
+
+
+# Guard types for inline guardrails
+
+GuardMode = Literal["strict", "permissive"]
+GuardAction = Literal["allow", "block", "redact", "warn"]
+
+
+@dataclass
+class GuardTriggered:
+    type: Literal["classification", "guardrail"]
+    name: str
+    reason: str
+
+
+@dataclass
+class GuardClassification:
+    risk_score: int
+    pii_detected: bool
+    pii_types: List[str]
+    toxicity_detected: bool
+    toxicity_severity: str
+    prompt_injection_detected: bool
+    prompt_injection_risk: str
+
+
+@dataclass
+class GuardResult:
+    """Result from inline guard check."""
+    allowed: bool
+    action: GuardAction
+    output: str
+    triggered: List[GuardTriggered]
+    latency_ms: int
+    fallback: bool
+    classification: Optional[GuardClassification] = None
+    error: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "GuardResult":
+        triggered = [
+            GuardTriggered(
+                type=t.get("type", "guardrail"),
+                name=t.get("name", "Unknown"),
+                reason=t.get("reason", ""),
+            )
+            for t in data.get("triggered", [])
+        ]
+        
+        classification = None
+        if data.get("classification"):
+            c = data["classification"]
+            classification = GuardClassification(
+                risk_score=c.get("risk_score", 0),
+                pii_detected=c.get("pii", {}).get("detected", False),
+                pii_types=c.get("pii", {}).get("types", []),
+                toxicity_detected=c.get("toxicity", {}).get("detected", False),
+                toxicity_severity=c.get("toxicity", {}).get("severity", "none"),
+                prompt_injection_detected=c.get("prompt_injection", {}).get("detected", False),
+                prompt_injection_risk=c.get("prompt_injection", {}).get("risk", "none"),
+            )
+        
+        return cls(
+            allowed=data.get("allowed", True),
+            action=data.get("action", "allow"),
+            output=data.get("output", ""),
+            triggered=triggered,
+            latency_ms=data.get("latency_ms", 0),
+            fallback=data.get("fallback", False),
+            classification=classification,
+        )
+
+
+class GuardBlockedError(Exception):
+    """Raised when content is blocked in fail_closed mode."""
+    def __init__(self, result: GuardResult):
+        self.result = result
+        reasons = [t.reason for t in result.triggered]
+        super().__init__(f"Content blocked: {'; '.join(reasons)}")

driftrail-2.0.0.dist-info/METADATA

@@ -0,0 +1,226 @@
+Metadata-Version: 2.4
+Name: driftrail
+Version: 2.0.0
+Summary: DriftRail SDK - AI Safety & Observability Platform for LLM monitoring, guardrails, and compliance
+Author-email: DriftRail <support@driftrail.com>
+Maintainer-email: DriftRail <support@driftrail.com>
+License: MIT
+Project-URL: Homepage, https://driftrail.com
+Project-URL: Documentation, https://docs.driftrail.com
+Project-URL: Repository, https://github.com/cutmob/DriftRail-Python
+Project-URL: Changelog, https://github.com/cutmob/DriftRail-Python/blob/main/CHANGELOG.md
+Project-URL: Bug Tracker, https://github.com/cutmob/DriftRail-Python/issues
+Keywords: ai,llm,observability,safety,monitoring,audit,guardrails,compliance,openai,anthropic,gemini,machine-learning,mlops
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: System :: Monitoring
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: async
+Requires-Dist: aiohttp>=3.8.0; extra == "async"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# DriftRail Python SDK
+
+[![PyPI version](https://badge.fury.io/py/driftrail.svg)](https://pypi.org/project/driftrail/)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+AI Safety & Observability Platform — Monitor, classify, and audit every LLM interaction.
+
+## Installation
+
+```bash
+pip install driftrail
+
+# For async support
+pip install driftrail[async]
+```
+
+## Quick Start
+
+```python
+from driftrail import DriftRail
+
+client = DriftRail(
+    api_key="dr_live_...",
+    app_id="my-app"
+)
+
+# Log an LLM interaction
+response = client.ingest(
+    model="claude-sonnet-4",
+    provider="anthropic",
+    input={"prompt": "What is the capital of France?"},
+    output={"text": "The capital of France is Paris."}
+)
+
+print(f"Event ID: {response.event_id}")
+```
+
+## Inline Guardrails
+
+Block dangerous outputs BEFORE they reach users:
+
+```python
+from driftrail import DriftRail
+
+client = DriftRail(api_key="...", app_id="my-app")
+
+# Get response from your LLM
+llm_response = your_llm_call(user_prompt)
+
+# Guard it before returning to user
+result = client.guard(
+    output=llm_response,
+    input=user_prompt,
+    mode="strict"  # or "permissive"
+)
+
+if result.allowed:
+    return result.output  # May be redacted if PII was found
+else:
+    print(f"Blocked: {[t.reason for t in result.triggered]}")
+    return "Sorry, I can't help with that."
+```
+
+### Guard Modes
+
+- `strict` (default): Blocks on medium+ risk (PII, moderate toxicity, prompt injection)
+- `permissive`: Only blocks on high risk (severe toxicity, high-risk injection)
+
+### Fail-Open vs Fail-Closed
+
+```python
+# Fail-open (default): If DriftRail is unavailable, content is allowed through
+client = DriftRail(api_key="...", app_id="...", guard_mode="fail_open")
+
+# Fail-closed: If DriftRail is unavailable, raises exception
+client = DriftRail(api_key="...", app_id="...", guard_mode="fail_closed")
+
+try:
+    result = client.guard(output=llm_response)
+except GuardBlockedError as e:
+    print(f"Blocked: {e.result.triggered}")
+```
+
+## Async Usage
+
+```python
+import asyncio
+from driftrail import DriftRailAsync
+
+async def main():
+    async with DriftRailAsync(api_key="...", app_id="my-app") as client:
+        response = await client.ingest(
+            model="claude-3",
+            provider="anthropic",
+            input={"prompt": "Hello"},
+            output={"text": "Hi there!"}
+        )
+
+asyncio.run(main())
+```
+
+## Fire-and-Forget (Non-blocking)
+
+```python
+# Won't block your main thread
+client.ingest_async(
+    model="gpt-4o",
+    provider="openai",
+    input={"prompt": "..."},
+    output={"text": "..."}
+)
+```
+
+> ⚠️ **Serverless Warning**: Do not use `ingest_async()` in AWS Lambda, Google Cloud Functions, or other serverless environments. Use the synchronous `ingest()` method instead.
+
+## With Metadata
+
+```python
+import time
+
+start = time.time()
+# ... your LLM call ...
+latency = int((time.time() - start) * 1000)
+
+client.ingest(
+    model="gpt-4o",
+    provider="openai",
+    input={"prompt": "..."},
+    output={"text": "..."},
+    metadata={
+        "latency_ms": latency,
+        "tokens_in": 50,
+        "tokens_out": 150,
+        "temperature": 0.7
+    }
+)
+```
+
+## With RAG Sources
+
+```python
+client.ingest(
+    model="claude-3.5-haiku",
+    provider="anthropic",
+    input={
+        "prompt": "What does our refund policy say?",
+        "retrieved_sources": [
+            {"id": "doc-123", "content": "Refunds are available within 30 days..."},
+            {"id": "doc-456", "content": "Contact support for refund requests..."}
+        ]
+    },
+    output={"text": "According to our policy, refunds are available within 30 days..."}
+)
+```
+
+## Enterprise Features
+
+```python
+from driftrail import DriftRailEnterprise
+
+client = DriftRailEnterprise(api_key="...", app_id="my-app")
+
+# Incident management
+stats = client.get_incident_stats()
+
+# Compliance status
+compliance = client.get_compliance_status()
+
+# Model leaderboard
+leaderboard = client.get_model_leaderboard(metric="avg_risk_score")
+
+# Brand safety checks
+violations = client.check_brand_safety("Some AI output text")
+```
+
+## Documentation
+
+- [Full Documentation](https://docs.driftrail.com)
+- [API Reference](https://docs.driftrail.com/api)
+- [Dashboard](https://app.driftrail.com)
+- [GitHub Repository](https://github.com/cutmob/DriftRail-Python)
+
+## License
+
+MIT

driftrail-2.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+driftrail/__init__.py,sha256=bM87N2M9Ii431s-lN2DAkMYceMauPGRSVY_Q6QB5aQ8,433
+driftrail/client.py,sha256=g4XQChRpqTXhbIQo8lisH86_Tm09MLNvTRWZrSAzUas,16470
+driftrail/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+driftrail/types.py,sha256=5WEpnl7e513b9ugtmFitC6blbMe2VC5oUV11ARYodj4,5232
+driftrail-2.0.0.dist-info/licenses/LICENSE,sha256=c9ZcDM-aSAaN2gLxDBnXkKHd9qeTS25eXQg4i2vYQcU,1066
+driftrail-2.0.0.dist-info/METADATA,sha256=y5SA5wuDhSJCDKWQgQaoPYHMvYg3IwPQL-uO3KlegWA,6334
+driftrail-2.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+driftrail-2.0.0.dist-info/top_level.txt,sha256=Ok_mUwZ0Sktm13smRuubG2jZTSyoQEwjsbrEHoqTTnU,10
+driftrail-2.0.0.dist-info/RECORD,,

driftrail-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

driftrail-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 DriftRail
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

driftrail-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+driftrail