uro-core 0.2.0__tar.gz

uro_core-0.2.0/.gitignore

@@ -0,0 +1,27 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+.python-version.local
+
+# Tooling caches
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+
+# Deployment config holds credential references — commit uro.example.toml instead (docs/14)
+uro.toml
+.env
+
+# IDE / OS
+.idea/
+.vscode/
+.DS_Store
+
+# Stray local data dumps — never commit (a PII file named `data` was found here once)
+/data

uro_core-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 cupskeee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

uro_core-0.2.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: uro-core
+Version: 0.2.0
+Summary: Uro Engine core library — persistent, AI-driven RPG world engine (embeddable, headless)
+Project-URL: Homepage, https://github.com/cupskeee/uro
+Project-URL: Repository, https://github.com/cupskeee/uro
+Project-URL: Issues, https://github.com/cupskeee/uro/issues
+Author: cupskeee
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,event-sourcing,game-engine,llm,rpg,worldbuilding
+Requires-Python: >=3.12
+Requires-Dist: jinja2>=3.1
+Requires-Dist: pydantic>=2.9
+Requires-Dist: python-ulid>=2.7
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: all
+Requires-Dist: asyncpg>=0.30; extra == 'all'
+Requires-Dist: httpx>=0.27; extra == 'all'
+Requires-Dist: pgvector>=0.5.0; extra == 'all'
+Provides-Extra: llm
+Requires-Dist: httpx>=0.27; extra == 'llm'
+Provides-Extra: postgres
+Requires-Dist: asyncpg>=0.30; extra == 'postgres'
+Requires-Dist: pgvector>=0.5.0; extra == 'postgres'
+Description-Content-Type: text/markdown
+
+# uro-core
+
+**The Uro Engine core library — the embeddable, headless world-state engine.**
+
+Uro is a *world-state engine*: the persistent, versioned, forkable canonical record of a
+living fictional world. A model narrates; a fenced extractor distills that narration into a
+queryable world model — actors, places, factions, beliefs, open threads — that stays
+authoritative while the story plays over it. It tracks not only what is *true* but *who knows
+it*, and world state is **versioned and forkable**: a finished campaign's ending becomes a
+point in history any new campaign can continue from, branch off, or explore as a what-if.
+
+`uro-core` contains all engine logic and is embeddable in any consumer — the engine only ever
+sees ports (hexagonal architecture), never concrete adapters.
+
+## Install
+
+```sh
+pip install "uro-core[postgres,llm]"
+```
+
+The base install is the pure engine (it imports only ports). The shipped adapters live behind
+extras:
+
+- `postgres` — the bundled event store + semantic memory over PostgreSQL + pgvector.
+- `llm` — the bundled LLM provider adapters (OpenAI-compatible + Anthropic).
+- `all` — both.
+
+An embedder can install the base package and supply their own adapters behind the same ports.
+
+## Runtime
+
+The bundled store requires **PostgreSQL 17 + pgvector**. The reference setup runs it via
+Docker on host port 5433; see the project repository.
+
+## Links
+
+- Source, docs, and the reference CLI/server: https://github.com/cupskeee/uro
+- License: MIT

uro_core-0.2.0/README.md

@@ -0,0 +1,38 @@
+# uro-core
+
+**The Uro Engine core library — the embeddable, headless world-state engine.**
+
+Uro is a *world-state engine*: the persistent, versioned, forkable canonical record of a
+living fictional world. A model narrates; a fenced extractor distills that narration into a
+queryable world model — actors, places, factions, beliefs, open threads — that stays
+authoritative while the story plays over it. It tracks not only what is *true* but *who knows
+it*, and world state is **versioned and forkable**: a finished campaign's ending becomes a
+point in history any new campaign can continue from, branch off, or explore as a what-if.
+
+`uro-core` contains all engine logic and is embeddable in any consumer — the engine only ever
+sees ports (hexagonal architecture), never concrete adapters.
+
+## Install
+
+```sh
+pip install "uro-core[postgres,llm]"
+```
+
+The base install is the pure engine (it imports only ports). The shipped adapters live behind
+extras:
+
+- `postgres` — the bundled event store + semantic memory over PostgreSQL + pgvector.
+- `llm` — the bundled LLM provider adapters (OpenAI-compatible + Anthropic).
+- `all` — both.
+
+An embedder can install the base package and supply their own adapters behind the same ports.
+
+## Runtime
+
+The bundled store requires **PostgreSQL 17 + pgvector**. The reference setup runs it via
+Docker on host port 5433; see the project repository.
+
+## Links
+
+- Source, docs, and the reference CLI/server: https://github.com/cupskeee/uro
+- License: MIT

