extodan-agentsync 0.1.0__py3-none-any.whl

agentsync/models.py

@@ -0,0 +1,251 @@
+"""The three-strategy contract.
+
+Everything in the benchmark flows through these types so that LWW,
+LLM-transactional, and CRDT (Loro) are measured behind ONE common interface.
+The types here are deliberately small and backend-agnostic: a strategy is a
+class with an `apply(write) -> Outcome` method and a `finalize_state()` call.
+
+Two value kinds matter for the thesis:
+
+* ``FieldKind.scalar``  — a single value; two concurrent writes to the same
+  scalar with differing values are a SEMANTIC conflict (un-mergeable). LWW
+  silently picks one; CRDT must ESCALATE.
+* ``FieldKind.grow_set`` / ``FieldKind.append_text`` — monotone, mergeable.
+  Concurrent writes union / concatenate; no write is lost. This is where the
+  CRDT wins for free and LWW still corrupts (it overwrites the whole field).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Literal, Protocol
+
+
+class EndState(str, Enum):
+    """How a strategy reached its end state on a workload.
+
+    This is intentionally SEPARATE from ``verdict`` (which only says "reached an
+    acceptable end state"). Two strategies can both PASS yet get there by
+    different, non-interchangeable routes — and conflating them is the trap this
+    column exists to prevent.
+
+    ``escalated`` vs ``resolved`` is the one that matters and is the easiest to
+    misread. ``resolved`` spends work NOW to produce a field the next agent can
+    act on. ``escalated`` is cheap precisely because it does NOT resolve — it
+    defers BOTH the cost AND the correctness: the conflicting field stays
+    divergent until someone drains the queue, so an agent that needs to read it
+    on its next step is blocked. For async knowledge-merge that deferral is
+    free; for a synchronous read it re-incurs the inference downstream, plus a
+    stall. Escalate is the safer *primitive* (you can always bolt a resolver on
+    later); it is not a free lunch on time-to-usable-state.
+
+    * ``auto_merged`` — no semantic conflict in the workload; mergeable writes
+                       unioned/concatenated. Every correct strategy lands here
+                       on a clean merge. LWW lands here only if it didn't drop
+                       writes — otherwise it's ``corrupted``.
+    * ``corrupted``   — a conflict (or a concurrent write to a mergeable field)
+                       existed and the strategy silently dropped or overwrote
+                       it with NO signal. LWW. The corruption baseline.
+    * ``resolved``    — a real conflict existed and the strategy spent work
+                       (a model call) to autonomously decide and repair.
+                       transactional. Correct end state, costs inference, acts
+                       without a human in the loop.
+    * ``escalated``   — a real conflict existed and the strategy flagged it for
+                       a downstream consumer instead of deciding. crdt. Cheap
+                       because it defers resolution — see the note above.
+    """
+
+    auto_merged = "auto_merged"
+    corrupted = "corrupted"
+    resolved = "resolved"
+    escalated = "escalated"
+
+
+class FieldKind(str, Enum):
+    """How a field's concurrent writes should combine.
+
+    ``scalar`` fields are the source of semantic conflicts. The grow_set and
+    append_text kinds are mergeable by construction (union / concatenation) and
+    are where the CRDT converges for free.
+    """
+
+    scalar = "scalar"
+    grow_set = "grow_set"
+    append_text = "append_text"
+
+
+@dataclass(frozen=True)
+class Write:
+    """A single attributed write by one agent.
+
+    ``agent_id`` and ``op_id`` survive every merge — attribution completeness
+    is a first-class measured metric, not a side effect. ``op_id`` orders
+    writes from the same agent; ``happens_after`` (optional) lets a workload
+    express the partial order ("agent B's write saw agent A's write") so the
+    harness can distinguish true concurrency from sequential causality.
+    """
+
+    agent_id: str
+    op_id: int
+    field: str
+    value: Any
+    kind: FieldKind = FieldKind.scalar
+    happens_after: tuple[str, int] | None = None  # (agent_id, op_id) of a write this one observed
+
+
+@dataclass
+class Outcome:
+    """What a strategy reports for a single applied write.
+
+    ``applied`` is True if the write is reflected in finalized state. A False
+    here under LWW means the write was overwritten (the corruption signal).
+    The optional ``escalation`` is non-None only when the strategy detected a
+    semantic conflict and surfaced it instead of silently merging.
+    """
+
+    applied: bool
+    escalation: "Escalation | None" = None
+    # Diagnostics the strategy may set; not all are meaningful for every
+    # strategy (e.g. model_calls is nonzero only for transactional).
+    overwrote_prior: bool = False
+
+
+@dataclass
+class Escalation:
+    """A semantic conflict the strategy refused to auto-resolve.
+
+    Per the thesis, CRDT auto-merges mergeable state and ESCALATES semantic /
+    un-mergeable conflicts rather than silently picking a winner. LWW never
+    escalates (it silently corrupts); transactional escalates via a model call.
+    """
+
+    field: str
+    contenders: list["Contender"]
+    reason: str = "semantic_conflict"
+
+    @dataclass
+    class Contender:
+        agent_id: str
+        op_id: int
+        value: Any
+
+
+@dataclass
+class Metrics:
+    """Per-run counters accumulated across all writes.
+
+    These map 1:1 to the comparison-table columns. ``writes_lost`` is the
+    convergence-correctness signal: it counts writes that were applied to a
+    replica but did NOT survive into the final converged state.
+    """
+
+    writes_seen: int = 0
+    writes_applied: int = 0
+    writes_lost: int = 0
+    escalations: int = 0
+    model_calls: int = 0  # only nonzero for the transactional strategy
+
+
+class MergeStrategy(Protocol):
+    """The ONE interface all three strategies implement.
+
+    A strategy owns one replica's view of the document. The harness creates one
+    instance per (strategy, replica) pair, applies that replica's writes to it,
+    then merges replicas via :meth:`export_state` / :meth:`import_state`.
+
+    Why merge-by-export rather than a central ``apply_to_all``: it mirrors how
+    real multi-agent systems actually replicate — each agent edits a local copy
+    and the sync layer reconciles. LWW/transactional simulate this with a
+    shared dict + timestamp; CRDT does it natively via Loro frontiers/blobs.
+    """
+
+    name: str
+
+    def apply(self, write: Write) -> Outcome: ...
+
+    def export_state(self) -> bytes:
+        """Serialize this replica's state for transfer to another replica."""
+        ...
+
+    def import_state(self, blob: bytes) -> None:
+        """Merge another replica's exported state into this one."""
+        ...
+
+    def finalized_state(self) -> dict[str, Any]:
+        """Return the human-readable converged document for assertion / display."""
+        ...
+
+    def metrics(self) -> Metrics: ...
+
+
+# ---------------------------------------------------------------------------
+# Workload definitions
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class Workload:
+    """A named workload: the partial order of writes each agent performs.
+
+    ``writes_by_replica[replica_id]`` is the sequence of writes that replica
+    applies LOCALLY before any merge. The harness then merges replicas and
+    checks convergence. ``expectation`` states what a CORRECT strategy should
+    produce, so the table can show pass/fail per metric, not just numbers.
+    """
+
+    name: str
+    description: str
+    writes_by_replica: dict[str, list[Write]]
+    expectation: "Expectation"
+
+
+@dataclass
+class Expectation:
+    """What correct behavior looks like for a workload.
+
+    Used to turn raw metrics into pass/fail verdicts in the comparison table.
+    ``semantic_conflict_on`` lists fields where a correct strategy MUST
+    escalate (non-empty) — empty means the workload is clean-merge and any
+    escalation or lost write is a failure.
+    """
+
+    clean_merge: bool  # True => no semantic conflict is expected
+    all_writes_survive: bool  # True => writes_lost must be 0 for a correct strategy
+    semantic_conflict_on: tuple[str, ...] = ()
+
+
+@dataclass
+class RunResult:
+    """One row of the comparison table: one strategy on one workload."""
+
+    strategy: str
+    workload: str
+    converged: bool  # all replicas reached identical finalized_state
+    writes_lost: int
+    attribution_complete: bool  # every surviving write traces to an agent
+    escalations: int
+    model_calls: int
+    latency_ms: float
+    peak_mem_kb: float
+    # How the strategy reached its end state — NOT interchangeable across
+    # strategies even when both PASS. ``verdict`` says "acceptable end state";
+    # ``outcome`` says *how*. This is the one column that keeps escalate vs
+    # resolve vs corrupt from masquerading as the same green checkmark.
+    outcome: EndState = EndState.auto_merged
+    verdict: Literal["PASS", "FAIL"] = "PASS"
+    notes: list[str] = field(default_factory=list)
+
+
+__all__ = [
+    "FieldKind",
+    "EndState",
+    "Write",
+    "Outcome",
+    "Escalation",
+    "Metrics",
+    "MergeStrategy",
+    "Workload",
+    "Expectation",
+    "RunResult",
+]

agentsync/repro.py

@@ -0,0 +1,146 @@
+"""Independent reproduction of the langgraph silent-write-loss bug.
+
+This module exists to prove the bug is real in VANILLA langgraph — no
+agentsync code in the write path. A hostile reader's first instinct is "the
+demo was rigged to make agentsync look good"; this closes that door.
+
+Run two parallel nodes that ``store.put()`` to the SAME key against the STOCK
+``InMemoryStore``. Show the raw final state: one write gone, no error raised.
+Then, clearly delineated, run the SAME graph against ``SyncedStore`` to show
+the fix.
+
+    python -m agentsync.repro        # or: make repro
+"""
+
+from __future__ import annotations
+
+import sys
+from importlib.metadata import version as pkg_version
+from typing import Any, Callable
+
+from langgraph.graph import END, START, StateGraph
+from langgraph.store.base import BaseStore
+from langgraph.store.memory import InMemoryStore
+from typing_extensions import TypedDict
+
+from .store import SyncedStore
+
+NS = ("ctx",)
+KEY = "k"
+
+
+class _S(TypedDict):
+    """Minimal graph state. The shared memory lives in the store, not here."""
+    trigger: int
+
+
+def _node(agent_id: str, payload: dict[str, Any]) -> Callable:
+    """A node that writes ``payload`` to the shared key as ``agent_id``.
+
+    Pure langgraph on its own: it calls the injected ``store.put``. On a stock
+    ``InMemoryStore`` that is a blind overwrite; on ``SyncedStore`` it merges.
+    The node code is IDENTICAL for both — only the store instance differs, which
+    is the whole point of the reproduction.
+    """
+    # NOTE: nodes that want agentsync attribution use ``store.acting_as``; the
+    # BASELINE run uses a stock InMemoryStore which has no such method, so we
+    # guard it. The put() call itself is the same either way.
+    def node(_state: _S, store: BaseStore) -> dict:
+        if hasattr(store, "acting_as"):
+            with store.acting_as(agent_id):
+                store.put(NS, KEY, payload)
+        else:
+            store.put(NS, KEY, payload)
+        return {}
+
+    return node
+
+
+def _build_and_run(store: BaseStore, nodes: dict[str, Callable]) -> dict | None:
+    g = StateGraph(_S)
+    for name, fn in nodes.items():
+        g.add_node(name, fn)
+        g.add_edge(START, name)
+        g.add_edge(name, END)
+    g.compile(store=store).invoke({"trigger": 0})
+    item = store.get(NS, KEY)
+    return item.value if item else None
+
+
+def _section(title: str) -> None:
+    print("\n" + "=" * 68)
+    print(title)
+    print("=" * 68)
+
+
+def main() -> int:
+    try:
+        lg_version = pkg_version("langgraph")
+    except Exception:  # pragma: no cover
+        lg_version = "unknown"
+
+    print("agentsync bug reproduction — langgraph silent write-loss")
+    print(f"detected langgraph version: {lg_version}")
+
+    # The two concurrent writes. Both target the SAME key. All fields are
+    # mergeable in principle (tags are lists, status is a scalar that diverges).
+    payload_a = {"tags": ["crdt", "agents"], "status": "draft"}
+    payload_b = {"tags": ["benchmark"], "status": "published"}
+    nodes = {"agent_A": _node("A", payload_a), "agent_B": _node("B", payload_b)}
+
+    # ------------------------------------------------------------------ #
+    # PART 1 — stock langgraph. NO agentsync in the write path.
+    # ------------------------------------------------------------------ #
+    _section("PART 1 — stock langgraph InMemoryStore (no agentsync in play)")
+    print(f"agent_A puts: {payload_a}")
+    print(f"agent_B puts: {payload_b}")
+    print("running two PARALLEL nodes against InMemoryStore...")
+
+    plain = InMemoryStore()
+    final = _build_and_run(plain, nodes)
+    print(f"\nfinal store value: {final}")
+    a_tags_survive = final and "crdt" in (final.get("tags") or [])
+    print(
+        "agent_A's tags survived? "
+        + ("YES — unexpected" if a_tags_survive else "NO — silently dropped")
+    )
+    if not a_tags_survive:
+        print("-> BUG REPRODUCED: one concurrent write is gone. No exception was raised.")
+
+    # ------------------------------------------------------------------ #
+    # PART 2 — the SAME graph, only the store instance changes.
+    # ------------------------------------------------------------------ #
+    _section("PART 2 — same graph, SyncedStore (agentsync in play)")
+    synced = SyncedStore()
+    final2 = _build_and_run(synced, nodes)
+    print(f"final store value: {final2}")
+    all_tags = set((final2 or {}).get("tags") or [])
+    print(f"agent_A's tags survived? {'YES' if 'crdt' in all_tags else 'NO'}")
+    print(f"agent_B's tags survived? {'YES' if 'benchmark' in all_tags else 'NO'}")
+    escs = synced.escalations()
+    if escs:
+        for esc in escs:
+            contenders = ", ".join(f"{c.agent_id}='{c.value}'" for c in esc.contenders)
+            print(f"semantic conflict on '{esc.field}' ESCALATED (not auto-resolved): {contenders}")
+    else:
+        print("no escalations")
+
+    # ------------------------------------------------------------------ #
+    # Verdict
+    # ------------------------------------------------------------------ #
+    _section("VERDICT")
+    print(
+        "stock InMemoryStore: "
+        + ("silent write-loss reproduced" if not a_tags_survive else "no loss observed")
+    )
+    print(
+        f"SyncedStore:        merged tags = {sorted(all_tags)}, "
+        f"{len(escs)} escalation(s)"
+    )
+    print("\nThe bug is in vanilla langgraph. SyncedStore fixes it. Same graph,")
+    print("same writes — only the store instance differs.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

agentsync/store.py

@@ -0,0 +1,223 @@
+"""SyncedStore — the drop-in shared-state backend that fixes LangGraph's silent
+write-loss.
+
+The problem this exists to solve (verified against langgraph 1.2.6): when two
+parallel nodes call ``store.put`` on the SAME key, ``InMemoryStore`` silently
+overwrites the first write with the second. No error, no merge, no signal —
+last-write-wins, A's contribution gone. A team wiring parallel agents to shared
+context never learns a write was dropped.
+
+``SyncedStore`` subclasses ``InMemoryStore`` so it's a 1-line swap, and routes
+every ``PutOp`` through a per-key CRDT engine (the same Loro/eg-walker merge
+from the benchmark). Concurrent writes to the SAME key now:
+
+* **merge** when they're mergeable — list values union (set-style), nested dicts
+  deep-merge, text-convention keys concatenate. No write is lost.
+* **escalate** when they're a semantic conflict — two agents setting the same
+  SCALAR field to different values. The conflict is recorded as an
+  :class:`Escalation` event with both contenders attributed, and NOT silently
+  resolved. The field holds a sentinel until someone drains the escalation.
+
+Every write is attributed to an ``agent_id``. langgraph's ``store.put`` has no
+agent parameter, so attribution is wired through a contextvar: wrap a node's
+puts in ``with store.acting_as(agent_id):`` (one extra line) and every put
+inside carries that id through merges.
+
+The rest of the store — ``get``/``delete``/``search`` — is inherited unchanged
+from ``InMemoryStore``; only the write path is intercepted.
+"""
+
+from __future__ import annotations
+
+import contextvars
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Callable, Iterable
+
+from langgraph.store.base import Op, PutOp
+from langgraph.store.memory import InMemoryStore
+
+from .models import Escalation, FieldKind, Write
+from .strategies.crdt import CRDTStrategy
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+# The agent_id attribution context. langgraph's batch() receives no config, so
+# a contextvar is the honest channel for "which agent is writing right now". It
+# defaults to "anonymous" so the store never hard-fails on an unwrapped put —
+# but attribution completeness then can't be guaranteed, and metrics say so.
+_current_agent: contextvars.ContextVar[str] = contextvars.ContextVar(
+    "agentsync_agent_id", default="anonymous"
+)
+
+
+@dataclass
+class _KeyEngine:
+    """One CRDT engine per logical key ((namespace, key) pair).
+
+    langgraph calls ``batch`` once per node per key per superstep, so a key hit
+    by N parallel nodes sees N separate writes — each lands here and the engine
+    merges them. This is the per-key accumulator the merge lives in.
+    """
+
+    engine: CRDTStrategy = field(default_factory=CRDTStrategy)
+    # Monotone op counter per agent so the CRDT can order that agent's writes.
+    _ops: dict[str, int] = field(default_factory=dict)
+
+    def next_op(self, agent_id: str) -> int:
+        n = self._ops.get(agent_id, 0)
+        self._ops[agent_id] = n + 1
+        return n
+
+    def state(self) -> dict[str, Any]:
+        return self.engine.finalized_state()
+
+    def escalations(self) -> list[Escalation]:
+        # finalized_state() recomputes escalations into the engine's list.
+        self.engine.finalized_state()
+        return list(self.engine._escalations)
+
+
+def _classify_field(key: str, value: Any) -> FieldKind:
+    """Heuristic field-kind for a JSON-store value.
+
+    The benchmark workloads declared kinds explicitly; a drop-in store only sees
+    raw JSON values, so we infer. Lists are mergeable (union); string values
+    under a *-text / notes / findings key are append-style; everything else is a
+    scalar (the conflict surface). Conservative: when unsure, scalar — which
+    means "escalate on divergence" rather than "silently merge".
+    """
+    if isinstance(value, list):
+        return FieldKind.grow_set
+    if isinstance(value, str) and any(
+        tag in key.lower() for tag in ("text", "notes", "findings", "log")
+    ):
+        return FieldKind.append_text
+    return FieldKind.scalar
+
+
+class SyncedStore(InMemoryStore):
+    """``InMemoryStore`` whose writes CRDT-merge instead of last-write-wins.
+
+    Drop-in: ``graph = builder.compile(store=SyncedStore())``. Get merges +
+    attribution + escalation for free; lose nothing that ``InMemoryStore``
+    already does.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        # One CRDT engine per key. Keys are (namespace, key) tuples.
+        self._engines: dict[tuple[tuple[str, ...], str], _KeyEngine] = {}
+
+    # ------------------------------------------------------------------
+    # Attribution context
+    # ------------------------------------------------------------------
+    @contextmanager
+    def acting_as(self, agent_id: str) -> "Iterator[SyncedStore]":
+        """Scope the agent_id attributed to puts inside this block.
+
+        Example::
+
+            with store.acting_as("researcher"):
+                store.put(("ctx",), "notes", {...})   # attributed to researcher
+
+        Why a contextvar and not a put() arg: langgraph's store API has no agent
+        parameter, and ``batch()`` receives no config. A contextvar is the one
+        channel that threads an id from a node into the store without forking
+        langgraph internals.
+        """
+        token = _current_agent.set(agent_id)
+        try:
+            yield self
+        finally:
+            _current_agent.reset(token)
+
+    @property
+    def current_agent(self) -> str:
+        return _current_agent.get()
+
+    # ------------------------------------------------------------------
+    # The write path — intercept PutOps and route through the CRDT engine
+    # ------------------------------------------------------------------
+    def batch(self, ops: Iterable[Op]) -> list:
+        """Override the chokepoint: merge same-key concurrent writes.
+
+        ``put`` is concrete in ``BaseStore`` and calls ``self.batch([PutOp])``,
+        so this is the single place every write passes through. For each
+        ``PutOp`` we (a) feed each field of the value into the key's CRDT
+        engine, (b) read back the merged value, (c) hand a *merged* PutOp to
+        super().batch so the parent storage reflects the union, not the clobber.
+        """
+        prepared: list[Op] = []
+        for op in ops:
+            if isinstance(op, PutOp) and op.value is not None:
+                merged = self._merge_through_crdt(op)
+                op = PutOp(
+                    op.namespace, op.key, merged, index=op.index, ttl=op.ttl
+                )
+            prepared.append(op)
+        return super().batch(prepared)
+
+    def _merge_through_crdt(self, op: PutOp) -> dict[str, Any]:
+        """Feed one PutOp's value fields into the key's CRDT, return merged value.
+
+        The store's value model is a flat ``dict[str, JSON]``. Each top-level
+        field becomes a CRDT field; its kind is inferred from value shape. The
+        engine merges concurrent fields across the multiple batch() calls the
+        runtime makes for parallel nodes.
+        """
+        k = (op.namespace, op.key)
+        engine = self._engines.setdefault(k, _KeyEngine())
+        agent_id = _current_agent.get()
+        for field_name, field_value in op.value.items():
+            kind = _classify_field(field_name, field_value)
+            # Coerce list into the set semantics the CRDT grow_set expects.
+            crdt_value = set(field_value) if kind is FieldKind.grow_set else field_value
+            engine.engine.apply(
+                Write(
+                    agent_id=agent_id,
+                    op_id=engine.next_op(agent_id),
+                    field=field_name,
+                    value=crdt_value,
+                    kind=kind,
+                )
+            )
+        # Read back the merged, materialized state — this is what gets stored.
+        merged = engine.state()
+        # Surface CRDT escalations on the store so a caller can drain them.
+        for esc in engine.escalations():
+            self._on_escalation(esc)
+        return merged
+
+    # ------------------------------------------------------------------
+    # Escalation surface
+    # ------------------------------------------------------------------
+    # Callable hook: a consumer wires ``store.on_escalation(my_callback)`` to be
+    # notified instead of polling. Deliberately just a function attribute, not a
+    # queue/worker — the consumer's shape (human? supervisor? retry?) is unknown
+    # until validated, so we surface the event and get out of the way.
+    def on_escalation(self, callback: Callable[[Escalation], None]) -> None:
+        self._escalation_cb = callback  # type: ignore[attr-defined]
+
+    def _on_escalation(self, esc: Escalation) -> None:
+        cb = getattr(self, "_escalation_cb", None)
+        if cb is not None:
+            cb(esc)
+
+    def escalations(self) -> list[Escalation]:
+        """All semantic conflicts observed across all keys (drain point)."""
+        out: list[Escalation] = []
+        for engine in self._engines.values():
+            out.extend(engine.escalations())
+        return out
+
+    def attribution(self) -> dict[str, dict[str, dict[str, Any]]]:
+        """Per-key, per-write attribution: which agent wrote each surviving field."""
+        return {
+            f"{ns}:{key}": eng.engine.attribution()
+            for (ns, key), eng in self._engines.items()
+        }
+
+
+__all__ = ["SyncedStore"]

agentsync/strategies/__init__.py

@@ -0,0 +1,43 @@
+"""Strategies for reconciling concurrent agent writes to shared state.
+
+Each module implements :class:`agentsync.models.MergeStrategy` behind the ONE
+common interface so the benchmark harness can swap them without touching
+workload or measurement code.
+
+* :mod:`lww`           — last-write-wins. The silent-corruption baseline.
+* :mod:`transactional` — LLM-mediated conflict resolution (CoAgent MTPO approx).
+* :mod:`crdt`          — Loro / eg-walker deterministic merge.
+
+Exported here as factory callables (``make_strategy(name)``) so the harness and
+workloads share a single registry.
+"""
+
+from __future__ import annotations
+
+from ..models import MergeStrategy
+
+
+def make_strategy(name: str) -> MergeStrategy:
+    """Construct a fresh replica for the named strategy.
+
+    Raising on unknown names (rather than returning None) keeps a typo from
+    silently turning the benchmark into a two-strategy comparison.
+    """
+    # Imported lazily so that a missing optional dep (e.g. loro) only blows up
+    # when its strategy is actually selected, not on package import.
+    if name == "lww":
+        from .lww import LWWStrategy
+
+        return LWWStrategy()
+    if name == "transactional":
+        from .transactional import TransactionalStrategy
+
+        return TransactionalStrategy()
+    if name == "crdt":
+        from .crdt import CRDTStrategy
+
+        return CRDTStrategy()
+    raise ValueError(f"unknown strategy: {name!r}")
+
+
+__all__ = ["make_strategy"]