fix: harden JSON misformat handling to prevent infinite loops and crashes

Circuit breaker now covers BOTH failure modes:
- Case A: complete parse failure (tool_request is None)
- Case B: parseable-but-invalid JSON (RepairableException from validation)

Previously, Case B bypassed the consecutive_misformat counter entirely
because RepairableException was swallowed by _50_handle_repairable_exception
extension, allowing the agent to loop forever on models producing JSON
without required tool_name/tool_args fields.

Changes:
- agent.py: Wrap validate_tool_request in try/except RepairableException
  inside process_tools; increment counter for Case B; move counter reset
  to after validation passes (not after tool execution)
- prompts/fw.msg_misformat.md: Add attempt countdown, remove contradictory
  code-fence example, compress to single-line JSON example
- tests/test_misformat_circuit_breaker.py: 73 tests covering extraction,
  validation, circuit breaker (both cases), and end-to-end pipeline

Workaround: Models producing frequent misformats (especially thinking/reasoning
models like MiniMax M2.5) can be improved by adding response_format to the
Chat model additional parameters in Agent Zero settings:
  response_format={"type": "json_object"}
This forces JSON output at the token generation level. Confirmed supported
on OpenRouter for MiniMax M2.5, DeepSeek V3, Gemini 2.5 Flash, Grok 4.1.

Author: PaoloC68

agent.py

@@ -334,6 +334,7 @@ def __init__(self, **kwargs):
         self.params_temporary: dict = {}
         self.params_persistent: dict = {}
         self.current_tool = None
+        self.consecutive_misformat = 0
 
         # override values with kwargs
         for key, value in kwargs.items():
@@ -844,10 +845,27 @@ async def process_tools(self, msg: str):
         # search for tool usage requests in agent message
         tool_request = extract_tools.json_parse_dirty(msg)
 
-        # basic validation + extensions
-        await self.validate_tool_request(tool_request)
+        # Validate tool request — catches both Case A (None) and Case B (invalid dict).
+        # RepairableException from validation counts toward the circuit breaker:
+        # the _50_handle_repairable_exception extension swallows RepairableException
+        # and continues the loop, so without counting here, the agent loops forever
+        # on models that produce parseable-but-invalid JSON (e.g., missing tool_name).
+        try:
+            await self.validate_tool_request(tool_request)
+        except RepairableException:
+            self.loop_data.consecutive_misformat += 1
+            if self.loop_data.consecutive_misformat >= 5:
+                raise HandledException(
+                    "Too many consecutive misformat errors (5/5). Stopping to prevent infinite loop."
+                )
+            raise  # propagate to handle_exception for the standard warning
 
         if tool_request is not None:
+            # Validation passed — the model produced correctly-formatted JSON.
+            # Reset the misformat counter regardless of whether the tool is found,
+            # since format correctness (not tool existence) is what we're tracking.
+            self.loop_data.consecutive_misformat = 0
+
             raw_tool_name = tool_request.get("tool_name", tool_request.get("tool",""))  # Get the raw tool name
             tool_args = tool_request.get("tool_args", tool_request.get("args", {}))
 
@@ -933,22 +951,34 @@ async def process_tools(self, msg: str):
                     type="warning", content=f"{self.agent_name}: {error_detail}"
                 )
         else:
-            warning_msg_misformat = self.read_prompt("fw.msg_misformat.md")
+            self.loop_data.consecutive_misformat += 1
+            warning_msg_misformat = self.read_prompt(
+                "fw.msg_misformat.md",
+                attempt=self.loop_data.consecutive_misformat,
+                max_attempts=5,
+            )
             self.hist_add_warning(warning_msg_misformat)
             PrintStyle(font_color="red", padding=True).print(warning_msg_misformat)
             self.context.log.log(
                 type="warning",
-                content=f"{self.agent_name}: Message misformat, no valid tool request found.",
+                content=f"{self.agent_name}: Message misformat ({self.loop_data.consecutive_misformat}/5), no valid tool request found.",
             )
+            if self.loop_data.consecutive_misformat >= 5:
+                raise HandledException(
+                    "Too many consecutive misformat errors (5/5). Stopping to prevent infinite loop."
+                )
+            return
 
     @extension.extensible
     async def validate_tool_request(self, tool_request: Any):
+        if tool_request is None:
+            return  # let process_tools handle the misformat case
         if not isinstance(tool_request, dict):
-            raise ValueError("Tool request must be a dictionary")
+            raise RepairableException("Tool request must be a dictionary")
         if not tool_request.get("tool_name") or not isinstance(tool_request.get("tool_name"), str):
-            raise ValueError("Tool request must have a tool_name (type string) field")
+            raise RepairableException("Tool request must have a tool_name (type string) field")
         if not tool_request.get("tool_args") or not isinstance(tool_request.get("tool_args"), dict):
-            raise ValueError("Tool request must have a tool_args (type dictionary) field")
+            raise RepairableException("Tool request must have a tool_args (type dictionary) field")
 
 
 

helpers/extract_tools.py

@@ -25,14 +25,32 @@ def extract_json_object_string(content):
     if start == -1:
         return ""
 
-    # Find the first '{'
-    end = content.rfind('}')
-    if end == -1:
-        # If there's no closing '}', return from start to the end
-        return content[start:]
-    else:
-        # If there's a closing '}', return the substring from start to end
-        return content[start:end+1]
+    # Walk forward from the first '{' tracking brace depth, respecting strings and escapes
+    depth = 0
+    in_string = False
+    escape_next = False
+    for i in range(start, len(content)):
+        ch = content[i]
+        if escape_next:
+            escape_next = False
+            continue
+        if ch == '\\' and in_string:
+            escape_next = True
+            continue
+        if ch == '"':
+            in_string = not in_string
+            continue
+        if in_string:
+            continue
+        if ch == '{':
+            depth += 1
+        elif ch == '}':
+            depth -= 1
+            if depth == 0:
+                return content[start:i+1]
+
+    # No matching '}' found — return from start to end
+    return content[start:]
 
 def extract_json_string(content):
     # Regular expression pattern to match a JSON object

prompts/fw.msg_misformat.md

@@ -1 +1,7 @@
-You have misformatted your message. Follow system prompt instructions on JSON message formatting precisely.
+WARNING: Your response could not be parsed as a valid JSON tool call (attempt {{attempt}}/{{max_attempts}}).
+
+You MUST respond with a single, raw JSON object — no markdown, no code fences, no XML. Example:
+
+{"thoughts": ["your reasoning"], "headline": "Short summary", "tool_name": "response", "tool_args": {"text": "your message"}}
+
+If you want to reply to the user, use tool_name "response" with tool_args.text containing your message.