tripwire-litellm 0.1.0__tar.gz

tripwire_litellm-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: tripwire-litellm
+Version: 0.1.0
+Summary: Tripwire hard-stop and ingest callback for a customer's LiteLLM proxy
+Requires-Python: >=3.9
+Requires-Dist: httpx
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"

tripwire_litellm-0.1.0/README.md

@@ -0,0 +1,47 @@
+# tripwire-litellm
+
+Pre-call budget check and post-call ingest for a customer's LiteLLM proxy. Product behavior, fail-open, and overshoot are in `docs/hard-stop.md` at the repo root.
+
+## Install
+
+Python 3.9 or newer. The proxy already has LiteLLM.
+
+```bash
+pip install -e integrations/litellm
+```
+
+## Config
+
+`callbacks` must point at the instance:
+
+```yaml
+litellm_settings:
+  callbacks: ["tripwire_litellm.handler.proxy_handler_instance"]
+```
+
+```bash
+TRIPWIRE_INGEST_TOKEN=tw_live_...          # required, never log it
+TRIPWIRE_BASE_URL=https://www.tripwire.agency
+TRIPWIRE_FAIL_MODE=open                    # or closed
+TRIPWIRE_CHECK_TIMEOUT_MS=800
+TRIPWIRE_DENY_STATUS=402                   # not 429; SDKs retry 429
+TRIPWIRE_RESERVE_USD=0
+TRIPWIRE_HARD_STOP=on                      # off = ingest only
+TRIPWIRE_CLIENT_ID=
+TRIPWIRE_PROJECT_ID=
+```
+
+## Verified hook
+
+Checked against the LiteLLM proxy call-hook docs (fetched 2026-10-05). Minimum proxy version: **1.65.0** (the `async_pre_call_hook` arguments and `UserAPIKeyAuth.metadata` / `team_metadata` are stable there). These unit tests stub `litellm.integrations.custom_logger` when the package is not installed.
+
+- `async_pre_call_hook(self, user_api_key_dict, cache, data, call_type)`
+- Request attribution: `data["metadata"]["tripwire_client_id"]` and `tripwire_project_id`
+- Virtual key: `user_api_key_dict.metadata`
+- Team: `user_api_key_dict.team_metadata`
+- Fallback: `TRIPWIRE_CLIENT_ID` and `TRIPWIRE_PROJECT_ID`
+- `async_log_success_event(self, kwargs, response_obj, start_time, end_time)`
+- Call id: `kwargs["litellm_call_id"]`, then `kwargs["litellm_params"]["litellm_call_id"]`, then `response_obj.id`
+- Cost and provider: `kwargs["response_cost"]`, `kwargs["litellm_params"]["custom_llm_provider"]`, `kwargs["model"]`
+
+A deny raises `fastapi.HTTPException` 402 with `error.code` `tripwire_budget_exceeded`. Allow returns `data` unchanged.

tripwire_litellm-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "tripwire-litellm"
+version = "0.1.0"
+description = "Tripwire hard-stop and ingest callback for a customer's LiteLLM proxy"
+requires-python = ">=3.9"
+dependencies = ["httpx"]
+
+[project.optional-dependencies]
+test = ["pytest", "pytest-asyncio"]
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["tripwire_litellm*"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

tripwire_litellm-0.1.0/setup.cfg

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

tripwire_litellm-0.1.0/tests/test_handler.py

@@ -0,0 +1,307 @@
+import asyncio
+import json
+import logging
+import os
+
+import httpx
+import pytest
+
+from tripwire_litellm.handler import TripwireHandler, proxy_handler_instance
+
+TOKEN = "tw_live_SUPERSECRET"
+CLIENT = "11111111-1111-4111-8111-111111111111"
+PROJECT = "44444444-4444-4444-8444-444444444444"
+
+
+class Key:
+    def __init__(self, metadata=None, team_metadata=None):
+        self.metadata = metadata or {}
+        self.team_metadata = team_metadata or {}
+
+
+def allow_body(ttl=15, **extra):
+    body = {
+        "decision": "allow",
+        "enforced": True,
+        "reason": "within_budget",
+        "scope": "client",
+        "ttl_seconds": ttl,
+        "spend_usd": 1,
+        "budget_usd": 10,
+    }
+    body.update(extra)
+    return body
+
+
+def deny_body():
+    return {
+        "decision": "deny",
+        "enforced": True,
+        "reason": "budget_exceeded",
+        "scope": "project",
+        "ttl_seconds": 30,
+        "spend_usd": 10,
+        "budget_usd": 10,
+    }
+
+
+@pytest.fixture
+def env(monkeypatch):
+    monkeypatch.setenv("TRIPWIRE_INGEST_TOKEN", TOKEN)
+    monkeypatch.setenv("TRIPWIRE_BASE_URL", "https://www.tripwire.agency")
+    monkeypatch.setenv("TRIPWIRE_FAIL_MODE", "open")
+    monkeypatch.setenv("TRIPWIRE_HARD_STOP", "on")
+    monkeypatch.delenv("TRIPWIRE_CLIENT_ID", raising=False)
+    monkeypatch.delenv("TRIPWIRE_PROJECT_ID", raising=False)
+    monkeypatch.delenv("TRIPWIRE_DENY_STATUS", raising=False)
+    monkeypatch.delenv("TRIPWIRE_RESERVE_USD", raising=False)
+
+
+def handler(transport, clock=None):
+    box = {"t": 0.0}
+
+    def now():
+        return box["t"] if clock is None else clock["t"]
+
+    return TripwireHandler(transport=transport, now=now), box if clock is None else clock
+
+
+def data_for(client=CLIENT, project=""):
+    meta = {}
+    if client:
+        meta["tripwire_client_id"] = client
+    if project:
+        meta["tripwire_project_id"] = project
+    return {"model": "gpt-4o", "metadata": meta}
+
+
+async def test_allow_returns_data_and_deny_raises_402(env):
+    calls = {"n": 0}
+
+    def transport(request: httpx.Request) -> httpx.Response:
+        calls["n"] += 1
+        body = json.loads(request.content.decode())
+        if body.get("estimated_cost_usd") == 0 and "client_id" in body:
+            return httpx.Response(200, json=allow_body())
+        return httpx.Response(200, json=deny_body())
+
+    hook, _clock = handler(httpx.MockTransport(transport))
+    payload = data_for()
+    assert await hook.async_pre_call_hook(Key(), None, payload, "completion") is payload
+
+    denied = data_for(project=PROJECT)
+    # Force the deny response by a separate handler.
+    def deny_transport(request: httpx.Request) -> httpx.Response:
+        assert request.headers["authorization"] == f"Bearer {TOKEN}"
+        assert TOKEN not in request.content.decode()
+        return httpx.Response(200, json=deny_body())
+
+    deny_hook, _clock = handler(httpx.MockTransport(deny_transport))
+    with pytest.raises(Exception) as caught:
+        await deny_hook.async_pre_call_hook(Key(), None, data_for(project=PROJECT), "completion")
+    assert caught.value.status_code == 402
+    assert caught.value.detail["error"]["code"] == "tripwire_budget_exceeded"
+    assert "monthly budget" in caught.value.detail["error"]["message"]
+    assert "$10.00 of $10.00" in caught.value.detail["error"]["message"]
+    assert denied is not payload
+
+
+async def test_cache_hit_skips_the_second_request_and_ttl_0_rechecks(env):
+    calls = {"n": 0}
+
+    def transport(request: httpx.Request) -> httpx.Response:
+        calls["n"] += 1
+        ttl = 15 if calls["n"] == 1 else 0
+        return httpx.Response(200, json=allow_body(ttl=ttl if calls["n"] < 3 else 0))
+
+    hook, clock = handler(httpx.MockTransport(transport))
+    await hook.async_pre_call_hook(Key(), None, data_for(), "completion")
+    await hook.async_pre_call_hook(Key(), None, data_for(), "completion")
+    assert calls["n"] == 1
+
+    zero = {"n": 0}
+
+    def always(request: httpx.Request) -> httpx.Response:
+        zero["n"] += 1
+        return httpx.Response(200, json=allow_body(ttl=0))
+
+    fresh, _clock = handler(httpx.MockTransport(always))
+    await fresh.async_pre_call_hook(Key(), None, data_for(), "completion")
+    await fresh.async_pre_call_hook(Key(), None, data_for(), "completion")
+    assert zero["n"] == 2
+    assert clock["t"] == 0
+
+
+async def test_concurrent_misses_share_one_request(env):
+    calls = {"n": 0}
+    started = asyncio.Event()
+    release = asyncio.Event()
+
+    class Slow(httpx.AsyncBaseTransport):
+        async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
+            calls["n"] += 1
+            started.set()
+            await release.wait()
+            return httpx.Response(200, json=allow_body(ttl=15))
+
+    hook, _clock = handler(Slow())
+
+    async def one():
+        return await hook.async_pre_call_hook(Key(), None, data_for(), "completion")
+
+    pending = [asyncio.create_task(one()) for _ in range(50)]
+    await asyncio.wait_for(started.wait(), timeout=2)
+    await asyncio.sleep(0.05)
+    release.set()
+    results = await asyncio.gather(*pending)
+    assert calls["n"] == 1
+    assert all(item["metadata"]["tripwire_client_id"] == CLIENT for item in results)
+
+
+async def test_timeout_allows_when_open_and_503_when_closed(env, monkeypatch):
+    def boom(request: httpx.Request) -> httpx.Response:
+        raise httpx.ReadTimeout("timed out", request=request)
+
+    open_hook, _clock = handler(httpx.MockTransport(boom))
+    payload = data_for()
+    assert await open_hook.async_pre_call_hook(Key(), None, payload, "completion") is payload
+
+    monkeypatch.setenv("TRIPWIRE_FAIL_MODE", "closed")
+    closed, _clock = handler(httpx.MockTransport(boom))
+    with pytest.raises(Exception) as caught:
+        await closed.async_pre_call_hook(Key(), None, data_for(), "completion")
+    assert caught.value.status_code == 503
+    assert caught.value.detail["error"]["code"] == "tripwire_unavailable"
+
+
+async def test_circuit_breaker_opens_and_recovers(env):
+    calls = {"n": 0}
+
+    def transport(request: httpx.Request) -> httpx.Response:
+        calls["n"] += 1
+        if calls["n"] <= 5:
+            raise httpx.ConnectError("down")
+        return httpx.Response(200, json=allow_body(ttl=0))
+
+    clock = {"t": 100.0}
+    hook, _clock = handler(httpx.MockTransport(transport), clock)
+    for _ in range(5):
+        await hook.async_pre_call_hook(Key(), None, data_for(), "completion")
+    assert calls["n"] == 5
+    await hook.async_pre_call_hook(Key(), None, data_for(), "completion")
+    assert calls["n"] == 5
+    clock["t"] = 130.0
+    await hook.async_pre_call_hook(Key(), None, data_for(), "completion")
+    assert calls["n"] == 6
+
+
+async def test_attribution_precedence_and_missing_warns_once(env, monkeypatch, caplog):
+    seen = []
+
+    def transport(request: httpx.Request) -> httpx.Response:
+        seen.append(json.loads(request.content.decode()))
+        return httpx.Response(200, json=allow_body(ttl=0))
+
+    hook, _clock = handler(httpx.MockTransport(transport))
+    monkeypatch.setenv("TRIPWIRE_CLIENT_ID", "env-client")
+    monkeypatch.setenv("TRIPWIRE_PROJECT_ID", "env-project")
+    key = Key(
+        metadata={"tripwire_client_id": "key-client", "tripwire_project_id": "key-project"},
+        team_metadata={"tripwire_client_id": "team-client", "tripwire_project_id": "team-project"},
+    )
+    await hook.async_pre_call_hook(
+        key,
+        None,
+        {"metadata": {"tripwire_client_id": "req-client", "tripwire_project_id": "req-project"}},
+        "completion",
+    )
+    await hook.async_pre_call_hook(key, None, {"metadata": {}}, "completion")
+    await hook.async_pre_call_hook(
+        Key(team_metadata={"tripwire_client_id": "team-client"}),
+        None,
+        {},
+        "completion",
+    )
+    await hook.async_pre_call_hook(Key(), None, {}, "completion")
+    assert seen[0]["client_id"] == "req-client"
+    assert seen[0]["project_id"] == "req-project"
+    assert seen[1]["client_id"] == "key-client"
+    assert seen[2]["client_id"] == "team-client"
+    assert seen[2]["project_id"] == "env-project"
+
+    monkeypatch.delenv("TRIPWIRE_CLIENT_ID", raising=False)
+    monkeypatch.delenv("TRIPWIRE_PROJECT_ID", raising=False)
+    caplog.set_level(logging.WARNING, logger="tripwire_litellm")
+    bare = TripwireHandler(transport=httpx.MockTransport(transport), now=lambda: 0)
+    await bare.async_pre_call_hook(Key(), None, {}, "completion")
+    await bare.async_pre_call_hook(Key(), None, {}, "completion")
+    warnings = [rec.message for rec in caplog.records if "no client or project" in rec.message]
+    assert len(warnings) == 1
+
+
+async def test_success_log_invalidates_the_cache(env):
+    calls = {"check": 0, "ingest": 0}
+    bodies = []
+
+    def transport(request: httpx.Request) -> httpx.Response:
+        if request.url.path.endswith("/budget/check"):
+            calls["check"] += 1
+            return httpx.Response(200, json=allow_body(ttl=60))
+        calls["ingest"] += 1
+        bodies.append(json.loads(request.content.decode()))
+        assert TOKEN not in request.content.decode()
+        return httpx.Response(201, json={"event": {"id": "evt-1"}})
+
+    hook, _clock = handler(httpx.MockTransport(transport))
+    payload = data_for(project=PROJECT)
+    await hook.async_pre_call_hook(Key(), None, payload, "completion")
+    await hook.async_pre_call_hook(Key(), None, payload, "completion")
+    assert calls["check"] == 1
+
+    class Usage:
+        prompt_tokens = 12
+        completion_tokens = 4
+
+    class Response:
+        id = "chatcmpl-1"
+        usage = Usage()
+
+    await hook.async_log_success_event(
+        {
+            "model": "gpt-4o",
+            "response_cost": 0.02,
+            "litellm_call_id": "call-99",
+            "litellm_params": {
+                "custom_llm_provider": "openai",
+                "metadata": {"tripwire_client_id": CLIENT, "tripwire_project_id": PROJECT},
+            },
+        },
+        Response(),
+        None,
+        None,
+    )
+    assert calls["ingest"] == 1
+    assert bodies[0]["external_request_id"] == "call-99"
+    assert bodies[0]["estimated_cost_usd"] == 0.02
+    assert bodies[0]["client_id"] == CLIENT
+    assert bodies[0]["input_tokens"] == 12
+    await hook.async_pre_call_hook(Key(), None, payload, "completion")
+    assert calls["check"] == 2
+
+
+async def test_token_never_appears_in_logs(env, caplog):
+    def boom(request: httpx.Request) -> httpx.Response:
+        raise httpx.ReadTimeout("timed out", request=request)
+
+    caplog.set_level(logging.DEBUG)
+    hook, _clock = handler(httpx.MockTransport(boom))
+    await hook.async_pre_call_hook(Key(), None, data_for(), "completion")
+    text = "\n".join(record.getMessage() for record in caplog.records)
+    assert TOKEN not in text
+    assert "SUPERSECRET" not in text
+    assert "Bearer" not in text
+
+
+def test_proxy_handler_instance_is_an_instance():
+    assert isinstance(proxy_handler_instance, TripwireHandler)
+    assert not isinstance(proxy_handler_instance, type)

tripwire_litellm-0.1.0/tripwire_litellm/__init__.py

@@ -0,0 +1,5 @@
+"""Tripwire budget check and usage ingest for a LiteLLM proxy."""
+
+from tripwire_litellm.handler import TripwireHandler, proxy_handler_instance
+
+__all__ = ["TripwireHandler", "proxy_handler_instance"]

tripwire_litellm-0.1.0/tripwire_litellm/handler.py

@@ -0,0 +1,406 @@
+"""LiteLLM proxy callback: stop a call before it runs, then ingest it.
+
+Configure an instance, not the class:
+
+    litellm_settings:
+      callbacks: ["tripwire_litellm.handler.proxy_handler_instance"]
+
+Hook signature verified against the LiteLLM proxy call-hook docs
+(async_pre_call_hook(user_api_key_dict, cache, data, call_type)).
+Virtual-key metadata is UserAPIKeyAuth.metadata. Team metadata is
+UserAPIKeyAuth.team_metadata. Request overrides live on
+data["metadata"] as tripwire_client_id and tripwire_project_id.
+Success logging is async_log_success_event(kwargs, response_obj,
+start_time, end_time). The call id is kwargs["litellm_call_id"],
+then litellm_params.litellm_call_id, then response_obj.id.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import time
+from typing import Any, Callable, Dict, Optional, Tuple
+
+import httpx
+
+try:
+    from litellm.integrations.custom_logger import CustomLogger
+except ImportError:  # LiteLLM is installed on the proxy, not in unit tests.
+
+    class CustomLogger:  # type: ignore[no-redef]
+        pass
+
+
+logger = logging.getLogger("tripwire_litellm")
+
+Scope = Tuple[str, str]
+
+
+class _Result:
+    def __init__(self, kind: str, body: Optional[dict] = None) -> None:
+        self.kind = kind
+        self.body = body or {}
+
+
+class TripwireHandler(CustomLogger):
+    def __init__(
+        self,
+        transport: Optional[httpx.AsyncBaseTransport] = None,
+        now: Optional[Callable[[], float]] = None,
+    ) -> None:
+        self._transport = transport
+        self._now = now or time.monotonic
+        self._cache: Dict[Scope, Tuple[float, _Result]] = {}
+        self._inflight: Dict[Scope, "asyncio.Task[_Result]"] = {}
+        self._lock: Optional[asyncio.Lock] = None
+        self._failures = 0
+        self._open_until = 0.0
+        self._warned_missing = False
+        self._last_warn = -1e9
+
+    async def async_pre_call_hook(self, user_api_key_dict: Any, cache: Any, data: dict, call_type: str) -> dict:
+        del cache, call_type
+        if not isinstance(data, dict):
+            data = {}
+        if not _hard_stop_enabled():
+            return data
+        client_id, project_id = resolve_attribution(data, user_api_key_dict)
+        if not client_id and not project_id:
+            self._warn_missing()
+            return data
+        result = await self._cached_check(client_id, project_id, _model(data))
+        if result.kind == "deny":
+            _raise(_deny_status(), _deny_detail(result.body))
+        if result.kind == "error":
+            if _fail_closed():
+                self._warn_limited("Tripwire budget check failed; blocking the call")
+                _raise(503, _unavailable_detail())
+            self._warn_limited("Tripwire budget check failed; allowing the call")
+        return data
+
+    async def async_log_success_event(self, kwargs: dict, response_obj: Any, start_time: Any, end_time: Any) -> None:
+        del start_time, end_time
+        if not isinstance(kwargs, dict):
+            kwargs = {}
+        client_id, project_id = attribution_from_kwargs(kwargs)
+        if not client_id and not project_id:
+            self._warn_missing()
+            return
+        self._cache.pop((client_id, project_id), None)
+        if not _token():
+            self._warn_limited("Tripwire ingest token is not set; usage was not recorded")
+            return
+        payload = _ingest_payload(kwargs, response_obj, client_id, project_id)
+        try:
+            async with self._client(10) as client:
+                await client.post(_url("/api/v1/ingest/usage"), headers=_headers(), json=payload)
+        except Exception:
+            self._warn_limited("Tripwire usage ingest failed")
+
+    async def _cached_check(self, client_id: str, project_id: str, model: Optional[str]) -> _Result:
+        key: Scope = (client_id, project_id)
+        now = self._now()
+        async with self._guard():
+            if now < self._open_until:
+                return _Result("error")
+            cached = self._cache.get(key)
+            if cached and cached[0] > now:
+                return cached[1]
+            task = self._inflight.get(key)
+            if task is None:
+                task = asyncio.create_task(self._fetch(client_id, project_id, model, key))
+                self._inflight[key] = task
+        try:
+            return await task
+        finally:
+            async with self._guard():
+                if self._inflight.get(key) is task:
+                    self._inflight.pop(key, None)
+
+    def _guard(self) -> asyncio.Lock:
+        if self._lock is None:
+            self._lock = asyncio.Lock()
+        return self._lock
+
+    async def _fetch(self, client_id: str, project_id: str, model: Optional[str], key: Scope) -> _Result:
+        result = await self._request(client_id, project_id, model)
+        if result.kind == "error":
+            self._note_failure()
+            return result
+        self._failures = 0
+        self._open_until = 0.0
+        ttl = _ttl(result)
+        if ttl > 0:
+            self._cache[key] = (self._now() + ttl, result)
+        return result
+
+    async def _request(self, client_id: str, project_id: str, model: Optional[str]) -> _Result:
+        if not _token():
+            return _Result("error")
+        body: Dict[str, Any] = {"estimated_cost_usd": _reserve()}
+        if client_id:
+            body["client_id"] = client_id
+        if project_id:
+            body["project_id"] = project_id
+        if model:
+            body["model"] = model
+        timeout = _timeout_seconds()
+        try:
+            async with self._client(timeout) as client:
+                response = await client.post(_url("/api/v1/budget/check"), headers=_headers(), json=body)
+        except Exception:
+            return _Result("error")
+        if response.status_code == 401 or response.status_code >= 500 or response.status_code != 200:
+            return _Result("error")
+        try:
+            payload = response.json()
+        except Exception:
+            return _Result("error")
+        if not isinstance(payload, dict):
+            return _Result("error")
+        decision = payload.get("decision")
+        if decision == "deny":
+            return _Result("deny", payload)
+        if decision == "allow":
+            return _Result("allow", payload)
+        return _Result("error")
+
+    def _note_failure(self) -> None:
+        self._failures += 1
+        if self._failures >= 5:
+            self._open_until = self._now() + 30
+            self._failures = 0
+
+    def _client(self, timeout: float) -> httpx.AsyncClient:
+        kwargs: Dict[str, Any] = {"timeout": timeout}
+        if self._transport is not None:
+            kwargs["transport"] = self._transport
+        return httpx.AsyncClient(**kwargs)
+
+    def _warn_missing(self) -> None:
+        if self._warned_missing:
+            return
+        self._warned_missing = True
+        logger.warning("Tripwire has no client or project attribution; allowing the call")
+
+    def _warn_limited(self, message: str) -> None:
+        now = self._now()
+        if now - self._last_warn < 30:
+            return
+        self._last_warn = now
+        logger.warning(message)
+
+
+proxy_handler_instance = TripwireHandler()
+
+
+def resolve_attribution(data: Any, user_api_key_dict: Any) -> Tuple[str, str]:
+    """First source that sets an id wins for that id. Request metadata, then the virtual key, then the team, then env."""
+    sources = [
+        _meta(data, "metadata") if isinstance(data, dict) else {},
+        _obj_dict(user_api_key_dict, "metadata"),
+        _obj_dict(user_api_key_dict, "team_metadata"),
+        {
+            "tripwire_client_id": os.environ.get("TRIPWIRE_CLIENT_ID", ""),
+            "tripwire_project_id": os.environ.get("TRIPWIRE_PROJECT_ID", ""),
+        },
+    ]
+    client_id = ""
+    project_id = ""
+    for source in sources:
+        if not client_id:
+            client_id = _clean(source.get("tripwire_client_id"))
+        if not project_id:
+            project_id = _clean(source.get("tripwire_project_id"))
+    return client_id, project_id
+
+
+def attribution_from_kwargs(kwargs: dict) -> Tuple[str, str]:
+    params = kwargs.get("litellm_params")
+    if not isinstance(params, dict):
+        params = {}
+    metadata = params.get("metadata")
+    if not isinstance(metadata, dict):
+        raw = kwargs.get("metadata")
+        metadata = raw if isinstance(raw, dict) else {}
+    key = kwargs.get("user_api_key_dict")
+    if key is None:
+        key = params.get("user_api_key_dict")
+    if key is None:
+        key = _DictKey(
+            metadata.get("user_api_key_metadata") if isinstance(metadata.get("user_api_key_metadata"), dict) else {},
+            metadata.get("user_api_key_team_metadata")
+            if isinstance(metadata.get("user_api_key_team_metadata"), dict)
+            else {},
+        )
+    return resolve_attribution({"metadata": metadata}, key)
+
+
+class _DictKey:
+    def __init__(self, metadata: dict, team_metadata: dict) -> None:
+        self.metadata = metadata
+        self.team_metadata = team_metadata
+
+
+def _ingest_payload(kwargs: dict, response_obj: Any, client_id: str, project_id: str) -> dict:
+    params = kwargs.get("litellm_params") if isinstance(kwargs.get("litellm_params"), dict) else {}
+    usage = getattr(response_obj, "usage", None)
+    payload: Dict[str, Any] = {
+        "source_type": "litellm_proxy",
+        "provider_name": params.get("custom_llm_provider") or "unknown",
+        "model_name": kwargs.get("model") or "unknown",
+        "status": "success",
+        "input_tokens": int(getattr(usage, "prompt_tokens", 0) or 0),
+        "output_tokens": int(getattr(usage, "completion_tokens", 0) or 0),
+        "estimated_cost_usd": float(kwargs.get("response_cost") or 0),
+    }
+    if client_id:
+        payload["client_id"] = client_id
+    if project_id:
+        payload["project_id"] = project_id
+    call_id = _call_id(kwargs, params, response_obj)
+    if call_id:
+        payload["external_request_id"] = call_id
+    return payload
+
+
+def _call_id(kwargs: dict, params: dict, response_obj: Any) -> str:
+    for value in (kwargs.get("litellm_call_id"), params.get("litellm_call_id"), getattr(response_obj, "id", None)):
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return ""
+
+
+def _deny_detail(body: dict) -> dict:
+    scope = body.get("scope")
+    label = "This project" if scope == "project" else "This client" if scope == "client" else "This budget"
+    spend = _money(body.get("spend_usd"))
+    budget = _money(body.get("budget_usd"))
+    message = f"{label} has used its monthly budget ({spend} of {budget}). Raise the budget in Tripwire to resume."
+    return {"error": {"type": "budget_exceeded", "code": "tripwire_budget_exceeded", "message": message}}
+
+
+def _unavailable_detail() -> dict:
+    return {
+        "error": {
+            "type": "tripwire_unavailable",
+            "code": "tripwire_unavailable",
+            "message": "Tripwire budget check is unavailable.",
+        }
+    }
+
+
+def _raise(status: int, detail: dict) -> None:
+    try:
+        from fastapi import HTTPException
+    except ImportError:
+
+        class HTTPException(Exception):
+            def __init__(self, status_code: int, detail: Any = None) -> None:
+                self.status_code = status_code
+                self.detail = detail
+                super().__init__(str(detail))
+
+    raise HTTPException(status_code=status, detail=detail)
+
+
+def _headers() -> Dict[str, str]:
+    return {
+        "Authorization": f"Bearer {_token()}",
+        "Content-Type": "application/json",
+    }
+
+
+def _token() -> str:
+    return os.environ.get("TRIPWIRE_INGEST_TOKEN", "").strip()
+
+
+def _base_url() -> str:
+    raw = os.environ.get("TRIPWIRE_BASE_URL", "").strip() or "https://www.tripwire.agency"
+    return raw.rstrip("/")
+
+
+def _url(path: str) -> str:
+    return f"{_base_url()}{path}"
+
+
+def _hard_stop_enabled() -> bool:
+    value = os.environ.get("TRIPWIRE_HARD_STOP", "on").strip().lower()
+    return value not in {"off", "0", "false", "no"}
+
+
+def _fail_closed() -> bool:
+    return os.environ.get("TRIPWIRE_FAIL_MODE", "open").strip().lower() == "closed"
+
+
+def _timeout_seconds() -> float:
+    raw = os.environ.get("TRIPWIRE_CHECK_TIMEOUT_MS", "").strip()
+    try:
+        ms = int(raw) if raw else 800
+    except ValueError:
+        ms = 800
+    return max(ms, 1) / 1000
+
+
+def _deny_status() -> int:
+    raw = os.environ.get("TRIPWIRE_DENY_STATUS", "").strip()
+    try:
+        status = int(raw) if raw else 402
+    except ValueError:
+        return 402
+    return status if 400 <= status <= 599 else 402
+
+
+def _reserve() -> float:
+    raw = os.environ.get("TRIPWIRE_RESERVE_USD", "").strip()
+    try:
+        value = float(raw) if raw else 0
+    except ValueError:
+        return 0
+    return value if value > 0 else 0
+
+
+def _ttl(result: _Result) -> float:
+    raw = result.body.get("ttl_seconds")
+    try:
+        ttl = float(raw)
+    except (TypeError, ValueError):
+        return 60 if result.kind == "allow" else 0
+    return ttl if ttl > 0 else 0
+
+
+def _money(value: Any) -> str:
+    try:
+        return f"${float(value):.2f}"
+    except (TypeError, ValueError):
+        return "$0.00"
+
+
+def _model(data: dict) -> Optional[str]:
+    model = data.get("model")
+    if isinstance(model, str) and model.strip():
+        return model.strip()
+    return None
+
+
+def _meta(data: dict, key: str) -> dict:
+    raw = data.get(key)
+    return raw if isinstance(raw, dict) else {}
+
+
+def _obj_dict(obj: Any, name: str) -> dict:
+    raw = getattr(obj, name, None)
+    if isinstance(raw, dict):
+        return raw
+    if isinstance(obj, dict):
+        value = obj.get(name)
+        return value if isinstance(value, dict) else {}
+    return {}
+
+
+def _clean(value: Any) -> str:
+    if not isinstance(value, str):
+        return ""
+    return value.strip()

tripwire_litellm-0.1.0/tripwire_litellm.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: tripwire-litellm
+Version: 0.1.0
+Summary: Tripwire hard-stop and ingest callback for a customer's LiteLLM proxy
+Requires-Python: >=3.9
+Requires-Dist: httpx
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"

tripwire_litellm-0.1.0/tripwire_litellm.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+tests/test_handler.py
+tripwire_litellm/__init__.py
+tripwire_litellm/handler.py
+tripwire_litellm.egg-info/PKG-INFO
+tripwire_litellm.egg-info/SOURCES.txt
+tripwire_litellm.egg-info/dependency_links.txt
+tripwire_litellm.egg-info/requires.txt
+tripwire_litellm.egg-info/top_level.txt

tripwire_litellm-0.1.0/tripwire_litellm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tripwire_litellm-0.1.0/tripwire_litellm.egg-info/requires.txt

@@ -0,0 +1,5 @@
+httpx
+
+[test]
+pytest
+pytest-asyncio

tripwire_litellm-0.1.0/tripwire_litellm.egg-info/top_level.txt

@@ -0,0 +1 @@
+tripwire_litellm