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

Three interrelated fixes for the misformat handling pipeline:

1. extract_json_object_string: replace rfind with brace-depth tracking
   that respects string literals and escape sequences, preventing
   false JSON extraction when model output contains incidental braces.

2. process_tools: add consecutive misformat counter on LoopData with
   a circuit breaker at 5 attempts, raising HandledException to stop
   the agent instead of looping indefinitely.

3. validate_tool_request: return early for None (already handled by
   the misformat path) and raise RepairableException instead of
   ValueError so the agent can retry instead of crashing.

Also improves fw.msg_misformat.md to show the expected JSON format
explicitly instead of the vague original one-liner.

Author: PaoloC68

agent.py

@@ -341,6 +341,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():
@@ -943,22 +944,37 @@ 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
+
+        # Reset counter on successful tool parse
+        self.loop_data.consecutive_misformat = 0
 
     @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,14 @@
-You have misformatted your message. Follow system prompt instructions on JSON message formatting precisely.
+Your response could not be parsed as a valid JSON tool call. You MUST respond with a single JSON object in this exact format:
+
+```json
+{
+    "thoughts": ["your reasoning here"],
+    "headline": "Short description of action",
+    "tool_name": "response",
+    "tool_args": {
+        "text": "your message to the user"
+    }
+}
+```
+
+Do NOT wrap JSON in markdown code fences. Do NOT use XML-style tool calls. Output ONLY the raw JSON object, nothing else.