macp-mcp 0.1.0__py3-none-any.whl

macp_mcp/__init__.py

@@ -0,0 +1,7 @@
+"""macp-mcp: an MCP server for running or joining MACP Decision sessions."""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+__all__ = ["__version__"]

macp_mcp/__main__.py

@@ -0,0 +1,31 @@
+"""Entry point: ``macp-mcp`` / ``python -m macp_mcp`` (stdio transport)."""
+
+from __future__ import annotations
+
+import logging
+import sys
+
+from .config import ConfigError, load_settings
+
+
+def main() -> None:
+    # stdout carries the MCP protocol; every log line must go to stderr.
+    logging.basicConfig(stream=sys.stderr, level=logging.WARNING)
+    try:
+        settings = load_settings()
+    except ConfigError as exc:
+        print(f"macp-mcp: {exc}", file=sys.stderr)
+        raise SystemExit(2) from None
+
+    from .server import build_server
+
+    print(
+        f"macp-mcp: agent={settings.agent_id} runtime={settings.target} "
+        f"auth={settings.auth_mode} tls={'off' if settings.allow_insecure else 'on'}",
+        file=sys.stderr,
+    )
+    build_server(settings).run("stdio")
+
+
+if __name__ == "__main__":
+    main()

macp_mcp/_contract.py

@@ -0,0 +1,118 @@
+"""The cross-language tool contract (``contract/tools.json``).
+
+macp-mcp has a TypeScript twin with the identical tool surface. Both packages
+test against one manifest: the tool names, descriptions, annotations, input
+schemas and output schemas, plus the server instructions. Schema generators
+differ, so schemas are compared after :func:`normalize_schema`, which
+inlines ``$ref``, drops ``title``, and writes nullable types as a type array.
+What is left is the part a client actually validates against. The manifest
+is fully inlined and uses plain JSON Schema keywords only. The TypeScript
+twin serves it verbatim and validates with ajv.
+
+Regenerate after an intentional surface change with ``make contract`` and
+review the diff. ``make verify-contract`` (CI) fails on drift.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+from typing import Any
+
+from mcp import Client
+
+from .config import Settings
+from .server import INSTRUCTIONS, build_server
+
+#: Bump on any breaking change to the manifest.
+CONTRACT_VERSION = "1"
+
+#: Dialect of every schema in the manifest (stated once, not per schema).
+JSON_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema"
+
+_DROPPED_KEYS = {"title", "$defs"}
+
+
+def _as_nullable(schema: dict[str, Any]) -> dict[str, Any] | None:
+    """``{"anyOf": [{"type": T, ...}, {"type": "null"}]}`` → ``{"type": [T, "null"], ...}``.
+
+    pydantic spells ``str | None`` with ``anyOf``. The manifest uses the type
+    array, which every validator (ajv included) handles the same way.
+    """
+    branches = schema.get("anyOf")
+    if not isinstance(branches, list) or len(branches) != 2 or {"type": "null"} not in branches:
+        return None
+    other = next(b for b in branches if b != {"type": "null"})
+    if not isinstance(other, dict) or not isinstance(other.get("type"), str):
+        return None
+    rest = {k: v for k, v in schema.items() if k != "anyOf"}
+    return {**other, **rest, "type": [other["type"], "null"]}
+
+
+def normalize_schema(schema: Any, defs: dict[str, Any] | None = None) -> Any:
+    """Inline local ``$ref``s, drop ``title`` / ``$defs``, sort keys and ``required``."""
+    if isinstance(schema, dict):
+        if defs is None:
+            defs = schema.get("$defs", {})
+        ref = schema.get("$ref")
+        if isinstance(ref, str) and ref.startswith("#/$defs/"):
+            target = dict(defs[ref.removeprefix("#/$defs/")])
+            siblings = {k: v for k, v in schema.items() if k != "$ref"}
+            return normalize_schema({**target, **siblings}, defs)
+        nullable = _as_nullable(schema)
+        if nullable is not None:
+            return normalize_schema(nullable, defs)
+        out: dict[str, Any] = {}
+        for key, value in sorted(schema.items()):
+            if key in _DROPPED_KEYS:
+                continue
+            if key == "properties" and isinstance(value, dict):
+                # Property names are data, not keywords: a property called
+                # "title" must survive.
+                out[key] = {p: normalize_schema(v, defs) for p, v in sorted(value.items())}
+            elif key == "required" and isinstance(value, list):
+                out[key] = sorted(value)
+            else:
+                out[key] = normalize_schema(value, defs)
+        return out
+    if isinstance(schema, list):
+        return [normalize_schema(v, defs) for v in schema]
+    return schema
+
+
+async def listed_contract() -> dict[str, Any]:
+    """The contract as this server actually advertises it over MCP."""
+    async with Client(build_server(Settings())) as client:
+        tools = (await client.list_tools()).tools
+        instructions = client.instructions
+    return {
+        "contract_version": CONTRACT_VERSION,
+        "json_schema_dialect": JSON_SCHEMA_DIALECT,
+        "server_name": "macp-mcp",
+        "instructions": instructions if instructions is not None else INSTRUCTIONS,
+        "tools": [
+            {
+                "name": tool.name,
+                "description": tool.description,
+                "annotations": tool.annotations.model_dump(by_alias=True, exclude_none=True)
+                if tool.annotations
+                else {},
+                "inputSchema": normalize_schema(tool.input_schema),
+                "outputSchema": normalize_schema(tool.output_schema),
+            }
+            for tool in sorted(tools, key=lambda t: t.name)
+        ],
+    }
+
+
+def render(contract: dict[str, Any]) -> str:
+    return json.dumps(contract, indent=2, ensure_ascii=False) + "\n"
+
+
+def main() -> None:
+    sys.stdout.write(render(asyncio.run(listed_contract())))
+
+
+if __name__ == "__main__":
+    main()

macp_mcp/bridge.py

@@ -0,0 +1,399 @@
+"""The MACP side of the server: Decision-mode actions over ``AsyncMacpClient``.
+
+The bridge is deliberately stateless. It keeps no per-session objects
+between tool calls; every action is built from the session id plus what the
+runtime reports (``GetSession`` metadata and the replayed, append-only
+session history). That has two consequences worth knowing:
+
+- A server that restarts mid-session loses nothing, and a server that never
+  started a session can still join it: knowing the ``session_id`` is enough.
+- ``get_session`` and ``get_commitment`` reflect every participant's
+  messages, not just this agent's, because they read the runtime's history
+  rather than a local projection.
+"""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import time
+from collections.abc import Callable
+from typing import Protocol
+
+from macp.v1 import core_pb2, envelope_pb2
+from macp_sdk import (
+    AsyncDecisionSession,
+    AsyncMacpClient,
+    MacpTimeoutError,
+    commitment_hash,
+    verify_commitment_hash,
+)
+from macp_sdk.commitment_hash import LABEL as COMMITMENT_HASH_LABEL
+from macp_sdk.projections import DecisionProjection
+
+from .config import Settings
+from .results import (
+    AckResult,
+    CommitAckResult,
+    CommitmentResult,
+    CommitmentView,
+    ProposalAckResult,
+    SessionResult,
+    StartSessionResult,
+    VerifyResult,
+    VerifySource,
+    VoteAckResult,
+)
+
+MODE_DECISION = "macp.mode.decision.v1"
+
+#: Cap on a single replay, so a busy open session cannot pin a tool call.
+REPLAY_MAX_SECONDS = 15.0
+
+
+class _Stream(Protocol):
+    async def send_subscribe(self, session_id: str, after_sequence: int = 0) -> None: ...
+
+    async def read(self, timeout: float | None = None) -> envelope_pb2.Envelope | None: ...
+
+    async def __aenter__(self) -> _Stream: ...
+
+    async def __aexit__(self, exc_type: object, exc: object, tb: object) -> None: ...
+
+
+ClientFactory = Callable[[Settings], AsyncMacpClient]
+
+
+def default_client_factory(settings: Settings) -> AsyncMacpClient:
+    """Build the SDK's asyncio client from settings (call inside the event loop)."""
+    return AsyncMacpClient(
+        target=settings.target,
+        allow_insecure=settings.allow_insecure,
+        auth=settings.auth,
+        root_certificates=settings.root_certificates,
+        client_name="macp-mcp",
+    )
+
+
+def _state_name(state: int) -> str:
+    name = envelope_pb2.SessionState.Name(state)
+    return name.removeprefix("SESSION_STATE_")
+
+
+def _ack_dict(ack: envelope_pb2.Ack) -> AckResult:
+    return {
+        "ok": ack.ok,
+        "duplicate": ack.duplicate,
+        "message_id": ack.message_id,
+        "session_id": ack.session_id,
+        "session_state": _state_name(ack.session_state),
+    }
+
+
+def _commitment_dict(payload: core_pb2.CommitmentPayload) -> CommitmentView:
+    out: CommitmentView = {
+        "commitment_id": payload.commitment_id,
+        "action": payload.action,
+        "authority_scope": payload.authority_scope,
+        "reason": payload.reason,
+        "outcome_positive": payload.outcome_positive,
+        "mode_version": payload.mode_version,
+        "policy_version": payload.policy_version,
+        "configuration_version": payload.configuration_version,
+    }
+    if payload.HasField("supersedes"):
+        out["supersedes"] = {
+            "session_id": payload.supersedes.session_id,
+            "commitment_hash": payload.supersedes.commitment_hash,
+        }
+    return out
+
+
+class MacpBridge:
+    """Decision-mode actions for one MACP agent identity."""
+
+    def __init__(
+        self,
+        settings: Settings,
+        client_factory: ClientFactory = default_client_factory,
+        clock: Callable[[], float] = time.monotonic,
+    ) -> None:
+        self.settings = settings
+        self._client_factory = client_factory
+        self._client: AsyncMacpClient | None = None
+        self._clock = clock
+
+    @property
+    def client(self) -> AsyncMacpClient:
+        # Created lazily so it binds to the server's running event loop
+        # (grpc.aio channels bind to the loop current at creation).
+        if self._client is None:
+            self._client = self._client_factory(self.settings)
+        return self._client
+
+    async def aclose(self) -> None:
+        if self._client is not None:
+            await self._client.close()
+            self._client = None
+
+    def _session(
+        self, session_id: str, metadata: core_pb2.SessionMetadata | None = None
+    ) -> AsyncDecisionSession:
+        if metadata is None:
+            return AsyncDecisionSession(self.client, session_id=session_id)
+        return AsyncDecisionSession(
+            self.client,
+            session_id=session_id,
+            mode_version=metadata.mode_version,
+            configuration_version=metadata.configuration_version,
+            policy_version=metadata.policy_version,
+        )
+
+    async def _metadata(self, session_id: str) -> core_pb2.SessionMetadata:
+        return (await self.client.get_session(session_id)).metadata
+
+    # -- history ----------------------------------------------------------
+
+    async def replay(self, session_id: str) -> list[envelope_pb2.Envelope]:
+        """Return the session's accepted history, oldest first.
+
+        Opens a ``StreamSession`` and sends a subscribe frame with
+        ``after_sequence=0`` (RFC-MACP-0006-A1), which replays every accepted
+        envelope and then switches to live delivery. The replay is treated
+        as complete once a ``Commitment`` arrives (nothing follows a terminal
+        message) or no envelope arrives for ``replay_idle_ms``.
+        """
+        idle = self.settings.replay_idle_ms / 1000.0
+        deadline = self._clock() + REPLAY_MAX_SECONDS
+        history: list[envelope_pb2.Envelope] = []
+        seen: set[str] = set()
+        stream: _Stream = self.client.open_stream()
+        async with stream:
+            await stream.send_subscribe(session_id, after_sequence=0)
+            while self._clock() < deadline:
+                try:
+                    envelope = await stream.read(timeout=idle)
+                except MacpTimeoutError:
+                    break
+                if envelope is None:
+                    break
+                if envelope.session_id != session_id or envelope.message_id in seen:
+                    continue
+                seen.add(envelope.message_id)
+                history.append(envelope)
+                if envelope.message_type == "Commitment":
+                    break
+        return history
+
+    @staticmethod
+    def _find_commitment(history: list[envelope_pb2.Envelope]) -> envelope_pb2.Envelope | None:
+        for envelope in history:
+            if envelope.message_type == "Commitment":
+                return envelope
+        return None
+
+    # -- tools ------------------------------------------------------------
+
+    async def start_session(
+        self,
+        intent: str,
+        participants: list[str],
+        ttl_ms: int = 0,
+        context_id: str = "",
+    ) -> StartSessionResult:
+        members = list(dict.fromkeys(p.strip() for p in participants if p.strip()))
+        if self.settings.agent_id not in members:
+            members.insert(0, self.settings.agent_id)
+        session = self._session("")
+        ack = await session.start(
+            intent=intent,
+            participants=members,
+            ttl_ms=ttl_ms or self.settings.default_ttl_ms,
+            context_id=context_id,
+        )
+        return {
+            **_ack_dict(ack),
+            "session_id": session.session_id,
+            "mode": MODE_DECISION,
+            "initiator": self.settings.agent_id,
+            "participants": members,
+            "ttl_ms": ttl_ms or self.settings.default_ttl_ms,
+        }
+
+    async def propose(
+        self, session_id: str, proposal_id: str, option: str, rationale: str = ""
+    ) -> ProposalAckResult:
+        ack = await self._session(session_id).propose(proposal_id, option, rationale=rationale)
+        return {**_ack_dict(ack), "proposal_id": proposal_id, "sender": self.settings.agent_id}
+
+    async def evaluate(
+        self,
+        session_id: str,
+        proposal_id: str,
+        recommendation: str,
+        confidence: float,
+        reason: str = "",
+    ) -> ProposalAckResult:
+        ack = await self._session(session_id).evaluate(
+            proposal_id, recommendation, confidence=confidence, reason=reason
+        )
+        return {**_ack_dict(ack), "proposal_id": proposal_id, "sender": self.settings.agent_id}
+
+    async def vote(
+        self, session_id: str, proposal_id: str, vote: str, reason: str = ""
+    ) -> VoteAckResult:
+        ack = await self._session(session_id).vote(proposal_id, vote, reason=reason)
+        return {
+            **_ack_dict(ack),
+            "proposal_id": proposal_id,
+            "vote": vote.upper(),
+            "sender": self.settings.agent_id,
+        }
+
+    async def commit(
+        self,
+        session_id: str,
+        action: str,
+        authority_scope: str,
+        reason: str,
+        outcome_positive: bool = True,
+    ) -> CommitAckResult:
+        # Bind the commitment to the versions the session was started with,
+        # so a joining committer cannot drift from the initiator's binding.
+        metadata = await self._metadata(session_id)
+        ack = await self._session(session_id, metadata).commit(
+            action=action,
+            authority_scope=authority_scope,
+            reason=reason,
+            outcome_positive=outcome_positive,
+        )
+        return {**_ack_dict(ack), "sender": self.settings.agent_id}
+
+    async def get_session(self, session_id: str) -> SessionResult:
+        metadata = await self._metadata(session_id)
+        history = await self.replay(session_id)
+        projection = DecisionProjection()
+        for envelope in history:
+            projection.apply_envelope(envelope)
+        winner = projection.majority_winner()
+        return {
+            "session_id": metadata.session_id,
+            "mode": metadata.mode,
+            "state": _state_name(metadata.state),
+            "initiator": metadata.initiator,
+            "participants": list(metadata.participants),
+            "mode_version": metadata.mode_version,
+            "configuration_version": metadata.configuration_version,
+            "policy_version": metadata.policy_version,
+            "started_at_unix_ms": metadata.started_at_unix_ms,
+            "expires_at_unix_ms": metadata.expires_at_unix_ms,
+            "you": self.settings.agent_id,
+            "phase": projection.phase,
+            "proposals": [
+                {
+                    "proposal_id": p.proposal_id,
+                    "option": p.option,
+                    "rationale": p.rationale,
+                    "sender": p.sender,
+                }
+                for p in projection.proposals.values()
+            ],
+            "evaluations": [
+                {
+                    "proposal_id": e.proposal_id,
+                    "recommendation": e.recommendation,
+                    "confidence": e.confidence,
+                    "reason": e.reason,
+                    "sender": e.sender,
+                }
+                for e in projection.evaluations
+            ],
+            "objections": [
+                {
+                    "proposal_id": o.proposal_id,
+                    "reason": o.reason,
+                    "severity": o.severity,
+                    "sender": o.sender,
+                }
+                for o in projection.objections
+            ],
+            "votes": [
+                {"proposal_id": pid, "vote": v.vote, "reason": v.reason, "sender": v.sender}
+                for pid, by_sender in projection.votes.items()
+                for v in by_sender.values()
+            ],
+            "approve_totals": projection.vote_totals(),
+            "majority_winner": winner,
+            "blocking_objection": projection.has_blocking_objection(winner),
+            "committed": projection.is_committed,
+            "history": [
+                {"message_type": e.message_type, "sender": e.sender, "message_id": e.message_id}
+                for e in history
+            ],
+        }
+
+    async def get_commitment(self, session_id: str) -> CommitmentResult:
+        metadata = await self._metadata(session_id)
+        envelope = self._find_commitment(await self.replay(session_id))
+        if envelope is None:
+            return {
+                "session_id": session_id,
+                "state": _state_name(metadata.state),
+                "found": False,
+            }
+        payload = core_pb2.CommitmentPayload()
+        payload.ParseFromString(envelope.payload)
+        return {
+            "session_id": session_id,
+            "state": _state_name(metadata.state),
+            "found": True,
+            "sender": envelope.sender,
+            "message_id": envelope.message_id,
+            "commitment": _commitment_dict(payload),
+            "payload_b64": base64.b64encode(envelope.payload).decode("ascii"),
+            "commitment_hash": commitment_hash(payload),
+            "hash_label": COMMITMENT_HASH_LABEL,
+        }
+
+    async def verify(
+        self,
+        commitment_hash_claim: str,
+        session_id: str = "",
+        payload_b64: str = "",
+    ) -> VerifyResult:
+        """Recompute the RFC-MACP-0013 hash and compare it with a claim.
+
+        Exactly one source of payload bytes is used: ``payload_b64`` (bytes
+        the caller already holds) or ``session_id`` (bytes re-fetched from
+        the runtime's history, independent of any earlier tool result).
+        """
+        if bool(session_id) == bool(payload_b64):
+            raise ValueError("pass exactly one of session_id or payload_b64")
+        if payload_b64:
+            try:
+                wire = base64.b64decode(payload_b64, validate=True)
+            except (binascii.Error, ValueError):
+                raise ValueError("payload_b64 is not valid base64") from None
+            source: VerifySource = "payload_b64"
+        else:
+            envelope = self._find_commitment(await self.replay(session_id))
+            if envelope is None:
+                raise ValueError(f"session {session_id} has no Commitment in its history")
+            wire = envelope.payload
+            source = "runtime_history"
+        outcome = verify_commitment_hash(wire, commitment_hash_claim)
+        recomputed: str | None = None
+        if outcome != "cannot_verify":
+            payload = core_pb2.CommitmentPayload()
+            payload.ParseFromString(wire)
+            recomputed = commitment_hash(payload)
+        result: VerifyResult = {
+            "outcome": outcome,
+            "claimed_hash": commitment_hash_claim,
+            "recomputed_hash": recomputed,
+            "hash_label": COMMITMENT_HASH_LABEL,
+            "source": source,
+        }
+        if session_id:
+            result["session_id"] = session_id
+        return result

