langchain-openentity 0.1.0__tar.gz

langchain_openentity-0.1.0/.gitignore

@@ -0,0 +1,14 @@
+node_modules/
+dist/
+.astro/
+.wrangler/
+.dev.vars
+.env*
+!.env.example
+__pycache__/
+*.pyc
+.venv/
+*.egg-info/
+.DS_Store
+coverage/
+.claude/

langchain_openentity-0.1.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.5
+Name: langchain-openentity
+Version: 0.1.0
+Summary: RuthlessSchemaGuard: LangChain middleware and HTTP transport guard that raises on malformed API and tool responses, with an optional signed ledger reporter.
+Project-URL: Homepage, https://openentity.org
+Project-URL: Documentation, https://oeis.dev
+Project-URL: Source, https://github.com/moltbot-den/openentity
+License-Expression: MIT
+Requires-Python: >=3.11
+Requires-Dist: httpx
+Requires-Dist: jsonschema>=4.18
+Requires-Dist: langchain>=1.4
+Requires-Dist: pydantic>=2
+Provides-Extra: aiohttp
+Requires-Dist: aiohttp; extra == 'aiohttp'
+Provides-Extra: ledger
+Requires-Dist: openentity>=0.4; extra == 'ledger'
+Provides-Extra: requests
+Requires-Dist: requests; extra == 'requests'
+Description-Content-Type: text/markdown
+
+# langchain-openentity
+
+RuthlessSchemaGuard for LangChain: middleware and HTTP transport guard that raise `OpenEntitySchemaViolation` on malformed tool and API responses, a dead-loop breaker, and an optional signed ledger reporter.
+
+```bash
+pip install langchain-openentity
+```
+
+```python
+from langchain_openentity import RuthlessSchemaGuard
+
+guard = RuthlessSchemaGuard()
+guard.register("get_pulls", list[Pull])
+guard.guard_http()
+agent = create_agent(model, tools=[get_pulls], middleware=[guard])  # first in the list
+```
+
+Full documentation, the rule table and the ledger settings: <https://github.com/moltbot-den/openentity/tree/main/integrations/langchain>

langchain_openentity-0.1.0/README.md

@@ -0,0 +1,18 @@
+# langchain-openentity
+
+RuthlessSchemaGuard for LangChain: middleware and HTTP transport guard that raise `OpenEntitySchemaViolation` on malformed tool and API responses, a dead-loop breaker, and an optional signed ledger reporter.
+
+```bash
+pip install langchain-openentity
+```
+
+```python
+from langchain_openentity import RuthlessSchemaGuard
+
+guard = RuthlessSchemaGuard()
+guard.register("get_pulls", list[Pull])
+guard.guard_http()
+agent = create_agent(model, tools=[get_pulls], middleware=[guard])  # first in the list
+```
+
+Full documentation, the rule table and the ledger settings: <https://github.com/moltbot-den/openentity/tree/main/integrations/langchain>

langchain_openentity-0.1.0/langchain_openentity/__init__.py

@@ -0,0 +1,8 @@
+from .core import OpenEntityLoopDetected, OpenEntitySchemaViolation, inspect_response, scrub
+from .guard import RuthlessSchemaGuard
+from .ledger import DEFAULT_URL, LedgerReporter
+
+__all__ = [
+    "RuthlessSchemaGuard", "OpenEntitySchemaViolation", "OpenEntityLoopDetected",
+    "LedgerReporter", "DEFAULT_URL", "inspect_response", "scrub",
+]

langchain_openentity-0.1.0/langchain_openentity/core.py

@@ -0,0 +1,266 @@
+"""Response inspection shared by the middleware and the HTTP transport hooks.
+
+The rules and rule names mirror the JS package (`@openentity/langchain`); `fixtures/` holds the
+corpus both test suites run, so the two stay in step.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import urlsplit
+
+from jsonschema import Draft202012Validator
+from pydantic import TypeAdapter, ValidationError
+
+EXCERPT = 500
+SAMPLE = 2048
+
+
+class OpenEntitySchemaViolation(Exception):
+    """A response broke its contract. Never converted to a ToolMessage by this package."""
+
+    def __init__(self, tool: str, errors: list[str], raw_excerpt: str = ""):
+        self.tool = tool
+        self.errors = list(errors)
+        self.raw_excerpt = scrub(raw_excerpt)[:EXCERPT]
+        self.rule = self.errors[0].split(":", 1)[0] if self.errors else ""
+        super().__init__(f"{tool}: " + "; ".join(self.errors[:3]))
+
+
+class OpenEntityLoopDetected(Exception):
+    """The same tool call with the same arguments failed `count` times in a row."""
+
+    def __init__(self, tool: str, args_hash: str, count: int):
+        self.tool, self.args_hash, self.count = tool, args_hash, count
+        super().__init__(f"{tool} failed {count} times with identical arguments ({args_hash[:12]})")
+
+
+# ---- scrubbing (rules ported from the ClawGRC/SMA secret scanner; same list in the JS package) ----
+_FULL = [re.compile(p) for p in (
+    r"AKIA[0-9A-Z]{16}",
+    r"gh[pousr]_[A-Za-z0-9_]{36,255}",
+    r"xox[bpsa]-[0-9]+-[0-9A-Za-z-]+",
+    r"eyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+",
+    r"-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|(?![\s\S]))",
+    r"(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis|mssql)://[^:\s/]+:[^@\s]+@[^/\s\"']+",
+    r"[sr]k_(?:live|test)_[A-Za-z0-9]{20,}",
+    r"SG\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}",
+    r"[Bb]earer\s+[A-Za-z0-9._~+/=-]{16,}",
+    r"https?://[^/\s:@]+:[^/\s@]+@[^\s/\"']+",
+)]
+_KV = re.compile(
+    r"(\"?(?:api[_-]?key|api[_-]?secret|api[_-]?token|auth[_-]?token|access[_-]?token|refresh[_-]?token"
+    r"|secret[_-]?key|client[_-]?secret|password|passwd|token|secret)\"?\s*[=:]\s*\"?)[^\s\"',}&]{6,}",
+    re.I,
+)
+
+
+def scrub(text: str) -> str:
+    for rx in _FULL:
+        text = rx.sub("[REDACTED]", text)
+    return _KV.sub(lambda m: m.group(1) + "[REDACTED]", text)
+
+
+# ---- schemas ----
+def stable_json(v: Any) -> str:
+    return json.dumps(v, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
+
+
+@dataclass
+class Schema:
+    """A registered contract: a Pydantic model/type, or a JSON Schema dict."""
+
+    json_schema: dict
+    _check: Any
+
+    @property
+    def hash(self) -> str:
+        return hashlib.sha256(stable_json(self.json_schema).encode()).hexdigest()
+
+    @property
+    def declared(self) -> set[str]:
+        s, defs = self.json_schema, {**self.json_schema.get("$defs", {})}
+        if "$ref" in s:
+            name = s["$ref"].rsplit("/", 1)[-1]
+            s = defs.get(name) or self.json_schema.get("components", {}).get("schemas", {}).get(name, {})
+        keys = set(s.get("properties", {}))
+        for k in ("allOf", "anyOf", "oneOf"):
+            for sub in s.get(k, []):
+                keys |= set(sub.get("properties", {}))
+        return keys
+
+    def validate(self, parsed: Any, raw: str) -> list[str]:
+        return self._check(parsed, raw)
+
+
+def _nullable(node: Any) -> Any:
+    """OpenAPI 3.0 `nullable: true` -> JSON Schema type union."""
+    if isinstance(node, list):
+        return [_nullable(n) for n in node]
+    if not isinstance(node, dict):
+        return node
+    out = {k: _nullable(v) for k, v in node.items()}
+    if out.get("nullable") is True and isinstance(out.get("type"), str):
+        out["type"] = [out["type"], "null"]
+        if isinstance(out.get("enum"), list) and None not in out["enum"]:
+            out["enum"] = [*out["enum"], None]
+    out.pop("nullable", None)
+    return out
+
+
+def compile_schema(obj: Any) -> Schema:
+    if isinstance(obj, Schema):
+        return obj
+    if isinstance(obj, dict):
+        js = _nullable(obj)
+        v = Draft202012Validator(js)
+
+        def check(parsed: Any, _raw: str) -> list[str]:
+            errs = sorted(v.iter_errors(parsed), key=lambda e: list(map(str, e.absolute_path)))
+            return [f"schema: {'/'.join(map(str, e.absolute_path)) or '$'}: {e.message[:200]}" for e in errs[:10]]
+
+        return Schema(js, check)
+    ta = TypeAdapter(obj)
+
+    def check_py(_parsed: Any, raw: str) -> list[str]:
+        try:
+            ta.validate_json(raw, strict=True)
+        except ValidationError as e:
+            return [f"schema: {'/'.join(map(str, x['loc'])) or '$'}: {x['msg'][:200]}" for x in e.errors()[:10]]
+        return []
+
+    return Schema(ta.json_schema(), check_py)
+
+
+# ---- routes ----
+def _pattern(url: str) -> re.Pattern:
+    sp = urlsplit(url)
+    path = sp.path.rstrip("/")
+    esc = lambda s: re.escape(s).replace(r"\*", "[^/]+")  # noqa: E731
+    host = esc(sp.netloc.lower())
+    segs = []
+    for seg in path.split("/"):
+        if seg == "**":
+            segs.append(".*")
+        elif re.fullmatch(r"\{[^}]*\}", seg) or seg == "*":
+            segs.append("[^/]+")
+        else:
+            segs.append(esc(seg))
+    return re.compile(f"{sp.scheme.lower()}://{host}{'/'.join(segs)}/?", re.I)
+
+
+class Routes:
+    def __init__(self) -> None:
+        self._routes: list[tuple[str, re.Pattern, str, Schema]] = []
+
+    def add(self, route: str, schema: Schema) -> None:
+        method, _, url = route.strip().partition(" ")
+        if not url:
+            raise ValueError(f"route must look like 'GET https://host/path', got {route!r}")
+        self._routes.append((method.upper(), _pattern(url.strip()), urlsplit(url.strip()).path or "/", schema))
+
+    def match(self, method: str, url: str) -> tuple[Schema, str] | None:
+        sp = urlsplit(url)
+        bare = f"{sp.scheme}://{sp.netloc}{sp.path}"
+        for m, rx, path, schema in self._routes:
+            if m in ("*", method.upper()) and rx.fullmatch(bare):
+                return schema, path
+        return None
+
+
+_ID = re.compile(r"^(?:\d+|[0-9a-f]{8}-[0-9a-f-]{27}|[0-9a-f]{16,})$", re.I)
+
+
+def path_template(url: str) -> str:
+    return "/".join("{id}" if _ID.match(s) else s for s in urlsplit(url).path.split("/")) or "/"
+
+
+# ---- inspection ----
+_WS = " \t\n\r"
+_JSONP = re.compile(r"[A-Za-z_$][\w$.]*\s*\(")
+_NOT_JSON_STREAM = re.compile(r"ndjson|jsonl|event-stream|octet-stream", re.I)
+
+
+def _unbalanced(t: str) -> bool:
+    depth, in_str, esc = 0, False, False
+    for c in t:
+        if in_str:
+            if esc:
+                esc = False
+            elif c == "\\":
+                esc = True
+            elif c == '"':
+                in_str = False
+        elif c == '"':
+            in_str = True
+        elif c in "{[":
+            depth += 1
+        elif c in "}]":
+            depth -= 1
+    return in_str or depth > 0
+
+
+def _truthy(v: Any) -> bool:
+    return not (v is None or v is False or v == 0 or v == "" or v == [] or v == {})
+
+
+def _no_const(c: str) -> Any:
+    raise ValueError(c)
+
+
+def expects_json(content_type: str, accept: str, has_schema: bool) -> bool:
+    if _NOT_JSON_STREAM.search(content_type):
+        return False
+    return has_schema or "json" in content_type.lower() or "json" in accept.lower()
+
+
+def inspect_response(
+    status: int,
+    content_type: str,
+    body: bytes | str,
+    schema: Schema | None = None,
+    accept: str = "",
+    ignore: frozenset[str] | set[str] = frozenset(),
+) -> list[str]:
+    """Return the violations ("rule: detail") of a response; empty when it is fine or not checked."""
+    if not 200 <= status < 300 or status in (204, 205):
+        return []
+    if not expects_json(content_type, accept, schema is not None):
+        return []
+    text = body.decode("utf-8", "replace") if isinstance(body, bytes) else body
+    if text.startswith(""):
+        return ["bom: body starts with a byte order mark"]
+    t = text.lstrip(_WS)
+    if not t:
+        return ["empty: 2xx response with no body"]
+    ct = content_type.lower()
+    if t[0] == "<":
+        if t[:5].lower() == "<?xml" or ("xml" in ct and "html" not in ct):
+            return ["xml: body is XML, not JSON"]
+        return ["html: body is HTML, not JSON"]
+    if t.startswith(")]}'"):
+        return ["jsonp: XSSI guard prefix before JSON"]
+    if _JSONP.match(t):
+        return ["jsonp: body is a function call (JSONP), not JSON"]
+    try:
+        parsed = json.loads(text, parse_constant=_no_const)
+    except ValueError:
+        if _unbalanced(t) or t.rstrip(_WS)[-1] in ",:":
+            return ["truncated: JSON ends before it is complete"]
+        return ["invalid_json: body does not parse as JSON"]
+    errs: list[str] = []
+    declared = schema.declared if schema else set()
+    if isinstance(parsed, dict) and "error_envelope" not in ignore:
+        for k in ("error", "errors"):
+            if k in parsed and k not in declared and _truthy(parsed[k]):
+                errs.append(f"error_envelope: 2xx body carries '{k}'")
+        for k in ("success", "ok"):
+            if parsed.get(k) is False and k not in declared:
+                errs.append(f"error_envelope: 2xx body carries {k}=false")
+    if schema is not None and "schema" not in ignore:
+        errs += schema.validate(parsed, text)
+    return errs

langchain_openentity-0.1.0/langchain_openentity/guard.py

@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+import contextvars
+import hashlib
+import json
+import urllib.request
+from collections.abc import Awaitable, Callable
+from typing import Any, Literal
+from urllib.parse import urlsplit
+
+from langchain.agents.middleware import AgentMiddleware, hook_config
+from langchain_core.messages import ToolMessage
+
+from . import http as _http
+from .core import (
+    SAMPLE,
+    OpenEntityLoopDetected,
+    OpenEntitySchemaViolation,
+    Routes,
+    Schema,
+    compile_schema,
+    expects_json,
+    inspect_response,
+    path_template,
+    scrub,
+    stable_json,
+)
+from .ledger import LedgerReporter
+
+HALT_FLAG = "openentity_halt"
+# Violations raised by guarded HTTP calls inside the running tool. A tool that catches its own exception,
+# or a ToolNode that converts it to a ToolMessage, still cannot hide one from wrap_tool_call.
+_CALL: contextvars.ContextVar[list | None] = contextvars.ContextVar("openentity_call", default=None)
+
+
+def _text(content: Any) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        return "".join(b if isinstance(b, str) else b.get("text", "") for b in content if isinstance(b, (str, dict)))
+    return json.dumps(content, default=str)
+
+
+class RuthlessSchemaGuard(AgentMiddleware):
+    """Raise on malformed tool output and malformed HTTP responses instead of letting the model guess.
+
+    Put it first in `middleware=[...]`: the first entry is outermost, so an inner `ToolErrorMiddleware`
+    or `ToolRetryMiddleware` cannot turn the violation into a ToolMessage before it is raised.
+    """
+
+    def __init__(
+        self,
+        schemas: dict[str, Any] | None = None,
+        *,
+        mode: Literal["raise", "halt"] = "raise",
+        max_failures: int = 3,
+        ledger: LedgerReporter | str | bool | None = None,
+        ignore: tuple[str, ...] = (),
+        only_registered: bool = False,
+    ) -> None:
+        super().__init__()
+        self.mode, self.max_failures, self.ignore, self.only_registered = mode, max_failures, frozenset(ignore), only_registered
+        self.routes = Routes()
+        self.tool_schemas: dict[str, Schema] = {}
+        # ponytail: one failure counter per guard; call reset() between unrelated runs.
+        self._failures: dict[tuple[str, str], int] = {}
+        self.last_report: str | None = None
+        self.ledger = ledger if isinstance(ledger, LedgerReporter) else LedgerReporter(
+            url=ledger if isinstance(ledger, str) else None, enabled=False if ledger is False else None)
+        self._uninstall: Callable[[], None] | None = None
+        for k, v in (schemas or {}).items():
+            self.register(k, v)
+
+    # ---- registration ----
+    def register(self, target: str, schema: Any) -> RuthlessSchemaGuard:
+        """`"GET https://api.example.com/items/*"` registers a route; a bare name registers a tool."""
+        s = compile_schema(schema)
+        if "://" in target:
+            self.routes.add(target, s)
+        else:
+            self.tool_schemas[target] = s
+        return self
+
+    def from_openapi(self, spec: dict | str, base_url: str | None = None) -> RuthlessSchemaGuard:
+        """Register every 2xx application/json response of an OpenAPI 3 document (dict, URL or JSON string)."""
+        if isinstance(spec, str):
+            if spec.lstrip().startswith("{"):
+                spec = json.loads(spec)
+            else:
+                with urllib.request.urlopen(spec, timeout=15) as r:
+                    spec = json.load(r)
+        servers = spec.get("servers") or [{}]
+        base = (base_url or servers[0].get("url") or "").rstrip("/")
+        if "://" not in base:
+            raise ValueError("from_openapi needs base_url when the document has no absolute servers[0].url")
+        comps = {"components": spec.get("components", {})}
+        for path, item in spec.get("paths", {}).items():
+            for method, op in item.items():
+                if method.upper() not in ("GET", "POST", "PUT", "PATCH", "DELETE", "HEAD") or not isinstance(op, dict):
+                    continue
+                for code, resp in op.get("responses", {}).items():
+                    if not str(code).startswith("2") or str(code) in ("204", "205"):
+                        continue
+                    for ct, media in (resp.get("content") or {}).items():
+                        if "json" in ct and "schema" in media:
+                            self.register(f"{method.upper()} {base}{path}", {**comps, **media["schema"]})
+                            break
+        return self
+
+    # ---- transport ----
+    def guard_http(self) -> Callable[[], None]:
+        """Guard httpx, httpx2, requests and aiohttp (whichever are installed). Returns the uninstaller."""
+        if self._uninstall is None:
+            self._uninstall = _http.install(self)
+        return self.unguard_http
+
+    def unguard_http(self) -> None:
+        if self._uninstall:
+            self._uninstall()
+            self._uninstall = None
+
+    def _wants(self, method: str, url: str, status: int, ct: str, accept: str) -> bool:
+        schema = self.routes.match(method, url)
+        if self.only_registered and not schema:
+            return False
+        return 200 <= status < 300 and expects_json(ct, accept, schema is not None)
+
+    def _check(self, method: str, url: str, status: int, ct: str, accept: str, get_body: Callable[[], bytes]) -> None:
+        if not self._wants(method, url, status, ct, accept):
+            return
+        hit = self.routes.match(method, url)
+        schema = hit[0] if hit else None
+        body = get_body()
+        errs = inspect_response(status, ct, body, schema, accept, self.ignore)
+        if not errs:
+            return
+        sp = urlsplit(url)
+        text = body.decode("utf-8", "replace") if isinstance(body, bytes) else body
+        self.ledger.report({
+            "host": sp.hostname or "", "method": method.upper(),
+            "path_template": hit[1] if hit else path_template(url),
+            "expected_schema_hash": schema.hash if schema else "",
+            "status": status, "content_type": ct,
+            "body_sha256": hashlib.sha256(body if isinstance(body, bytes) else body.encode()).hexdigest(),
+            "sample": scrub(text)[:SAMPLE],
+        })
+        exc = OpenEntitySchemaViolation(f"{method.upper()} {sp.scheme}://{sp.netloc}{sp.path}", errs, text)
+        if (seen := _CALL.get()) is not None:
+            seen.append(exc)
+        raise exc
+
+    # ---- tools ----
+    def reset(self) -> None:
+        self._failures.clear()
+
+    def _key(self, request: Any) -> tuple[str, tuple[str, str]]:
+        """Failures are counted per thread, so a guard shared by concurrent runs does not mix them."""
+        tc = request.tool_call
+        cfg = getattr(getattr(request, "runtime", None), "config", None) or {}
+        thread = str((cfg.get("configurable") or {}).get("thread_id", ""))
+        return tc["name"], (thread, hashlib.sha256(f"{tc['name']}\0{stable_json(tc.get('args', {}))}".encode()).hexdigest())
+
+    def _count(self, name: str, key: tuple[str, str]) -> OpenEntityLoopDetected | None:
+        self._failures[key] = n = self._failures.get(key, 0) + 1
+        return OpenEntityLoopDetected(name, key[1], n) if n >= self.max_failures else None
+
+    def _validate(self, name: str, result: Any) -> None:
+        schema = self.tool_schemas.get(name)
+        if schema is None or not isinstance(result, ToolMessage) or result.status == "error":
+            return
+        text = _text(result.content)
+        errs = inspect_response(200, "application/json", text, schema, "", self.ignore)
+        if errs:
+            raise OpenEntitySchemaViolation(name, errs, text)
+
+    def _halted(self, request: Any, exc: BaseException) -> ToolMessage:
+        errs = getattr(exc, "errors", None) or [str(exc)]
+        self.last_report = f"RuthlessSchemaGuard halted the run: {exc.__class__.__name__} in {request.tool_call['name']}: " + "; ".join(errs[:5])
+        return ToolMessage(self.last_report, tool_call_id=request.tool_call["id"], name=request.tool_call["name"],
+                           status="error", additional_kwargs={HALT_FLAG: True})
+
+    def _outcome(self, request: Any, run: Callable[[], Any], seen: list) -> Any:
+        name, key = self._key(request)
+        try:
+            result = run()
+            if seen:
+                raise seen[0]
+            self._validate(name, result)
+        except (OpenEntitySchemaViolation, OpenEntityLoopDetected) as e:
+            return self._exit(request, self._count(name, key) or e)
+        except Exception as e:  # noqa: BLE001 - counted; re-raised unchanged until the limit
+            loop = self._count(name, key)
+            if loop is None:
+                raise
+            return self._exit(request, loop)
+        if isinstance(result, ToolMessage) and result.status == "error":
+            if loop := self._count(name, key):
+                return self._exit(request, loop)
+            return result
+        self._failures.pop(key, None)
+        return result
+
+    def _exit(self, request: Any, exc: BaseException) -> ToolMessage:
+        if self.mode == "halt":
+            return self._halted(request, exc)
+        raise exc
+
+    def wrap_tool_call(self, request: Any, handler: Callable[[Any], Any]) -> Any:
+        seen: list = []
+        token = _CALL.set(seen)
+        try:
+            return self._outcome(request, lambda: handler(request), seen)
+        finally:
+            _CALL.reset(token)
+
+    async def awrap_tool_call(self, request: Any, handler: Callable[[Any], Awaitable[Any]]) -> Any:
+        # Await first, then reuse the sync logic on the outcome.
+        seen: list = []
+        token = _CALL.set(seen)
+        try:
+            result = await handler(request)
+        except Exception as e:  # noqa: BLE001
+            def fail() -> Any:
+                raise e
+            return self._outcome(request, fail, seen)
+        finally:
+            _CALL.reset(token)
+        return self._outcome(request, lambda: result, seen)
+
+    # ---- halt mode ----
+    @hook_config(can_jump_to=["end"])
+    def before_model(self, state: Any, runtime: Any) -> dict[str, Any] | None:
+        last = state["messages"][-1] if state.get("messages") else None
+        if isinstance(last, ToolMessage) and last.additional_kwargs.get(HALT_FLAG):
+            return {"jump_to": "end"}
+        return None
+
+    @hook_config(can_jump_to=["end"])
+    async def abefore_model(self, state: Any, runtime: Any) -> dict[str, Any] | None:
+        return self.before_model(state, runtime)

langchain_openentity-0.1.0/langchain_openentity/http.py

@@ -0,0 +1,82 @@
+"""Patch the send path of httpx, httpx2 (Open-SWE uses it), requests and aiohttp, when installed.
+
+Streaming responses (`stream=True`, SSE) are never read, so they are never checked.
+"""
+
+from __future__ import annotations
+
+import functools
+import importlib
+from typing import Any, Callable
+
+
+def _patch(obj: Any, name: str, make: Callable[[Callable], Callable], undo: list) -> None:
+    orig = getattr(obj, name)
+    setattr(obj, name, functools.wraps(orig)(make(orig)))
+    undo.append(lambda: setattr(obj, name, orig))
+
+
+def install(guard: Any) -> Callable[[], None]:
+    undo: list[Callable[[], None]] = []
+
+    def httpx_like(mod: Any) -> None:
+        def sync(orig):
+            def send(self, request, *a, **kw):
+                resp = orig(self, request, *a, **kw)
+                if not kw.get("stream"):
+                    r = resp.request
+                    guard._check(r.method, str(r.url), resp.status_code, resp.headers.get("content-type", ""),
+                                 r.headers.get("accept", ""), lambda: resp.content)
+                return resp
+            return send
+
+        def asyn(orig):
+            async def send(self, request, *a, **kw):
+                resp = await orig(self, request, *a, **kw)
+                if not kw.get("stream"):
+                    r = resp.request
+                    guard._check(r.method, str(r.url), resp.status_code, resp.headers.get("content-type", ""),
+                                 r.headers.get("accept", ""), lambda: resp.content)
+                return resp
+            return send
+
+        _patch(mod.Client, "send", sync, undo)
+        _patch(mod.AsyncClient, "send", asyn, undo)
+
+    def requests_(mod: Any) -> None:
+        def make(orig):
+            def send(self, request, **kw):
+                resp = orig(self, request, **kw)
+                if not kw.get("stream"):
+                    guard._check(request.method, resp.url, resp.status_code, resp.headers.get("content-type", ""),
+                                 request.headers.get("Accept", ""), lambda: resp.content)
+                return resp
+            return send
+
+        _patch(mod.Session, "send", make, undo)
+
+    def aiohttp_(mod: Any) -> None:
+        def make(orig):
+            async def _request(self, method, str_or_url, **kw):
+                resp = await orig(self, method, str_or_url, **kw)
+                ct = resp.headers.get("content-type", "")
+                accept = (kw.get("headers") or {}).get("Accept", "")
+                if guard._wants(method, str(resp.url), resp.status, ct, accept):
+                    body = await resp.read()
+                    guard._check(method, str(resp.url), resp.status, ct, accept, lambda: body)
+                return resp
+            return _request
+
+        _patch(mod.ClientSession, "_request", make, undo)
+
+    for name, fn in (("httpx", httpx_like), ("httpx2", httpx_like), ("requests", requests_), ("aiohttp", aiohttp_)):
+        try:
+            fn(importlib.import_module(name))
+        except ImportError:
+            continue
+
+    def uninstall() -> None:
+        while undo:
+            undo.pop()()
+
+    return uninstall