wayfinder-paths 0.1.30__py3-none-any.whl → 0.1.31__py3-none-any.whl

wayfinder_paths/tests/test_manifests.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import importlib
+from pathlib import Path
+from typing import Any
+
+import pytest
+import yaml
+
+from wayfinder_paths.core.engine.manifest import load_strategy_manifest
+
+
+def _load_yaml(path: Path) -> dict[str, Any]:
+    data = yaml.safe_load(path.read_text())
+    assert isinstance(data, dict), f"manifest must be a mapping: {path}"
+    return data
+
+
+def _import_entrypoint(entrypoint: str) -> None:
+    assert isinstance(entrypoint, str) and entrypoint.strip()
+    module_path, symbol = entrypoint.rsplit(".", 1)
+
+    last_exc: Exception | None = None
+    for candidate in (module_path, f"wayfinder_paths.{module_path}"):
+        try:
+            mod = importlib.import_module(candidate)
+            if not hasattr(mod, symbol):
+                raise AttributeError(f"{candidate} missing {symbol}")
+            return
+        except Exception as exc:  # noqa: BLE001
+            last_exc = exc
+
+    raise AssertionError(f"Failed to import entrypoint: {entrypoint}") from last_exc
+
+
+def test_all_adapters_have_manifest_yaml_and_entrypoint_imports():
+    adapters_dir = Path(__file__).parent.parent / "adapters"
+    if not adapters_dir.exists():
+        pytest.skip("Adapters directory not found")
+
+    missing: list[str] = []
+    for adapter_dir in sorted(adapters_dir.iterdir()):
+        if not adapter_dir.is_dir() or adapter_dir.name.startswith("_"):
+            continue
+        if not (adapter_dir / "adapter.py").exists():
+            continue
+
+        manifest_path = adapter_dir / "manifest.yaml"
+        if not manifest_path.exists():
+            missing.append(adapter_dir.name)
+            continue
+
+        manifest = _load_yaml(manifest_path)
+        assert manifest.get("schema_version"), (
+            f"Missing schema_version: {manifest_path}"
+        )
+        entrypoint = manifest.get("entrypoint")
+        assert entrypoint, f"Missing entrypoint: {manifest_path}"
+        _import_entrypoint(str(entrypoint))
+
+        caps = manifest.get("capabilities")
+        assert isinstance(caps, list), f"capabilities must be a list: {manifest_path}"
+
+    if missing:
+        pytest.fail(f"Adapters missing manifest.yaml: {', '.join(missing)}")
+
+
+def test_all_strategies_have_manifest_yaml_and_validate():
+    strategies_dir = Path(__file__).parent.parent / "strategies"
+    if not strategies_dir.exists():
+        pytest.skip("Strategies directory not found")
+
+    missing: list[str] = []
+    for strat_dir in sorted(strategies_dir.iterdir()):
+        if not strat_dir.is_dir() or strat_dir.name.startswith("_"):
+            continue
+        if not (strat_dir / "strategy.py").exists():
+            continue
+
+        manifest_path = strat_dir / "manifest.yaml"
+        if not manifest_path.exists():
+            missing.append(strat_dir.name)
+            continue
+
+        # Use the canonical validator.
+        manifest = load_strategy_manifest(str(manifest_path))
+        assert manifest.schema_version
+        assert manifest.entrypoint
+
+        _import_entrypoint(manifest.entrypoint)
+
+    if missing:
+        pytest.fail(f"Strategies missing manifest.yaml: {', '.join(missing)}")

