runlayer-hooks-sdk 0.2.1__tar.gz → 0.2.2__tar.gz

{runlayer_hooks_sdk-0.2.1 → runlayer_hooks_sdk-0.2.2}/.gitignore

@@ -4,6 +4,12 @@
 .worktrees
 node_modules/
 .pnpm-store
+
+# Any stray `pnpm` invocation in a bun subproject writes these into the working
+# tree. Ignore by default; re-allow the subprojects that are still on pnpm.
+pnpm-lock.yaml
+pnpm-workspace.yaml
+!/llm-gateway/test/clients/pnpm-lock.yaml
 /test-results/
 /playwright-report/
 /blob-report/
@@ -110,3 +116,7 @@ docs/superpowers/
 # SDD (subagent-driven-development) task reports — internal artifacts
 sdd/
 tmp/
+
+# Extractor-emitted load models are artifacts; the committed fixture stays hand-built.
+/load-testing/load-model.json
+/load-testing/model/load-model.json

{runlayer_hooks_sdk-0.2.1 → runlayer_hooks_sdk-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runlayer-hooks-sdk
-Version: 0.2.1
+Version: 0.2.2
 Summary: Runlayer Hooks SDK for Python agent runtimes
 Project-URL: Homepage, https://runlayer.com
 Project-URL: Documentation, https://docs.runlayer.com/

{runlayer_hooks_sdk-0.2.1 → runlayer_hooks_sdk-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "runlayer-hooks-sdk"
-version = "0.2.1"
+version = "0.2.2"
 description = "Runlayer Hooks SDK for Python agent runtimes"
 readme = "README.md"
 requires-python = ">=3.10"

{runlayer_hooks_sdk-0.2.1 → runlayer_hooks_sdk-0.2.2}/runlayer_sdk/hook_transport.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
+import gzip
 from collections.abc import Callable
 from contextlib import AbstractContextManager
 from dataclasses import dataclass
-from typing import Any, Protocol
+from typing import Any, Protocol, TypedDict
 
 import httpx
 from runlayer_sdk.types import FetchLike, FetchResponse
@@ -12,6 +13,38 @@ API_KEY_HEADER_NAME = "x-runlayer-api-key"
 ENFORCEMENT_HOOK_TIMEOUT_SECONDS = 30
 EVENT_HOOK_TIMEOUT_SECONDS = 5
 
+# Compress only bodies past this size: small hook bodies gain nothing from
+# gzip, and the compress call would just add CPU to the latency-critical path.
+GZIP_MIN_PAYLOAD_BYTES = 16 * 1024
+# Speed over ratio: hook POSTs are latency-critical, and level 1 already
+# collapses JSON transcript bodies dramatically.
+GZIP_COMPRESS_LEVEL = 1
+
+
+class WireBody(TypedDict):
+    """What actually goes on the wire: body + any transport headers it needs."""
+
+    content: str | bytes
+    headers: dict[str, str]
+
+
+def encode_wire_body(payload: str | bytes, *, compress: bool = False) -> WireBody:
+    """Gzip the payload when opted in and larger than ``GZIP_MIN_PAYLOAD_BYTES``.
+
+    ``bytes`` input is treated as an already-encoded wire body and passed
+    through untouched, so a caller that pre-encoded (to measure the wire size)
+    can post the result without double-compressing.
+    """
+    if not compress or isinstance(payload, bytes):
+        return {"content": payload, "headers": {}}
+    raw = payload.encode("utf-8")
+    if len(raw) <= GZIP_MIN_PAYLOAD_BYTES:
+        return {"content": payload, "headers": {}}
+    return {
+        "content": gzip.compress(raw, compresslevel=GZIP_COMPRESS_LEVEL),
+        "headers": {"Content-Encoding": "gzip"},
+    }
+
 
 @dataclass(frozen=True)
 class HookTarget:
@@ -22,6 +55,7 @@ class HookTarget:
 HOOK_RELAY_TARGETS: dict[str, HookTarget] = {
     "enforce": HookTarget("/api/v1/hooks/cursor", ENFORCEMENT_HOOK_TIMEOUT_SECONDS),
     "event": HookTarget("/api/v1/hooks/events", EVENT_HOOK_TIMEOUT_SECONDS),
+    "mcp-usage": HookTarget("/api/v1/hooks/mcp-usage", EVENT_HOOK_TIMEOUT_SECONDS),
     # Tool lifecycle endpoints normalize into LocalToolPre/PostRequest for
     # scanning. Routing them to /events would silently downgrade enforcement.
     "tool-pre": HookTarget("/api/v1/hooks/tool/pre", ENFORCEMENT_HOOK_TIMEOUT_SECONDS),
@@ -44,9 +78,9 @@ class HookHTTPClient(Protocol):
         self,
         url: str,
         *,
-        content: str,
+        content: str | bytes,
         headers: dict[str, str],
-        timeout: int | float,
+        timeout: int | float | httpx.Timeout,
     ) -> HookHTTPResponse: ...
 
 
@@ -67,9 +101,9 @@ class FetchLikeHookHTTPClient:
         self,
         url: str,
         *,
-        content: str,
+        content: str | bytes,
         headers: dict[str, str],
-        timeout: int | float,
+        timeout: int | float | httpx.Timeout,
     ) -> FetchResponse:
         return self.fetch_impl(
             url,
@@ -86,11 +120,14 @@ def post_hook_endpoint(
     http_client: HookHTTPClient,
     base_url: str,
     endpoint: str,
-    payload: str,
+    payload: str | bytes,
     *,
     headers: dict[str, str],
-    timeout: int | float,
+    timeout: int | float | httpx.Timeout,
 ) -> HookHTTPResponse:
+    # Compression happens upstream via encode_wire_body: callers that opt in
+    # pre-encode the payload (and its Content-Encoding header) so they can
+    # also measure the wire size without re-compressing. bytes pass through.
     return http_client.post(
         f"{base_url.rstrip('/')}{endpoint}",
         content=payload,
@@ -117,9 +154,9 @@ class HookAPIClient:
     def post_target(
         self,
         target: str,
-        payload: str,
+        payload: str | bytes,
         *,
-        timeout: int | float | None = None,
+        timeout: int | float | httpx.Timeout | None = None,
     ) -> HookHTTPResponse:
         spec = HOOK_RELAY_TARGETS[target]
         effective_timeout = timeout if timeout is not None else spec.timeout
@@ -128,9 +165,9 @@ class HookAPIClient:
     def post_endpoint(
         self,
         endpoint: str,
-        payload: str,
+        payload: str | bytes,
         *,
-        timeout: int | float,
+        timeout: int | float | httpx.Timeout,
     ) -> HookHTTPResponse:
         with self.http_client_factory() as http_client:
             return post_hook_endpoint(

{runlayer_hooks_sdk-0.2.1 → runlayer_hooks_sdk-0.2.2}/runlayer_sdk/tool_enforcement.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import re
 from collections.abc import Sequence
 from typing import cast
 from urllib.parse import ParseResult, urljoin, urlparse
@@ -186,7 +185,26 @@ def _option_bool(
 
 
 def _has_explicit_origin_reference(value: str) -> bool:
-    return bool(re.match(r"^[a-zA-Z][a-zA-Z\d+\-.]*:", value)) or value.startswith("//")
+    # Detects an RFC-3986 scheme prefix (``scheme:``) or a protocol-relative
+    # ``//`` origin. Pure string scan: a published SDK must not carry a
+    # regex-engine dependency for one prefix check. Semantics are exactly
+    # ``^[a-zA-Z][a-zA-Z\d+\-.]*:`` with Unicode-aware ``\d`` — first char an
+    # ASCII letter, then a run of scheme chars (ASCII letter, any Unicode
+    # decimal digit per ``str.isdecimal()`` == the ``Nd`` category, or one of
+    # ``+ - .``), then a colon.
+    if value.startswith("//"):
+        return True
+    if not value or not ("a" <= value[0] <= "z" or "A" <= value[0] <= "Z"):
+        return False
+    i = 1
+    while i < len(value) and (
+        "a" <= value[i] <= "z"
+        or "A" <= value[i] <= "Z"
+        or value[i] in "+-."
+        or value[i].isdecimal()
+    ):
+        i += 1
+    return i < len(value) and value[i] == ":"
 
 
 def _has_valid_explicit_host(value: str) -> bool:

runlayer_hooks_sdk-0.2.2/tests/test_hook_transport.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import gzip
+import json
+
+from runlayer_sdk.hook_transport import (
+    GZIP_MIN_PAYLOAD_BYTES,
+    HookAPIClient,
+    encode_wire_body,
+    post_hook_endpoint,
+)
+
+_LARGE_PAYLOAD = json.dumps({"transcript": "x" * (GZIP_MIN_PAYLOAD_BYTES + 1024)})
+_SMALL_PAYLOAD = json.dumps({"k": "v"})
+
+
+class _Response:
+    text = "{}"
+    status_code = 200
+    is_success = True
+
+    def json(self):
+        return {}
+
+
+class _CapturingHTTPClient:
+    def __init__(self) -> None:
+        self.calls: list[dict] = []
+
+    def __enter__(self) -> _CapturingHTTPClient:
+        return self
+
+    def __exit__(self, *_args: object) -> None:
+        pass
+
+    def post(self, url, *, content, headers, timeout):
+        self.calls.append(
+            {"url": url, "content": content, "headers": headers, "timeout": timeout}
+        )
+        return _Response()
+
+
+class TestEncodeWireBody:
+    def test_default_is_identity(self):
+        wire = encode_wire_body(_LARGE_PAYLOAD)
+        assert wire["content"] == _LARGE_PAYLOAD
+        assert wire["headers"] == {}
+
+    def test_small_payload_not_compressed_even_when_opted_in(self):
+        wire = encode_wire_body(_SMALL_PAYLOAD, compress=True)
+        assert wire["content"] == _SMALL_PAYLOAD
+        assert wire["headers"] == {}
+
+    def test_payload_at_threshold_not_compressed(self):
+        payload = "x" * GZIP_MIN_PAYLOAD_BYTES
+        wire = encode_wire_body(payload, compress=True)
+        assert wire["content"] == payload
+        assert wire["headers"] == {}
+
+    def test_large_payload_compressed_with_header_and_round_trips(self):
+        wire = encode_wire_body(_LARGE_PAYLOAD, compress=True)
+        content = wire["content"]
+        assert isinstance(content, bytes)
+        assert len(content) < len(_LARGE_PAYLOAD.encode("utf-8"))
+        assert wire["headers"] == {"Content-Encoding": "gzip"}
+        assert gzip.decompress(content).decode("utf-8") == _LARGE_PAYLOAD
+
+    def test_bytes_input_passes_through_without_double_compression(self):
+        pre_encoded = encode_wire_body(_LARGE_PAYLOAD, compress=True)["content"]
+        assert isinstance(pre_encoded, bytes)
+        wire = encode_wire_body(pre_encoded, compress=True)
+        assert wire["content"] is pre_encoded
+        assert wire["headers"] == {}
+
+
+class TestPostHookEndpoint:
+    def test_str_payload_sent_identity(self):
+        http_client = _CapturingHTTPClient()
+        post_hook_endpoint(
+            http_client,
+            "https://api.example.test",
+            "/api/v1/hooks/events",
+            _LARGE_PAYLOAD,
+            headers={},
+            timeout=5,
+        )
+        (call,) = http_client.calls
+        assert call["content"] == _LARGE_PAYLOAD
+        assert "Content-Encoding" not in call["headers"]
+
+    def test_pre_encoded_bytes_and_headers_pass_through_untouched(self):
+        """Compression lives in encode_wire_body; the transport posts exactly
+        the bytes + headers the caller pre-encoded."""
+        wire = encode_wire_body(_LARGE_PAYLOAD, compress=True)
+        http_client = _CapturingHTTPClient()
+        post_hook_endpoint(
+            http_client,
+            "https://api.example.test",
+            "/api/v1/hooks/events",
+            wire["content"],
+            headers={"x-runlayer-api-key": "sk", **wire["headers"]},
+            timeout=5,
+        )
+        (call,) = http_client.calls
+        assert call["content"] is wire["content"]
+        assert call["headers"]["Content-Encoding"] == "gzip"
+        assert call["headers"]["x-runlayer-api-key"] == "sk"
+        assert gzip.decompress(call["content"]).decode("utf-8") == _LARGE_PAYLOAD
+
+    def test_post_target_sends_payload_as_given(self):
+        http_client = _CapturingHTTPClient()
+        client = HookAPIClient(
+            "https://api.example.test",
+            headers={},
+            http_client_factory=lambda: http_client,
+        )
+        client.post_target("event", _LARGE_PAYLOAD)
+        (call,) = http_client.calls
+        assert call["url"].endswith("/api/v1/hooks/events")
+        assert call["content"] == _LARGE_PAYLOAD
+        assert "Content-Encoding" not in call["headers"]

{runlayer_hooks_sdk-0.2.1 → runlayer_hooks_sdk-0.2.2}/tests/test_tool_enforcement.py

@@ -225,3 +225,51 @@ def test_client_sends_tool_url_to_enforcement_filter_only():
         "/api/v1/hooks/events",
     ]
     assert "tool_url" not in request_json(requests[1])
+
+
+# regex-engine: stdlib-parity
+def test_has_explicit_origin_reference_matches_old_regex():
+    """Pins the pure-string scheme detector to the pre-RE2 regex exactly,
+    including the Unicode-decimal-digit behavior of the old ``\\d`` (ENG-4056)."""
+    import random
+    import re as stdlib_re
+
+    from runlayer_sdk.tool_enforcement import _has_explicit_origin_reference
+
+    old = stdlib_re.compile(r"^[a-zA-Z][a-zA-Z\d+\-.]*:")
+
+    def old_impl(value: str) -> bool:
+        return bool(old.match(value)) or value.startswith("//")
+
+    corpus = [
+        "",
+        "http://x",
+        "https://x",
+        "mailto:a@b",
+        "a+b-c.d:rest",
+        "//protocol-relative",
+        "/single-slash",
+        "no-scheme-here",
+        "1http:",  # leading digit -> not a scheme
+        "+bad:",  # leading + -> not a scheme
+        ".bad:",
+        "a b:",  # space breaks the run before the colon
+        "scheme",  # no colon
+        "scheme:",
+        "x:",
+        "HTTP://X",
+        "a:",
+        "://",
+        "a²:",  # superscript-2 (category No) — NOT \d, breaks the run
+        "a٠:",  # Arabic-Indic digit (category Nd) — IS \d
+        "a\n:",
+        "urn:isbn:0451450523",
+    ]
+    for v in corpus:
+        assert _has_explicit_origin_reference(v) == old_impl(v), repr(v)
+
+    rng = random.Random(4056)
+    alphabet = "abAB01+-.: /²٠\t"
+    for _ in range(2000):
+        v = "".join(rng.choices(alphabet, k=rng.randint(0, 8)))
+        assert _has_explicit_origin_reference(v) == old_impl(v), repr(v)

{runlayer_hooks_sdk-0.2.1 → runlayer_hooks_sdk-0.2.2}/uv.lock

@@ -3,7 +3,7 @@ revision = 3
 requires-python = ">=3.10"
 
 [options]
-exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values.
+exclude-newer = "2026-08-04T20:02:56.085185Z"
 exclude-newer-span = "P7D"
 
 [[package]]
@@ -177,7 +177,7 @@ wheels = [
 
 [[package]]
 name = "runlayer-hooks-sdk"
-version = "0.2.1"
+version = "0.2.2"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },