deepagents-cli 0.0.57__tar.gz → 0.0.58__tar.gz

{deepagents_cli-0.0.57 → deepagents_cli-0.0.58}/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Deep Agents CLI Changelog
 
+## [0.0.58](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.57...deepagents-cli==0.0.58) (2026-05-12)
+
+### Features
+
+* Pin v0.6 and fix import race ([4db09ac](https://github.com/langchain-ai/deepagents/commit/4db09acba34b38521192b8f278723524be560779))
+
 ## [0.0.57](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.56...deepagents-cli==0.0.57) (2026-05-12)
 
 ### Features

{deepagents_cli-0.0.57 → deepagents_cli-0.0.58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-cli
-Version: 0.0.57
+Version: 0.0.58
 Summary: Terminal interface for Deep Agents - interactive AI agent with file operations, shell access, and sub-agent capabilities.
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
 Project-URL: Documentation, https://reference.langchain.com/python/deepagents/
@@ -27,18 +27,18 @@ Classifier: Topic :: Terminals
 Requires-Python: <4.0,>=3.11
 Requires-Dist: aiosqlite<1.0.0,>=0.19.0
 Requires-Dist: deepagents-acp>=0.0.4
-Requires-Dist: deepagents==0.5.9
+Requires-Dist: deepagents==0.6.1
 Requires-Dist: httpx<1.0.0,>=0.28.1
 Requires-Dist: langchain-anthropic<2.0.0,>=1.4.3
 Requires-Dist: langchain-google-genai<5.0.0,>=4.2.2
 Requires-Dist: langchain-mcp-adapters<1.0.0,>=0.2.2
 Requires-Dist: langchain-openai<2.0.0,>=1.2.1
-Requires-Dist: langchain<2.0.0,>=1.2.17
-Requires-Dist: langgraph-checkpoint-sqlite<4.0.0,>=3.0.3
+Requires-Dist: langchain<2.0.0,>=1.3.0
+Requires-Dist: langgraph-checkpoint-sqlite<4.0.0,>=3.1.0
 Requires-Dist: langgraph-cli[inmem]<1.0.0,>=0.4.24
-Requires-Dist: langgraph-prebuilt<2.0.0,>=1.0.13
+Requires-Dist: langgraph-runtime-inmem<1.0.0,>=0.28.1
 Requires-Dist: langgraph-sdk<1.0.0,>=0.3.13
-Requires-Dist: langgraph<2.0.0,>=1.1.10
+Requires-Dist: langgraph<2.0.0,>=1.2.0
 Requires-Dist: langsmith[sandbox]>=0.8.0
 Requires-Dist: markdownify<2.0.0,>=0.13.0
 Requires-Dist: packaging>=23.0

{deepagents_cli-0.0.57 → deepagents_cli-0.0.58}/THREAT_MODEL.md

@@ -57,7 +57,7 @@
 
 ### Architecture Diagram
 
-```
+```txt
 ┌──────────────────────────────────────────────────────────────────────┐
 │                        User (local machine)                          │
 │                                                                      │
@@ -138,6 +138,7 @@
 | C17 | Model Config Loader         | Resolves model provider, supports `class_path` for arbitrary `BaseChatModel` instantiation via `importlib`          | user-controlled      | N/A      | `config.create_model`, `config._create_model_from_class`, `model_config.ModelConfig.load`         |
 
 **Notes:**
+
 1. `http_request` and `fetch_url` enabled by default; `web_search` requires `TAVILY_API_KEY`.
 2. MCP servers only load if `.mcp.json` config files are present.
 3. Hooks only execute if `~/.deepagents/hooks.json` exists.

{deepagents_cli-0.0.57 → deepagents_cli-0.0.58}/deepagents_cli/_version.py

@@ -1,6 +1,6 @@
 """Version information and lightweight constants for `deepagents-cli`."""
 
-__version__ = "0.0.57"  # x-release-please-version
+__version__ = "0.0.58"  # x-release-please-version
 
 DOCS_URL = "https://docs.langchain.com/oss/python/deepagents/cli"
 """URL for `deepagents-cli` documentation."""

{deepagents_cli-0.0.57 → deepagents_cli-0.0.58}/deepagents_cli/app.py

@@ -1591,7 +1591,7 @@ class DeepAgentsApp(App):
         - The agent is a local `Pregel` graph (e.g. ACP mode, test harnesses).
 
         Used to gate features that require a server-backed agent (e.g. model
-        switching via `ConfigurableModelMiddleware`, checkpointer fallback).
+        switching via `ConfigurableModelMiddleware`, thread registration).
         Checks the agent type rather than server ownership so this works for
         both CLI-spawned servers and externally managed ones.
 
@@ -5486,9 +5486,6 @@ class DeepAgentsApp(App):
             if result.offload_warning:
                 await self._mount_message(ErrorMessage(result.offload_warning))
 
-            if remote := self._remote_agent():
-                await remote.aensure_thread(config)  # ty: ignore[invalid-argument-type]
-
             await self._agent.aupdate_state(
                 config, {"_summarization_event": result.new_event}
             )
@@ -5835,12 +5832,14 @@ class DeepAgentsApp(App):
         return result
 
     async def _get_thread_state_values(self, thread_id: str) -> dict[str, Any]:
-        """Fetch thread state values, with remote checkpointer fallback.
+        """Fetch thread state values for a thread.
 
-        In server mode the LangGraph dev server can report an empty thread state
-        after a restart even when checkpoints exist on disk. When that happens,
-        read the latest checkpoint directly so resumed threads can still load
-        history and offload correctly.
+        In server mode the LangGraph dev server starts with an empty in-memory
+        thread store, so `aget_state` returns empty state for any thread that
+        was not registered in the current server session. Calling
+        `aensure_thread` first registers the thread idempotently so the
+        subsequent `aget_state` call can read from the checkpointer correctly,
+        including proper reconstruction of delta channels.
 
         Args:
             thread_id: Thread ID to fetch from checkpoint storage.
@@ -5853,46 +5852,20 @@ class DeepAgentsApp(App):
             return {}
 
         config: RunnableConfig = {"configurable": {"thread_id": thread_id}}
-        state = await self._agent.aget_state(config)
+        remote_config: dict[str, Any] = {"configurable": {"thread_id": thread_id}}
 
-        values: dict[str, Any] = {}
-        if state and state.values:
-            values = dict(state.values)
+        if remote := self._remote_agent():
+            await remote.aensure_thread(remote_config)
 
-        messages = values.get("messages")
-        if isinstance(messages, list) and messages:
-            return values
-        if not self._remote_agent():
-            return values
+        state = await self._agent.aget_state(config)
 
-        logger.debug(
-            "Remote state empty for thread %s; falling back to local checkpointer",
-            thread_id,
-        )
-        fallback_values = await self._read_channel_values_from_checkpointer(thread_id)
-        fallback_messages = fallback_values.get("messages")
-        if isinstance(fallback_messages, list) and fallback_messages:
-            values["messages"] = fallback_messages
-        if (
-            values.get("_summarization_event") is None
-            and "_summarization_event" in fallback_values
-        ):
-            values["_summarization_event"] = fallback_values["_summarization_event"]
-        if (
-            values.get("_context_tokens") is None
-            and "_context_tokens" in fallback_values
-        ):
-            values["_context_tokens"] = fallback_values["_context_tokens"]
-        return values
+        if state and state.values:
+            return dict(state.values)
+        return {}
 
     async def _fetch_thread_history_data(self, thread_id: str) -> _ThreadHistoryPayload:
         """Fetch and convert stored messages for a thread.
 
-        In server mode the LangGraph dev server starts with an empty thread
-        store, so `aget_state` via the HTTP API returns no messages even when
-        checkpoints exist on disk. We fall back to reading the SQLite
-        checkpointer directly to guarantee resumed threads load their history.
-
         Args:
             thread_id: Thread ID to fetch from checkpoint storage.
 
@@ -5910,10 +5883,8 @@ class DeepAgentsApp(App):
         if not messages:
             return _ThreadHistoryPayload([], context_tokens)
 
-        # Server mode / direct checkpointer may return dicts; convert to
+        # RemoteGraph.aget_state returns values as raw JSON dicts; convert to
         # LangChain message objects so _convert_messages_to_data works.
-        # `any(...)` guards against heterogeneous lists where only some
-        # elements are serialized.
         if any(isinstance(m, dict) for m in messages):
             from langchain_core.messages.utils import convert_to_messages
 
@@ -5923,44 +5894,6 @@ class DeepAgentsApp(App):
         data = await asyncio.to_thread(self._convert_messages_to_data, messages)
         return _ThreadHistoryPayload(data, context_tokens)
 
-    @staticmethod
-    async def _read_channel_values_from_checkpointer(thread_id: str) -> dict[str, Any]:
-        """Read checkpoint channel values directly from the SQLite checkpointer.
-
-        Args:
-            thread_id: Thread ID to look up.
-
-        Returns:
-            Channel values from the latest checkpoint, or an empty dict on
-                failure.
-        """
-        try:
-            from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
-
-            from deepagents_cli.sessions import get_db_path
-
-            db_path = str(get_db_path())
-            config: RunnableConfig = {"configurable": {"thread_id": thread_id}}
-            async with AsyncSqliteSaver.from_conn_string(db_path) as saver:
-                tup = await saver.aget_tuple(config)
-                if tup and tup.checkpoint:
-                    channel_values = tup.checkpoint.get("channel_values", {})
-                    if isinstance(channel_values, dict):
-                        return dict(channel_values)
-        except (ImportError, OSError) as exc:
-            logger.warning(
-                "Failed to read checkpointer directly for %s: %s",
-                thread_id,
-                exc,
-            )
-        except Exception:
-            logger.warning(
-                "Unexpected error reading checkpointer for %s",
-                thread_id,
-                exc_info=True,
-            )
-        return {}
-
     async def _upgrade_thread_message_link(
         self,
         widget: AppMessage,

{deepagents_cli-0.0.57 → deepagents_cli-0.0.58}/deepagents_cli/integrations/sandbox_factory.py

@@ -710,7 +710,7 @@ class _AgentCoreProvider(SandboxProvider):
 
         # Validate AWS credentials early for a clear error message.
         try:
-            import boto3  # ty: ignore[unresolved-import, unused-ignore-comment]
+            import boto3  # ty: ignore[unresolved-import]
 
             session = boto3.Session()
             credentials = session.get_credentials()

{deepagents_cli-0.0.57 → deepagents_cli-0.0.58}/deepagents_cli/local_context.py

@@ -104,6 +104,7 @@ class _AsyncExecutableBackend(Protocol):
 
 logger = logging.getLogger(__name__)
 
+
 # ---------------------------------------------------------------------------
 # Context detection script
 #

{deepagents_cli-0.0.57 → deepagents_cli-0.0.58}/deepagents_cli/remote_client.py

@@ -183,7 +183,8 @@ class RemoteAgent:
     ) -> Any:  # noqa: ANN401
         """Get the current state of a thread.
 
-        Returns `None` when the thread does not exist on the server (404).
+        Returns `None` when the thread does not exist on the server (404) or
+        when the thread exists but has no checkpoint yet (new/empty thread).
         All other errors (network, auth, 500) are logged at WARNING and
         re-raised so callers can handle them.
 
@@ -196,10 +197,11 @@ class RemoteAgent:
 
         Returns:
             Thread state object with `values` and `next` attributes, or `None`
-                if the thread is not found.
+                if the thread is not found or has no checkpoint.
 
         Raises:
             ValueError: If `thread_id` is not present in `config`.
+            TypeError: If the server returns an unexpected state shape.
         """  # noqa: DOC502 — raised by _require_thread_id
         from langgraph_sdk.errors import NotFoundError
 
@@ -211,6 +213,20 @@ class RemoteAgent:
         except NotFoundError:
             logger.debug("Thread %s not found on server", thread_id)
             return None
+        except TypeError as e:
+            # langgraph SDK bug: _create_state_snapshot does
+            # state["checkpoint"]["thread_id"], but the server returns
+            # checkpoint=null for threads with no checkpoint yet (new threads,
+            # or threads registered via aensure_thread before any run).
+            if "subscriptable" in str(e).lower():
+                logger.debug(
+                    "Thread %s has no checkpoint yet; treating as empty", thread_id
+                )
+                return None
+            logger.warning(
+                "Failed to get state for thread %s", thread_id, exc_info=True
+            )
+            raise
         except Exception:
             logger.warning(
                 "Failed to get state for thread %s", thread_id, exc_info=True

{deepagents_cli-0.0.57 → deepagents_cli-0.0.58}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "deepagents-cli"
-version = "0.0.57"
+version = "0.0.58"
 description = "Terminal interface for Deep Agents - interactive AI agent with file operations, shell access, and sub-agent capabilities."
 readme = "README.md"
 license = { text = "MIT" }
@@ -26,15 +26,15 @@ classifiers = [
 ]
 dependencies = [
     # Framework
-    "deepagents==0.5.9",
-    "langchain>=1.2.17,<2.0.0",
-    "langgraph>=1.1.10,<2.0.0",
-    "langgraph-checkpoint-sqlite>=3.0.3,<4.0.0",
-    "langgraph-prebuilt>=1.0.13,<2.0.0",
+    "deepagents==0.6.1",
+    "langchain>=1.3.0,<2.0.0",
+    "langgraph>=1.2.0,<2.0.0",
+    "langgraph-checkpoint-sqlite>=3.1.0,<4.0.0",
 
     # Client-server architecture
     "langgraph-sdk>=0.3.13,<1.0.0",
     "langgraph-cli[inmem]>=0.4.24,<1.0.0",
+    "langgraph-runtime-inmem>=0.28.1,<1.0.0",
     "httpx>=0.28.1,<1.0.0",
 
     # Core model providers - others are added as optional

{deepagents_cli-0.0.57 → deepagents_cli-0.0.58}/tests/integration_tests/test_compact_resume.py

@@ -2,9 +2,7 @@
 
 from __future__ import annotations
 
-from types import SimpleNamespace
 from typing import TYPE_CHECKING
-from unittest.mock import AsyncMock
 
 import pytest
 
@@ -62,12 +60,11 @@ def _event_field(event: object, key: str) -> object | None:
 async def test_compact_resumed_thread_uses_persisted_history(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
-    """Compacts a resumed thread after restart using SQLite-backed history.
+    """Offloads a resumed thread after restart using remote server state.
 
     The test seeds a real persisted thread on one server instance, restarts the
     server, resumes that thread in a fresh `DeepAgentsApp`, and verifies that
-    `/compact` succeeds even when the resumed history comes from the
-    checkpointer rather than live in-memory server state.
+    `/offload` succeeds after the app registers the thread with the server.
     """
     home_dir = tmp_path / "home"
     project_dir = tmp_path / "project"
@@ -92,7 +89,7 @@ async def test_compact_resumed_thread_uses_persisted_history(
     from deepagents_cli.app import DeepAgentsApp
     from deepagents_cli.config import create_model
     from deepagents_cli.server_manager import server_session
-    from deepagents_cli.sessions import generate_thread_id, thread_exists
+    from deepagents_cli.sessions import generate_thread_id
     from deepagents_cli.widgets.messages import AppMessage, ErrorMessage
 
     config_path = home_dir / ".deepagents" / "config.toml"
@@ -124,15 +121,12 @@ async def test_compact_resumed_thread_uses_persisted_history(
                     prompt=_build_long_prompt(turn),
                 )
 
-        assert await thread_exists(thread_id)
-
         compact_backend = CompositeBackend(
             default=FilesystemBackend(root_dir=backend_root, virtual_mode=True),
             routes={},
         )
 
-        # Server 2: same SQLite DB, but a fresh server process and empty
-        # in-memory thread registry.
+        # Server 2: same SQLite DB, but a fresh server process.
         async with server_session(
             assistant_id=assistant_id,
             model_name="itest:fake",
@@ -142,15 +136,6 @@ async def test_compact_resumed_thread_uses_persisted_history(
             sandbox_type="none",
         ) as (agent, _server_proc):
             config = {"configurable": {"thread_id": thread_id}}
-            actual_state = await agent.aget_state(config)
-            actual_values = getattr(actual_state, "values", None) or {}
-
-            # Fresh dev servers may return empty state for persisted threads
-            # after restart. If that behavior changes upstream, force the
-            # empty-state precondition so this test still covers the SQLite
-            # fallback path.
-            if actual_values:
-                agent.aget_state = AsyncMock(return_value=SimpleNamespace(values={}))  # ty: ignore[invalid-assignment]
 
             app = DeepAgentsApp(
                 agent=agent,  # ty: ignore[invalid-argument-type]
@@ -170,20 +155,15 @@ async def test_compact_resumed_thread_uses_persisted_history(
                         break
 
                 assert app._message_store.total_count > 0
-                resume_messages = app.query(AppMessage)
-                assert any(
-                    "Resumed thread:" in str(widget._content)
-                    for widget in resume_messages
-                )
 
                 await app._handle_offload()
 
-                # `/compact` posts a success message after the async state write
+                # `/offload` posts a success message after the async state write
                 # and archive offload finish.
                 for _ in range(120):
                     await pilot.pause(0.1)
                     if any(
-                        "Conversation compacted." in str(widget._content)
+                        "Offloaded " in str(widget._content)
                         for widget in app.query(AppMessage)
                     ):
                         break
@@ -195,16 +175,15 @@ async def test_compact_resumed_thread_uses_persisted_history(
                     str(widget._content) for widget in app.query(ErrorMessage)
                 ]
 
-            assert "Nothing to compact" not in "\n".join(app_messages)
-            assert any("Conversation compacted." in content for content in app_messages)
+            assert "Nothing to offload" not in "\n".join(app_messages)
+            assert any("Offloaded " in content for content in app_messages)
             assert not error_messages
 
-            # The summarization event must be checkpointed so subsequent turns
-            # see compacted context instead of the full message history.
-            channel_values = await DeepAgentsApp._read_channel_values_from_checkpointer(
-                thread_id
-            )
-            summarization_event = channel_values.get("_summarization_event")
+            # The summarization event must be visible through server state so
+            # subsequent turns see compacted context instead of full history.
+            state = await agent.aget_state(config)
+            values = getattr(state, "values", None) or {}
+            summarization_event = values.get("_summarization_event")
             assert summarization_event is not None
             cutoff = _event_field(summarization_event, "cutoff_index")
             assert isinstance(cutoff, int)
@@ -219,7 +198,7 @@ async def test_compact_resumed_thread_uses_persisted_history(
         archive_path = backend_root / "conversation_history" / f"{thread_id}.md"
         assert archive_path.exists()
         archive_text = archive_path.read_text()
-        assert "Compacted at" in archive_text
+        assert "Offloaded at" in archive_text
         assert "keeps enough unique detail" in archive_text
     finally:
         model_config.clear_caches()

{deepagents_cli-0.0.57 → deepagents_cli-0.0.58}/tests/unit_tests/test_app.py

@@ -4355,67 +4355,60 @@ class TestFetchThreadHistoryData:
         assert payload.messages[1].type == MessageType.ASSISTANT
         assert payload.messages[1].content == "Hi there!"
 
-    async def test_server_mode_falls_back_to_checkpointer(self) -> None:
-        """When the server returns empty state, read SQLite checkpointer directly."""
+    async def test_server_mode_ensures_thread_before_fetching_state(self) -> None:
+        """Server-mode history reads should fetch state through the remote server."""
         from langchain_core.messages import AIMessage, HumanMessage
 
         from deepagents_cli.remote_client import RemoteAgent
-        from deepagents_cli.widgets.message_store import MessageData, MessageType
+        from deepagents_cli.widgets.message_store import MessageType
 
-        # Server returns empty state (fresh restart, thread not loaded)
-        empty_state = MagicMock()
-        empty_state.values = {}
+        state = MagicMock()
+        state.values = {
+            "messages": [
+                HumanMessage(content="hello", id="h1"),
+                AIMessage(content="world", id="a1"),
+            ]
+        }
 
-        # spec=RemoteAgent so _remote_agent() isinstance check passes
         mock_agent = MagicMock(spec=RemoteAgent)
-        mock_agent.aget_state = AsyncMock(return_value=empty_state)
+        mock_agent.aensure_thread = AsyncMock()
+        mock_agent.aget_state = AsyncMock(return_value=state)
 
         app = DeepAgentsApp(agent=mock_agent, thread_id="t-1")
+        payload = await app._fetch_thread_history_data("t-1")
 
-        # Patch the checkpointer fallback to return messages
-        checkpointer_msgs = [
-            HumanMessage(content="hello", id="h1"),
-            AIMessage(content="world", id="a1"),
-        ]
-        with patch.object(
-            DeepAgentsApp,
-            "_read_channel_values_from_checkpointer",
-            return_value={"messages": checkpointer_msgs},
-        ):
-            payload = await app._fetch_thread_history_data("t-1")
-
+        mock_agent.aensure_thread.assert_awaited_once_with(
+            {"configurable": {"thread_id": "t-1"}}
+        )
         assert len(payload.messages) == 2
         assert payload.messages[0].type == MessageType.USER
         assert payload.messages[0].content == "hello"
         assert payload.messages[1].type == MessageType.ASSISTANT
         assert payload.messages[1].content == "world"
 
-    async def test_server_mode_fallback_includes_context_tokens(self) -> None:
-        """Server-mode fallback should merge `_context_tokens` from the checkpointer."""
+    async def test_server_mode_state_includes_context_tokens(self) -> None:
+        """Server-mode history reads should preserve `_context_tokens` from state."""
         from langchain_core.messages import HumanMessage
 
         from deepagents_cli.remote_client import RemoteAgent
         from deepagents_cli.widgets.message_store import MessageType
 
-        empty_state = MagicMock()
-        empty_state.values = {}
+        state = MagicMock()
+        state.values = {
+            "messages": [HumanMessage(content="hi", id="h1")],
+            "_context_tokens": 5000,
+        }
 
         mock_agent = MagicMock(spec=RemoteAgent)
-        mock_agent.aget_state = AsyncMock(return_value=empty_state)
+        mock_agent.aensure_thread = AsyncMock()
+        mock_agent.aget_state = AsyncMock(return_value=state)
 
         app = DeepAgentsApp(agent=mock_agent, thread_id="t-1")
+        payload = await app._fetch_thread_history_data("t-1")
 
-        checkpointer_data = {
-            "messages": [HumanMessage(content="hi", id="h1")],
-            "_context_tokens": 5000,
-        }
-        with patch.object(
-            DeepAgentsApp,
-            "_read_channel_values_from_checkpointer",
-            return_value=checkpointer_data,
-        ):
-            payload = await app._fetch_thread_history_data("t-1")
-
+        mock_agent.aensure_thread.assert_awaited_once_with(
+            {"configurable": {"thread_id": "t-1"}}
+        )
         assert payload.context_tokens == 5000
         assert len(payload.messages) == 1
         assert payload.messages[0].type == MessageType.USER

{deepagents_cli-0.0.57 → deepagents_cli-0.0.58}/tests/unit_tests/test_offload.py

@@ -906,8 +906,8 @@ class TestOffloadRouting:
 class TestOffloadRemoteFallback:
     """Verify `/offload` handles resumed remote threads."""
 
-    async def test_resumed_remote_thread_uses_checkpointer_state(self) -> None:
-        """Should offload using checkpoint fallback when remote state is empty."""
+    async def test_resumed_remote_thread_uses_server_state(self) -> None:
+        """Should offload using state returned by the remote server."""
         from deepagents_cli.remote_client import RemoteAgent
 
         app = DeepAgentsApp()
@@ -924,11 +924,14 @@ class TestOffloadRemoteFallback:
                 "file_path": None,
             }
 
-            empty_state = MagicMock()
-            empty_state.values = {}
+            state = MagicMock()
+            state.values = {
+                "messages": messages,
+                "_summarization_event": prior_event,
+            }
 
             app._agent = MagicMock(spec=RemoteAgent)
-            app._agent.aget_state = AsyncMock(return_value=empty_state)
+            app._agent.aget_state = AsyncMock(return_value=state)
             app._agent.aensure_thread = AsyncMock()
             app._agent.aupdate_state = AsyncMock()
             app._backend = MagicMock()
@@ -942,27 +945,14 @@ class TestOffloadRemoteFallback:
                 messages_kept=12,
             )
 
-            with (
-                patch.object(
-                    DeepAgentsApp,
-                    "_read_channel_values_from_checkpointer",
-                    return_value={
-                        "messages": messages,
-                        "_summarization_event": prior_event,
-                    },
-                ) as checkpointer_mock,
-                patch(
-                    _PERFORM_OFFLOAD_PATH,
-                    new_callable=AsyncMock,
-                    return_value=result,
-                ) as mock_perform,
-            ):
+            with patch(
+                _PERFORM_OFFLOAD_PATH,
+                new_callable=AsyncMock,
+                return_value=result,
+            ) as mock_perform:
                 await app._handle_offload()
                 await pilot.pause()
 
-            checkpointer_mock.assert_awaited_once_with("test-thread")
-
-            # Verify perform_offload was called with the fallback state
             kwargs = mock_perform.call_args.kwargs
             assert kwargs["messages"] == messages
             assert kwargs["prior_event"] is prior_event
@@ -1070,7 +1060,9 @@ class TestOffloadRemoteStateNormalization:
 
             passed_event = mock_mw._apply_event_to_messages.call_args[0][1]
             assert isinstance(passed_event["summary_message"], BaseMessage)
-            app._agent.aensure_thread.assert_not_called()
+            app._agent.aensure_thread.assert_awaited_once_with(
+                {"configurable": {"thread_id": "test-thread"}}
+            )
             app._agent.aupdate_state.assert_not_called()
 
 

{deepagents_cli-0.0.57 → deepagents_cli-0.0.58}/tests/unit_tests/test_offload_dict_messages.py

@@ -1,7 +1,7 @@
 """Tests for #2741 fix: `perform_offload()` handles serialized state payloads.
 
-Remote HTTP state snapshots and checkpointer fallbacks may surface messages as
-raw dicts rather than `BaseMessage` objects. `perform_offload()` must
+Remote HTTP state snapshots may surface messages as raw dicts rather than
+`BaseMessage` objects. `perform_offload()` must
 normalize these before passing them to middleware helpers like
 `get_buffer_string()`.
 """
@@ -18,8 +18,7 @@ from deepagents_cli.offload import OffloadResult, perform_offload
 if TYPE_CHECKING:
     from deepagents.middleware.summarization import SummarizationEvent
 
-# Raw dict messages — what remote state snapshots and checkpoint fallbacks
-# may return before deserialization.
+# Raw dict messages — what remote state snapshots may return before deserialization.
 _DICT_MESSAGES: list[dict[str, Any]] = [
     {
         "content": "Hi!",