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

{runlayer_hooks_sdk-0.2.0 → 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/
@@ -30,7 +36,11 @@ terraform.tfstate.*
 .terraform.lock.hcl
 terraform.tfvars
 terraform.*.tfvars
-tfplan
+# Prefix glob on purpose: plan/state artifacts get ad-hoc names (tfplan2,
+# tfplan-restore, ...) and embed resolved secrets in plaintext — a bare
+# `tfplan` rule let a 388KB plan+state zip reach a PR once.
+tfplan*
+*.tfplan
 
 # Python
 __pycache__/
@@ -105,3 +115,8 @@ 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.2/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

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

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: runlayer-hooks-sdk
-Version: 0.2.0
+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/
 Author-email: Runlayer <engineering@runlayer.com>
 License: Apache-2.0
+License-File: LICENSE
 Keywords: agent,llm,mcp,runlayer,security
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
@@ -60,6 +61,11 @@ export RUNLAYER_AGENT_SUBJECT_TOKEN="user@example.com"
 export RUNLAYER_AGENT_SUBJECT_TOKEN_TYPE="urn:runlayer:token-type:user-email"
 ```
 
+The SDK mints an agent token with `client_credentials` and, when an OBO subject
+is configured, exchanges it via RFC 8693 token exchange
+(`urn:ietf:params:oauth:grant-type:token-exchange`); both tokens are cached and
+refreshed internally.
+
 Optional runtime controls:
 
 | Variable | Purpose |
@@ -122,6 +128,9 @@ for the actionable reasons so a misconfiguration is not silent:
   workspace. Enable the client (and any required SDK toggle) in Runlayer
   settings. This is a separate switch from tool enforcement, so both must be on
   to get full session + tool telemetry.
+- `sessions_disabled` — the applicable MDM configuration disables session
+  reporting. Ask a Runlayer administrator to enable **Sessions** in that MDM
+  configuration.
 - `actor_unresolved` — the request authenticated but Runlayer could not map it
   to a user/agent. With an organization API key, set `RUNLAYER_USER_EMAIL` (or
   the `user_email` client option) to the Runlayer user the deployment runs as;
@@ -162,3 +171,16 @@ The adapter exports:
 - `tool_type_from_name`
 
 TypeScript-style camelCase aliases are also available for SDK parity.
+
+Each `query()` call starts a new Claude Agent SDK session with a fresh
+`session_id`, and Runlayer records each session id as a separate session. To
+keep a multi-prompt conversation in a single Runlayer session, resume the
+previous session on follow-up calls (leave `fork_session` unset so the session
+id is preserved), then emit the transcript `Stop` per run as usual:
+
+```python
+options = ClaudeAgentOptions(
+    hooks=create_claude_agent_sdk_hooks(runlayer, include_stop=False),
+    resume=session_id,  # session_id captured from the previous run's init message
+)
+```

{runlayer_hooks_sdk-0.2.0 → runlayer_hooks_sdk-0.2.2}/README.md

@@ -39,6 +39,11 @@ export RUNLAYER_AGENT_SUBJECT_TOKEN="user@example.com"
 export RUNLAYER_AGENT_SUBJECT_TOKEN_TYPE="urn:runlayer:token-type:user-email"
 ```
 
+The SDK mints an agent token with `client_credentials` and, when an OBO subject
+is configured, exchanges it via RFC 8693 token exchange
+(`urn:ietf:params:oauth:grant-type:token-exchange`); both tokens are cached and
+refreshed internally.
+
 Optional runtime controls:
 
 | Variable | Purpose |
@@ -101,6 +106,9 @@ for the actionable reasons so a misconfiguration is not silent:
   workspace. Enable the client (and any required SDK toggle) in Runlayer
   settings. This is a separate switch from tool enforcement, so both must be on
   to get full session + tool telemetry.
+- `sessions_disabled` — the applicable MDM configuration disables session
+  reporting. Ask a Runlayer administrator to enable **Sessions** in that MDM
+  configuration.
 - `actor_unresolved` — the request authenticated but Runlayer could not map it
   to a user/agent. With an organization API key, set `RUNLAYER_USER_EMAIL` (or
   the `user_email` client option) to the Runlayer user the deployment runs as;
@@ -141,3 +149,16 @@ The adapter exports:
 - `tool_type_from_name`
 
 TypeScript-style camelCase aliases are also available for SDK parity.
+
+Each `query()` call starts a new Claude Agent SDK session with a fresh
+`session_id`, and Runlayer records each session id as a separate session. To
+keep a multi-prompt conversation in a single Runlayer session, resume the
+previous session on follow-up calls (leave `fork_session` unset so the session
+id is preserved), then emit the transcript `Stop` per run as usual:
+
+```python
+options = ClaudeAgentOptions(
+    hooks=create_claude_agent_sdk_hooks(runlayer, include_stop=False),
+    resume=session_id,  # session_id captured from the previous run's init message
+)
+```

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

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

{runlayer_hooks_sdk-0.2.0 → runlayer_hooks_sdk-0.2.2}/runlayer_sdk/client.py

@@ -43,6 +43,8 @@ from runlayer_sdk.types import (
 DEFAULT_TIMEOUT_MS = 10_000
 DEFAULT_MAX_TOOL_OUTPUT_BYTES = 64 * 1024
 DEFAULT_TOKEN_REFRESH_WINDOW_MS = 60_000
+_TOKEN_EXCHANGE_GRANT = "urn:ietf:params:oauth:grant-type:token-exchange"
+_ACCESS_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:access_token"
 
 
 @dataclass
@@ -52,6 +54,12 @@ class _CachedAgentToken:
     refresh_at_ms: int
 
 
+@dataclass
+class _CachedActorToken:
+    access_token: str
+    expires_at_ms: int
+
+
 class RunlayerClient:
     def __init__(
         self,
@@ -116,6 +124,7 @@ class RunlayerClient:
         )
         self._timeout_override_seconds = timeout_ms / 1000 if timeout_ms else None
         self._cached_agent_token: _CachedAgentToken | None = None
+        self._cached_actor_token: _CachedActorToken | None = None
         self._agent_token_lock = threading.Lock()
         self._warned_ignored_reasons: set[str] = set()
 
@@ -305,7 +314,7 @@ class RunlayerClient:
         transcript: str | None = None,
         *,
         strict: bool = False,
-    ) -> None:
+    ) -> JsonObject | None:
         try:
             response = self._post(
                 HOOK_RELAY_TARGETS["event"].endpoint,
@@ -318,10 +327,12 @@ class RunlayerClient:
                 target="event",
             )
             self._warn_if_ignored(event_name, response)