uro_core-0.2.0/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "uro-core"
+version = "0.2.0"
+description = "Uro Engine core library — persistent, AI-driven RPG world engine (embeddable, headless)"
+license = "MIT"
+license-files = ["LICENSE"]
+readme = "README.md"
+authors = [{ name = "cupskeee" }]
+keywords = ["ai", "llm", "rpg", "game-engine", "event-sourcing", "worldbuilding"]
+requires-python = ">=3.12"
+# Base = the engine logic (the hexagonal core ring imports only these). The shipped
+# concrete adapters live behind extras — see D-43 / docs/14: `import uro_core` and the
+# core ring stay importable without a DB driver or an HTTP client, so an embedder can
+# supply its own adapters. The bundled Postgres store and LLM providers need the extras.
+dependencies = [
+    "pydantic>=2.9",
+    "python-ulid>=2.7",
+    "jinja2>=3.1",
+    "pyyaml>=6.0",
+]
+
+[project.optional-dependencies]
+# The bundled EventStore/VectorIndex adapter (uro_core.adapters.postgres).
+postgres = ["asyncpg>=0.30", "pgvector>=0.5.0"]
+# The bundled LLM provider adapters (uro_core.providers.adapters — OpenAI-compatible + Anthropic).
+llm = ["httpx>=0.27"]
+# Everything the reference deployment uses.
+all = ["uro-core[postgres,llm]"]
+
+[project.urls]
+Homepage = "https://github.com/cupskeee/uro"
+Repository = "https://github.com/cupskeee/uro"
+Issues = "https://github.com/cupskeee/uro/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["uro_core"]

uro_core-0.2.0/tests/conftest.py

@@ -0,0 +1,24 @@
+import os
+from collections.abc import AsyncIterator
+
+import asyncpg
+import pytest
+import pytest_asyncio
+from uro_core.adapters.postgres.store import PostgresEventStore
+
+DSN = os.environ.get("URO_DATABASE_URL", "postgresql://uro:uro@localhost:5433/uro")
+
+
+@pytest_asyncio.fixture
+async def store() -> AsyncIterator[PostgresEventStore]:
+    """A connected, migrated Postgres store — skips the test if no DB is reachable."""
+    s = PostgresEventStore(DSN)
+    try:
+        await s.connect()
+    except (OSError, asyncpg.PostgresError) as exc:  # pragma: no cover - env dependent
+        pytest.skip(f"Postgres unavailable at {DSN} ({exc})")
+    try:
+        await s.migrate()
+        yield s
+    finally:
+        await s.close()

uro_core-0.2.0/tests/test_alien_acceptance.py

