sentinel-oversight 0.1.0__tar.gz

sentinel_oversight-0.1.0/.gitignore

@@ -0,0 +1,14 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+dist/
+*.egg-info/
+.pytest_cache/
+.coverage
+.env
+.venv/
+venv/
+

sentinel_oversight-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Christopher Sellers / RegEngine, Inc.
+
+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.
+

sentinel_oversight-0.1.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: sentinel-oversight
+Version: 0.1.0
+Summary: Python SDK for Sentinel human-in-the-loop oversight
+Project-URL: Homepage, https://oversight.sh
+Project-URL: Repository, https://github.com/PetrefiedThunder/sentinel-sdk
+Author: Christopher Sellers / RegEngine, Inc.
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Sentinel SDK
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![PyPI version](https://img.shields.io/badge/pypi-v0.1.0-blue.svg)](https://pypi.org/project/sentinel-oversight/)
+
+**Oversight infrastructure for AI agents.**
+
+Sentinel adds human-in-the-loop approval to any Python function your agent calls.
+Wrap the function with `@oversight`, and the SDK pauses execution, requests
+approval, and only runs once a human approves.
+
+## Install
+
+```bash
+pip install sentinel-oversight
+```
+
+## Quick start
+
+```python
+from sentinel import configure, oversight
+
+configure(api_key="sk_live_...")
+
+@oversight(
+    risk_level="high",
+    approvers=["slack://channel/agent-approvals"],
+    timeout_seconds=300,
+)
+def transfer_funds(amount: int, recipient: str):
+    return stripe.transfers.create(amount=amount, destination=recipient)
+```
+
+When your agent calls `transfer_funds(1000, "acct_xyz")`, Sentinel pauses
+execution, posts an approval card to Slack, and only runs the function once a
+human clicks Approve. If rejected, `ApprovalRejected` is raised. If no response
+within `timeout_seconds`, `ApprovalTimeout` is raised (unless `fallback="execute"`).
+
+## Configuration
+
+Set via `configure(...)` or env vars:
+
+- `SENTINEL_API_URL` (default `https://api.oversight.sh`)
+- `SENTINEL_API_KEY`
+- `SENTINEL_TIMEOUT` (default `300`)
+- `SENTINEL_FALLBACK` (default `reject`)
+
+## LangChain
+
+```python
+from sentinel.adapters.langchain import SentinelCallbackHandler
+
+agent.run("...", callbacks=[SentinelCallbackHandler(risk_level="high")])
+```
+
+Install with `pip install sentinel-oversight[langchain]`.
+
+## Links
+
+- Website: https://oversight.sh
+- API repo: https://github.com/PetrefiedThunder/sentinel-api
+- This SDK: https://github.com/PetrefiedThunder/sentinel-sdk
+
+## License
+
+MIT

sentinel_oversight-0.1.0/README.md

@@ -0,0 +1,66 @@
+# Sentinel SDK
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![PyPI version](https://img.shields.io/badge/pypi-v0.1.0-blue.svg)](https://pypi.org/project/sentinel-oversight/)
+
+**Oversight infrastructure for AI agents.**
+
+Sentinel adds human-in-the-loop approval to any Python function your agent calls.
+Wrap the function with `@oversight`, and the SDK pauses execution, requests
+approval, and only runs once a human approves.
+
+## Install
+
+```bash
+pip install sentinel-oversight
+```
+
+## Quick start
+
+```python
+from sentinel import configure, oversight
+
+configure(api_key="sk_live_...")
+
+@oversight(
+    risk_level="high",
+    approvers=["slack://channel/agent-approvals"],
+    timeout_seconds=300,
+)
+def transfer_funds(amount: int, recipient: str):
+    return stripe.transfers.create(amount=amount, destination=recipient)
+```
+
+When your agent calls `transfer_funds(1000, "acct_xyz")`, Sentinel pauses
+execution, posts an approval card to Slack, and only runs the function once a
+human clicks Approve. If rejected, `ApprovalRejected` is raised. If no response
+within `timeout_seconds`, `ApprovalTimeout` is raised (unless `fallback="execute"`).
+
+## Configuration
+
+Set via `configure(...)` or env vars:
+
+- `SENTINEL_API_URL` (default `https://api.oversight.sh`)
+- `SENTINEL_API_KEY`
+- `SENTINEL_TIMEOUT` (default `300`)
+- `SENTINEL_FALLBACK` (default `reject`)
+
+## LangChain
+
+```python
+from sentinel.adapters.langchain import SentinelCallbackHandler
+
+agent.run("...", callbacks=[SentinelCallbackHandler(risk_level="high")])
+```
+
+Install with `pip install sentinel-oversight[langchain]`.
+
+## Links
+
+- Website: https://oversight.sh
+- API repo: https://github.com/PetrefiedThunder/sentinel-api
+- This SDK: https://github.com/PetrefiedThunder/sentinel-sdk
+
+## License
+
+MIT

sentinel_oversight-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "sentinel-oversight"
+version = "0.1.0"
+description = "Python SDK for Sentinel human-in-the-loop oversight"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [{ name = "Christopher Sellers / RegEngine, Inc." }]
+dependencies = [
+    "httpx>=0.27",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio",
+]
+
+[project.urls]
+Homepage = "https://oversight.sh"
+Repository = "https://github.com/PetrefiedThunder/sentinel-sdk"
+
+[tool.hatch.build.targets.wheel]
+packages = ["sentinel"]

sentinel_oversight-0.1.0/sentinel/__init__.py

@@ -0,0 +1,21 @@
+"""Sentinel SDK — oversight infrastructure for AI agents."""
+
+from .client import SentinelClient
+from .config import SentinelConfig, configure, get_config
+from .decorator import oversight
+from .exceptions import ApprovalRejected, ApprovalTimeout, SentinelConfigError, SentinelError
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "oversight",
+    "SentinelClient",
+    "SentinelConfig",
+    "configure",
+    "get_config",
+    "SentinelError",
+    "SentinelConfigError",
+    "ApprovalRejected",
+    "ApprovalTimeout",
+    "__version__",
+]

sentinel_oversight-0.1.0/sentinel/adapters/langchain.py

@@ -0,0 +1,71 @@
+"""LangChain adapter for Sentinel.
+
+Provides a callback handler that creates an approval request when a tool starts
+and blocks until a decision is reached.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from ..client import SentinelClient
+from ..exceptions import ApprovalRejected
+
+
+class SentinelCallbackHandler:
+    """LangChain callback handler that gates tool execution behind Sentinel approvals.
+
+    Inherits from langchain_core.callbacks.BaseCallbackHandler at instantiation
+    time so the langchain dependency stays optional.
+    """
+
+    def __new__(cls, *args, **kwargs):
+        try:
+            from langchain_core.callbacks import BaseCallbackHandler  # type: ignore
+        except ImportError as e:
+            raise ImportError(
+                "langchain-core is required for SentinelCallbackHandler. "
+                "Install with: pip install sentinel-oversight[langchain]"
+            ) from e
+
+        # Dynamically create a subclass mixing in BaseCallbackHandler.
+        if not issubclass(cls, BaseCallbackHandler):
+            new_cls = type(cls.__name__, (cls, BaseCallbackHandler), {})
+            instance = object.__new__(new_cls)
+            return instance
+        return object.__new__(cls)
+
+    def __init__(
+        self,
+        client: Optional[SentinelClient] = None,
+        risk_level: str = "medium",
+        approvers: Optional[list] = None,
+        timeout_seconds: Optional[float] = None,
+    ):
+        self.client = client or SentinelClient()
+        self.risk_level = risk_level
+        self.approvers = approvers
+        self.timeout_seconds = timeout_seconds
+
+    def on_tool_start(
+        self,
+        serialized: dict,
+        input_str: str,
+        **kwargs: Any,
+    ) -> None:
+        tool_name = (serialized or {}).get("name", "unknown_tool")
+        approval = self.client.create_approval(
+            function_name=tool_name,
+            arguments={"input": input_str},
+            risk_level=self.risk_level,
+            approvers=self.approvers,
+            timeout_seconds=self.timeout_seconds,
+        )
+        action_id = approval.get("action_id") or approval.get("id")
+        decision = self.client.wait_for_decision(action_id, timeout=self.timeout_seconds)
+        status = decision.get("status") or decision.get("decision")
+        if status != "approved":
+            raise ApprovalRejected(
+                reason=decision.get("reason", "Tool execution not approved"),
+                action_id=action_id,
+            )

sentinel_oversight-0.1.0/sentinel/client.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any, Optional
+
+import httpx
+
+from .config import SentinelConfig, get_config
+from .exceptions import ApprovalTimeout, SentinelConfigError, SentinelError
+
+USER_AGENT = "sentinel-sdk-python/0.1.0"
+
+
+class SentinelClient:
+    def __init__(self, config: Optional[SentinelConfig] = None):
+        self.config = config or get_config()
+
+    # ------------- internals -------------
+    def _headers(self) -> dict:
+        if not self.config.api_key:
+            raise SentinelConfigError("Call sentinel.configure(api_key=...) before using Sentinel")
+        h = {"User-Agent": USER_AGENT, "Content-Type": "application/json"}
+        h["Authorization"] = f"Bearer {self.config.api_key}"
+        return h
+
+    def _url(self, path: str) -> str:
+        return f"{self.config.api_url.rstrip('/')}{path}"
+
+    # ------------- sync API -------------
+    def create_approval(
+        self,
+        function_name: str,
+        arguments: Any,
+        risk_level: str = "medium",
+        approvers: Optional[list] = None,
+        timeout_seconds: Optional[float] = None,
+    ) -> dict:
+        payload = {
+            "function_name": function_name,
+            "arguments": arguments,
+            "risk_level": risk_level,
+            "approvers": approvers or [],
+            "timeout_seconds": timeout_seconds or self.config.timeout_seconds,
+        }
+        with httpx.Client(timeout=30.0) as c:
+            r = c.post(self._url("/v1/approvals"), json=payload, headers=self._headers())
+            r.raise_for_status()
+            return r.json()
+
+    def get_approval(self, action_id: str) -> dict:
+        with httpx.Client(timeout=30.0) as c:
+            r = c.get(self._url(f"/v1/approvals/{action_id}"), headers=self._headers())
+            r.raise_for_status()
+            return r.json()
+
+    def wait_for_decision(
+        self,
+        action_id: str,
+        timeout: Optional[float] = None,
+        poll_interval: Optional[float] = None,
+    ) -> dict:
+        timeout = timeout or self.config.timeout_seconds
+        poll_interval = poll_interval or self.config.poll_interval
+        deadline = time.monotonic() + timeout
+        while True:
+            data = self.get_approval(action_id)
+            status = data.get("status") or data.get("decision")
+            if status in ("approved", "rejected"):
+                return data
+            if time.monotonic() >= deadline:
+                raise ApprovalTimeout(action_id=action_id, timeout_seconds=timeout)
+            time.sleep(poll_interval)
+
+    def emit_audit_event(
+        self,
+        action_id: str,
+        execution_result: Any = None,
+        error: Optional[str] = None,
+    ) -> None:
+        payload = {
+            "action_id": action_id,
+            "execution_result": execution_result,
+            "error": error,
+        }
+        try:
+            with httpx.Client(timeout=10.0) as c:
+                c.post(self._url("/v1/audit-events"), json=payload, headers=self._headers())
+        except Exception:
+            # best-effort — never raises
+            pass
+
+    # ------------- async API -------------
+    async def acreate_approval(
+        self,
+        function_name: str,
+        arguments: Any,
+        risk_level: str = "medium",
+        approvers: Optional[list] = None,
+        timeout_seconds: Optional[float] = None,
+    ) -> dict:
+        payload = {
+            "function_name": function_name,
+            "arguments": arguments,
+            "risk_level": risk_level,
+            "approvers": approvers or [],
+            "timeout_seconds": timeout_seconds or self.config.timeout_seconds,
+        }
+        async with httpx.AsyncClient(timeout=30.0) as c:
+            r = await c.post(self._url("/v1/approvals"), json=payload, headers=self._headers())
+            r.raise_for_status()
+            return r.json()
+
+    async def aget_approval(self, action_id: str) -> dict:
+        async with httpx.AsyncClient(timeout=30.0) as c:
+            r = await c.get(self._url(f"/v1/approvals/{action_id}"), headers=self._headers())
+            r.raise_for_status()
+            return r.json()
+
+    async def await_for_decision(
+        self,
+        action_id: str,
+        timeout: Optional[float] = None,
+        poll_interval: Optional[float] = None,
+    ) -> dict:
+        timeout = timeout or self.config.timeout_seconds
+        poll_interval = poll_interval or self.config.poll_interval
+        deadline = time.monotonic() + timeout
+        while True:
+            data = await self.aget_approval(action_id)
+            status = data.get("status") or data.get("decision")
+            if status in ("approved", "rejected"):
+                return data
+            if time.monotonic() >= deadline:
+                raise ApprovalTimeout(action_id=action_id, timeout_seconds=timeout)
+            await asyncio.sleep(poll_interval)
+
+    async def aemit_audit_event(
+        self,
+        action_id: str,
+        execution_result: Any = None,
+        error: Optional[str] = None,
+    ) -> None:
+        payload = {
+            "action_id": action_id,
+            "execution_result": execution_result,
+            "error": error,
+        }
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as c:
+                await c.post(self._url("/v1/audit-events"), json=payload, headers=self._headers())
+        except Exception:
+            pass
+
+
+__all__ = ["SentinelClient", "SentinelError"]

sentinel_oversight-0.1.0/sentinel/config.py

@@ -0,0 +1,45 @@
+import os
+from dataclasses import dataclass, field, replace
+from typing import Optional
+
+
+def _default_api_url() -> str:
+    return os.environ.get("SENTINEL_API_URL", "https://api.oversight.sh")
+
+
+def _default_api_key() -> Optional[str]:
+    return os.environ.get("SENTINEL_API_KEY")
+
+
+def _default_timeout() -> float:
+    try:
+        return float(os.environ.get("SENTINEL_TIMEOUT", "300"))
+    except ValueError:
+        return 300.0
+
+
+def _default_fallback() -> str:
+    return os.environ.get("SENTINEL_FALLBACK", "reject")
+
+
+@dataclass
+class SentinelConfig:
+    api_url: str = field(default_factory=_default_api_url)
+    api_key: Optional[str] = field(default_factory=_default_api_key)
+    timeout_seconds: float = field(default_factory=_default_timeout)
+    poll_interval: float = 2.0
+    fallback: str = field(default_factory=_default_fallback)
+
+
+_config: SentinelConfig = SentinelConfig()
+
+
+def configure(**kwargs) -> SentinelConfig:
+    """Mutate the module-global config."""
+    global _config
+    _config = replace(_config, **kwargs)
+    return _config
+
+
+def get_config() -> SentinelConfig:
+    return _config

sentinel_oversight-0.1.0/sentinel/decorator.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import functools
+import inspect
+from typing import Any, Callable, Optional
+
+from .client import SentinelClient
+from .config import get_config
+from .exceptions import ApprovalRejected, ApprovalTimeout
+
+_PRIMITIVES = (str, int, float, bool, type(None))
+_MAX_REPR = 500
+
+
+def _truncate_repr(obj: Any) -> str:
+    s = repr(obj)
+    if len(s) > _MAX_REPR:
+        return s[:_MAX_REPR] + "...<truncated>"
+    return s
+
+
+def _serialize_arguments(value: Any) -> Any:
+    if isinstance(value, _PRIMITIVES):
+        return value
+    if isinstance(value, (list, tuple)):
+        return [_serialize_arguments(v) for v in value]
+    if isinstance(value, dict):
+        return {str(k): _serialize_arguments(v) for k, v in value.items()}
+    return _truncate_repr(value)
+
+
+def _bound_arguments(fn: Callable, args: tuple, kwargs: dict) -> dict:
+    signature = inspect.signature(fn)
+    bound = signature.bind_partial(*args, **kwargs)
+    bound.apply_defaults()
+    return _serialize_arguments(dict(bound.arguments))
+
+
+def oversight(
+    risk_level: str = "medium",
+    approvers: Optional[list] = None,
+    timeout_seconds: Optional[float] = None,
+    fallback: Optional[str] = None,
+) -> Callable:
+    def decorator(fn: Callable) -> Callable:
+        is_async = inspect.iscoroutinefunction(fn)
+
+        if is_async:
+            @functools.wraps(fn)
+            async def awrapper(*args, **kwargs):
+                cfg = get_config()
+                client = SentinelClient(cfg)
+                fb = fallback or cfg.fallback
+                arguments = _bound_arguments(fn, args, kwargs)
+                approval = await client.acreate_approval(
+                    function_name=fn.__name__,
+                    arguments=arguments,
+                    risk_level=risk_level,
+                    approvers=approvers,
+                    timeout_seconds=timeout_seconds,
+                )
+                action_id = approval.get("action_id") or approval.get("id")
+                try:
+                    decision = await client.await_for_decision(
+                        action_id, timeout=timeout_seconds
+                    )
+                except ApprovalTimeout:
+                    if fb == "execute":
+                        result = await fn(*args, **kwargs)
+                        await client.aemit_audit_event(
+                            action_id, execution_result=_truncate_repr(result),
+                            error="timeout-fallback-execute",
+                        )
+                        return result
+                    raise
+
+                status = decision.get("status") or decision.get("decision")
+                if status == "approved":
+                    try:
+                        result = await fn(*args, **kwargs)
+                    except Exception as e:
+                        await client.aemit_audit_event(
+                            action_id, execution_result=None, error=_truncate_repr(e)
+                        )
+                        raise
+                    await client.aemit_audit_event(
+                        action_id, execution_result=_truncate_repr(result)
+                    )
+                    return result
+                if status == "rejected":
+                    raise ApprovalRejected(
+                        reason=decision.get("reason", ""), action_id=action_id
+                    )
+                raise ApprovalRejected(
+                    reason=f"Unknown decision status: {status}", action_id=action_id
+                )
+
+            return awrapper
+
+        @functools.wraps(fn)
+        def wrapper(*args, **kwargs):
+            cfg = get_config()
+            client = SentinelClient(cfg)
+            fb = fallback or cfg.fallback
+            arguments = _bound_arguments(fn, args, kwargs)
+            approval = client.create_approval(
+                function_name=fn.__name__,
+                arguments=arguments,
+                risk_level=risk_level,
+                approvers=approvers,
+                timeout_seconds=timeout_seconds,
+            )
+            action_id = approval.get("action_id") or approval.get("id")
+            try:
+                decision = client.wait_for_decision(action_id, timeout=timeout_seconds)
+            except ApprovalTimeout:
+                if fb == "execute":
+                    result = fn(*args, **kwargs)
+                    client.emit_audit_event(
+                        action_id, execution_result=_truncate_repr(result),
+                        error="timeout-fallback-execute",
+                    )
+                    return result
+                raise
+
+            status = decision.get("status") or decision.get("decision")
+            if status == "approved":
+                try:
+                    result = fn(*args, **kwargs)
+                except Exception as e:
+                    client.emit_audit_event(
+                        action_id, execution_result=None, error=_truncate_repr(e)
+                    )
+                    raise
+                client.emit_audit_event(
+                    action_id, execution_result=_truncate_repr(result)
+                )
+                return result
+            if status == "rejected":
+                raise ApprovalRejected(
+                    reason=decision.get("reason", ""), action_id=action_id
+                )
+            raise ApprovalRejected(
+                reason=f"Unknown decision status: {status}", action_id=action_id
+            )
+
+        return wrapper
+
+    return decorator

sentinel_oversight-0.1.0/sentinel/exceptions.py

@@ -0,0 +1,25 @@
+class SentinelError(Exception):
+    """Base error for the Sentinel SDK."""
+
+
+class SentinelConfigError(SentinelError):
+    """Raised when the SDK is used without required configuration."""
+
+
+class ApprovalRejected(SentinelError):
+    """Raised when an approval request is rejected by an approver."""
+
+    def __init__(self, reason: str = "", action_id: str | None = None):
+        self.reason = reason
+        self.action_id = action_id
+        super().__init__(reason or "Approval rejected")
+
+
+class ApprovalTimeout(SentinelError):
+    """Raised when an approval request times out without a decision."""
+
+    def __init__(self, action_id: str | None = None, timeout_seconds: float | None = None):
+        self.action_id = action_id
+        self.timeout_seconds = timeout_seconds
+        msg = f"Approval timed out after {timeout_seconds}s" if timeout_seconds else "Approval timed out"
+        super().__init__(msg)

sentinel_oversight-0.1.0/tests/test_decorator.py

@@ -0,0 +1,58 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from sentinel import ApprovalRejected, SentinelClient, SentinelConfigError, configure, oversight
+
+
+@patch("sentinel.decorator.SentinelClient")
+def test_approval_success(mock_client_cls):
+    mock_client = MagicMock()
+    mock_client.create_approval.return_value = {"action_id": "act_1"}
+    mock_client.wait_for_decision.return_value = {"status": "approved"}
+    mock_client_cls.return_value = mock_client
+
+    @oversight(risk_level="high")
+    def transfer_funds(amount, to):
+        return {"amount": amount, "to": to}
+
+    result = transfer_funds(100, to="alice")
+    assert result == {"amount": 100, "to": "alice"}
+    mock_client.create_approval.assert_called_once_with(
+        function_name="transfer_funds",
+        arguments={"amount": 100, "to": "alice"},
+        risk_level="high",
+        approvers=None,
+        timeout_seconds=None,
+    )
+    mock_client.wait_for_decision.assert_called_once_with("act_1", timeout=None)
+    mock_client.emit_audit_event.assert_called_once()
+
+
+@patch("sentinel.decorator.SentinelClient")
+def test_rejection(mock_client_cls):
+    mock_client = MagicMock()
+    mock_client.create_approval.return_value = {"action_id": "act_2"}
+    mock_client.wait_for_decision.return_value = {
+        "status": "rejected",
+        "reason": "too risky",
+    }
+    mock_client_cls.return_value = mock_client
+
+    ran = {"v": False}
+
+    @oversight()
+    def dangerous():
+        ran["v"] = True
+        return "done"
+
+    with pytest.raises(ApprovalRejected) as exc:
+        dangerous()
+    assert "too risky" in str(exc.value)
+    assert ran["v"] is False
+
+
+def test_requires_api_key_before_network_calls():
+    configure(api_key=None)
+    with pytest.raises(SentinelConfigError):
+        SentinelClient().create_approval(function_name="dangerous", arguments={})