+            return response
         except Exception as exc:
             if strict:
                 raise
             _debug("Runlayer event hook failed", exc)
+            return None
 
     def _warn_if_ignored(self, event_name: str, response: JsonObject) -> None:
         # A 200 with status="ignored" means the event was accepted but dropped
@@ -333,7 +344,7 @@ class RunlayerClient:
             return
         reason = response.get("reason") or "unknown"
 
-        if reason in ("client_not_enabled", "actor_unresolved"):
+        if reason in ("client_not_enabled", "actor_unresolved", "sessions_disabled"):
             if reason in self._warned_ignored_reasons:
                 return
             self._warned_ignored_reasons.add(reason)
@@ -342,6 +353,12 @@ class RunlayerClient:
                     f'Enable SDK session monitoring for client "{self.client}" '
                     "in Runlayer settings."
                 )
+            elif reason == "sessions_disabled":
+                remedy = (
+                    "Your MDM configuration disables session reporting. Contact "
+                    "your Runlayer administrator to enable Sessions in the "
+                    "applicable MDM configuration."
+                )
             else:
                 remedy = (
                     "The acting identity could not be resolved. With an "
@@ -851,33 +868,69 @@ class RunlayerClient:
                     return self._cached_agent_token.access_token
                 raise
 
-    def _fetch_agent_access_token(self, agent_account: AgentAccountOptions) -> str:
-        form = _strip_empty(
-            {
-                "client_id": agent_account["client_id"],
-                "client_secret": agent_account["client_secret"],
-                "grant_type": "client_credentials",
-                "subject_token": agent_account.get("subject_token"),
-                "subject_token_type": agent_account.get("subject_token_type"),
-            }
-        )
-        response = self._post_token_request(form)
+    def _request_token(self, form: dict[str, str | None]) -> dict[str, Any]:
+        response = self._post_token_request(_strip_empty(form))
         text = response.text
         if not response.is_success:
             raise RuntimeError(
                 f"Runlayer token request failed ({response.status_code}): {text}"
             )
-
         token = response.json()
-        access_token = token.get("access_token")
-        if not access_token:
+        if not token.get("access_token"):
             raise RuntimeError("Runlayer token response did not include access_token")
         token_type = token.get("token_type")
         if token_type and token_type.lower() != "bearer":
             raise RuntimeError(
                 f"Runlayer token response used unsupported token_type {token_type}"
             )
+        return token
+
+    def _actor_access_token(self, agent_account: AgentAccountOptions) -> str:
+        now = int(time.time() * 1000)
+        cached = self._cached_actor_token
+        # Fixed 60s skew (vs the configurable agent refresh window): the actor
+        # token is only used transiently to mint exchange tokens, so a simple
+        # skew is sufficient.
+        if cached and cached.expires_at_ms - 60_000 > now:
+            return cached.access_token
+        token = self._request_token(
+            {
+                "client_id": agent_account["client_id"],
+                "client_secret": agent_account["client_secret"],
+                "grant_type": "client_credentials",
+            }
+        )
+        access_token = token["access_token"]
+        expires_in_ms = _token_expires_in_ms(token.get("expires_in"))
+        self._cached_actor_token = _CachedActorToken(
+            access_token=access_token,
+            expires_at_ms=int(time.time() * 1000) + expires_in_ms,
+        )
+        return access_token
+
+    def _fetch_agent_access_token(self, agent_account: AgentAccountOptions) -> str:
+        subject_token = agent_account.get("subject_token")
+        if subject_token:
+            actor_token = self._actor_access_token(agent_account)
+            token = self._request_token(
+                {
+                    "grant_type": _TOKEN_EXCHANGE_GRANT,
+                    "actor_token": actor_token,
+                    "actor_token_type": _ACCESS_TOKEN_TYPE,
+                    "subject_token": subject_token,
+                    "subject_token_type": agent_account.get("subject_token_type"),
+                }
+            )
+        else:
+            token = self._request_token(
+                {
+                    "client_id": agent_account["client_id"],
+                    "client_secret": agent_account["client_secret"],
+                    "grant_type": "client_credentials",
+                }
+            )
 
+        access_token = token["access_token"]
         expires_in_ms = _token_expires_in_ms(token.get("expires_in"))
         issued_at_ms = int(time.time() * 1000)
         refresh_window_ms = max(

{runlayer_hooks_sdk-0.2.0 → 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.0 → runlayer_hooks_sdk-0.2.2}/runlayer_sdk/preflight.py

@@ -8,6 +8,7 @@ from uuid import uuid4
 
 if TYPE_CHECKING:
     from runlayer_sdk.client import RunlayerClient
+    from runlayer_sdk.types import JsonObject
 
 
 @dataclass(frozen=True)
@@ -24,6 +25,28 @@ class PreflightOptions(TypedDict, total=False):
     source: str
 
 
+def _require_ingested(response: JsonObject | None) -> None:
+    if response is not None and response.get("status") == "ingested":
+        return
+
+    reason = response.get("reason") if response is not None else None
+    if reason == "sessions_disabled":
+        message = "The applicable MDM configuration disables Sessions."
+    elif reason == "client_not_enabled":
+        message = "SDK session monitoring is not enabled for this workspace."
+    else:
+        message = (
+            response.get("message")
+            if response is not None
+            else "Runlayer preflight event was not ingested."
+        )
+        message = (
+            message
+            or f"Runlayer preflight event was not ingested: {reason or 'unknown'}"
+        )
+    raise RuntimeError(message)
+
+
 def send_runlayer_preflight(
     runlayer: RunlayerClient,
     *,
@@ -35,7 +58,7 @@ def send_runlayer_preflight(
     session_id = f"python-sdk-preflight-{uuid4()}"
     timestamp = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
 
-    runlayer.emit_event(
+    response = runlayer.emit_event(
         "SessionStart",
         {
             "cwd": cwd or os.getcwd(),
@@ -47,7 +70,9 @@ def send_runlayer_preflight(
         },
         strict=True,
     )
-    runlayer.emit_event(
+    _require_ingested(response)
+
+    response = runlayer.emit_event(
         "UserPromptSubmit",
         {
             "model": model,
@@ -58,7 +83,9 @@ def send_runlayer_preflight(
         },
         strict=True,
     )
-    runlayer.emit_event(
+    _require_ingested(response)
+
+    response = runlayer.emit_event(
         "Stop",
         {
             "model": model,
@@ -68,6 +95,7 @@ def send_runlayer_preflight(
         },
         strict=True,
     )
+    _require_ingested(response)
 
     return PreflightResult(
         client=runlayer.client_name,

{runlayer_hooks_sdk-0.2.0 → 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.0 → runlayer_hooks_sdk-0.2.2}/tests/test_client.py

@@ -199,10 +199,21 @@ def test_agent_account_auth_exchanges_and_reuses_bearer_token():
     def handler(request: httpx.Request) -> httpx.Response:
         requests.append(request)
         if request.url.path == "/api/v1/oauth/token":
+            form = parse_qs(request.content.decode())
+            grant_type = form.get("grant_type", [None])[0]
+            if grant_type == "client_credentials":
+                return httpx.Response(
+                    200,
+                    json={
+                        "access_token": "agent-actor-token",
+                        "expires_in": 3600,
+                        "token_type": "Bearer",
+                    },
+                )
             return httpx.Response(
                 200,
                 json={
-                    "access_token": "agent-access-token",
+                    "access_token": "obo-access-token",
                     "expires_in": 3600,
                     "token_type": "Bearer",
                 },
@@ -224,19 +235,130 @@ def test_agent_account_auth_exchanges_and_reuses_bearer_token():
     client.emit_event("SessionStart", {"session_id": "sess-1"}, strict=True)
     client.emit_event("Stop", {"session_id": "sess-1"}, strict=True)
 
-    form = parse_qs(requests[0].content.decode())
-    assert requests[0].url.path == "/api/v1/oauth/token"
-    assert requests[0].headers["Content-Type"] == "application/x-www-form-urlencoded"
-    assert form == {
+    token_requests = [r for r in requests if r.url.path == "/api/v1/oauth/token"]
+    assert len(token_requests) == 2
+
+    actor_form = parse_qs(token_requests[0].content.decode())
+    assert (
+        token_requests[0].headers["Content-Type"] == "application/x-www-form-urlencoded"
+    )
+    assert actor_form == {
         "client_id": ["client_123"],
         "client_secret": ["secret_123"],
         "grant_type": ["client_credentials"],
+    }
+    assert "subject_token" not in actor_form
+    assert "actor_token" not in actor_form
+
+    exchange_form = parse_qs(token_requests[1].content.decode())
+    assert exchange_form == {
+        "grant_type": ["urn:ietf:params:oauth:grant-type:token-exchange"],
+        "actor_token": ["agent-actor-token"],
+        "actor_token_type": ["urn:ietf:params:oauth:token-type:access_token"],
         "subject_token": ["user@example.com"],
         "subject_token_type": ["urn:runlayer:token-type:user-email"],
     }
-    assert requests[1].headers["Authorization"] == "Bearer agent-access-token"
-    assert requests[2].headers["Authorization"] == "Bearer agent-access-token"
-    assert [request.url.path for request in requests].count("/api/v1/oauth/token") == 1
+    assert "client_secret" not in exchange_form
+    assert "client_id" not in exchange_form
+
+    hook_requests = [r for r in requests if r.url.path != "/api/v1/oauth/token"]
+    assert hook_requests[0].headers["Authorization"] == "Bearer obo-access-token"
+    assert hook_requests[1].headers["Authorization"] == "Bearer obo-access-token"
+
+
+def test_agent_account_m2m_uses_single_client_credentials_request():
+    requests = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        requests.append(request)
+        if request.url.path == "/api/v1/oauth/token":
+            return httpx.Response(
+                200,
+                json={
+                    "access_token": "m2m-access-token",
+                    "expires_in": 3600,
+                    "token_type": "Bearer",
+                },
+            )
+        return httpx.Response(200, json={})
+
+    client = RunlayerClient(
+        agent_account={
+            "client_id": "client_123",
+            "client_secret": "secret_123",
+        },
+        allow_insecure_transport=True,
+        base_url="http://tenant.runlayer.test",
+        http_client=httpx.Client(transport=httpx.MockTransport(handler)),
+    )
+
+    client.emit_event("SessionStart", {"session_id": "sess-1"}, strict=True)
+    client.emit_event("Stop", {"session_id": "sess-1"}, strict=True)
+
+    token_requests = [r for r in requests if r.url.path == "/api/v1/oauth/token"]
+    assert len(token_requests) == 1
+    form = parse_qs(token_requests[0].content.decode())
+    assert form == {
+        "client_id": ["client_123"],
+        "client_secret": ["secret_123"],
+        "grant_type": ["client_credentials"],
+    }
+    assert "subject_token" not in form
+    assert "actor_token" not in form
+
+
+def test_agent_account_reuses_cached_actor_token_across_exchange_refreshes(monkeypatch):
+    client_credentials_requests = 0
+    token_exchange_requests = 0
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        nonlocal client_credentials_requests, token_exchange_requests
+        if request.url.path == "/api/v1/oauth/token":
+            form = parse_qs(request.content.decode())
+            grant_type = form.get("grant_type", [None])[0]
+            if grant_type == "client_credentials":
+                client_credentials_requests += 1
+                return httpx.Response(
+                    200,
+                    json={
+                        "access_token": "agent-actor-token",
+                        "expires_in": 3600,
+                        "token_type": "Bearer",
+                    },
+                )
+            token_exchange_requests += 1
+            return httpx.Response(
+                200,
+                json={
+                    "access_token": f"obo-access-token-{token_exchange_requests}",
+                    "expires_in": 30,
+                    "token_type": "Bearer",
+                },
+            )
+        return httpx.Response(200, json={})
+
+    client = RunlayerClient(
+        agent_account={
+            "client_id": "client_123",
+            "client_secret": "secret_123",
+            "subject_token": "user@example.com",
+            "subject_token_type": "urn:runlayer:token-type:user-email",
+            "token_refresh_window_ms": 60_000,
+        },
+        allow_insecure_transport=True,
+        base_url="http://tenant.runlayer.test",
+        http_client=httpx.Client(transport=httpx.MockTransport(handler)),
+    )
+
+    now = 1_000.0
+    monkeypatch.setattr(client_module.time, "time", lambda: now)
+
+    client.emit_event("SessionStart", {"session_id": "sess-1"}, strict=True)
+    now += 25.0
+    client.emit_event("Stop", {"session_id": "sess-1"}, strict=True)
+
+    assert client_credentials_requests == 1
+    assert token_exchange_requests >= 2
 
 
 def test_agent_account_auth_coalesces_concurrent_token_refreshes():
@@ -580,6 +702,24 @@ def test_emit_event_warns_once_when_server_ignores_client_not_enabled(capsys):
     assert "send_runlayer_preflight" in err
 
 
+def test_emit_event_warns_once_when_mdm_disables_session_reporting(capsys):
+    client, _requests = make_client(
+        [
+            {"status": "ignored", "reason": "sessions_disabled"},
+            {"status": "ignored", "reason": "sessions_disabled"},
+        ]
+    )
+
+    client.emit_event("SessionStart", {"session_id": "sess-1"})
+    client.emit_event("Stop", {"session_id": "sess-1"})
+
+    err = capsys.readouterr().err
+    assert err.count("status=ignored") == 1
+    assert "sessions_disabled" in err
+    assert "MDM configuration disables session reporting" in err
+    assert "contact your runlayer administrator" in err.lower()
+
+
 def test_emit_event_surfaces_org_key_guidance_on_actor_unresolved(capsys):
     client, _requests = make_client(
         [{"status": "ignored", "reason": "actor_unresolved"}]
@@ -610,7 +750,13 @@ def test_emit_event_stays_quiet_on_transient_ignored_without_debug(capsys, monke
 
 
 def test_send_runlayer_preflight_emits_strict_session_events():
-    client, requests = make_client([{}, {}, {}])
+    client, requests = make_client(
+        [
+            {"status": "ingested"},
+            {"status": "ingested"},
+            {"status": "ingested"},
+        ]
+    )
 
     result = send_runlayer_preflight(client, cwd="/workspace", prompt="preflight")
 
@@ -626,3 +772,14 @@ def test_send_runlayer_preflight_emits_strict_session_events():
     assert payload["cwd"] == "/workspace"
     assert payload["prompt"] == "preflight"
     assert payload["session_id"] == result.session_id
+
+
+def test_send_runlayer_preflight_fails_when_mdm_disables_sessions():
+    client, requests = make_client(
+        [{"status": "ignored", "reason": "sessions_disabled"}]
+    )
+
+    with pytest.raises(RuntimeError, match="MDM configuration disables Sessions"):
+        send_runlayer_preflight(client)
+
+    assert len(requests) == 1

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.2/tests/test_license.py

@@ -0,0 +1,11 @@
+from pathlib import Path
+
+
+PACKAGE_ROOT = Path(__file__).parents[1]
+
+
+def test_package_ships_apache_2_license_text():
+    license_text = (PACKAGE_ROOT / "LICENSE").read_text()
+
+    assert "Apache License" in license_text
+    assert "Version 2.0, January 2004" in license_text

{runlayer_hooks_sdk-0.2.0 → 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.0 → 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.0"
+version = "0.2.2"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },