Merge pull request #158 from vstorm-co/fix/patch-tool-calls-drops-trailing-request

fix: keep trailing ModelRequest when patching strips all orphaned results

Author: DEENUU1

CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.32] - 2026-06-26
+
+### Changed
+
+- **Migrated to pydantic-ai 2.0.** pydantic-ai 2.0 removed the deprecated `Agent(history_processors=...)` parameter and the `pydantic_ai.usage.Usage` class. User-supplied `history_processors` are now wrapped in `ProcessHistory` capabilities and registered via the capabilities API (`pydantic_deep/agent.py`); the `history_processors=` argument to `create_deep_agent()` is unchanged. The CLI headless runner now uses `RunUsage` instead of `Usage` (`apps/cli/run.py`); its JSON output keys (`request_tokens` / `response_tokens`) are unchanged, sourced from `RunUsage.input_tokens` / `output_tokens`.
+- **`WebSearch` / `WebFetch` keep their local fallback under pydantic-ai 2.0** (`pydantic_deep/agent.py`). 2.0 changed the capability default to `local=None` (native-only), so a model whose provider lacks a native `WebFetchTool` now errored (`Native tool(s) ['WebFetchTool'] not supported by this model`) instead of falling back. We now pass `WebSearch(local="duckduckgo")` and `WebFetch(local=True)` to restore the pre-2.0 behaviour: the native tool is used when the provider supports it, and the local fallback kicks in otherwise.
+
+### Fixed
+
+- **`PatchToolCallsCapability` no longer drops a trailing `ModelRequest` left empty after stripping orphaned tool results** (`pydantic_deep/processors/patch.py`). Phase 2 removes `ToolReturnPart`s that have no matching `ToolCallPart`, then discarded any `ModelRequest` left with no parts. When that request was the **last** message — a resumed or interrupted history whose tail holds only orphaned results — dropping it left the history ending on a `ModelResponse`, which trips pydantic-ai's `Processed history must end with a `ModelRequest`` validation (`UserError`). This is the same class of bug as the upstream `LimitWarnerProcessor` fix. The stripped request is now kept as an empty `ModelRequest` structural placeholder (the shape pydantic-ai uses when resuming without a prompt) when it is the final message; interior empty requests are still dropped.
+
+### Dependencies
+
+- **Bumped `pydantic-ai-slim` to `>=2.0.0`** (`pyproject.toml`). pydantic-deep now targets the pydantic-ai 2.0 line (see *Changed* above). Consumers still pinned to pydantic-ai 1.x must stay on pydantic-deep 0.3.31.
+- **Bumped `summarization-pydantic-ai` to `>=0.1.10`** (`pyproject.toml`). Picks up two history-rewriting fixes of the same trailing-`ModelRequest` class: `LimitWarnerProcessor` no longer drops the already-empty trailing `ModelRequest` that pydantic-ai appends when resuming without a prompt, and `SlidingWindowProcessor` no longer trims history down to empty on a zero `keep`.
+
 ## [0.3.31] - 2026-06-22
 
 ### Changed

apps/cli/modals/diff_picker.py

@@ -260,8 +260,6 @@ def _render_action_hint(self) -> str:
             "[dim]·  Esc cancel[/dim]"
         )
 
-    # ── Actions ───────────────────────────────────────────────────
-
     def action_move_path_up(self) -> None:
         if not self._paths:
             return
@@ -329,8 +327,6 @@ def action_browse_merge_view(self) -> None:
     def action_cancel(self) -> None:
         self.dismiss(None)
 
-    # ── Internal helpers ──────────────────────────────────────────
-
     def _refresh_paths(self) -> None:
         for i in range(len(self._paths)):
             with contextlib.suppress(Exception):  # pragma: no cover - defensive

apps/cli/run.py

@@ -21,7 +21,7 @@
     TextPartDelta,
     ThinkingPartDelta,
 )
-from pydantic_ai.usage import Usage
+from pydantic_ai.usage import RunUsage
 
 from apps.cli.agent import create_cli_agent
 from apps.cli.init import ensure_initialized
@@ -219,14 +219,14 @@ async def _run_verbose(agent: Any, task: str, deps: Any, run_kwargs: dict[str, A
     return run.result
 
 
-def _build_json_output(output: str, usage: Usage) -> dict[str, Any]:
+def _build_json_output(output: str, usage: RunUsage) -> dict[str, Any]:
     """Build a JSON-serializable output dict."""
     return {
         "output": output,
         "usage": {
             "total_tokens": usage.total_tokens,
-            "request_tokens": usage.request_tokens,
-            "response_tokens": usage.response_tokens,
+            "request_tokens": usage.input_tokens,
+            "response_tokens": usage.output_tokens,
             "requests": usage.requests,
         },
     }

pydantic_deep/agent.py

@@ -989,7 +989,7 @@ def _set_toolset_retries(toolset: AbstractToolset[DeepAgentDeps], max_retries: i
             skills=skills,
             directories=directories,  # type: ignore[arg-type]  # pyright: ignore[reportArgumentType]
         )
-        all_toolsets.append(skills_toolset)  # type: ignore[arg-type]
+        all_toolsets.append(skills_toolset)
 
     # Context toolset
     context_toolset = None
@@ -1219,9 +1219,6 @@ def _deep_agent_factory(cfg: dict[str, Any]) -> Any:  # pragma: no cover
                 on_cost_update=on_cost_update,
             )
 
-    if all_processors:
-        agent_create_kwargs["history_processors"] = all_processors
-
     # Anthropic-specific keys are silently ignored by non-Anthropic models,
     # so we set them unconditionally - no provider detection needed.
     effective_model_settings: dict[str, Any] = {
@@ -1333,22 +1330,36 @@ def _deep_agent_factory(cfg: dict[str, Any]) -> Any:  # pragma: no cover
     if cost_cap is not None:
         all_capabilities.append(cost_cap)
 
+    # `local=` provides a fallback for models whose provider has no native web
+    # tool. pydantic-ai 2.0 changed the default to `local=None` (no fallback),
+    # so a model that lacks native `WebFetchTool` now errors instead of falling
+    # back. We opt back into the local fallback to preserve pre-2.0 behaviour.
     if web_search:  # pragma: no cover
         from pydantic_ai.capabilities import WebSearch
 
-        all_capabilities.append(WebSearch())
+        all_capabilities.append(WebSearch(local="duckduckgo"))
 
     if web_fetch:  # pragma: no cover
         from pydantic_ai.capabilities import WebFetch
 
-        all_capabilities.append(WebFetch())
+        all_capabilities.append(WebFetch(local=True))
 
     if thinking is not False:  # pragma: no cover
         from pydantic_ai.capabilities import Thinking
 
         effort: Any = thinking if isinstance(thinking, str) else True
         all_capabilities.append(Thinking(effort=effort))
 
+    # User-provided history processors are wrapped as ProcessHistory
+    # capabilities — pydantic-ai 2.0 removed the `Agent(history_processors=...)`
+    # parameter in favour of the capabilities API. They run after the built-in
+    # history-affecting capabilities (context manager, eviction) so they operate
+    # on the already-managed history.
+    if all_processors:
+        from pydantic_ai.capabilities import ProcessHistory
+
+        all_capabilities.extend(ProcessHistory(processor) for processor in all_processors)
+
     # Add user-provided capabilities
     if capabilities:
         all_capabilities.extend(capabilities)

pydantic_deep/processors/patch.py

@@ -214,7 +214,9 @@ def patch_tool_calls_processor(
 
             if remaining_parts:
                 patched2.append(ModelRequest(parts=remaining_parts))
-            # If no parts remain, skip the message entirely
+            elif i == len(messages) - 1:
+                patched2.append(ModelRequest(parts=[]))
+            # Otherwise the request is interior; dropping it is safe.
 
         messages = patched2
 

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pydantic-deep"
-version = "0.3.31"
+version = "0.3.32"
 description = "Batteries-included agent harness for Python — tool-calling, sandboxed execution, multi-agent teams, and unlimited context on Pydantic AI"
 readme = "README.md"
 keywords = [
@@ -40,10 +40,10 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "pydantic-ai-slim[web-fetch]>=1.97.0",
+    "pydantic-ai-slim[web-fetch]>=2.0.0",
     "pydantic-ai-todo>=0.2.6",
     "pydantic-ai-backend[console]>=0.2.14",
-    "summarization-pydantic-ai>=0.1.9",
+    "summarization-pydantic-ai>=0.1.10",
     "subagents-pydantic-ai>=0.2.7",
     "pydantic-ai-shields>=0.3.4",
     "pydantic>=2.0",
@@ -63,7 +63,7 @@ cli = [
     "prompt-toolkit>=3.0.0",
     "tomli>=2.0; python_version < '3.11'",
     "python-dotenv>=1.0.0",
-    "pydantic-ai-slim[anthropic,openai,openrouter,web-fetch,duckduckgo]>=1.97.0",
+    "pydantic-ai-slim[anthropic,openai,openrouter,web-fetch,duckduckgo]>=2.0.0",
 ]
 # TUI (Textual-based terminal UI)
 tui = [
@@ -72,7 +72,7 @@ tui = [
     "rich>=13.0.0",
     "tomli>=2.0; python_version < '3.11'",
     "python-dotenv>=1.0.0",
-    "pydantic-ai-slim[anthropic,openai,openrouter,web-fetch,duckduckgo]>=1.97.0",
+    "pydantic-ai-slim[anthropic,openai,openrouter,web-fetch,duckduckgo]>=2.0.0",
 ]
 # Web server support (for full_app example)
 web = [
@@ -87,7 +87,7 @@ browser = [
 ]
 # MCP (Model Context Protocol) client support — connect to MCP servers.
 # py-key-value-aio[disk] persists OAuth tokens (e.g. hosted Figma) across runs.
-mcp = ["pydantic-ai-slim[mcp]>=1.97.0", "py-key-value-aio[disk]>=0.4.5"]
+mcp = ["pydantic-ai-slim[mcp]>=2.0.0", "py-key-value-aio[disk]>=0.4.5"]
 # Document parsing via LiteParse (requires Node.js >= 18)
 liteparse = ["liteparse>=0.1.0"]
 # ACP (Agent Client Protocol) support for editor integration

tests/test_cli_run.py

@@ -115,8 +115,8 @@ def mock_agent(self) -> MagicMock:
         mock_result.output = "Task completed successfully"
         mock_usage = MagicMock()
         mock_usage.total_tokens = 1000
-        mock_usage.request_tokens = 800
-        mock_usage.response_tokens = 200
+        mock_usage.input_tokens = 800
+        mock_usage.output_tokens = 200
         mock_usage.requests = 3
         mock_result.usage.return_value = mock_usage
         agent.run = AsyncMock(return_value=mock_result)
@@ -299,8 +299,8 @@ class TestBuildJsonOutput:
     def test_builds_output(self) -> None:
         usage = MagicMock()
         usage.total_tokens = 500
-        usage.request_tokens = 400
-        usage.response_tokens = 100
+        usage.input_tokens = 400
+        usage.output_tokens = 100
         usage.requests = 2
 
         result = _build_json_output("Done", usage)

tests/test_patch_tool_calls.py

@@ -311,6 +311,27 @@ def test_orphaned_tool_result_all_stripped(self):
         assert isinstance(result[1], ModelResponse)
         assert isinstance(result[2], ModelResponse)
 
+    def test_orphaned_tool_result_all_stripped_at_end_keeps_placeholder(self):
+        """A trailing request of only orphaned results survives as an empty placeholder.
+
+        Dropping the final message would leave the history ending on a
+        `ModelResponse`, tripping pydantic-ai's "Processed history must end with
+        a `ModelRequest`" validation. The stripped request is kept as an empty
+        `ModelRequest` — the structural placeholder pydantic-ai uses when
+        resuming without a prompt.
+        """
+        messages = [
+            ModelRequest(parts=[UserPromptPart(content="hello")]),
+            ModelResponse(parts=[TextPart(content="no tool calls here")]),
+            # Trailing request holding only an orphaned tool result.
+            ModelRequest(parts=[ToolReturnPart(tool_name="t1", content="r1", tool_call_id="c1")]),
+        ]
+        result = patch_tool_calls_processor(messages)
+        assert len(result) == 3
+        last = result[-1]
+        assert isinstance(last, ModelRequest)
+        assert last.parts == []
+
     def test_mixed_valid_and_orphaned_results(self):
         """Some ToolReturnParts have matching calls, some don't."""
         messages = [