fix: patch dangling tool calls on error, move undo to context manager

agent/context_manager/manager.py

@@ -131,9 +131,57 @@ class ContextManager:
         self.items.append(message)
 
     def get_messages(self) -> list[Message]:
-        """Get all messages for sending to LLM"""
+        """Get all messages for sending to LLM.
+
+        Automatically patches any dangling tool_calls (assistant messages
+        with tool_calls that have no matching tool-result message).  This
+        can happen after errors or cancellations and would cause the LLM
+        API to reject the request.
+        """
+        self._patch_dangling_tool_calls()
         return self.items
 
+    def _patch_dangling_tool_calls(self) -> None:
+        """Add stub tool results for any tool_calls that lack a matching result."""
+        if not self.items:
+            return
+        last = self.items[-1]
+        if getattr(last, "role", None) != "assistant" or not getattr(last, "tool_calls", None):
+            return
+        answered_ids = {
+            getattr(m, "tool_call_id", None)
+            for m in self.items
+            if getattr(m, "role", None) == "tool"
+        }
+        for tc in last.tool_calls:
+            if tc.id not in answered_ids:
+                self.items.append(
+                    Message(
+                        role="tool",
+                        content="Tool was not executed (interrupted or error).",
+                        tool_call_id=tc.id,
+                        name=tc.function.name,
+                    )
+                )
+
+    def undo_last_turn(self) -> bool:
+        """Remove the last complete turn (user msg + all assistant/tool msgs that follow).
+
+        Pops from the end until the last user message is removed, keeping the
+        tool_use/tool_result pairing valid.
+
+        Returns True if a user message was found and removed.
+        """
+        if not self.items:
+            return False
+
+        while self.items:
+            msg = self.items.pop()
+            if getattr(msg, "role", None) == "user":
+                return True
+
+        return False
+
     async def compact(
         self, model_name: str, tool_specs: list[dict] | None = None
     ) -> None:

agent/core/agent_loop.py

@@ -163,34 +163,6 @@ async def _compact_and_notify(session: Session) -> None:
         )
 
 
-def _patch_dangling_tool_calls(session: Session) -> None:
-    """Add stub tool results for any tool_calls that lack a matching result.
-
-    After cancellation the last assistant message may contain tool_calls
-    whose results were never recorded.  LLM APIs require every tool_call
-    to have a corresponding tool-result message, so we inject placeholders.
-    """
-    items = session.context_manager.items
-    if not items:
-        return
-    last = items[-1]
-    if getattr(last, "role", None) != "assistant" or not getattr(last, "tool_calls", None):
-        return
-    answered_ids = {
-        getattr(m, "tool_call_id", None)
-        for m in items
-        if getattr(m, "role", None) == "tool"
-    }
-    for tc in last.tool_calls:
-        if tc.id not in answered_ids:
-            items.append(
-                Message(
-                    role="tool",
-                    content="Cancelled by user.",
-                    tool_call_id=tc.id,
-                    name=tc.function.name,
-                )
-            )
 
 
 class Handlers:
@@ -382,7 +354,6 @@ class Handlers:
 
                 # ── Cancellation check: before tool execution ──
                 if session.is_cancelled:
-                    _patch_dangling_tool_calls(session)
                     break
 
                 # Separate tools into those requiring approval and those that don't
@@ -566,28 +537,10 @@ class Handlers:
 
     @staticmethod
     async def undo(session: Session) -> None:
-        """Remove the last complete turn (user msg + all assistant/tool msgs that follow).
-
-        Anthropic requires every tool_use to have a matching tool_result,
-        so we can't just pop 2 items — we must pop everything back to
-        (and including) the last user message to keep the history valid.
-        """
-        items = session.context_manager.items
-        if not items:
-            await session.send_event(Event(event_type="undo_complete"))
-            return
-
-        # Pop from the end until we've removed the last user message
-        removed_user = False
-        while items:
-            msg = items.pop()
-            if getattr(msg, "role", None) == "user":
-                removed_user = True
-                break
-
-        if not removed_user:
+        """Remove the last complete turn and notify the frontend."""
+        removed = session.context_manager.undo_last_turn()
+        if not removed:
             logger.warning("Undo: no user message found to remove")
-
         await session.send_event(Event(event_type="undo_complete"))
 
     @staticmethod