wayfinder_paths/tests/test_mcp_balances.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from wayfinder_paths.mcp.tools.balances import _dedupe_ordered, balances
+
+
+def test_dedupe_ordered_is_case_insensitive():
+    assert _dedupe_ordered(["ETH", "eth", "USDC", "usdc", "Eth"]) == ["ETH", "USDC"]
+
+
+@pytest.mark.asyncio
+async def test_balances_enriched_filters_solana_for_evm_wallet():
+    fake_client = AsyncMock()
+    fake_client.get_enriched_wallet_balances = AsyncMock(
+        return_value={
+            "balances": [
+                {"network": "base", "balanceUSD": 1.5},
+                {"network": "solana", "balanceUSD": 999.0},
+                {"network": "arbitrum", "balanceUSD": "2.0"},
+            ],
+            "total_balance_usd": 1002.5,
+        }
+    )
+
+    with patch(
+        "wayfinder_paths.mcp.tools.balances.BalanceClient", return_value=fake_client
+    ):
+        out = await balances(
+            "enriched",
+            wallet_address="0x000000000000000000000000000000000000dEaD",
+            include_solana=False,
+        )
+
+    assert out["ok"] is True
+    res = out["result"]
+    assert res["total_balance_usd"] == pytest.approx(3.5)
+    assert res["chain_breakdown"]["base"] == pytest.approx(1.5)
+    assert res["chain_breakdown"]["arbitrum"] == pytest.approx(2.0)
+    assert all(b["network"].lower() != "solana" for b in res["balances"])
+    assert res["filtered"]["original_count"] == 3
+    assert res["filtered"]["filtered_count"] == 2
+
+
+@pytest.mark.asyncio
+async def test_balances_token_dedupes_and_returns_per_token_results():
+    fake_client = AsyncMock()
+
+    async def _get_token_balance(
+        *, token_id: str, wallet_address: str, human_readable: bool
+    ):
+        if token_id == "bad":
+            raise RuntimeError("boom")
+        return {"token_id": token_id, "balance": 1}
+
+    fake_client.get_token_balance = AsyncMock(side_effect=_get_token_balance)
+
+    with patch(
+        "wayfinder_paths.mcp.tools.balances.BalanceClient", return_value=fake_client
+    ):
+        out = await balances(
+            "token",
+            wallet_address="0x000000000000000000000000000000000000dEaD",
+            token_ids=["a", "A", "bad", "a"],
+        )
+
+    assert out["ok"] is True
+    rows = out["result"]["balances"]
+    assert [r["token_id"] for r in rows] == ["a", "bad"]
+    assert rows[0]["ok"] is True
+    assert rows[1]["ok"] is False

wayfinder_paths/tests/test_mcp_discovery.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import pytest
+
+from wayfinder_paths.mcp.tools.discovery import describe, discover
+
+
+@pytest.mark.asyncio
+async def test_discover_adapters_includes_hyperliquid():
+    out = await discover("adapter")
+    assert out["ok"] is True
+    items = out["result"]["items"]
+    names = {i["name"] for i in items}
+    assert "hyperliquid_adapter" in names
+
+
+@pytest.mark.asyncio
+async def test_discover_strategies_includes_basis_and_boros():
+    out = await discover("strategy")
+    assert out["ok"] is True
+    items = out["result"]["items"]
+    names = {i["name"] for i in items}
+    assert "boros_hype_strategy" in names
+    assert "basis_trading_strategy" in names
+
+
+@pytest.mark.asyncio
+async def test_describe_strategy_returns_manifest_and_readme_excerpt():
+    out = await describe("strategy", "boros_hype_strategy")
+    assert out["ok"] is True
+    res = out["result"]
+    assert res["kind"] == "strategy"
+    assert res["name"] == "boros_hype_strategy"
+    assert isinstance(res.get("manifest"), dict)

