agentic-runner 3.6.0__tar.gz → 3.8.0__tar.gz

{agentic_runner-3.6.0 → agentic_runner-3.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentic-runner
-Version: 3.6.0
+Version: 3.8.0
 Summary: The Agentic OS Runner: an activity-only Temporal executor for workspaces, Agent Runtimes and verb seams
 License-Expression: AGPL-3.0-only
 License-File: LICENSE

{agentic_runner-3.6.0 → agentic_runner-3.8.0}/src/agentic_runner/__init__.py

@@ -7,6 +7,6 @@ stay on the platform; this package imports none of them, and a CI partition test
 (``tests/test_package_partition.py``) fails the build if that changes.
 """
 
-__version__ = "3.6.0"
+__version__ = "3.8.0"
 
 __all__ = ["__version__"]

{agentic_runner-3.6.0 → agentic_runner-3.8.0}/src/agentic_runner/activities.py

@@ -118,6 +118,7 @@ from agentic_runner.message_store import MessageStore, WorkflowSignaller
 from agentic_runner.registration import RunnerRegistrationError
 from agentic_runner.runtime import verifier_command
 from agentic_runner.runtime.verifier_command import CommandValidationError
+from agentic_runner.usage_windows import UsageWindows
 from agentic_runner.workers._runtime_support import (
     RESERVED_DIRECTIVE_ENV,
     bound_text,
@@ -174,6 +175,7 @@ from agentic_runner_contracts.activity_io import (
     GitHubCallError,
     GitHubCallFailure,
     HarnessHold,
+    HarnessHoldKind,
     LearningDirectiveInput,
     LearningDirectiveOutput,
     MemberDirectiveInput,
@@ -1616,10 +1618,13 @@ class RunnerRalphActivities:
         tool_server_health: ToolServerHealthLog | None = None,
         attempt_records: AttemptRecords | None = None,
         directives_in_flight: DirectivesInFlight | None = None,
+        usage_windows: UsageWindows | None = None,
     ) -> None:
         self._fastapi_client = fastapi_client
         # Read by the harness self-test, which never runs beside a Contract's Directive.
         self._directives_in_flight = directives_in_flight or DirectivesInFlight()
+        # Local-agents 10: None off a user-hosted Runner, which reports no usage windows.
+        self._usage_windows = usage_windows
         # Wall-clock source for per-Directive runtime, accrued against the Budget's
         # wall-clock dimension (ADR-0007). Activities run outside the Temporal sandbox,
         # so a real monotonic clock is allowed here (it must never be used in the
@@ -5273,6 +5278,13 @@ class RunnerRalphActivities:
             error=result.error,
             now=datetime.now(UTC),
         )
+        if self._usage_windows is not None and runtime_state.contract_id:
+            self._usage_windows.after_directive(
+                runtime_state.contract_id,
+                runtime_state.cli_kind,
+                result.usage_windows,
+                usage_limit=hold is not None and hold.kind == HarnessHoldKind.USAGE_LIMIT,
+            )
         if hold is None:
             return None
         await self._fastapi_client.append_evidence(

agentic_runner-3.8.0/src/agentic_runner/integrations/oauth/__init__.py

@@ -0,0 +1,68 @@
+"""The OAuth provider port: one form POST to a token or revocation endpoint (issue 30).
+
+RFC 6749 §4.1.3 / §6 and RFC 7009 are each a form POST answered with JSON, so the port is
+exactly that and the protocol lives in :mod:`agentic_runner.oauth_connectors`, where a
+fake provider exercises all of it. ``HttpOAuthProvider`` is the Runner's own outbound HTTPS
+-- the exchange never touches the control plane.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import Final, Protocol
+
+import httpx
+
+__all__ = [
+    "HttpOAuthProvider",
+    "OAuthProvider",
+    "OAuthProviderError",
+    "ProviderResponse",
+]
+
+# One beat's budget: the exchange and a refresh run on the heartbeat, so a provider that
+# hangs must cost a failed step and not a stale link.
+_TIMEOUT: Final[float] = 10.0
+
+
+class OAuthProviderError(RuntimeError):
+    """The provider could not be reached or did not answer HTTP. Never carries a body."""
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderResponse:
+    status: int
+    # repr=False: a token response is the one body that must never reach a log line.
+    body: Mapping[str, object] = field(default_factory=dict, repr=False)
+
+
+class OAuthProvider(Protocol):
+    async def post_form(self, url: str, form: Mapping[str, str]) -> ProviderResponse: ...
+
+
+class HttpOAuthProvider:
+    """The real provider: HTTPS only, no redirects, JSON asked for.
+
+    Redirects are not followed because a 30x on a token endpoint would re-send the code
+    and the verifier to wherever it points. ``Accept: application/json`` because GitHub,
+    among others, answers form-encoded unless asked.
+    """
+
+    async def post_form(self, url: str, form: Mapping[str, str]) -> ProviderResponse:
+        try:
+            async with httpx.AsyncClient(timeout=_TIMEOUT, follow_redirects=False) as client:
+                response = await client.post(
+                    url, data=dict(form), headers={"Accept": "application/json"}
+                )
+        except httpx.HTTPError as error:
+            # The type only: an httpx error's text can carry the request URL, and a
+            # refresh's form is in no URL, but nothing here needs more than the class.
+            raise OAuthProviderError(type(error).__name__) from None
+        try:
+            body = response.json()
+        except ValueError:
+            body = {}
+        return ProviderResponse(
+            status=response.status_code, body=body if isinstance(body, dict) else {}
+        )

agentic_runner-3.8.0/src/agentic_runner/integrations/oauth/fake_provider.py

@@ -0,0 +1,134 @@
+"""A fake OAuth provider that enforces what a real one does (issue 30's Runner tests).
+
+Strict on purpose: a code is single-use and bound to its client, redirect and S256
+challenge; a refresh token rotates and the old one stops working; revocation ends both.
+A Runner that sent the wrong verifier, replayed a code or kept an old refresh token fails
+here the way it would fail against a provider.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import secrets
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from urllib.parse import parse_qs, urlsplit
+
+from agentic_runner.integrations.oauth import ProviderResponse
+
+__all__ = ["FakeOAuthProvider"]
+
+AUTHORIZE = "https://provider.test/authorize"
+TOKEN = "https://provider.test/token"
+REVOKE = "https://provider.test/revoke"
+
+
+@dataclass
+class _Grant:
+    client_id: str
+    redirect_uri: str
+    challenge: str
+    scope: str
+
+
+@dataclass
+class FakeOAuthProvider:
+    client_id: str = "client-123"
+    client_secret: str | None = None
+    expires_in: int | None = 3600
+    authorize_endpoint: str = AUTHORIZE
+    token_endpoint: str = TOKEN
+    revocation_endpoint: str = REVOKE
+    requests: list[tuple[str, dict[str, str]]] = field(default_factory=list)
+    issued: list[str] = field(default_factory=list)
+    revoked: set[str] = field(default_factory=set)
+    _codes: dict[str, _Grant] = field(default_factory=dict)
+    # token -> the grant it belongs to; a refresh token also keeps the grant's scope.
+    _access: dict[str, str] = field(default_factory=dict)
+    _refresh: dict[str, tuple[str, str]] = field(default_factory=dict)
+
+    def consent(self, authorize_url: str) -> tuple[str, str]:
+        """The person approves: the ``(code, state)`` the callback URL would carry."""
+
+        query = {key: values[0] for key, values in parse_qs(urlsplit(authorize_url).query).items()}
+        assert query["response_type"] == "code"
+        assert query["code_challenge_method"] == "S256"
+        code = f"code-{secrets.token_hex(8)}"
+        self._codes[code] = _Grant(
+            client_id=query["client_id"],
+            redirect_uri=query["redirect_uri"],
+            challenge=query["code_challenge"],
+            scope=query.get("scope", ""),
+        )
+        return code, query["state"]
+
+    def access_valid(self, token: str) -> bool:
+        return token in self._access and token not in self.revoked
+
+    async def post_form(self, url: str, form: Mapping[str, str]) -> ProviderResponse:
+        self.requests.append((url, dict(form)))
+        if url == self.revocation_endpoint:
+            return self._revoke(form)
+        if url != self.token_endpoint:
+            return ProviderResponse(404)
+        if not self._client_ok(form):
+            return _error(401, "invalid_client")
+        if form.get("grant_type") == "authorization_code":
+            return self._exchange(form)
+        if form.get("grant_type") == "refresh_token":
+            return self._rotate(form)
+        return _error(400, "unsupported_grant_type")
+
+    def _client_ok(self, form: Mapping[str, str]) -> bool:
+        if form.get("client_id") != self.client_id:
+            return False
+        return self.client_secret is None or form.get("client_secret") == self.client_secret
+
+    def _exchange(self, form: Mapping[str, str]) -> ProviderResponse:
+        grant = self._codes.pop(form.get("code", ""), None)
+        if grant is None or grant.redirect_uri != form.get("redirect_uri"):
+            return _error(400, "invalid_grant")
+        verifier = form.get("code_verifier", "")
+        digest = hashlib.sha256(verifier.encode("ascii")).digest()
+        if base64.urlsafe_b64encode(digest).rstrip(b"=").decode("ascii") != grant.challenge:
+            return _error(400, "invalid_grant")
+        return self._tokens(f"grant-{secrets.token_hex(8)}", grant.scope)
+
+    def _rotate(self, form: Mapping[str, str]) -> ProviderResponse:
+        held = self._refresh.pop(form.get("refresh_token", ""), None)
+        if held is None:
+            return _error(400, "invalid_grant")
+        return self._tokens(*held)
+
+    def _tokens(self, grant_id: str, scope: str) -> ProviderResponse:
+        access = f"at-{secrets.token_hex(16)}"
+        refresh = f"rt-{secrets.token_hex(16)}"
+        self._access[access] = grant_id
+        self._refresh[refresh] = (grant_id, scope)
+        self.issued += [access, refresh]
+        body: dict[str, object] = {
+            "access_token": access,
+            "refresh_token": refresh,
+            "token_type": "Bearer",
+            "scope": scope,
+        }
+        if self.expires_in is not None:
+            body["expires_in"] = self.expires_in
+        return ProviderResponse(200, body)
+
+    def _revoke(self, form: Mapping[str, str]) -> ProviderResponse:
+        if not self._client_ok(form):
+            return _error(401, "invalid_client")
+        token = form.get("token", "")
+        self.revoked.add(token)
+        # RFC 7009 §2.1: revoking a refresh token may revoke the grant's access tokens;
+        # this provider does, so the test can see the access token stop working.
+        held = self._refresh.pop(token, None)
+        if held is not None:
+            self.revoked.update(t for t, grant_id in self._access.items() if grant_id == held[0])
+        return ProviderResponse(200)
+
+
+def _error(status: int, code: str) -> ProviderResponse:
+    return ProviderResponse(status, {"error": code, "error_description": "fake provider"})