contextwall-sdk 0.1.1__tar.gz

contextwall_sdk-0.1.1/.gitignore

@@ -0,0 +1,29 @@
+# Secrets — never commit these
+.env
+.env.*
+!.env.example
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+dist/
+build/
+*.egg-info/
+.venv/
+venv/
+
+# Runtime data
+.ctxfw/
+*.db
+*.pid
+
+# Editor
+.vscode/
+.idea/
+*.swp
+.DS_Store

contextwall_sdk-0.1.1/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: contextwall-sdk
+Version: 0.1.1
+Summary: ContextWall SDK - drop-in wrapper for Anthropic and OpenAI with context firewall enforcement
+Author-email: Context Firewall <sumesh.punakkal@gmail.com>
+License: Apache-2.0
+Keywords: ai,anthropic,context-firewall,governance,openai,security
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.0
+Provides-Extra: all
+Requires-Dist: anthropic>=0.25; extra == 'all'
+Requires-Dist: openai>=1.0; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.25; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: anthropic>=0.25; extra == 'dev'
+Requires-Dist: httpx>=0.27; extra == 'dev'
+Requires-Dist: openai>=1.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# contextwall-sdk
+
+Drop-in wrapper for Anthropic and OpenAI that routes calls through a local [ContextWall](https://contextwall.io) daemon, enforcing your context firewall policy with no other code changes.
+
+## Install
+
+```bash
+pip install 'contextwall-sdk[anthropic]'
+pip install 'contextwall-sdk[openai]'
+pip install 'contextwall-sdk[all]'
+```
+
+## Usage
+
+```python
+from contextwall_sdk import SafeAnthropic
+
+client = SafeAnthropic(api_key="sk-ant-...", ctxfw_url="http://localhost:8080")
+# use exactly like the standard Anthropic client
+```
+
+```python
+from contextwall_sdk import SafeOpenAI
+
+client = SafeOpenAI(api_key="sk-...", ctxfw_url="http://localhost:8080")
+```
+
+Blocked requests raise `contextwall_sdk.ContextWallBlockedError` with the policy violation detail.
+
+## Daemon setup
+
+The SDK requires a running ContextWall daemon. See the [quickstart](https://contextwall.io/quickstart) or the [GitHub repo](https://github.com/bytewise-ca/context-wall).

contextwall_sdk-0.1.1/README.md

@@ -0,0 +1,32 @@
+# contextwall-sdk
+
+Drop-in wrapper for Anthropic and OpenAI that routes calls through a local [ContextWall](https://contextwall.io) daemon, enforcing your context firewall policy with no other code changes.
+
+## Install
+
+```bash
+pip install 'contextwall-sdk[anthropic]'
+pip install 'contextwall-sdk[openai]'
+pip install 'contextwall-sdk[all]'
+```
+
+## Usage
+
+```python
+from contextwall_sdk import SafeAnthropic
+
+client = SafeAnthropic(api_key="sk-ant-...", ctxfw_url="http://localhost:8080")
+# use exactly like the standard Anthropic client
+```
+
+```python
+from contextwall_sdk import SafeOpenAI
+
+client = SafeOpenAI(api_key="sk-...", ctxfw_url="http://localhost:8080")
+```
+
+Blocked requests raise `contextwall_sdk.ContextWallBlockedError` with the policy violation detail.
+
+## Daemon setup
+
+The SDK requires a running ContextWall daemon. See the [quickstart](https://contextwall.io/quickstart) or the [GitHub repo](https://github.com/bytewise-ca/context-wall).

contextwall_sdk-0.1.1/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["hatchling>=1.21"]
+build-backend = "hatchling.build"
+
+[project]
+name = "contextwall-sdk"
+version = "0.1.1"
+description = "ContextWall SDK - drop-in wrapper for Anthropic and OpenAI with context firewall enforcement"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "Apache-2.0" }
+authors = [
+    { name = "Context Firewall", email = "sumesh.punakkal@gmail.com" },
+]
+keywords = ["ai", "security", "context-firewall", "anthropic", "openai", "governance"]
+
+dependencies = [
+    "httpx>=0.27",
+    "pydantic>=2.0",
+]
+
+[project.optional-dependencies]
+anthropic = ["anthropic>=0.25"]
+openai = ["openai>=1.0"]
+all = ["anthropic>=0.25", "openai>=1.0"]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.24", "anthropic>=0.25", "openai>=1.0", "httpx>=0.27"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/contextwall_sdk"]
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.ruff]
+target-version = "py311"
+line-length = 100

contextwall_sdk-0.1.1/src/contextwall_sdk/__init__.py

@@ -0,0 +1,59 @@
+"""CRE SDK - drop-in context firewall for Anthropic and OpenAI agents.
+
+Quick start::
+
+    pip install 'contextwall-sdk[anthropic]'
+
+    from contextwall_sdk import SafeAnthropic, CREBlockedError
+
+    client = SafeAnthropic()   # reads CRE_KEY and CRE_URL from env
+
+    try:
+        response = client.messages.create(
+            model="claude-opus-4-5",
+            max_tokens=1024,
+            messages=[{"role": "user", "content": "Hello"}],
+        )
+    except CREBlockedError as e:
+        print(f"Blocked: {e.violations}")
+
+Provisioning a key (admin)::
+
+    from contextwall_sdk import CREClient
+
+    cre = CREClient(api_key="...", base_url="http://localhost:8080")
+    result = cre.keys.create(
+        project_id="my-agent",
+        upstream_key="sk-ant-...",
+    )
+    print(result.key)   # sk-cre-xxx  - store this securely
+"""
+
+from .exceptions import CREError, CREBlockedError, CREUnavailableError, CREAuthError
+from ._anthropic import SafeAnthropic, AsyncSafeAnthropic
+from ._openai import SafeOpenAI, AsyncSafeOpenAI
+from .client import CREClient, AsyncCREClient, Source, ProxyKeyResult, HealthStatus, AnalyticsSummary
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # Exceptions
+    "CREError",
+    "CREBlockedError",
+    "CREUnavailableError",
+    "CREAuthError",
+    # Anthropic wrappers
+    "SafeAnthropic",
+    "AsyncSafeAnthropic",
+    # OpenAI wrappers
+    "SafeOpenAI",
+    "AsyncSafeOpenAI",
+    # Admin client
+    "CREClient",
+    "AsyncCREClient",
+    # Response models
+    "Source",
+    "ProxyKeyResult",
+    "HealthStatus",
+    "AnalyticsSummary",
+]

contextwall_sdk-0.1.1/src/contextwall_sdk/_anthropic.py

@@ -0,0 +1,269 @@
+"""SafeAnthropic - drop-in Anthropic client with CRE enforcement.
+
+Usage::
+
+    # Before
+    import anthropic
+    client = anthropic.Anthropic(api_key="sk-ant-...")
+
+    # After (one line change, everything else identical)
+    from contextwall_sdk import SafeAnthropic
+    client = SafeAnthropic(cre_key="sk-cre-...", cre_url="http://localhost:8080")
+
+    # Same API
+    response = client.messages.create(
+        model="claude-opus-4-5",
+        max_tokens=1024,
+        messages=[{"role": "user", "content": "Hello"}],
+    )
+
+Environment variables (no code changes needed)::
+
+    CRE_KEY=sk-cre-...
+    CRE_URL=http://localhost:8080
+
+    from contextwall_sdk import SafeAnthropic
+    client = SafeAnthropic()  # reads from env
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Iterator, AsyncIterator
+
+from .exceptions import CREBlockedError, CREUnavailableError, CREAuthError
+
+
+def _check_cre_block(body: Any) -> None:
+    """Raise CREBlockedError if the response body is a CRE policy violation."""
+    if not isinstance(body, dict):
+        return
+    err = body.get("error", {})
+    if isinstance(err, dict) and err.get("type") == "cre_policy_violation":
+        raise CREBlockedError(
+            blocked_reason=err.get("message", "policy violation"),
+            violations=err.get("violations", []),
+            raw_body=body,
+        )
+
+
+def _wrap_exception(exc: Exception, cre_url: str) -> None:
+    """Convert underlying SDK exceptions into CRE-specific ones where applicable."""
+    try:
+        import httpx
+        if isinstance(exc, httpx.ConnectError):
+            raise CREUnavailableError(cre_url, cause=exc) from exc
+    except ImportError:
+        pass
+
+    # Anthropic SDK exception inspection
+    exc_type = type(exc).__name__
+    if exc_type in ("AuthenticationError",):
+        raise CREAuthError() from exc
+
+    if exc_type in ("BadRequestError", "APIStatusError"):
+        body = getattr(exc, "body", None)
+        _check_cre_block(body)
+
+
+class _StreamContextWrapper:
+    """Wraps an Anthropic stream context manager to catch CRE blocks on entry."""
+
+    def __init__(self, stream_cm: Any, cre_url: str) -> None:
+        self._cm = stream_cm
+        self._cre_url = cre_url
+
+    def __enter__(self) -> Any:
+        try:
+            return self._cm.__enter__()
+        except Exception as exc:
+            _wrap_exception(exc, self._cre_url)
+            raise
+
+    def __exit__(self, *args: Any) -> Any:
+        return self._cm.__exit__(*args)
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._cm, name)
+
+
+class _AsyncStreamContextWrapper:
+    def __init__(self, stream_cm: Any, cre_url: str) -> None:
+        self._cm = stream_cm
+        self._cre_url = cre_url
+
+    async def __aenter__(self) -> Any:
+        try:
+            return await self._cm.__aenter__()
+        except Exception as exc:
+            _wrap_exception(exc, self._cre_url)
+            raise
+
+    async def __aexit__(self, *args: Any) -> Any:
+        return await self._cm.__aexit__(*args)
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._cm, name)
+
+
+class _MessagesWrapper:
+    """Wraps anthropic.resources.Messages to surface CRE-specific errors."""
+
+    def __init__(self, messages: Any, cre_url: str, fallback: bool) -> None:
+        self._messages = messages
+        self._cre_url = cre_url
+        self._fallback = fallback
+
+    def create(self, **kwargs: Any) -> Any:
+        try:
+            return self._messages.create(**kwargs)
+        except Exception as exc:
+            _wrap_exception(exc, self._cre_url)
+            raise
+
+    def stream(self, **kwargs: Any) -> _StreamContextWrapper:
+        # stream() returns a context manager; errors from CRE surface on __enter__
+        return _StreamContextWrapper(self._messages.stream(**kwargs), self._cre_url)
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._messages, name)
+
+
+class _AsyncMessagesWrapper:
+    def __init__(self, messages: Any, cre_url: str, fallback: bool) -> None:
+        self._messages = messages
+        self._cre_url = cre_url
+        self._fallback = fallback
+
+    async def create(self, **kwargs: Any) -> Any:
+        try:
+            return await self._messages.create(**kwargs)
+        except Exception as exc:
+            _wrap_exception(exc, self._cre_url)
+            raise
+
+    def stream(self, **kwargs: Any) -> _AsyncStreamContextWrapper:
+        return _AsyncStreamContextWrapper(self._messages.stream(**kwargs), self._cre_url)
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._messages, name)
+
+
+class SafeAnthropic:
+    """Drop-in replacement for ``anthropic.Anthropic`` with CRE enforcement.
+
+    Args:
+        cre_key:               Your ``sk-cre-xxx`` key. Falls back to
+                               ``CRE_KEY`` then ``ANTHROPIC_API_KEY`` env vars.
+        cre_url:               CRE daemon URL. Falls back to ``CRE_URL`` env var,
+                               then ``http://localhost:8080``.
+        fallback_on_unavailable: If True and CRE is unreachable, raises
+                               ``CREUnavailableError`` (default False = fail fast).
+        **kwargs:              Passed through to ``anthropic.Anthropic()``.
+
+    Raises:
+        CREBlockedError:       When CRE blocks the request (policy violation).
+        CREUnavailableError:   When CRE cannot be reached (and fallback is off).
+        CREAuthError:          When the CRE key is rejected.
+        ImportError:           If ``anthropic`` package is not installed.
+    """
+
+    def __init__(
+        self,
+        cre_key: str | None = None,
+        cre_url: str | None = None,
+        fallback_on_unavailable: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        try:
+            import anthropic
+        except ImportError as e:
+            raise ImportError(
+                "anthropic package is required: pip install 'contextwall-sdk[anthropic]'"
+            ) from e
+
+        self._cre_url = (
+            cre_url or os.environ.get("CRE_URL") or "http://localhost:8080"
+        ).rstrip("/")
+        self._fallback = fallback_on_unavailable
+
+        key = (
+            cre_key
+            or os.environ.get("CRE_KEY")
+            or os.environ.get("ANTHROPIC_API_KEY")
+            or ""
+        )
+
+        self._client = anthropic.Anthropic(
+            api_key=key,
+            base_url=f"{self._cre_url}/proxy/anthropic",
+            **kwargs,
+        )
+
+    @property
+    def messages(self) -> _MessagesWrapper:
+        return _MessagesWrapper(self._client.messages, self._cre_url, self._fallback)
+
+    @property
+    def beta(self) -> Any:
+        return self._client.beta
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._client, name)
+
+
+class AsyncSafeAnthropic:
+    """Async version of SafeAnthropic. Drop-in for ``anthropic.AsyncAnthropic``.
+
+    Example::
+
+        client = AsyncSafeAnthropic()
+        response = await client.messages.create(
+            model="claude-opus-4-5",
+            max_tokens=1024,
+            messages=[{"role": "user", "content": "Hello"}],
+        )
+    """
+
+    def __init__(
+        self,
+        cre_key: str | None = None,
+        cre_url: str | None = None,
+        fallback_on_unavailable: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        try:
+            import anthropic
+        except ImportError as e:
+            raise ImportError(
+                "anthropic package is required: pip install 'contextwall-sdk[anthropic]'"
+            ) from e
+
+        self._cre_url = (
+            cre_url or os.environ.get("CRE_URL") or "http://localhost:8080"
+        ).rstrip("/")
+        self._fallback = fallback_on_unavailable
+
+        key = (
+            cre_key
+            or os.environ.get("CRE_KEY")
+            or os.environ.get("ANTHROPIC_API_KEY")
+            or ""
+        )
+
+        self._client = anthropic.AsyncAnthropic(
+            api_key=key,
+            base_url=f"{self._cre_url}/proxy/anthropic",
+            **kwargs,
+        )
+
+    @property
+    def messages(self) -> _AsyncMessagesWrapper:
+        return _AsyncMessagesWrapper(self._client.messages, self._cre_url, self._fallback)
+
+    @property
+    def beta(self) -> Any:
+        return self._client.beta
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._client, name)