macp_mcp/config.py

@@ -0,0 +1,124 @@
+"""Environment-driven configuration for the macp-mcp server.
+
+One server process is one MACP agent. Every setting comes from the
+environment, because MCP clients (Claude Desktop, Claude Code, Cursor)
+launch the server as a subprocess and pass configuration through an ``env``
+block, not flags.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from dataclasses import dataclass
+
+from macp_sdk import AuthConfig
+
+DEFAULT_TARGET = "127.0.0.1:50051"
+DEFAULT_AGENT_ID = "mcp-agent"
+DEFAULT_TTL_MS = 300_000
+DEFAULT_REPLAY_IDLE_MS = 1_000
+
+_TRUE = {"1", "true", "yes", "on"}
+
+
+class ConfigError(ValueError):
+    """Raised when the environment holds an unusable configuration."""
+
+
+@dataclass(frozen=True)
+class Settings:
+    """Resolved server settings.
+
+    :param target: runtime gRPC address (``host:port``).
+    :param agent_id: the MACP identity this server acts as. With dev-agent
+        auth it is also the bearer token; with a real token it is the
+        identity the runtime binds that token to.
+    :param token: bearer token issued by the runtime, or ``None`` for
+        dev-agent auth (local runtimes started with ``MACP_ALLOW_INSECURE=1``).
+    :param allow_insecure: use a plaintext channel instead of TLS.
+    :param root_certificates: PEM bundle for a private CA, or ``None`` for the
+        system trust store.
+    :param default_ttl_ms: TTL used by ``start_session`` when the caller
+        does not pass one.
+    :param replay_idle_ms: how long a history replay waits for the next
+        envelope before treating the replay as complete.
+    """
+
+    target: str = DEFAULT_TARGET
+    agent_id: str = DEFAULT_AGENT_ID
+    token: str | None = None
+    allow_insecure: bool = False
+    root_certificates: bytes | None = None
+    default_ttl_ms: int = DEFAULT_TTL_MS
+    replay_idle_ms: int = DEFAULT_REPLAY_IDLE_MS
+
+    @property
+    def auth(self) -> AuthConfig:
+        """The SDK auth config for this agent.
+
+        A token selects ``AuthConfig.for_bearer`` bound to ``agent_id``;
+        no token selects ``AuthConfig.for_dev_agent``, whose bearer value is
+        the agent id itself (the runtime's dev fallback binds it verbatim).
+        """
+        if self.token:
+            return AuthConfig.for_bearer(self.token, expected_sender=self.agent_id)
+        return AuthConfig.for_dev_agent(self.agent_id)
+
+    @property
+    def auth_mode(self) -> str:
+        return "bearer" if self.token else "dev-agent"
+
+
+def _int(env: Mapping[str, str], name: str, default: int) -> int:
+    raw = env.get(name, "").strip()
+    if not raw:
+        return default
+    try:
+        value = int(raw)
+    except ValueError:
+        raise ConfigError(f"{name} must be an integer, got {raw!r}") from None
+    if value <= 0:
+        raise ConfigError(f"{name} must be positive, got {value}")
+    return value
+
+
+def load_settings(env: Mapping[str, str] | None = None) -> Settings:
+    """Build :class:`Settings` from ``env`` (defaults to ``os.environ``).
+
+    Recognised variables:
+
+    - ``MACP_RUNTIME_TARGET``: runtime address (default ``127.0.0.1:50051``).
+    - ``MACP_AGENT_ID``: this agent's identity (default ``mcp-agent``).
+    - ``MACP_AUTH_TOKEN``: bearer token; unset means dev-agent auth.
+    - ``MACP_ALLOW_INSECURE``: ``1`` for a plaintext channel (local dev only).
+    - ``MACP_TLS_CA_FILE``: PEM file for a private CA.
+    - ``MACP_DEFAULT_TTL_MS``: default session TTL (default 300000).
+    - ``MACP_REPLAY_IDLE_MS``: replay idle cutoff (default 1000).
+    """
+    env = os.environ if env is None else env
+    target = env.get("MACP_RUNTIME_TARGET", "").strip() or DEFAULT_TARGET
+    agent_id = env.get("MACP_AGENT_ID", "").strip() or DEFAULT_AGENT_ID
+    token = env.get("MACP_AUTH_TOKEN", "").strip() or None
+    allow_insecure = env.get("MACP_ALLOW_INSECURE", "").strip().lower() in _TRUE
+
+    root_certificates: bytes | None = None
+    ca_file = env.get("MACP_TLS_CA_FILE", "").strip()
+    if ca_file:
+        if allow_insecure:
+            raise ConfigError("MACP_TLS_CA_FILE and MACP_ALLOW_INSECURE are mutually exclusive")
+        try:
+            with open(ca_file, "rb") as fh:
+                root_certificates = fh.read()
+        except OSError as exc:
+            raise ConfigError(f"cannot read MACP_TLS_CA_FILE {ca_file!r}: {exc}") from None
+
+    return Settings(
+        target=target,
+        agent_id=agent_id,
+        token=token,
+        allow_insecure=allow_insecure,
+        root_certificates=root_certificates,
+        default_ttl_ms=_int(env, "MACP_DEFAULT_TTL_MS", DEFAULT_TTL_MS),
+        replay_idle_ms=_int(env, "MACP_REPLAY_IDLE_MS", DEFAULT_REPLAY_IDLE_MS),
+    )