Keep only the consecutive-format-error cap; drop the truncation-message handling

Builds on Entrpi's #851 but keeps only the bounce-loop guard in DefaultAgent
(max_consecutive_format_errors, default 3, exit_status=FormatErrorsExceeded) and
reverts the LitellmModel truncation_error_template / _is_truncated handling back
to main. A successful step resets the counter.

Author: klieret

src/minisweagent/agents/default.py

@@ -29,10 +29,8 @@ class AgentConfig(BaseModel):
     """Stop agent after exceeding (!) this cost."""
     wall_time_limit_seconds: int = 0
     """Stop agent after this many seconds of wall-clock time. 0 means no limit."""
-    max_consecutive_format_errors: int = 0
-    """Stop the agent after this many format errors in a row (e.g. repeated max_tokens truncations
-    that never produce a tool call). 0 means no limit. Guards against a model burning the whole
-    budget in a bounce loop; exits cleanly with exit_status=RepeatedFormatError."""
+    max_consecutive_format_errors: int = 3
+    """Exit after this many format errors in a row (0 = no limit)."""
     output_path: Path | None = None
     """Save the trajectory to this path."""
 
@@ -48,7 +46,7 @@ def __init__(self, model: Model, env: Environment, *, config_class: type = Agent
         self.logger = logging.getLogger("agent")
         self.cost = 0.0
         self.n_calls = 0
-        self._consecutive_format_errors = 0
+        self.n_consecutive_format_errors = 0
         self._start_time = time.time()
 
     def get_template_vars(self, **kwargs) -> dict:
@@ -98,26 +96,24 @@ def run(self, task: str = "", **kwargs) -> dict:
         while True:
             try:
                 self.step()
+                self.n_consecutive_format_errors = 0  # reset on any clean step
             except FormatError as e:
-                self.add_messages(*e.messages)
-                self._consecutive_format_errors += 1
-                if 0 < self.config.max_consecutive_format_errors <= self._consecutive_format_errors:
-                    # Too many no-tool-call / truncation turns in a row: stop cleanly instead of
-                    # looping until the budget is gone.
+                self.n_consecutive_format_errors += 1
+                if 0 < self.config.max_consecutive_format_errors <= self.n_consecutive_format_errors:
                     self.add_messages(
                         {
                             "role": "exit",
                             "content": "RepeatedFormatError",
                             "extra": {"exit_status": "RepeatedFormatError", "submission": ""},
                         }
                     )
+                else:
+                    self.add_messages(*e.messages)
             except InterruptAgentFlow as e:
                 self.add_messages(*e.messages)
             except Exception as e:
                 self.handle_uncaught_exception(e)
                 raise
-            else:
-                self._consecutive_format_errors = 0  # a step completed without a format error
             finally:
                 self.save(self.config.output_path)
             if self.messages[-1].get("role") == "exit":

src/minisweagent/models/litellm_model.py

@@ -7,7 +7,6 @@
 from typing import Any, Literal
 
 import litellm
-from jinja2 import StrictUndefined, Template
 from pydantic import BaseModel
 
 from minisweagent.exceptions import FormatError
@@ -38,13 +37,6 @@ class LitellmModelConfig(BaseModel):
     """Cost tracking mode for this model. Can be "default" or "ignore_errors" (ignore errors/missing cost info)"""
     format_error_template: str = "{{ error }}"
     """Template used when the LM's output is not in the expected format."""
-    truncation_error_template: str = (
-        "Your previous response reached the output token limit (finish_reason={{ finish_reason }}) "
-        "before you produced a tool call, so it was cut off. Respond more concisely and finish with "
-        "exactly one tool call. If you need to think more, do so briefly."
-    )
-    """Template used when a response is truncated at max_tokens before a tool call is produced.
-    Distinct from format_error_template so the model is told it was cut off (not that it forgot)."""
     observation_template: str = (
         "{% if output.exception_info %}<exception>{{output.exception_info}}</exception>\n{% endif %}"
         "<returncode>{{output.returncode}}</returncode>\n<output>\n{{output.output}}</output>"
@@ -102,20 +94,6 @@ def query(self, messages: list[dict[str, str]], **kwargs) -> dict:
                 # model_dump failed (e.g. unserializable object); fall back to repr
                 # so the spec contract ("response MUST be persisted") holds unconditionally.
                 e.messages[0]["extra"]["response"] = repr(response)
-            # If the response was cut off at the output token limit before a tool call (common with
-            # reasoning models whose thinking can consume the whole max_tokens budget), tell the
-            # model it was truncated instead of the misleading default "no tool call found" retry.
-            if self._is_truncated(response):
-                finish_reason = response.choices[0].finish_reason
-                e.messages[0]["content"] = Template(
-                    self.config.truncation_error_template, undefined=StrictUndefined
-                ).render(finish_reason=finish_reason)
-                e.messages[0]["extra"]["truncated"] = True
-                logger.warning(
-                    "Model response truncated at the output token limit (finish_reason=%s) "
-                    "before a tool call -- consider raising max_tokens.",
-                    finish_reason,
-                )
             raise
         message = response.choices[0].message.model_dump()
         message["extra"] = {
@@ -151,22 +129,6 @@ def _parse_actions(self, response) -> list[dict]:
         tool_calls = response.choices[0].message.tool_calls or []
         return parse_toolcall_actions(tool_calls, format_error_template=self.config.format_error_template)
 
-    @staticmethod
-    def _is_truncated(response) -> bool:
-        """Whether a no-tool-call response was cut off at the output token limit.
-
-        ``length`` means the completion was truncated mid-output; ``tool_calls`` with an empty
-        payload means it was cut right at the tool-call boundary. Both are budget truncations,
-        distinct from a model that simply ended its turn (``stop``/``end_turn``) without acting.
-        """
-        try:
-            choice = response.choices[0]
-            finish_reason = choice.finish_reason
-            has_tool_calls = bool(choice.message.tool_calls)
-        except (AttributeError, IndexError):
-            return False
-        return finish_reason == "length" or (finish_reason == "tool_calls" and not has_tool_calls)
-
     def format_message(self, **kwargs) -> dict:
         return expand_multimodal_content(kwargs, pattern=self.config.multimodal_regex)
 

tests/models/test_litellm_model.py

@@ -62,52 +62,6 @@ def test_parse_actions_no_tool_calls_raises(self, mock_cost, mock_completion):
         with pytest.raises(FormatError):
             model.query([{"role": "user", "content": "test"}])
 
-    @patch("minisweagent.models.litellm_model.litellm.completion")
-    @patch("minisweagent.models.litellm_model.litellm.cost_calculator.completion_cost")
-    def test_truncation_finish_length_uses_truncation_message(self, mock_cost, mock_completion):
-        """finish_reason=length (cut off before a tool call) -> a truncation-aware retry, flagged."""
-        response = _mock_litellm_response(None)
-        response.choices[0].finish_reason = "length"
-        mock_completion.return_value = response
-        mock_cost.return_value = 0.001
-
-        with pytest.raises(FormatError) as exc:
-            LitellmModel(model_name="gpt-4").query([{"role": "user", "content": "test"}])
-
-        msg = exc.value.messages[0]
-        assert msg["extra"]["truncated"] is True
-        assert "cut off" in msg["content"] and "token limit" in msg["content"]
-        assert "No tool calls found" not in msg["content"]  # not the misleading "you forgot" message
-
-    @patch("minisweagent.models.litellm_model.litellm.completion")
-    @patch("minisweagent.models.litellm_model.litellm.cost_calculator.completion_cost")
-    def test_truncation_empty_toolcalls_payload_is_truncation(self, mock_cost, mock_completion):
-        """finish_reason=tool_calls but an empty payload = cut at the tool-call boundary."""
-        response = _mock_litellm_response(None)
-        response.choices[0].finish_reason = "tool_calls"
-        mock_completion.return_value = response
-        mock_cost.return_value = 0.001
-
-        with pytest.raises(FormatError) as exc:
-            LitellmModel(model_name="gpt-4").query([{"role": "user", "content": "test"}])
-        assert exc.value.messages[0]["extra"]["truncated"] is True
-        assert "cut off" in exc.value.messages[0]["content"]
-
-    @patch("minisweagent.models.litellm_model.litellm.completion")
-    @patch("minisweagent.models.litellm_model.litellm.cost_calculator.completion_cost")
-    def test_genuine_no_tool_call_is_not_truncation(self, mock_cost, mock_completion):
-        """finish_reason=stop with no tool call = the model really ended its turn without acting;
-        keep the normal 'no tool calls found' retry and do NOT flag truncation."""
-        response = _mock_litellm_response(None)
-        response.choices[0].finish_reason = "stop"
-        mock_completion.return_value = response
-        mock_cost.return_value = 0.001
-
-        with pytest.raises(FormatError) as exc:
-            LitellmModel(model_name="gpt-4").query([{"role": "user", "content": "test"}])
-        assert "truncated" not in exc.value.messages[0]["extra"]
-        assert "No tool calls found" in exc.value.messages[0]["content"]
-
     def test_format_observation_messages(self):
         model = LitellmModel(model_name="gpt-4", observation_template="{{ output.output }}")
         message = {"extra": {"actions": [{"command": "echo test", "tool_call_id": "call_1"}]}}