@@ -0,0 +1,247 @@
+"""Phase 6 ACCEPTANCE (OQ-13, D-30): the alien ruleset plays end-to-end. Deterministic — no LLM.
+
+The phase thesis: the engine is game-agnostic (D-1). Proof — a structurally non-d20 ruleset
+(uro_pbta: 2d6 vs 7/10, a harm clock, moves, no hp/ac) runs through the SAME port, runner,
+pipeline, persistence, and fork machinery as uro_basic, and produces a graded consequence a
+binary d20 result cannot express (the 7-9 PARTIAL). Asserted on committed events/projections.
+"""
+
+from collections.abc import AsyncIterator
+
+from uro_core.adapters.postgres.store import PostgresEventStore
+from uro_core.domain.events import actor_created, sheet_updated
+from uro_core.domain.ids import new_id
+from uro_core.export import verify_bundle
+from uro_core.pipeline.encounter import run_encounter
+from uro_core.pipeline.engine import Engine
+from uro_core.providers.adapters.stub import hashing_embedding
+from uro_core.providers.base import CompletionRequest
+from uro_core.providers.router import ProviderRouter
+from uro_core.rulesets import registry
+from uro_core.rulesets.base import CharSpec, Combatant
+from uro_core.rulesets.rng import Rng
+from uro_core.rulesets.uro_basic import UroBasic
+from uro_core.rulesets.uro_pbta import Sheet as PbtaSheet
+from uro_core.rulesets.uro_pbta import UroPbtA
+
+PBTA = UroPbtA()
+D20 = UroBasic()
+
+
+def _pbta(forceful: int) -> dict:
+    return PBTA.new_character(CharSpec(data={"stats": {"forceful": forceful}}), Rng(0))
+
+
+def _d20(abilities: dict[str, int]) -> dict:
+    return D20.new_character(CharSpec(data={"abilities": abilities}), Rng(0))
+
+
+# --- 1. the alien conflict resolves decisively and reaches the THREE-tier band (seed-invariant) ---
+
+
+def test_pbta_conflict_always_resolves_and_uses_three_tiers() -> None:
+    def combs() -> list[Combatant]:
+        return [
+            Combatant(actor_id="a:ash", team="party", sheet=_pbta(3)),
+            Combatant(actor_id="a:bane", team="foes", sheet=_pbta(-3)),
+        ]
+
+    tiers: set[str] = set()
+    for seed in range(200):
+        events, outcome = run_encounter(PBTA, combs(), Rng(seed), encounter_id="e")
+        assert outcome.winner_team in ("party", "foes")  # a decisive result every seed
+        assert len(outcome.out_of_fight) >= 1  # never a draw or turn-cap stall
+        tiers |= {e.payload["result"] for e in events if e.event_type == "EncounterTurnTaken"}
+    # miss / partial / full ALL occur across play — the graded band a binary success:bool can't hold
+    assert {"miss", "partial", "full"} <= tiers
+
+
+# --- 2. THE HEADLINE: a 7-9 partial leaves a persistent canonical consequence, carried on a fork -
+
+
+async def test_partial_consequence_persists_and_forks(store: PostgresEventStore) -> None:
+    world = await store.create_world(
+        f"Ember-{new_id()}", ruleset_id="uro-pbta", ruleset_version=">=0"
+    )
+    main = world.main_branch_id
+    campaign = await store.start_campaign(
+        world.world_id,
+        main,
+        participant_id="p1",
+        new_pc_name="Ash",
+        new_pc_id="a:ash",
+        pc_sheet=_pbta(3),
+        ruleset_id="uro-pbta",
+        ruleset_version=">=0",
+    )
+    assert campaign.ruleset_id == "uro-pbta"
+    await store.append_beat(main, [actor_created(actor_id="a:bane", name="Bane", tier=2)])
+
+    # A conflict with a KNOWN 7-9 partial (seed 4): Ash seizes Bane, succeeds, but is left Exposed.
+    combatants = [
+        Combatant(actor_id="a:ash", team="party", sheet=_pbta(3)),
+        Combatant(actor_id="a:bane", team="foes", sheet=_pbta(-3)),
+    ]
+    events, outcome = run_encounter(PBTA, combatants, Rng(4), encounter_id="e:1")
+    results = [e.payload["result"] for e in events if e.event_type == "EncounterTurnTaken"]
+    assert "partial" in results  # the d20-inexpressible middle band actually happened
+    await store.append_beat(main, events)
+
+    # the partial's STANDING COST is canon: Ash carries the 'Exposed' condition (not a bool)
+    ash = await store.get_sheet(main, "a:ash")
+    assert ash is not None and "Exposed" in ash["conditions"]
+    assert "hp" not in ash  # PbtA harm, never a leaked hp scalar
+    bane = await store.get_sheet(main, "a:bane")
+    assert bane is not None and bane["harm"] == 4  # the harm clock filled → out of the fight
+    assert outcome.winner_team == "party" and "a:bane" in outcome.out_of_fight
+
+    # ...and it forks like any other state — a sibling branch inherits the condition + harm clock
+    head = await store.get_branch(main)
+    fork = await store.fork_branch(world.world_id, head.head_commit, "aftermath")
+    assert "Exposed" in (await store.get_sheet(fork.branch_id, "a:ash"))["conditions"]
+    assert (await store.get_sheet(fork.branch_id, "a:bane"))["harm"] == 4
+
+
+# --- 3. both rulesets coexist in one engine build (the game-agnosticism claim, concretely) ---
+
+
+def test_d20_and_pbta_coexist_with_distinct_harm_shapes() -> None:
+    d20_events, _ = run_encounter(
+        D20,
+        [
+            Combatant(actor_id="a:h", team="party", sheet=_d20({"STR": 20, "CON": 20})),
+            Combatant(actor_id="a:g", team="foes", sheet=_d20({"STR": 8, "CON": 6})),
+        ],
+        Rng(1),
+        encounter_id="e",
+    )
+    pbta_events, _ = run_encounter(
+        PBTA,
+        [
+            Combatant(actor_id="a:h", team="party", sheet=_pbta(3)),
+            Combatant(actor_id="a:g", team="foes", sheet=_pbta(-3)),
+        ],
+        Rng(1),
+        encounter_id="e",
+    )
+    d20_sheets = [e.payload["sheet"] for e in d20_events if e.event_type == "SheetUpdated"]
+    pbta_sheets = [e.payload["sheet"] for e in pbta_events if e.event_type == "SheetUpdated"]
+    # d20 harm = hp; PbtA harm = a clock — the SAME runner, two irreconcilable shapes, no leak
+    assert d20_sheets and all("hp" in s and "harm" not in s for s in d20_sheets)
+    assert pbta_sheets and all("harm" in s and "hp" not in s for s in pbta_sheets)
+
+
+# --- 4. end-to-end pipeline: a registry-bound PbtA campaign plays a fight beat ---
+
+
+class _Scripted:
+    def __init__(self, *, plan_json: str, narration: str) -> None:
+        self._plan = plan_json
+        self._narration = narration
+
+    async def stream(self, req: CompletionRequest) -> AsyncIterator[str]:
+        yield self._narration
+
+    async def complete(self, req: CompletionRequest) -> str:
+        return self._plan if req.stage_tag == "planner" else '{"actors": [], "claims": []}'
+
+    async def embed(self, texts: list[str]) -> list[list[float]]:
+        return [hashing_embedding(t) for t in texts]
+
+
+async def test_pbta_fight_through_the_pipeline(store: PostgresEventStore) -> None:
+    world = await store.create_world(
+        f"Ember-{new_id()}", ruleset_id="uro-pbta", ruleset_version=">=0"
+    )
+    main = world.main_branch_id
+    campaign = await store.start_campaign(
+        world.world_id,
+        main,
+        participant_id="p1",
+        new_pc_name="Ash",
+        new_pc_id="a:ash",
+        pc_sheet=_pbta(5),  # a strong mover so the fight resolves quickly
+        ruleset_id="uro-pbta",
+        ruleset_version=">=0",
+    )
+    await store.append_beat(
+        main,
+        [
+            actor_created(actor_id="a:bane", name="Bane", tier=2, role="thug"),
+            sheet_updated(actor_id="a:bane", sheet=_pbta(-3), ruleset_id="uro-pbta"),
+        ],
+    )
+
+    # the campaign's OWN ruleset is resolved via the registry (the 6.3 binding), not hard-coded
+    ruleset = registry.resolve(campaign.ruleset_id, campaign.ruleset_version)
+    assert isinstance(ruleset, UroPbtA)
+    plan = (
+        '{"intent_class":"action","triggers":["violence"],'
+        '"mechanics":[{"affordance":"seize_by_force","actor":"a:ash","target":"a:bane"}]}'
+    )
+    engine = Engine(
+        store,
+        ProviderRouter(bindings={}, default=_Scripted(plan_json=plan, narration="Ash moves in.")),
+        ruleset=ruleset,
+    )
+    result = await engine.run_beat(campaign, "p1", "I seize the Deep Vein from Bane")
+
+    async with store.pool.acquire() as conn:
+        rows = await conn.fetch(
+            "SELECT event_type, payload FROM events WHERE commit_id = $1 ORDER BY seq",
+            result.commit_id,
+        )
+    types = [r["event_type"] for r in rows]
+    assert types.count("ModeChanged") == 2  # freeroam→encounter→freeroam
+    assert "EncounterStarted" in types and "EncounterEnded" in types
+    assert types[-1] == "BeatResolved"
+    # every turn used the PbtA vocabulary, never a d20 hit/down
+    turn_results = {r["payload"]["result"] for r in rows if r["event_type"] == "EncounterTurnTaken"}
+    assert turn_results and turn_results <= {"miss", "partial", "full"}
+    # harm reached the timeline as opaque PbtA sheets (clock/conditions), never a leaked hp
+    fight_sheets = [
+        r["payload"]["sheet"]
+        for r in rows
+        if r["event_type"] == "SheetUpdated" and r["payload"]["actor_id"] in ("a:ash", "a:bane")
+    ]
+    assert fight_sheets and all("harm" in s and "hp" not in s for s in fight_sheets)
+
+    # the fight left persistent, ruleset-shaped state readable through the normal projection
+    ash = PbtaSheet.model_validate(await store.get_sheet(main, "a:ash"))
+    bane = PbtaSheet.model_validate(await store.get_sheet(main, "a:bane"))
+    assert not bane.in_fight or not ash.in_fight  # a decisive result persisted
+
+
+# --- 5. cross-phase cohesion: a PbtA world survives export/import (P6 x P5) ---
+
+
+async def test_pbta_world_survives_export_import(store: PostgresEventStore) -> None:
+    # A PbtA world's ruleset binding + opaque (hp-less) sheets must round-trip through export/import
+    # exactly as a fork does — the whole stack is ruleset-agnostic, so the Phase-5 export machinery
+    # replays PbtA events with no special-casing. (Cohesion check the phase-end review flagged as
+    # untested; verified here rather than assumed.)
+    src = await store.create_world(
+        f"Ember-{new_id()}", ruleset_id="uro-pbta", ruleset_version=">=0"
+    )
+    await store.append_beat(
+        src.main_branch_id,
+        [
+            actor_created(actor_id="a:river", name="River", tier=2),
+            sheet_updated(
+                actor_id="a:river",
+                sheet={**_pbta(2), "harm": 3, "conditions": ["Exposed"]},
+                ruleset_id="uro-pbta",
+            ),
+        ],
+    )
+    bundle = await store.export_world(src.world_id)
+    verify_bundle(bundle)  # self-consistent hash chain
+    dst = await store.import_world(bundle)
+    assert dst.world_id != src.world_id  # a fresh instance
+
+    # the ruleset binding survived (WorldGenesis carried it) and rebinds on the imported world
+    assert await store.world_ruleset(dst.main_branch_id) == ("uro-pbta", ">=0")
+    # the opaque PbtA sheet replayed verbatim — harm clock + condition intact, still no hp
+    river = await store.get_sheet(dst.main_branch_id, "a:river")
+    assert river is not None and river["harm"] == 3 and river["conditions"] == ["Exposed"]
+    assert "hp" not in river