wayfinder_paths/tests/test_mcp_execute.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from wayfinder_paths.mcp.tools.execute import execute
+
+
+@pytest.mark.asyncio
+async def test_execute_validation_error_is_structured():
+    out = await execute(request={"kind": "swap", "wallet_label": "main"})
+    assert out["ok"] is False
+    assert out["error"]["code"] == "invalid_request"
+    assert isinstance(out["error"]["details"], list)
+
+
+@pytest.mark.asyncio
+async def test_execute_swap_dry_run_is_idempotent(tmp_path: Path, monkeypatch):
+    monkeypatch.setenv("DRY_RUN", "1")
+    monkeypatch.setenv("WAYFINDER_MCP_STATE_PATH", str(tmp_path / "mcp.sqlite3"))
+    monkeypatch.setenv("WAYFINDER_RUNS_DIR", str(tmp_path / "runs"))
+
+    wallet = {
+        "address": "0x000000000000000000000000000000000000dEaD",
+        "private_key_hex": "0x" + "11" * 32,
+    }
+
+    class FakeTokenClient:
+        async def get_token_details(self, query: str):
+            if query == "from":
+                return {
+                    "token_id": "from",
+                    "symbol": "FROM",
+                    "decimals": 6,
+                    "chain_id": 42161,
+                    "address": "0x1111111111111111111111111111111111111111",
+                }
+            if query == "to":
+                return {
+                    "token_id": "to",
+                    "symbol": "TO",
+                    "decimals": 6,
+                    "chain_id": 42161,
+                    "address": "0x2222222222222222222222222222222222222222",
+                }
+            raise AssertionError(f"unexpected token query: {query}")
+
+        async def get_gas_token(self, chain_code: str):  # pragma: no cover
+            raise AssertionError("not used")
+
+    class FakeBRAPClient:
+        async def get_quote(self, **kwargs):  # noqa: ANN003
+            assert kwargs["from_chain"] == 42161
+            assert kwargs["to_chain"] == 42161
+            assert kwargs["from_amount"] == "1000000"
+            return {
+                "quotes": [
+                    {"provider": "brap_best"},
+                    {"provider": "brap_alt"},
+                ],
+                "best_quote": {
+                    "provider": "brap_best",
+                    "input_amount": "1000000",
+                    "calldata": {
+                        "to": "0x" + "33" * 20,
+                        "data": "0xdeadbeef",
+                        "value": "0",
+                    },
+                },
+            }
+
+    async def fake_ensure_allowance(**_kwargs):  # noqa: ANN003
+        return True, {"tx_hash": "0xapprove"}
+
+    with (
+        patch(
+            "wayfinder_paths.mcp.tools.execute.find_wallet_by_label",
+            return_value=wallet,
+        ),
+        patch(
+            "wayfinder_paths.mcp.tools.execute.TokenClient",
+            return_value=FakeTokenClient(),
+        ),
+        patch(
+            "wayfinder_paths.mcp.tools.execute.BRAPClient",
+            return_value=FakeBRAPClient(),
+        ),
+        patch(
+            "wayfinder_paths.mcp.tools.execute.ensure_allowance",
+            new=AsyncMock(side_effect=fake_ensure_allowance),
+        ),
+    ):
+        req = {
+            "kind": "swap",
+            "wallet_label": "main",
+            "from_token": "from",
+            "to_token": "to",
+            "amount": "1",
+            "slippage_bps": 50,
+        }
+        out1 = await execute(request=req)
+        assert out1["ok"] is True
+        assert out1["result"]["status"] == "dry_run"
+        assert out1["result"]["kind"] == "swap"
+        assert any(e.get("label") == "approve" for e in out1["result"]["effects"])
+
+        out2 = await execute(request=req)
+        assert out2["ok"] is True
+        assert out2["result"]["status"] == "duplicate"
+
+
+@pytest.mark.asyncio
+async def test_execute_does_not_cache_preflight_errors(tmp_path: Path, monkeypatch):
+    monkeypatch.setenv("DRY_RUN", "1")
+    monkeypatch.setenv("WAYFINDER_MCP_STATE_PATH", str(tmp_path / "mcp.sqlite3"))
+    monkeypatch.setenv("WAYFINDER_RUNS_DIR", str(tmp_path / "runs"))
+
+    req = {
+        "kind": "send",
+        "wallet_label": "main",
+        "token": "native",
+        "chain_id": 8453,
+        "recipient": "0x000000000000000000000000000000000000dEaD",
+        "amount": "0.01",
+    }
+
+    # First call: wallet missing -> ok=False error stored
+    with patch(
+        "wayfinder_paths.mcp.tools.execute.find_wallet_by_label", return_value=None
+    ):
+        out1 = await execute(request=req, idempotency_key="same")
+        assert out1["ok"] is False
+
+    # Second call with same idempotency key but now wallet exists -> should proceed
+    wallet = {
+        "address": "0x000000000000000000000000000000000000dEaD",
+        "private_key_hex": "0x" + "11" * 32,
+    }
+    with patch(
+        "wayfinder_paths.mcp.tools.execute.find_wallet_by_label", return_value=wallet
+    ):
+        out2 = await execute(request=req, idempotency_key="same")
+        assert out2["ok"] is True
+        assert out2["result"]["status"] == "dry_run"

wayfinder_paths/tests/test_mcp_hyperliquid_execute.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from wayfinder_paths.core.constants.hyperliquid import HYPE_FEE_WALLET
+from wayfinder_paths.mcp.tools.hyperliquid import (
+    _resolve_builder_fee,
+    _resolve_perp_asset_id,
+    hyperliquid_execute,
+)
+
+
+def test_resolve_builder_fee_rejects_wrong_builder_wallet():
+    with pytest.raises(ValueError, match="config builder_fee\\.b must be"):
+        _resolve_builder_fee(
+            config={"builder_fee": {"b": "0x" + "00" * 20, "f": 10}},
+            builder_fee_tenths_bp=None,
+        )
+
+
+def test_resolve_builder_fee_prefers_explicit_fee():
+    fee = _resolve_builder_fee(config={}, builder_fee_tenths_bp=7)
+    assert fee == {"b": HYPE_FEE_WALLET.lower(), "f": 7}
+
+
+def test_resolve_perp_asset_id_accepts_coin_and_strips_perp_suffix():
+    class StubAdapter:
+        coin_to_asset = {"HYPE": 7}
+
+    ok, res = _resolve_perp_asset_id(StubAdapter(), coin="HYPE-perp", asset_id=None)
+    assert ok is True
+    assert res == 7
+
+
+@pytest.mark.asyncio
+async def test_hyperliquid_execute_withdraw_dry_run_is_idempotent(
+    tmp_path: Path, monkeypatch
+):
+    monkeypatch.setenv("WAYFINDER_MCP_STATE_PATH", str(tmp_path / "mcp.sqlite3"))
+    monkeypatch.setenv("WAYFINDER_RUNS_DIR", str(tmp_path / "runs"))
+
+    wallet = {
+        "address": "0x000000000000000000000000000000000000dEaD",
+        "private_key_hex": "0x" + "11" * 32,
+    }
+
+    with (
+        patch(
+            "wayfinder_paths.mcp.tools.hyperliquid.find_wallet_by_label",
+            return_value=wallet,
+        ),
+        patch(
+            "wayfinder_paths.mcp.tools.hyperliquid.load_config_json", return_value={}
+        ),
+    ):
+        out1 = await hyperliquid_execute(
+            "withdraw", wallet_label="main", amount_usdc=10, dry_run=True
+        )
+        assert out1["ok"] is True
+        assert out1["result"]["status"] == "dry_run"
+
+        out2 = await hyperliquid_execute(
+            "withdraw", wallet_label="main", amount_usdc=10, dry_run=True
+        )
+        assert out2["ok"] is True
+        assert out2["result"]["status"] == "duplicate"

wayfinder_paths/tests/test_mcp_idempotency_store.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from wayfinder_paths.mcp.state.store import IdempotencyStore
+
+
+def test_idempotency_store_encodes_bytes(tmp_path: Path):
+    store = IdempotencyStore(tmp_path / "state.sqlite3")
+    store.put("k", {"req": b"\x01\x02"}, {"ok": True, "tx": b"\xaa"})
+    out = store.get("k")
+    assert out is not None
+    assert out["ok"] is True
+    assert out["tx"] == "aa"

wayfinder_paths/tests/test_mcp_quote_swap.py

@@ -163,3 +163,63 @@ async def test_quote_swap_can_include_calldata_when_requested():
     assert out["ok"] is True
     best = out["result"]["quote"]["best_quote"]
     assert best["calldata"] == calldata
+
+
+@pytest.mark.asyncio
+async def test_quote_swap_accepts_top_level_brap_shape():
+    fake_wallet = {"address": "0x000000000000000000000000000000000000dEaD"}
+
+    token_client = AsyncMock()
+    token_client.get_token_details = AsyncMock(
+        side_effect=[
+            {
+                "token_id": "usd-coin-arbitrum",
+                "asset_id": "usd-coin",
+                "symbol": "USDC",
+                "decimals": 6,
+                "chain_id": 42161,
+                "address": "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+            },
+            {
+                "token_id": "tether-arbitrum",
+                "asset_id": "tether",
+                "symbol": "USDT",
+                "decimals": 6,
+                "chain_id": 42161,
+                "address": "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+            },
+        ]
+    )
+
+    brap_client = AsyncMock()
+    brap_client.get_quote = AsyncMock(
+        return_value={
+            "quotes": [{"provider": "brap_best"}, {"provider": "brap_alt"}],
+            "best_quote": {
+                "provider": "brap_best",
+                "output_amount": "1",
+                "calldata": "0xabc",
+            },
+        }
+    )
+
+    with (
+        patch(
+            "wayfinder_paths.mcp.tools.quotes.find_wallet_by_label",
+            return_value=fake_wallet,
+        ),
+        patch(
+            "wayfinder_paths.mcp.tools.quotes.TokenClient", return_value=token_client
+        ),
+        patch("wayfinder_paths.mcp.tools.quotes.BRAPClient", return_value=brap_client),
+    ):
+        out = await quote_swap(
+            wallet_label="main",
+            from_token="usd-coin-arbitrum",
+            to_token="tether-arbitrum",
+            amount="1",
+        )
+
+    assert out["ok"] is True
+    assert out["result"]["quote"]["quote_count"] == 2
+    assert out["result"]["quote"]["providers"] == ["brap_best", "brap_alt"]

wayfinder_paths/tests/test_mcp_run_script.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from wayfinder_paths.mcp.tools.run_script import run_script
+
+
+@pytest.mark.asyncio
+async def test_run_script_rejects_outside_runs_dir(tmp_path: Path, monkeypatch):
+    runs_root = tmp_path / "runs"
+    runs_root.mkdir()
+    monkeypatch.setenv("WAYFINDER_RUNS_DIR", str(runs_root))
+    monkeypatch.setenv("WAYFINDER_MCP_STATE_PATH", str(tmp_path / "mcp.sqlite3"))
+
+    outside = tmp_path / "outside.py"
+    outside.write_text("print('nope')\n")
+
+    out = await run_script(script_path=str(outside), dry_run=True)
+    assert out["ok"] is False
+    assert out["error"]["code"] == "invalid_request"
+
+
+@pytest.mark.asyncio
+async def test_run_script_executes_and_is_idempotent(tmp_path: Path, monkeypatch):
+    runs_root = tmp_path / "runs"
+    runs_root.mkdir()
+    monkeypatch.setenv("WAYFINDER_RUNS_DIR", str(runs_root))
+    monkeypatch.setenv("WAYFINDER_MCP_STATE_PATH", str(tmp_path / "mcp.sqlite3"))
+
+    script = runs_root / "hello.py"
+    script.write_text(
+        "import os\n"
+        "print('DRY_RUN=' + os.getenv('DRY_RUN', ''))\n"
+        "print('PWD=' + os.getcwd())\n"
+    )
+
+    out1 = await run_script(script_path=str(script), dry_run=True, timeout_s=30)
+    assert out1["ok"] is True
+    assert out1["result"]["exit_code"] == 0
+    assert "DRY_RUN=1" in out1["result"]["stdout"]
+
+    out2 = await run_script(script_path=str(script), dry_run=True, timeout_s=30)
+    assert out2["ok"] is True
+    assert out2["result"]["status"] == "duplicate"
+    assert out2["result"]["idempotency_key"]

wayfinder_paths/tests/test_mcp_tokens.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from wayfinder_paths.mcp.tools.tokens import tokens
+
+
+@pytest.mark.asyncio
+async def test_tokens_resolve_requires_query():
+    out = await tokens("resolve", query=None)
+    assert out["ok"] is False
+    assert out["error"]["code"] == "invalid_request"
+
+
+@pytest.mark.asyncio
+async def test_tokens_resolve_happy_path():
+    fake_client = AsyncMock()
+    fake_client.get_token_details = AsyncMock(return_value={"symbol": "USDC"})
+
+    with patch(
+        "wayfinder_paths.mcp.tools.tokens.TokenClient", return_value=fake_client
+    ):
+        out = await tokens("resolve", query="usd-coin-arbitrum")
+
+    assert out["ok"] is True
+    assert out["result"]["token"]["symbol"] == "USDC"
+
+
+@pytest.mark.asyncio
+async def test_tokens_gas_requires_chain_code():
+    out = await tokens("gas", chain_code=None)
+    assert out["ok"] is False
+    assert out["error"]["code"] == "invalid_request"
+
+
+@pytest.mark.asyncio
+async def test_tokens_fuzzy_happy_path():
+    fake_client = AsyncMock()
+    fake_client.fuzzy_search = AsyncMock(return_value={"results": [{"id": "foo"}]})
+
+    with patch(
+        "wayfinder_paths.mcp.tools.tokens.TokenClient", return_value=fake_client
+    ):
+        out = await tokens("fuzzy", query="usd", chain_code="arbitrum")
+
+    assert out["ok"] is True
+    assert out["result"]["results"][0]["id"] == "foo"

wayfinder_paths/tests/test_mcp_utils.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import pytest
+
+from wayfinder_paths.mcp.utils import parse_amount_to_raw, repo_root, sha256_json
+
+
+def test_repo_root_finds_pyproject():
+    root = repo_root()
+    assert (root / "pyproject.toml").exists()
+
+
+def test_parse_amount_to_raw_scales_and_floors():
+    assert parse_amount_to_raw("1", 6) == 1_000_000
+    # Flooring: 1.23456789 with 6 decimals -> 1_234_567
+    assert parse_amount_to_raw("1.23456789", 6) == 1_234_567
+
+
+def test_parse_amount_to_raw_rejects_non_positive():
+    with pytest.raises(ValueError, match="positive"):
+        parse_amount_to_raw("0", 18)
+    with pytest.raises(ValueError, match="positive"):
+        parse_amount_to_raw("-1", 18)
+
+
+def test_parse_amount_to_raw_rejects_too_small_after_scaling():
+    with pytest.raises(ValueError, match="too small"):
+        parse_amount_to_raw("0.0000001", 6)
+
+
+def test_sha256_json_is_stable_for_key_order():
+    a = sha256_json({"b": 2, "a": 1})
+    b = sha256_json({"a": 1, "b": 2})
+    assert a == b
+    assert a.startswith("sha256:")

wayfinder_paths/tests/test_mcp_wallets.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import patch
+
+import pytest
+
+from wayfinder_paths.mcp.tools.wallets import _resolve_wallet_address, wallets
+
+
+def test_resolve_wallet_address_prefers_explicit_address():
+    addr, lbl = _resolve_wallet_address(
+        wallet_label="main", wallet_address="0x000000000000000000000000000000000000dEaD"
+    )
+    assert addr == "0x000000000000000000000000000000000000dEaD"
+    assert lbl is None
+
+
+@pytest.mark.asyncio
+async def test_wallets_discover_portfolio_requires_confirmation_when_many_protocols():
+    store = SimpleNamespace(
+        get_protocols_for_wallet=lambda _addr: ["hyperliquid", "pendle", "moonwell"]
+    )  # noqa: E501
+
+    with patch(
+        "wayfinder_paths.mcp.tools.wallets.WalletProfileStore.default",
+        return_value=store,
+    ):
+        out = await wallets(
+            "discover_portfolio",
+            wallet_address="0x000000000000000000000000000000000000dEaD",
+            parallel=False,
+        )
+
+    assert out["ok"] is True
+    res = out["result"]
+    assert res["requires_confirmation"] is True
+    assert set(res["protocols_to_query"]) == {"hyperliquid", "pendle", "moonwell"}

{wayfinder_paths-0.1.30.dist-info → wayfinder_paths-0.1.31.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: wayfinder-paths
-Version: 0.1.30
+Version: 0.1.31
 Summary: Wayfinder Path: strategies and adapters
 Author: Wayfinder
 Author-email: dev@wayfinder.ai