flightdeck-sensor 0.5.1__tar.gz → 0.5.3__tar.gz

flightdeck_sensor-0.5.3/CLAUDE.md

@@ -0,0 +1,78 @@
+# Flightdeck Sensor -- Claude Code Rules
+
+> Component-specific rules moved out of the root CLAUDE.md so they load only
+> when working under sensor/. All root CLAUDE.md rules still apply; the
+> numbering below keeps the original rule numbers.
+
+## Sensor Rules
+
+27. **The sensor must never add meaningful latency to the agent's hot path.**
+    All control plane communication is fire-and-forget or background.
+    Never introduce synchronous blocking calls in the LLM call intercept path.
+
+28. **The sensor must fail open.** If the control plane is unreachable and
+    FLIGHTDECK_UNAVAILABLE_POLICY=continue, the agent proceeds with no enforcement.
+    Do not raise exceptions for connectivity failures.
+
+29. **Token counting carries over from tokencap.** Do not rewrite the counting logic.
+    Extend it. Pre-call estimation, post-call reconciliation, delta correction -- these
+    are proven and must not be changed without Supervisor approval.
+
+30. **capture_prompts defaults to False.** The default init() call never captures
+    content. Always verify this default has not been accidentally changed.
+
+31. **init() limit param fires WARN only.** Never upgrade a local limit to BLOCK
+    or DEGRADE regardless of what the server policy says. See DECISIONS.md D035.
+
+32. **The sensor is a library wrapper, not an OS agent.** Never add background
+    threads, polling loops, or daemon threads to the sensor beyond the existing
+    event queue drain thread. If a feature requires background activity
+    independent of LLM calls, it does not belong in the sensor.
+
+---
+
+## Framework Coverage Discipline
+
+40d. **Framework coverage discipline.** Any phase that adds
+     framework support OR changes framework-emission behaviour
+     MUST include BOTH:
+
+     1. **Real-provider playground demos** per affected framework --
+        manual, NOT in CI (they cost money and need live API
+        credentials). Live under ``playground/`` and self-skip
+        (exit 2) when the relevant API key / framework / optional
+        gateway URL is missing so ``make playground-all`` runs
+        cleanly on any box. Driven via ``make playground-<script>``
+        targets. Each demo asserts payload shape inline using
+        ``print_result`` + ``raise AssertionError``; ``run_all.py``
+        exits 0 only when every script returned 0 (PASS) or 2
+        (SKIP). Results documented in the phase's audit doc before
+        PR merge.
+     2. **Integration tests** per framework × behaviour combo,
+        mock-free (or lightly mocked at the network boundary),
+        running in CI via the existing Integration job. Seed a
+        realistic event payload for each new framework + behaviour
+        combination and verify end-to-end landing.
+
+     V-pass for such a phase MUST enumerate the playground demos
+     and integration tests that will be added before
+     implementation starts. Skipping either is a phase-gate
+     failure.
+
+     Why: Phase 4 (agent communication coverage hardening) shipped
+     embeddings, streaming semantics, structured error events, and
+     session-lifecycle edge-case fixes. Mock-only coverage would
+     have let a future SDK upgrade silently break the classifier
+     (anthropic renames ``RateLimitError`` to ``QuotaError`` and
+     our classifier falls through to ``other``; no CI gate catches
+     it). The playground matrix is the only thing that exercises
+     the real class hierarchy every provider ships.
+
+     Applies to: every phase from Phase 4 onwards that touches
+     ``sensor/flightdeck_sensor/interceptor/*``, adds a new
+     interceptor file, or changes the event-emission shape for an
+     existing framework.
+
+     Does NOT apply to: non-framework sensor work (transport,
+     policy, directives) — those are covered by the standard unit
+     + integration suites.

{flightdeck_sensor-0.5.1 → flightdeck_sensor-0.5.3}/PKG-INFO

@@ -1,7 +1,9 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: flightdeck-sensor
-Version: 0.5.1
+Version: 0.5.3
 Summary: In-process agent observability sensor for Flightdeck
+Project-URL: Repository, https://github.com/flightdeckhq/flightdeck
+Author-email: Omri Arnon <omri.arnon@gmail.com>
 License-Expression: Apache-2.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers

{flightdeck_sensor-0.5.1 → flightdeck_sensor-0.5.3}/flightdeck_sensor/__init__.py

@@ -118,6 +118,8 @@ def _resolve_user_name() -> str:
 
         return pwd.getpwuid(os.getuid()).pw_name
     except Exception:
+        # pwd missing or UID unmapped (distroless, scratch, Windows):
+        # fall through to the env-var probes below.
         pass
     for key in ("USER", "USERNAME", "LOGNAME"):
         v = os.environ.get(key)
@@ -233,6 +235,7 @@ def init(
     agent_name: str | None = None,
     langgraph_agent_node_pattern: str | None = None,
     mcp_block_on_uncertainty: bool = False,
+    allow_insecure_transport: bool = False,
 ) -> None:
     """Initialize the sensor and start the run.
 
@@ -296,6 +299,16 @@ def init(
       for k8s pod grouping)
     - ``FLIGHTDECK_UNAVAILABLE_POLICY`` -- ``"continue"`` or ``"halt"``
     - ``FLIGHTDECK_CAPTURE_PROMPTS`` -- ``"true"`` to enable
+    - ``FLIGHTDECK_ALLOW_INSECURE_TRANSPORT`` -- ``"true"`` to allow plain
+      ``http://`` egress to a non-local control plane (overrides
+      *allow_insecure_transport*)
+
+    ``allow_insecure_transport`` opts in to plaintext ``http://`` egress
+    for a **non-local** control-plane host. Off by default: the resolved
+    ``server`` / ``api_url`` must use ``https://`` for any public host, or
+    init raises. Local / loopback / private hosts (``localhost``,
+    ``127.0.0.1``, RFC1918, ...) are always allowed over ``http``. A URL
+    with any scheme other than ``http`` / ``https`` is rejected outright.
 
     ``langgraph_agent_node_pattern`` (D126) is an optional regex
     string that narrows which LangGraph nodes the sub-agent
@@ -314,6 +327,23 @@ def init(
                 _log.warning("flightdeck_sensor.init() called twice; ignoring")
             return
 
+        # H-01: env-var precedence is preserved (env wins over the kwarg,
+        # matching every other init() knob), but a silent override of an
+        # explicitly-passed value is the vulnerability — a stale/hostile
+        # FLIGHTDECK_SERVER in the environment could redirect egress with
+        # no signal. Warn (naming both values) when the environment
+        # overrides a non-empty caller-supplied server with a different
+        # value, then keep the env value.
+        env_server = os.environ.get(_env.ENV_SERVER)
+        if env_server is not None and server and env_server != server:
+            _log.warning(
+                "%s=%r overrides the server=%r passed to init(); using the "
+                "environment value. Unset %s if this was not intended.",
+                _env.ENV_SERVER,
+                env_server,
+                server,
+                _env.ENV_SERVER,
+            )
         resolved_server = os.environ.get(_env.ENV_SERVER, server)
         resolved_token = os.environ.get(_env.ENV_TOKEN, token)
         if not resolved_server:
@@ -321,6 +351,12 @@ def init(
         if not resolved_token:
             raise ConfigurationError("token is required")
 
+        # H-01: resolve the plaintext-transport opt-in. Env wins over the
+        # kwarg (same precedence as every other flag); default False.
+        resolved_allow_insecure = _env_bool(
+            _env.ENV_ALLOW_INSECURE_TRANSPORT, allow_insecure_transport
+        )
+
         # KI20: normalize ``FLIGHTDECK_SERVER`` / ``server`` kwarg to
         # always carry the ``/ingest`` suffix. The Claude Code plugin
         # uses the same env var without the suffix (it appends
@@ -332,6 +368,17 @@ def init(
         if "/ingest" not in resolved_server:
             resolved_server = resolved_server.rstrip("/") + "/ingest"
 
+        # H-01: same silent-override guard for the control-plane API URL.
+        env_api_url = os.environ.get(_env.ENV_API_URL)
+        if env_api_url and api_url and env_api_url != api_url:
+            _log.warning(
+                "%s=%r overrides the api_url=%r passed to init(); using the "
+                "environment value. Unset %s if this was not intended.",
+                _env.ENV_API_URL,
+                env_api_url,
+                api_url,
+                _env.ENV_API_URL,
+            )
         resolved_api_url = os.environ.get(_env.ENV_API_URL) or api_url
         if not resolved_api_url:
             resolved_api_url = resolved_server.rstrip("/").replace("/ingest", "/api")
@@ -417,6 +464,7 @@ def init(
             "token": resolved_token,
             "api_url": resolved_api_url,
             "capture_prompts": capture,
+            "allow_insecure_transport": resolved_allow_insecure,
             "unavailable_policy": os.environ.get(_env.ENV_UNAVAILABLE_POLICY, "continue"),
             # Legacy wire-level ``flavor`` field stays populated for
             # backward compat with every downstream surface that still

{flightdeck_sensor-0.5.1 → flightdeck_sensor-0.5.3}/flightdeck_sensor/config.py

@@ -41,6 +41,9 @@ ENV_AGENT_FLAVOR_LEGACY = "AGENT_FLAVOR"
 # ----------------------------------------------------------------
 ENV_CAPTURE_PROMPTS = "FLIGHTDECK_CAPTURE_PROMPTS"
 ENV_UNAVAILABLE_POLICY = "FLIGHTDECK_UNAVAILABLE_POLICY"
+# H-01: opt-in to plaintext http:// egress for a non-local control
+# plane. Bool-coerced; default False forces https:// for public hosts.
+ENV_ALLOW_INSECURE_TRANSPORT = "FLIGHTDECK_ALLOW_INSECURE_TRANSPORT"
 
 
 # Stable list of every FLIGHTDECK_* env var the sensor consults, in
@@ -56,4 +59,5 @@ ALL_ENV_VARS: tuple[str, ...] = (
     ENV_HOSTNAME,
     ENV_CAPTURE_PROMPTS,
     ENV_UNAVAILABLE_POLICY,
+    ENV_ALLOW_INSECURE_TRANSPORT,
 )

{flightdeck_sensor-0.5.1 → flightdeck_sensor-0.5.3}/flightdeck_sensor/core/agent_id.py

@@ -74,10 +74,7 @@ def derive_agent_id(
     Returns a :class:`uuid.UUID`. Callers that need the canonical
     string form use ``str(derive_agent_id(...))``.
     """
-    path = (
-        f"flightdeck://{agent_type}/{user}@{hostname}"
-        f"/{client_type}/{agent_name}"
-    )
+    path = f"flightdeck://{agent_type}/{user}@{hostname}/{client_type}/{agent_name}"
     if agent_role is not None:
         trimmed = agent_role.strip()
         if trimmed:

{flightdeck_sensor-0.5.1 → flightdeck_sensor-0.5.3}/flightdeck_sensor/core/context.py

@@ -33,6 +33,7 @@ import re
 import socket
 import subprocess
 import sys
+from pathlib import Path
 from typing import Any, Protocol
 
 # Subprocess timeout for ``git`` invocations in GitCollector (M-5).
@@ -80,7 +81,7 @@ class ProcessCollector(BaseCollector):
         result["pid"] = os.getpid()
         argv0 = sys.argv[0] if sys.argv else ""
         if argv0:
-            result["process_name"] = os.path.basename(argv0)
+            result["process_name"] = Path(argv0).name
         return result
 
 
@@ -96,11 +97,7 @@ class OSCollector(BaseCollector):
 class UserCollector(BaseCollector):
     def _gather(self) -> dict[str, Any]:
         # USER on Unix, USERNAME on Windows, LOGNAME as final fallback.
-        user = (
-            os.environ.get("USER")
-            or os.environ.get("USERNAME")
-            or os.environ.get("LOGNAME")
-        )
+        user = os.environ.get("USER") or os.environ.get("USERNAME") or os.environ.get("LOGNAME")
         return {"user": user} if user else {}
 
 
@@ -149,7 +146,7 @@ class GitCollector(BaseCollector):
         if remote:
             # Strip embedded credentials before extracting the repo name.
             clean = re.sub(r"https?://[^@]+@", "https://", remote)
-            repo = os.path.basename(clean.rstrip("/"))
+            repo = Path(clean.rstrip("/")).name
             if repo.endswith(".git"):
                 repo = repo[:-4]
             if repo:
@@ -186,10 +183,7 @@ class KubernetesCollector(BaseCollector):
 
 class DockerComposeCollector(BaseCollector):
     def applies(self) -> bool:
-        return bool(
-            os.environ.get("COMPOSE_PROJECT_NAME")
-            or os.environ.get("COMPOSE_SERVICE")
-        )
+        return bool(os.environ.get("COMPOSE_PROJECT_NAME") or os.environ.get("COMPOSE_SERVICE"))
 
     def _gather(self) -> dict[str, Any]:
         result: dict[str, Any] = {"orchestration": "docker-compose"}
@@ -207,7 +201,7 @@ class DockerCollector(BaseCollector):
         # /.dockerenv only exists inside Linux containers; on Windows
         # or Mac hosts running Python natively this collector
         # correctly returns nothing.
-        return os.path.exists("/.dockerenv")
+        return Path("/.dockerenv").exists()
 
     def _gather(self) -> dict[str, Any]:
         return {"orchestration": "docker"}
@@ -224,7 +218,7 @@ class AWSECSCollector(BaseCollector):
         result: dict[str, Any] = {"orchestration": "aws-ecs"}
         task = os.environ.get("ECS_TASK_DEFINITION")
         if task:
-            result["ecs_task"] = os.path.basename(task)
+            result["ecs_task"] = Path(task).name
         return result
 
 
@@ -397,6 +391,7 @@ def collect() -> dict[str, Any]:
             if collector.applies():
                 ctx.update(collector.collect())
         except Exception:
+            # best-effort: a single broken collector must never crash init().
             pass
 
     for collector in ORCHESTRATION_COLLECTORS:
@@ -405,6 +400,7 @@ def collect() -> dict[str, Any]:
                 ctx.update(collector.collect())
                 break
         except Exception:
+            # best-effort: a single broken collector must never crash init().
             pass
 
     for collector in OTHER_COLLECTORS:
@@ -412,6 +408,7 @@ def collect() -> dict[str, Any]:
             if collector.applies():
                 ctx.update(collector.collect())
         except Exception:
+            # best-effort: a single broken collector must never crash init().
             pass
 
     return ctx

{flightdeck_sensor-0.5.1 → flightdeck_sensor-0.5.3}/flightdeck_sensor/core/errors.py

@@ -166,11 +166,7 @@ def _override_from_status_and_code(
     # OpenAI sometimes returns 503 "engine overloaded"; distinguish on
     # the message hint when present. The combined condition keeps ruff's
     # SIM102 happy without losing the 503-vs-500 branch clarity.
-    if (
-        http_status == 503
-        and provider_error_code
-        and "overload" in provider_error_code.lower()
-    ):
+    if http_status == 503 and provider_error_code and "overload" in provider_error_code.lower():
         return ErrorType.OVERLOADED
     if http_status == 400 and provider_error_code:
         code = provider_error_code.lower()

{flightdeck_sensor-0.5.1 → flightdeck_sensor-0.5.3}/flightdeck_sensor/core/schemas.py

@@ -11,6 +11,8 @@ from typing import Any
 
 from pydantic import BaseModel
 
+from flightdeck_sensor.core.types import _DEFAULT_GRACE_PERIOD_MS
+
 
 class DirectivePayloadSchema(BaseModel):
     """Payload for action='custom' directives."""
@@ -48,7 +50,7 @@ class DirectiveResponseSchema(BaseModel):
 
     action: str
     reason: str | None = None
-    grace_period_ms: int = 5000
+    grace_period_ms: int = _DEFAULT_GRACE_PERIOD_MS
     degrade_to: str | None = None
     payload: dict[str, Any] | None = None
 

{flightdeck_sensor-0.5.1 → flightdeck_sensor-0.5.3}/flightdeck_sensor/core/session.py

@@ -148,6 +148,12 @@ _PREFLIGHT_TIMEOUT_SECS = 1
 # directive queue but NOT event throughput.
 _CUSTOM_DIRECTIVE_HANDLER_TIMEOUT_SECS = 5
 
+# Per-(provider, request_id) retry-counter LRU bound. Eviction-on-overflow
+# keeps memory flat for long-lived sessions making millions of calls; the
+# counter only answers a short-window question ("did this retry chain give
+# up"), so dropping the oldest entries is safe.
+_RETRY_COUNTER_LRU_SIZE = 256
+
 # D126 § 6 sub-agent message routing thresholds.
 #
 # Bodies up to ``SUBAGENT_INLINE_THRESHOLD_BYTES`` ride inline on the
@@ -404,7 +410,7 @@ class Session:
             current = self._retry_counters.get(key, 0) + 1
             self._retry_counters[key] = current
             self._retry_counters.move_to_end(key)
-            while len(self._retry_counters) > 256:
+            while len(self._retry_counters) > _RETRY_COUNTER_LRU_SIZE:
                 self._retry_counters.popitem(last=False)
             return current
 
@@ -1267,6 +1273,11 @@ class Session:
             # "what budget/MCP rules were in effect at session start"
             # without joining time-windowed policy state.
             payload["sensor_version"] = _sensor_version()
+            # C-01: emit the session's capture posture authoritatively at
+            # session_start so the server can persist whether this session
+            # is capturing prompt content. Sourced directly from the
+            # resolved config — the single source of truth for the flag.
+            payload["capture_prompts"] = self.config.capture_prompts
             iv = _collect_interceptor_versions()
             if iv:
                 payload["interceptor_versions"] = iv

{flightdeck_sensor-0.5.1 → flightdeck_sensor-0.5.3}/flightdeck_sensor/core/types.py

@@ -3,9 +3,87 @@
 from __future__ import annotations
 
 import enum
+import ipaddress
 import uuid
 from dataclasses import dataclass, field
 from typing import Any, Callable, Literal
+from urllib.parse import urlparse
+
+# Schemes the sensor is willing to egress control-plane traffic over.
+# Anything else (file://, ftp://, gopher://, a bare host with no
+# scheme, ...) is rejected outright — the sensor only speaks HTTP(S)
+# to the control plane, and an unexpected scheme is almost always a
+# misconfiguration or an attempt to redirect egress somewhere it does
+# not belong.
+_ALLOWED_EGRESS_SCHEMES = frozenset({"https", "http"})
+
+
+def _is_local_host(host: str) -> bool:
+    """Return True when *host* is a local/loopback/private target for
+    which plain ``http://`` is acceptable without an explicit opt-in.
+
+    Covers ``localhost`` (and ``*.localhost``), loopback IPs
+    (127.0.0.0/8, ::1), RFC1918 / ULA private ranges, and link-local
+    addresses. Everything else — public hostnames and public IPs —
+    is treated as remote and must use TLS unless the operator opts in.
+    """
+    if not host:
+        return False
+    h = host.lower()
+    if h == "localhost" or h.endswith(".localhost"):
+        return True
+    try:
+        ip = ipaddress.ip_address(h)
+    except ValueError:
+        # Not an IP literal and not a localhost name → treat as a
+        # public host. DNS is deliberately NOT resolved here: the
+        # sensor must never make a blocking network call on the config
+        # path (Sensor Rule 27), and resolving would also open a
+        # rebinding hole. Operators pointing at a private hostname that
+        # only resolves to an RFC1918 address use the opt-in flag.
+        return False
+    return ip.is_loopback or ip.is_private or ip.is_link_local
+
+
+def validate_egress_url(
+    url: str,
+    *,
+    field_name: str,
+    allow_insecure_transport: bool = False,
+) -> None:
+    """Validate a resolved control-plane egress URL (H-01).
+
+    Raises :class:`ValueError` when:
+
+    - the URL does not parse to a scheme in ``{"https", "http"}`` — this
+      rejects ``file://``, ``ftp://``, scheme-less strings, etc.; or
+    - the URL uses plain ``http://`` for a non-local host and the
+      operator has not opted into insecure transport
+      (``allow_insecure_transport`` / ``FLIGHTDECK_ALLOW_INSECURE_TRANSPORT``).
+
+    ``field_name`` is the config field being checked (``"server"`` /
+    ``"api_url"``) and is woven into the error message so a
+    misconfiguration is self-describing.
+    """
+    parsed = urlparse(url)
+    scheme = parsed.scheme.lower()
+    if scheme not in _ALLOWED_EGRESS_SCHEMES:
+        raise ValueError(
+            f"{field_name} must use an http:// or https:// URL; got "
+            f"scheme {scheme or '(none)'!r} in {url!r}. The sensor only "
+            "egresses control-plane traffic over HTTP(S)."
+        )
+    if scheme == "http" and not allow_insecure_transport:
+        host = parsed.hostname or ""
+        if not _is_local_host(host):
+            raise ValueError(
+                f"{field_name} uses insecure http:// for non-local host "
+                f"{host or '(none)'!r} ({url!r}). Use https://, or opt in "
+                "to plaintext transport by setting allow_insecure_transport"
+                "=True (env FLIGHTDECK_ALLOW_INSECURE_TRANSPORT=true). "
+                "Plaintext control-plane traffic to a remote host exposes "
+                "the access token and event payloads on the wire."
+            )
 
 
 class SessionState(enum.Enum):
@@ -215,6 +293,13 @@ class SensorConfig:
     client_type: str = "flightdeck_sensor"
     api_url: str = ""
     capture_prompts: bool = False
+    # H-01: opt-in to plaintext http:// egress for a non-local control
+    # plane. Default False forces https:// for any public host; local /
+    # loopback / private targets are always allowed over http regardless.
+    # Env-readable via FLIGHTDECK_ALLOW_INSECURE_TRANSPORT (resolved in
+    # init()). Never flip this on for a real deployment — it exposes the
+    # access token and event payloads on the wire.
+    allow_insecure_transport: bool = False
     unavailable_policy: str = "continue"
     agent_flavor: str = "unknown"
     agent_type: str = "production"
@@ -233,6 +318,26 @@ class SensorConfig:
     def __post_init__(self) -> None:
         if not self.api_url:
             self.api_url = self.server
+        # H-01: validate the resolved control-plane egress URLs. Both
+        # ``server`` (ingestion) and ``api_url`` (control-plane API) are
+        # checked so every egress target is covered by the single helper.
+        validate_egress_url(
+            self.server,
+            field_name="server",
+            allow_insecure_transport=self.allow_insecure_transport,
+        )
+        validate_egress_url(
+            self.api_url,
+            field_name="api_url",
+            allow_insecure_transport=self.allow_insecure_transport,
+        )
+
+
+# Default directive grace period (ms): the window an agent gets to wind down
+# the current call before an enforcement action (degrade / block / shutdown)
+# takes effect. Mirrored as the default in DirectiveResponseSchema so a
+# wire-absent value resolves identically.
+_DEFAULT_GRACE_PERIOD_MS = 5000
 
 
 @dataclass(frozen=True)
@@ -241,7 +346,7 @@ class Directive:
 
     action: DirectiveAction
     reason: str
-    grace_period_ms: int = 5000
+    grace_period_ms: int = _DEFAULT_GRACE_PERIOD_MS
     payload: dict[str, Any] = field(default_factory=dict)
 
 

{flightdeck_sensor-0.5.1 → flightdeck_sensor-0.5.3}/flightdeck_sensor/interceptor/anthropic.py

@@ -94,6 +94,7 @@ try:
     from anthropic.resources.beta.beta import (
         Beta as _OrigBetaImported,
     )
+
     _OrigAnthropic: type | None = _anthropic_module.Anthropic
     _OrigAsyncAnthropic: type | None = _anthropic_module.AsyncAnthropic
     # The Beta / AsyncBeta classes are imported at module load so the
@@ -162,7 +163,10 @@ class SensorMessages:
         """
         if self._is_async:
             return base.call_stream_async(
-                self._real.stream, kwargs, self._session, self._provider,
+                self._real.stream,
+                kwargs,
+                self._session,
+                self._provider,
             )
         return base.call_stream(self._real.stream, kwargs, self._session, self._provider)
 
@@ -425,19 +429,27 @@ def patch_anthropic_classes(quiet: bool = False) -> None:
         return
 
     _patch_one_class(
-        _OrigAnthropic, is_async=False, quiet=quiet,
+        _OrigAnthropic,
+        is_async=False,
+        quiet=quiet,
         descriptor_cls=_AnthropicMessagesDescriptor,
     )
     _patch_one_class(
-        _OrigAsyncAnthropic, is_async=True, quiet=quiet,
+        _OrigAsyncAnthropic,
+        is_async=True,
+        quiet=quiet,
         descriptor_cls=_AnthropicMessagesDescriptor,
     )
     _patch_one_class(
-        _OrigBeta, is_async=False, quiet=quiet,
+        _OrigBeta,
+        is_async=False,
+        quiet=quiet,
         descriptor_cls=_AnthropicBetaMessagesDescriptor,
     )
     _patch_one_class(
-        _OrigAsyncBeta, is_async=True, quiet=quiet,
+        _OrigAsyncBeta,
+        is_async=True,
+        quiet=quiet,
         descriptor_cls=_AnthropicBetaMessagesDescriptor,
     )