spendwall 0.0.6__tar.gz

spendwall-0.0.6/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: spendwall
+Version: 0.0.6
+Summary: Spendwall SDK — local-first agent spend firewall
+Author: Spendwall
+License: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests-unixsocket>=0.3
+Requires-Dist: requests>=2.28
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.21; extra == "anthropic"
+Provides-Extra: all
+Requires-Dist: openai>=1.0; extra == "all"
+Requires-Dist: anthropic>=0.21; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: responses>=0.23; extra == "dev"
+
+# spendwall (Python)
+
+```python
+import openai
+import spendwall.openai as sw
+
+client = openai.OpenAI(api_key="sk-...")
+client = sw.wrap(client, mode="enforce")
+
+# Now every client.chat.completions.create(...) is observed by spendwalld.
+```

spendwall-0.0.6/README.md

@@ -0,0 +1,11 @@
+# spendwall (Python)
+
+```python
+import openai
+import spendwall.openai as sw
+
+client = openai.OpenAI(api_key="sk-...")
+client = sw.wrap(client, mode="enforce")
+
+# Now every client.chat.completions.create(...) is observed by spendwalld.
+```

spendwall-0.0.6/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "spendwall"
+version = "0.0.6"
+description = "Spendwall SDK — local-first agent spend firewall"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "Apache-2.0" }
+authors = [{ name = "Spendwall" }]
+dependencies = [
+    "requests-unixsocket>=0.3",
+    "requests>=2.28",
+]
+
+[project.optional-dependencies]
+openai     = ["openai>=1.0"]
+anthropic  = ["anthropic>=0.21"]
+all        = ["openai>=1.0", "anthropic>=0.21"]
+dev        = ["pytest>=7", "pytest-asyncio>=0.21", "responses>=0.23"]
+
+[tool.setuptools.packages.find]
+include = ["spendwall*"]

spendwall-0.0.6/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

spendwall-0.0.6/spendwall/__init__.py

@@ -0,0 +1,11 @@
+"""Spendwall — local-first agent spending firewall."""
+__version__ = "0.0.2"
+
+from spendwall.client import SpendwallClient  # noqa: F401
+from spendwall.errors import (  # noqa: F401
+    ApprovalRequiredError,
+    BlockedError,
+    SpendwallError,
+    SpendwallVersionMismatch,
+)
+from spendwall.modes import Mode  # noqa: F401

spendwall-0.0.6/spendwall/anthropic.py

@@ -0,0 +1,88 @@
+"""Wrapper for ``anthropic.Anthropic`` clients.
+
+Patches ``client.messages.create`` in-place so every upstream call is
+observed by spendwalld. In ``enforce`` mode, the wrapper consults policy
+*before* dispatching to the upstream and raises
+``BlockedError``/``ApprovalRequiredError`` when the daemon refuses.
+"""
+
+from __future__ import annotations
+
+import json as _json
+from typing import Any, Optional
+
+from spendwall.client import SpendwallClient
+from spendwall.modes import Mode, resolve as resolve_mode
+
+
+def _estimate_tokens(messages_or_input: Any) -> int:
+    try:
+        return max(1, len(_json.dumps(messages_or_input)) // 4)
+    except (TypeError, ValueError):
+        return 1
+
+
+def wrap(
+    anthropic_client: Any,
+    *,
+    sw_client: Optional[SpendwallClient] = None,
+    agent_id: str = "anonymous",
+    mode: Optional[Mode] = None,
+    tags: Optional[dict[str, str]] = None,
+) -> Any:
+    """Patch ``anthropic_client.messages.create`` to call into spendwall
+    before/after the upstream request.
+
+    Mutates the supplied client in-place AND returns it for ergonomic chaining:
+
+        client = wrap(anthropic.Anthropic(...), agent_id="x")
+    """
+    sw = sw_client or SpendwallClient()
+    configured_mode = mode
+
+    original = anthropic_client.messages.create
+
+    def patched(*args: Any, **kwargs: Any) -> Any:
+        call_mode = resolve_mode(configured=configured_mode)
+        model = kwargs.get("model", "unknown")
+        est_input_tokens = _estimate_tokens(kwargs.get("messages"))
+
+        if call_mode == "enforce":
+            sw.policy_check_strict(
+                agent_id=agent_id, provider="anthropic", model=model,
+                estimated_cost_cents=0, tags=tags or {},
+            )
+        elif call_mode == "advisory":
+            sw.policy_check(
+                agent_id=agent_id, provider="anthropic", model=model,
+                estimated_cost_cents=0, tags=tags or {},
+            )
+        # observe-mode skips policy_check entirely.
+        try:
+            result = original(*args, **kwargs)
+        except Exception:
+            sw.observe({
+                "agent_id": agent_id, "provider": "anthropic", "model": model,
+                "source": "sdk_python", "input_tokens": est_input_tokens,
+                "output_tokens": None, "estimated_cost_cents": 0,
+                "actual_cost_cents": None, "decision_str": "allowed",
+                "binding_caps": [], "tags": tags or {},
+                "outcome": "upstream_error",
+            })
+            raise
+
+        usage = getattr(result, "usage", None)
+        input_tokens = getattr(usage, "input_tokens", None) if usage else None
+        output_tokens = getattr(usage, "output_tokens", None) if usage else None
+        sw.observe({
+            "agent_id": agent_id, "provider": "anthropic", "model": model,
+            "source": "sdk_python", "input_tokens": input_tokens,
+            "output_tokens": output_tokens, "estimated_cost_cents": 0,
+            "actual_cost_cents": None, "decision_str": "allowed",
+            "binding_caps": [], "tags": tags or {},
+            "outcome": "success",
+        })
+        return result
+
+    anthropic_client.messages.create = patched
+    return anthropic_client

spendwall-0.0.6/spendwall/client.py

@@ -0,0 +1,118 @@
+"""UDS HTTP client for spendwalld."""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Optional
+from urllib.parse import quote
+
+import requests
+import requests_unixsocket
+
+from spendwall.errors import ApprovalRequiredError, BlockedError
+
+
+def _default_socket_path() -> str:
+    return os.environ.get(
+        "SPENDWALL_SOCKET",
+        os.path.expanduser("~/.spendwall/spendwall.sock"),
+    )
+
+
+def _default_bearer() -> Optional[str]:
+    return os.environ.get("SPENDWALL_TOKEN")
+
+
+class SpendwallClient:
+    """Talks to the spendwall daemon over its UDS HTTP API.
+
+    Fail-open: when ``fail_open=True`` and the socket is unreachable, ``observe()``
+    is silently dropped and ``policy_check()`` returns a synthetic "allowed"
+    decision. Default is ``fail_open=True`` because a spending firewall MUST NOT
+    bring down user agents when the daemon is down.
+    """
+
+    def __init__(
+        self,
+        socket_path: Optional[str] = None,
+        bearer: Optional[str] = None,
+        timeout_seconds: float = 2.0,
+        fail_open: bool = True,
+    ):
+        self.socket_path = socket_path or _default_socket_path()
+        self.bearer = bearer or _default_bearer()
+        self.timeout_seconds = timeout_seconds
+        self.fail_open = fail_open
+        self._session = requests_unixsocket.Session()
+        self._base = f"http+unix://{quote(self.socket_path, safe='')}"
+
+    def _headers(self) -> dict[str, str]:
+        h = {"content-type": "application/json"}
+        if self.bearer:
+            h["authorization"] = f"Bearer {self.bearer}"
+        return h
+
+    def policy_check(
+        self,
+        *,
+        agent_id: str,
+        provider: str,
+        model: str,
+        estimated_cost_cents: int,
+        tags: Optional[dict[str, str]] = None,
+    ) -> dict[str, Any]:
+        body = {
+            "agent_id": agent_id,
+            "provider": provider,
+            "model": model,
+            "estimated_cost_cents": estimated_cost_cents,
+            "tags": tags or {},
+        }
+        try:
+            r = self._session.post(
+                f"{self._base}/v1/policy/check",
+                json=body,
+                headers=self._headers(),
+                timeout=self.timeout_seconds,
+            )
+            r.raise_for_status()
+            return r.json()
+        except (requests.RequestException, ValueError):
+            if self.fail_open:
+                return {"decision": "allowed", "alert_caps": []}
+            raise
+
+    def policy_check_strict(self, **kwargs: Any) -> dict[str, Any]:
+        """Like ``policy_check`` but raises ``BlockedError`` /
+        ``ApprovalRequiredError`` on non-allowed decisions."""
+        d = self.policy_check(**kwargs)
+        if d.get("decision") == "blocked":
+            raise BlockedError(
+                cap_id=d.get("cap_id", "?"),
+                projected_cents=d.get("projected_cents", 0),
+                limit_cents=d.get("limit_cents", 0),
+            )
+        if d.get("decision") == "approval_required":
+            raise ApprovalRequiredError(approval_caps=d.get("approval_caps", []))
+        return d
+
+    def observe(self, event: dict[str, Any]) -> None:
+        try:
+            self._session.post(
+                f"{self._base}/v1/spend/observe",
+                json=event,
+                headers=self._headers(),
+                timeout=self.timeout_seconds,
+            )
+        except requests.RequestException:
+            if not self.fail_open:
+                raise
+            # Fail-open: drop on the floor.
+
+    def about(self) -> dict[str, Any]:
+        r = self._session.get(
+            f"{self._base}/v1/about",
+            timeout=self.timeout_seconds,
+        )
+        r.raise_for_status()
+        return r.json()

spendwall-0.0.6/spendwall/errors.py

@@ -0,0 +1,37 @@
+"""Spendwall SDK exceptions."""
+
+from __future__ import annotations
+
+
+class SpendwallError(Exception):
+    """Base for all spendwall-raised exceptions."""
+
+
+class BlockedError(SpendwallError):
+    """Raised in `enforce` mode when policy returned Blocked."""
+
+    def __init__(self, cap_id: str, projected_cents: int, limit_cents: int):
+        self.cap_id = cap_id
+        self.projected_cents = projected_cents
+        self.limit_cents = limit_cents
+        super().__init__(
+            f"Spendwall blocked by cap '{cap_id}': "
+            f"projected {projected_cents}c > limit {limit_cents}c"
+        )
+
+
+class ApprovalRequiredError(SpendwallError):
+    """Raised in `enforce` mode when policy returned ApprovalRequired and the
+    approval was denied or timed out."""
+
+    def __init__(self, approval_caps: list[str], reason: str = "denied"):
+        self.approval_caps = approval_caps
+        self.reason = reason
+        super().__init__(
+            f"Spendwall approval {reason} for caps={approval_caps}"
+        )
+
+
+class SpendwallVersionMismatch(SpendwallError):
+    """Raised once when the daemon's API version does not match the SDK's.
+    SDK falls back to fail-open `observe` mode for the rest of the process."""

spendwall-0.0.6/spendwall/modes.py

@@ -0,0 +1,26 @@
+"""Mode resolution — observe, advisory, enforce."""
+
+from __future__ import annotations
+
+import os
+from typing import Literal, Optional
+
+Mode = Literal["observe", "advisory", "enforce"]
+_VALID = ("observe", "advisory", "enforce")
+_ENV_VAR = "SPENDWALL_MODE"
+
+
+def resolve(per_call: Optional[str] = None, configured: Optional[str] = None) -> Mode:
+    """Precedence (most specific wins):
+    1. `per_call` kwarg passed by user code at the call site
+    2. `configured` value from `wrap(..., mode=...)`
+    3. `SPENDWALL_MODE` env var
+    4. Default: `observe`
+    """
+    for v in (per_call, configured, os.environ.get(_ENV_VAR)):
+        if v is None:
+            continue
+        if v not in _VALID:
+            raise ValueError(f"invalid spendwall mode: {v!r}; expected one of {_VALID}")
+        return v  # type: ignore[return-value]
+    return "observe"

spendwall-0.0.6/spendwall/openai.py

@@ -0,0 +1,98 @@
+"""Wrapper for ``openai.OpenAI`` clients.
+
+Patches ``client.chat.completions.create`` and ``client.responses.create``
+in-place so every upstream call is observed by spendwalld. In ``enforce``
+mode, the wrapper consults policy *before* dispatching to the upstream and
+raises ``BlockedError``/``ApprovalRequiredError`` when the daemon refuses.
+"""
+
+from __future__ import annotations
+
+import json as _json
+from typing import Any, Optional
+
+from spendwall.client import SpendwallClient
+from spendwall.modes import Mode, resolve as resolve_mode
+
+
+def _estimate_tokens(messages_or_input: Any) -> int:
+    """Cheap byte-based estimate; daemon reconciles cost post-flight."""
+    try:
+        return max(1, len(_json.dumps(messages_or_input)) // 4)
+    except (TypeError, ValueError):
+        return 1
+
+
+def wrap(
+    openai_client: Any,
+    *,
+    sw_client: Optional[SpendwallClient] = None,
+    agent_id: str = "anonymous",
+    mode: Optional[Mode] = None,
+    tags: Optional[dict[str, str]] = None,
+) -> Any:
+    """Patch ``openai_client.chat.completions.create`` (and ``.responses.create``)
+    to call into spendwall before/after the upstream request.
+
+    Mutates the supplied client in-place AND returns it for ergonomic chaining:
+
+        client = wrap(openai.OpenAI(...), agent_id="x")
+    """
+    sw = sw_client or SpendwallClient()
+    configured_mode = mode
+
+    def _patch(parent: Any, name: str) -> None:
+        original = getattr(parent, name)
+
+        def patched(*args: Any, **kwargs: Any) -> Any:
+            call_mode = resolve_mode(configured=configured_mode)
+            model = kwargs.get("model", "unknown")
+            est_input_tokens = _estimate_tokens(
+                kwargs.get("messages") or kwargs.get("input")
+            )
+            # Daemon does pricing lookup; SDK sends estimated_cost_cents=0
+            # to defer cost estimation to the daemon side.
+            if call_mode == "enforce":
+                sw.policy_check_strict(
+                    agent_id=agent_id, provider="openai", model=model,
+                    estimated_cost_cents=0, tags=tags or {},
+                )
+            elif call_mode == "advisory":
+                sw.policy_check(
+                    agent_id=agent_id, provider="openai", model=model,
+                    estimated_cost_cents=0, tags=tags or {},
+                )
+            # observe-mode skips policy_check entirely (zero added latency).
+            try:
+                result = original(*args, **kwargs)
+            except Exception:
+                sw.observe({
+                    "agent_id": agent_id, "provider": "openai", "model": model,
+                    "source": "sdk_python", "input_tokens": est_input_tokens,
+                    "output_tokens": None, "estimated_cost_cents": 0,
+                    "actual_cost_cents": None, "decision_str": "allowed",
+                    "binding_caps": [], "tags": tags or {},
+                    "outcome": "upstream_error",
+                })
+                raise
+
+            usage = getattr(result, "usage", None)
+            input_tokens = getattr(usage, "prompt_tokens", None) if usage else None
+            output_tokens = getattr(usage, "completion_tokens", None) if usage else None
+            sw.observe({
+                "agent_id": agent_id, "provider": "openai", "model": model,
+                "source": "sdk_python", "input_tokens": input_tokens,
+                "output_tokens": output_tokens, "estimated_cost_cents": 0,
+                "actual_cost_cents": None, "decision_str": "allowed",
+                "binding_caps": [], "tags": tags or {},
+                "outcome": "success",
+            })
+            return result
+
+        setattr(parent, name, patched)
+
+    if hasattr(openai_client, "chat") and hasattr(openai_client.chat, "completions"):
+        _patch(openai_client.chat.completions, "create")
+    if hasattr(openai_client, "responses"):
+        _patch(openai_client.responses, "create")
+    return openai_client

spendwall-0.0.6/spendwall.egg-info/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: spendwall
+Version: 0.0.6
+Summary: Spendwall SDK — local-first agent spend firewall
+Author: Spendwall
+License: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests-unixsocket>=0.3
+Requires-Dist: requests>=2.28
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.21; extra == "anthropic"
+Provides-Extra: all
+Requires-Dist: openai>=1.0; extra == "all"
+Requires-Dist: anthropic>=0.21; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: responses>=0.23; extra == "dev"
+
+# spendwall (Python)
+
+```python
+import openai
+import spendwall.openai as sw
+
+client = openai.OpenAI(api_key="sk-...")
+client = sw.wrap(client, mode="enforce")
+
+# Now every client.chat.completions.create(...) is observed by spendwalld.
+```

spendwall-0.0.6/spendwall.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+spendwall/__init__.py
+spendwall/anthropic.py
+spendwall/client.py
+spendwall/errors.py
+spendwall/modes.py
+spendwall/openai.py
+spendwall.egg-info/PKG-INFO
+spendwall.egg-info/SOURCES.txt
+spendwall.egg-info/dependency_links.txt
+spendwall.egg-info/requires.txt
+spendwall.egg-info/top_level.txt
+tests/test_anthropic_wrapper.py
+tests/test_client.py
+tests/test_errors.py
+tests/test_modes.py
+tests/test_openai_wrapper.py

spendwall-0.0.6/spendwall.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

spendwall-0.0.6/spendwall.egg-info/requires.txt

@@ -0,0 +1,17 @@
+requests-unixsocket>=0.3
+requests>=2.28
+
+[all]
+openai>=1.0
+anthropic>=0.21
+
+[anthropic]
+anthropic>=0.21
+
+[dev]
+pytest>=7
+pytest-asyncio>=0.21
+responses>=0.23
+
+[openai]
+openai>=1.0

spendwall-0.0.6/spendwall.egg-info/top_level.txt

@@ -0,0 +1 @@
+spendwall

spendwall-0.0.6/tests/test_anthropic_wrapper.py

@@ -0,0 +1,159 @@
+"""Tests for spendwall.anthropic.wrap()."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from spendwall.errors import BlockedError
+
+
+@pytest.fixture
+def fake_anthropic_client():
+    client = MagicMock(name="anthropic.Anthropic")
+    msg = MagicMock(name="Message")
+    msg.id = "msg_test"
+    msg.model = "claude-3-5-sonnet-20241022"
+    msg.usage = MagicMock(input_tokens=10, output_tokens=5)
+    client.messages.create.return_value = msg
+    return client
+
+
+def test_wrap_observe_passes_through_and_observes(
+    fake_anthropic_client, monkeypatch
+):
+    monkeypatch.setenv("SPENDWALL_MODE", "observe")
+    from spendwall.anthropic import wrap
+
+    sw = MagicMock()
+    wrapped = wrap(fake_anthropic_client, sw_client=sw, agent_id="a")
+    out = wrapped.messages.create(
+        model="claude-3-5-sonnet-20241022",
+        messages=[{"role": "user", "content": "hi"}],
+    )
+    assert out.id == "msg_test"
+    sw.policy_check_strict.assert_not_called()
+    sw.policy_check.assert_not_called()
+    sw.observe.assert_called_once()
+    payload = sw.observe.call_args.args[0]
+    assert payload["provider"] == "anthropic"
+    assert payload["source"] == "sdk_python"
+    assert payload["input_tokens"] == 10
+    assert payload["output_tokens"] == 5
+    assert payload["outcome"] == "success"
+
+
+def test_wrap_enforce_calls_policy_check_strict_then_observe(
+    fake_anthropic_client, monkeypatch
+):
+    monkeypatch.setenv("SPENDWALL_MODE", "enforce")
+    from spendwall.anthropic import wrap
+
+    sw = MagicMock()
+    sw.policy_check_strict.return_value = {"decision": "allowed"}
+    wrapped = wrap(fake_anthropic_client, sw_client=sw, agent_id="a")
+    wrapped.messages.create(
+        model="claude-3-5-sonnet-20241022",
+        messages=[{"role": "user", "content": "hi"}],
+    )
+    sw.policy_check_strict.assert_called_once()
+    pcs_kwargs = sw.policy_check_strict.call_args.kwargs
+    assert pcs_kwargs["provider"] == "anthropic"
+    assert pcs_kwargs["model"] == "claude-3-5-sonnet-20241022"
+    sw.observe.assert_called_once()
+
+
+def test_wrap_advisory_calls_non_strict_policy_check(
+    fake_anthropic_client, monkeypatch
+):
+    monkeypatch.setenv("SPENDWALL_MODE", "advisory")
+    from spendwall.anthropic import wrap
+
+    sw = MagicMock()
+    sw.policy_check.return_value = {"decision": "allowed"}
+    wrapped = wrap(fake_anthropic_client, sw_client=sw, agent_id="a")
+    wrapped.messages.create(
+        model="claude-3-5-sonnet-20241022",
+        messages=[{"role": "user", "content": "hi"}],
+    )
+    sw.policy_check.assert_called_once()
+    sw.policy_check_strict.assert_not_called()
+    sw.observe.assert_called_once()
+
+
+def test_wrap_enforce_blocked_raises_BlockedError_and_skips_upstream(
+    fake_anthropic_client, monkeypatch
+):
+    monkeypatch.setenv("SPENDWALL_MODE", "enforce")
+    from spendwall.anthropic import wrap
+
+    original_create = fake_anthropic_client.messages.create
+    sw = MagicMock()
+    sw.policy_check_strict.side_effect = BlockedError("cap-y", 99, 1)
+    wrapped = wrap(fake_anthropic_client, sw_client=sw, agent_id="a")
+    with pytest.raises(BlockedError):
+        wrapped.messages.create(
+            model="claude-3-5-sonnet-20241022",
+            messages=[{"role": "user", "content": "hi"}],
+        )
+    original_create.assert_not_called()
+    sw.observe.assert_not_called()
+
+
+def test_wrap_observes_upstream_error(fake_anthropic_client, monkeypatch):
+    monkeypatch.setenv("SPENDWALL_MODE", "observe")
+    from spendwall.anthropic import wrap
+
+    fake_anthropic_client.messages.create.side_effect = RuntimeError("boom")
+    sw = MagicMock()
+    wrapped = wrap(fake_anthropic_client, sw_client=sw, agent_id="a")
+    with pytest.raises(RuntimeError):
+        wrapped.messages.create(
+            model="claude-3-5-sonnet-20241022",
+            messages=[{"role": "user", "content": "hi"}],
+        )
+    sw.observe.assert_called_once()
+    payload = sw.observe.call_args.args[0]
+    assert payload["outcome"] == "upstream_error"
+
+
+def test_wrap_per_call_mode_overrides_env(fake_anthropic_client, monkeypatch):
+    monkeypatch.setenv("SPENDWALL_MODE", "observe")
+    from spendwall.anthropic import wrap
+
+    sw = MagicMock()
+    sw.policy_check_strict.return_value = {"decision": "allowed"}
+    wrapped = wrap(
+        fake_anthropic_client, sw_client=sw, agent_id="a", mode="enforce"
+    )
+    wrapped.messages.create(
+        model="claude-3-5-sonnet-20241022",
+        messages=[{"role": "user", "content": "hi"}],
+    )
+    sw.policy_check_strict.assert_called_once()
+
+
+def test_wrap_returns_same_client_instance(fake_anthropic_client):
+    from spendwall.anthropic import wrap
+
+    sw = MagicMock()
+    out = wrap(fake_anthropic_client, sw_client=sw, agent_id="a")
+    assert out is fake_anthropic_client
+
+
+def test_wrap_propagates_tags_into_observe(fake_anthropic_client, monkeypatch):
+    monkeypatch.setenv("SPENDWALL_MODE", "observe")
+    from spendwall.anthropic import wrap
+
+    sw = MagicMock()
+    wrapped = wrap(
+        fake_anthropic_client, sw_client=sw, agent_id="a",
+        tags={"env": "prod"},
+    )
+    wrapped.messages.create(
+        model="claude-3-5-sonnet-20241022",
+        messages=[{"role": "user", "content": "hi"}],
+    )
+    payload = sw.observe.call_args.args[0]
+    assert payload["tags"] == {"env": "prod"}

spendwall-0.0.6/tests/test_client.py

@@ -0,0 +1,253 @@
+"""Tests for SpendwallClient — uses a stub UDS HTTP server.
+
+The socket path lives under ``/tmp`` rather than pytest's ``tmp_path`` because
+macOS limits AF_UNIX paths to ~104 characters and ``tmp_path`` exceeds that.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import socket
+import tempfile
+import threading
+from contextlib import contextmanager
+from typing import Iterator
+
+import pytest
+
+from spendwall.client import SpendwallClient
+from spendwall.errors import ApprovalRequiredError, BlockedError
+
+
+@pytest.fixture
+def short_tmp_path() -> Iterator[str]:
+    """Return a short directory path safe for AF_UNIX sockets on macOS."""
+    d = tempfile.mkdtemp(prefix="sw_", dir="/tmp")
+    try:
+        yield d
+    finally:
+        shutil.rmtree(d, ignore_errors=True)
+
+
+@contextmanager
+def fake_uds_server(socket_path: str, responses: list[tuple[int, bytes]]) -> Iterator[list[bytes]]:
+    """Tiny HTTP/1.1 server bound to a UDS path. ``responses`` is a list of
+    (status_code, body) tuples — popped one per accepted connection. Returns
+    a mutable list of raw request payloads received, for assertions."""
+    if os.path.exists(socket_path):
+        os.unlink(socket_path)
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    sock.bind(socket_path)
+    sock.listen(8)
+    received: list[bytes] = []
+    stop_event = threading.Event()
+
+    def serve() -> None:
+        sock.settimeout(0.1)
+        while not stop_event.is_set() and responses:
+            try:
+                conn, _ = sock.accept()
+            except socket.timeout:
+                continue
+            except OSError:
+                return
+            data = b""
+            conn.settimeout(1.0)
+            try:
+                while b"\r\n\r\n" not in data:
+                    chunk = conn.recv(4096)
+                    if not chunk:
+                        break
+                    data += chunk
+                hdr_end = data.find(b"\r\n\r\n") + 4
+                hdrs = data[:hdr_end].decode(errors="ignore")
+                body_len = 0
+                for line in hdrs.split("\r\n"):
+                    if line.lower().startswith("content-length:"):
+                        body_len = int(line.split(":", 1)[1].strip())
+                while len(data) - hdr_end < body_len:
+                    chunk = conn.recv(4096)
+                    if not chunk:
+                        break
+                    data += chunk
+                received.append(data)
+                if not responses:
+                    conn.close()
+                    continue
+                status, body = responses.pop(0)
+                reason = "OK" if status < 400 else "ERR"
+                if status == 204:
+                    conn.send(
+                        f"HTTP/1.1 {status} No Content\r\n"
+                        f"Content-Length: 0\r\n\r\n".encode()
+                    )
+                else:
+                    conn.send(
+                        f"HTTP/1.1 {status} {reason}\r\n"
+                        f"Content-Length: {len(body)}\r\n"
+                        f"Content-Type: application/json\r\n\r\n".encode()
+                        + body
+                    )
+            finally:
+                conn.close()
+
+    t = threading.Thread(target=serve, daemon=True)
+    t.start()
+    try:
+        yield received
+    finally:
+        stop_event.set()
+        try:
+            sock.close()
+        except OSError:
+            pass
+        t.join(timeout=1.0)
+
+
+def test_policy_check_returns_decision_dict(short_tmp_path):
+    sp = os.path.join(short_tmp_path, "t.sock")
+    body = b'{"decision":"allowed","alert_caps":[]}'
+    with fake_uds_server(sp, [(200, body)]):
+        c = SpendwallClient(socket_path=sp, bearer="swk_test")
+        d = c.policy_check(
+            agent_id="a1", provider="openai", model="gpt-4o",
+            estimated_cost_cents=1,
+        )
+        assert d["decision"] == "allowed"
+
+
+def test_policy_check_strict_raises_blocked(short_tmp_path):
+    sp = os.path.join(short_tmp_path, "t.sock")
+    body = (
+        b'{"decision":"blocked","cap_id":"daily","projected_cents":100,'
+        b'"limit_cents":50,"alert_caps":[]}'
+    )
+    with fake_uds_server(sp, [(200, body)]):
+        c = SpendwallClient(socket_path=sp, bearer="swk_test")
+        with pytest.raises(BlockedError) as exc_info:
+            c.policy_check_strict(
+                agent_id="a1", provider="openai", model="gpt-4o",
+                estimated_cost_cents=1,
+            )
+        assert exc_info.value.cap_id == "daily"
+        assert exc_info.value.projected_cents == 100
+        assert exc_info.value.limit_cents == 50
+
+
+def test_policy_check_strict_raises_approval_required(short_tmp_path):
+    sp = os.path.join(short_tmp_path, "t.sock")
+    body = (
+        b'{"decision":"approval_required","approval_caps":["cap-x"],'
+        b'"alert_caps":[]}'
+    )
+    with fake_uds_server(sp, [(200, body)]):
+        c = SpendwallClient(socket_path=sp, bearer="swk_test")
+        with pytest.raises(ApprovalRequiredError) as exc_info:
+            c.policy_check_strict(
+                agent_id="a1", provider="openai", model="gpt-4o",
+                estimated_cost_cents=1,
+            )
+        assert exc_info.value.approval_caps == ["cap-x"]
+
+
+def test_observe_204_does_not_raise(short_tmp_path):
+    sp = os.path.join(short_tmp_path, "t.sock")
+    with fake_uds_server(sp, [(204, b"")]):
+        c = SpendwallClient(socket_path=sp, bearer="swk_test")
+        c.observe({
+            "agent_id": "a1", "provider": "openai", "model": "gpt-4o",
+            "source": "sdk_python", "estimated_cost_cents": 1,
+            "decision_str": "allowed", "outcome": "success",
+        })
+
+
+def test_observe_swallows_connection_error_when_fail_open(short_tmp_path):
+    sp = os.path.join(short_tmp_path, "no.sock")
+    c = SpendwallClient(socket_path=sp, bearer="swk_test", fail_open=True)
+    # Should NOT raise.
+    c.observe({
+        "agent_id": "a1", "provider": "openai", "model": "gpt-4o",
+        "source": "sdk_python", "estimated_cost_cents": 1,
+        "decision_str": "allowed", "outcome": "success",
+    })
+
+
+def test_observe_raises_when_fail_open_disabled(short_tmp_path):
+    sp = os.path.join(short_tmp_path, "no.sock")
+    c = SpendwallClient(socket_path=sp, bearer="swk_test", fail_open=False)
+    import requests as _requests
+    with pytest.raises(_requests.RequestException):
+        c.observe({"agent_id": "a1"})
+
+
+def test_policy_check_fail_open_returns_allowed_when_daemon_down(short_tmp_path):
+    sp = os.path.join(short_tmp_path, "no.sock")
+    c = SpendwallClient(socket_path=sp, bearer="swk_test", fail_open=True)
+    d = c.policy_check(
+        agent_id="a1", provider="openai", model="gpt-4o",
+        estimated_cost_cents=1,
+    )
+    assert d["decision"] == "allowed"
+    assert d["alert_caps"] == []
+
+
+def test_policy_check_raises_when_fail_open_disabled(short_tmp_path):
+    sp = os.path.join(short_tmp_path, "no.sock")
+    c = SpendwallClient(socket_path=sp, bearer="swk_test", fail_open=False)
+    import requests as _requests
+    with pytest.raises(_requests.RequestException):
+        c.policy_check(
+            agent_id="a1", provider="openai", model="gpt-4o",
+            estimated_cost_cents=1,
+        )
+
+
+def test_bearer_token_sent_on_every_request(short_tmp_path):
+    sp = os.path.join(short_tmp_path, "t.sock")
+    with fake_uds_server(sp, [
+        (200, b'{"decision":"allowed","alert_caps":[]}'),
+        (204, b""),
+    ]) as received:
+        c = SpendwallClient(socket_path=sp, bearer="swk_my_token_xyz")
+        c.policy_check(
+            agent_id="a1", provider="openai", model="gpt-4o",
+            estimated_cost_cents=1,
+        )
+        c.observe({"agent_id": "a1", "outcome": "success"})
+
+    # Both requests should have the bearer header.
+    assert len(received) == 2
+    for req in received:
+        lower = req.lower()
+        assert b"authorization: bearer swk_my_token_xyz" in lower
+
+
+def test_about_returns_daemon_metadata(short_tmp_path):
+    sp = os.path.join(short_tmp_path, "t.sock")
+    body = b'{"daemon_version":"0.1.0","api_versions_supported":["v1"]}'
+    with fake_uds_server(sp, [(200, body)]):
+        c = SpendwallClient(socket_path=sp, bearer="swk_test")
+        meta = c.about()
+        assert meta["daemon_version"] == "0.1.0"
+        assert meta["api_versions_supported"] == ["v1"]
+
+
+def test_policy_check_sends_request_body(short_tmp_path):
+    sp = os.path.join(short_tmp_path, "t.sock")
+    body = b'{"decision":"allowed","alert_caps":[]}'
+    with fake_uds_server(sp, [(200, body)]) as received:
+        c = SpendwallClient(socket_path=sp, bearer="swk_t")
+        c.policy_check(
+            agent_id="agent-x", provider="anthropic",
+            model="claude-3-5-sonnet-20241022",
+            estimated_cost_cents=42,
+            tags={"env": "test"},
+        )
+    assert len(received) == 1
+    payload = received[0]
+    assert b"agent-x" in payload
+    assert b"anthropic" in payload
+    assert b"claude-3-5-sonnet-20241022" in payload
+    assert b"42" in payload
+    assert b"env" in payload

spendwall-0.0.6/tests/test_errors.py

@@ -0,0 +1,57 @@
+"""Tests for spendwall.errors — class hierarchy and message construction."""
+
+import pytest
+
+from spendwall.errors import (
+    ApprovalRequiredError,
+    BlockedError,
+    SpendwallError,
+    SpendwallVersionMismatch,
+)
+
+
+def test_blocked_error_inherits_from_spendwall_error():
+    assert issubclass(BlockedError, SpendwallError)
+    assert issubclass(SpendwallError, Exception)
+
+
+def test_approval_required_error_inherits_from_spendwall_error():
+    assert issubclass(ApprovalRequiredError, SpendwallError)
+
+
+def test_version_mismatch_inherits_from_spendwall_error():
+    assert issubclass(SpendwallVersionMismatch, SpendwallError)
+
+
+def test_blocked_error_stores_attrs_and_formats_message():
+    err = BlockedError(cap_id="daily-cap", projected_cents=200, limit_cents=100)
+    assert err.cap_id == "daily-cap"
+    assert err.projected_cents == 200
+    assert err.limit_cents == 100
+    msg = str(err)
+    assert "daily-cap" in msg
+    assert "200" in msg
+    assert "100" in msg
+
+
+def test_approval_required_error_stores_caps_and_reason():
+    err = ApprovalRequiredError(approval_caps=["c1", "c2"])
+    assert err.approval_caps == ["c1", "c2"]
+    assert err.reason == "denied"
+    assert "c1" in str(err)
+
+
+def test_approval_required_error_custom_reason():
+    err = ApprovalRequiredError(approval_caps=["c1"], reason="timeout")
+    assert err.reason == "timeout"
+    assert "timeout" in str(err)
+
+
+def test_blocked_error_can_be_caught_as_spendwall_error():
+    with pytest.raises(SpendwallError):
+        raise BlockedError(cap_id="x", projected_cents=1, limit_cents=0)
+
+
+def test_approval_required_error_can_be_caught_as_spendwall_error():
+    with pytest.raises(SpendwallError):
+        raise ApprovalRequiredError(approval_caps=["x"])

spendwall-0.0.6/tests/test_modes.py

@@ -0,0 +1,28 @@
+import pytest
+
+import spendwall.modes as m
+
+
+def test_resolve_default_is_observe(monkeypatch):
+    monkeypatch.delenv("SPENDWALL_MODE", raising=False)
+    assert m.resolve() == "observe"
+
+
+def test_resolve_env_var_wins_over_default(monkeypatch):
+    monkeypatch.setenv("SPENDWALL_MODE", "enforce")
+    assert m.resolve() == "enforce"
+
+
+def test_resolve_configured_wins_over_env(monkeypatch):
+    monkeypatch.setenv("SPENDWALL_MODE", "observe")
+    assert m.resolve(configured="advisory") == "advisory"
+
+
+def test_resolve_per_call_wins_over_configured(monkeypatch):
+    monkeypatch.setenv("SPENDWALL_MODE", "observe")
+    assert m.resolve(per_call="enforce", configured="advisory") == "enforce"
+
+
+def test_resolve_rejects_invalid_mode():
+    with pytest.raises(ValueError):
+        m.resolve(per_call="block")

spendwall-0.0.6/tests/test_openai_wrapper.py

@@ -0,0 +1,178 @@
+"""Tests for spendwall.openai.wrap()."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from spendwall.errors import BlockedError
+
+
+@pytest.fixture
+def fake_openai_client():
+    client = MagicMock(name="openai.OpenAI")
+    completion = MagicMock(name="ChatCompletion")
+    completion.model = "gpt-4o"
+    completion.usage = MagicMock(prompt_tokens=10, completion_tokens=5)
+    completion.id = "chatcmpl_test"
+    client.chat.completions.create.return_value = completion
+
+    response = MagicMock(name="Response")
+    response.id = "resp_test"
+    response.usage = MagicMock(prompt_tokens=7, completion_tokens=3)
+    client.responses.create.return_value = response
+    return client
+
+
+def test_wrap_observe_mode_skips_policy_check_and_passes_through(
+    fake_openai_client, monkeypatch
+):
+    monkeypatch.setenv("SPENDWALL_MODE", "observe")
+    from spendwall.openai import wrap
+
+    sw_client = MagicMock(name="SpendwallClient")
+    wrapped = wrap(fake_openai_client, sw_client=sw_client, agent_id="a-test")
+    out = wrapped.chat.completions.create(
+        model="gpt-4o", messages=[{"role": "user", "content": "hi"}]
+    )
+    assert out.id == "chatcmpl_test"
+    sw_client.policy_check_strict.assert_not_called()
+    sw_client.policy_check.assert_not_called()
+    sw_client.observe.assert_called_once()
+    # Observe should carry post-flight token usage.
+    payload = sw_client.observe.call_args.args[0]
+    assert payload["agent_id"] == "a-test"
+    assert payload["provider"] == "openai"
+    assert payload["source"] == "sdk_python"
+    assert payload["input_tokens"] == 10
+    assert payload["output_tokens"] == 5
+    assert payload["outcome"] == "success"
+
+
+def test_wrap_enforce_mode_calls_policy_check_strict_then_observe(
+    fake_openai_client, monkeypatch
+):
+    monkeypatch.setenv("SPENDWALL_MODE", "enforce")
+    from spendwall.openai import wrap
+
+    sw_client = MagicMock(name="SpendwallClient")
+    sw_client.policy_check_strict.return_value = {
+        "decision": "allowed", "alert_caps": [],
+    }
+    wrapped = wrap(fake_openai_client, sw_client=sw_client, agent_id="a-test")
+    out = wrapped.chat.completions.create(
+        model="gpt-4o", messages=[{"role": "user", "content": "hi"}]
+    )
+    assert out.id == "chatcmpl_test"
+    sw_client.policy_check_strict.assert_called_once()
+    pcs_kwargs = sw_client.policy_check_strict.call_args.kwargs
+    assert pcs_kwargs["agent_id"] == "a-test"
+    assert pcs_kwargs["provider"] == "openai"
+    assert pcs_kwargs["model"] == "gpt-4o"
+    sw_client.observe.assert_called_once()
+
+
+def test_wrap_advisory_mode_calls_policy_check_non_strict(
+    fake_openai_client, monkeypatch
+):
+    monkeypatch.setenv("SPENDWALL_MODE", "advisory")
+    from spendwall.openai import wrap
+
+    sw_client = MagicMock(name="SpendwallClient")
+    sw_client.policy_check.return_value = {"decision": "allowed", "alert_caps": []}
+    wrapped = wrap(fake_openai_client, sw_client=sw_client, agent_id="a-test")
+    wrapped.chat.completions.create(
+        model="gpt-4o", messages=[{"role": "user", "content": "hi"}]
+    )
+    sw_client.policy_check.assert_called_once()
+    sw_client.policy_check_strict.assert_not_called()
+    sw_client.observe.assert_called_once()
+
+
+def test_wrap_enforce_blocked_raises_BlockedError_and_skips_upstream(
+    fake_openai_client, monkeypatch
+):
+    monkeypatch.setenv("SPENDWALL_MODE", "enforce")
+    from spendwall.openai import wrap
+
+    # Snapshot the original create-method mock before wrap() replaces it.
+    original_create = fake_openai_client.chat.completions.create
+
+    sw_client = MagicMock(name="SpendwallClient")
+    sw_client.policy_check_strict.side_effect = BlockedError("cap-x", 200, 100)
+    wrapped = wrap(fake_openai_client, sw_client=sw_client, agent_id="a-test")
+    with pytest.raises(BlockedError):
+        wrapped.chat.completions.create(
+            model="gpt-4o", messages=[{"role": "user", "content": "hi"}]
+        )
+    original_create.assert_not_called()
+    sw_client.observe.assert_not_called()
+
+
+def test_wrap_observes_upstream_error(fake_openai_client, monkeypatch):
+    monkeypatch.setenv("SPENDWALL_MODE", "observe")
+    from spendwall.openai import wrap
+
+    fake_openai_client.chat.completions.create.side_effect = RuntimeError("boom")
+    sw_client = MagicMock(name="SpendwallClient")
+    wrapped = wrap(fake_openai_client, sw_client=sw_client, agent_id="a-test")
+    with pytest.raises(RuntimeError):
+        wrapped.chat.completions.create(
+            model="gpt-4o", messages=[{"role": "user", "content": "hi"}]
+        )
+    sw_client.observe.assert_called_once()
+    payload = sw_client.observe.call_args.args[0]
+    assert payload["outcome"] == "upstream_error"
+
+
+def test_wrap_per_call_mode_overrides_configured(fake_openai_client, monkeypatch):
+    """Configured mode should override env default."""
+    monkeypatch.setenv("SPENDWALL_MODE", "observe")
+    from spendwall.openai import wrap
+
+    sw_client = MagicMock(name="SpendwallClient")
+    sw_client.policy_check_strict.return_value = {"decision": "allowed"}
+    # configured=enforce overrides env=observe.
+    wrapped = wrap(
+        fake_openai_client, sw_client=sw_client, agent_id="a", mode="enforce",
+    )
+    wrapped.chat.completions.create(
+        model="gpt-4o", messages=[{"role": "user", "content": "hi"}]
+    )
+    sw_client.policy_check_strict.assert_called_once()
+
+
+def test_wrap_patches_responses_create_too(fake_openai_client, monkeypatch):
+    monkeypatch.setenv("SPENDWALL_MODE", "observe")
+    from spendwall.openai import wrap
+
+    sw_client = MagicMock(name="SpendwallClient")
+    wrapped = wrap(fake_openai_client, sw_client=sw_client, agent_id="a")
+    out = wrapped.responses.create(model="gpt-4o", input="hi")
+    assert out.id == "resp_test"
+    sw_client.observe.assert_called_once()
+
+
+def test_wrap_returns_same_client_instance(fake_openai_client):
+    from spendwall.openai import wrap
+
+    sw_client = MagicMock(name="SpendwallClient")
+    out = wrap(fake_openai_client, sw_client=sw_client, agent_id="a")
+    assert out is fake_openai_client
+
+
+def test_wrap_propagates_tags_into_observe(fake_openai_client, monkeypatch):
+    monkeypatch.setenv("SPENDWALL_MODE", "observe")
+    from spendwall.openai import wrap
+
+    sw_client = MagicMock(name="SpendwallClient")
+    wrapped = wrap(
+        fake_openai_client, sw_client=sw_client, agent_id="a",
+        tags={"env": "test", "team": "ai"},
+    )
+    wrapped.chat.completions.create(
+        model="gpt-4o", messages=[{"role": "user", "content": "hi"}]
+    )
+    payload = sw_client.observe.call_args.args[0]
+    assert payload["tags"] == {"env": "test", "team": "ai"}