uro_core-0.2.0/tests/test_anthropic.py

@@ -0,0 +1,94 @@
+"""Anthropic Messages API adapter — SSE parsing and request shaping, via mock transport."""
+
+import httpx
+import pytest
+from uro_core.errors import ProviderError
+from uro_core.providers.adapters.anthropic import AnthropicProvider
+from uro_core.providers.base import CompletionRequest, Message
+
+
+def _provider(handler) -> AnthropicProvider:
+    return AnthropicProvider(
+        model="claude-x", api_key="test-key", transport=httpx.MockTransport(handler)
+    )
+
+
+def _req(json_mode: bool = False) -> CompletionRequest:
+    return CompletionRequest(
+        messages=[
+            Message(role="system", content="You are a narrator."),
+            Message(role="user", content="Describe the tavern."),
+        ],
+        stage_tag="narrator",
+        json_mode=json_mode,
+    )
+
+
+async def test_stream_yields_text_deltas() -> None:
+    sse = (
+        'event: content_block_delta\ndata: {"type":"content_block_delta",'
+        '"delta":{"type":"text_delta","text":"A warm "}}\n\n'
+        'event: content_block_delta\ndata: {"type":"content_block_delta",'
+        '"delta":{"type":"text_delta","text":"tavern."}}\n\n'
+        'event: message_stop\ndata: {"type":"message_stop"}\n\n'
+    )
+    provider = _provider(lambda request: httpx.Response(200, text=sse))
+    chunks = [c async for c in provider.stream(_req())]
+    assert "".join(chunks) == "A warm tavern."
+
+
+async def test_stream_puts_system_top_level_and_drops_system_message() -> None:
+    seen: dict = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        import json
+
+        seen.update(json.loads(request.content))
+        return httpx.Response(200, text='event: message_stop\ndata: {"type":"message_stop"}\n\n')
+
+    _ = [c async for c in _provider(handler).stream(_req())]
+    assert seen["system"] == "You are a narrator."  # system is top-level, not a message
+    assert [m["role"] for m in seen["messages"]] == ["user"]
+    assert seen["max_tokens"] > 0  # required by the API
+
+
+async def test_complete_joins_text_blocks() -> None:
+    data = {"content": [{"type": "text", "text": "It is quiet."}]}
+    provider = _provider(lambda request: httpx.Response(200, json=data))
+    assert await provider.complete(_req()) == "It is quiet."
+
+
+async def test_complete_json_mode_prefills_open_brace() -> None:
+    # json_mode prefills an assistant '{' so Claude returns a JSON object.
+    data = {"content": [{"type": "text", "text": '"actors":[],"claims":[]}'}]}
+    provider = _provider(lambda request: httpx.Response(200, json=data))
+    result = await provider.complete(_req(json_mode=True))
+    assert result == '{"actors":[],"claims":[]}'
+
+
+async def test_non_200_raises_provider_error() -> None:
+    provider = _provider(lambda request: httpx.Response(400, json={"error": {"message": "bad"}}))
+    with pytest.raises(ProviderError):
+        await provider.complete(_req())
+
+
+async def test_embed_raises() -> None:
+    provider = _provider(lambda request: httpx.Response(200, json={}))
+    with pytest.raises(ProviderError):
+        await provider.embed(["anything"])
+
+
+async def test_complete_raises_on_max_tokens_truncation() -> None:
+    # A truncated (stop_reason=max_tokens) response returns HTTP 200 with partial JSON;
+    # complete() must fail loudly so the extractor degrades instead of parsing garbage.
+    data = {"stop_reason": "max_tokens", "content": [{"type": "text", "text": '"actors":['}]}
+    provider = _provider(lambda request: httpx.Response(200, json=data))
+    with pytest.raises(ProviderError, match="max_tokens"):
+        await provider.complete(_req(json_mode=True))
+
+
+async def test_complete_raises_on_non_json_body() -> None:
+    # A gateway/proxy 200 with an HTML body must degrade to ProviderError, not crash.
+    provider = _provider(lambda request: httpx.Response(200, text="<html>gateway</html>"))
+    with pytest.raises(ProviderError):
+        await provider.complete(_req())