fix(tools): merge glued tool JSON fragments from local models

DeepSeek and similar models emit {…}{}{…} tool args; merge into one
object before dispatch instead of triplicate ls/Git/Grep calls. Fix Grep
format_output tool_footer TypeError on parse errors. Tests in
test_tool_arguments.py.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: JessicaMulein

cecli/coders/agent_coder.py

@@ -727,25 +727,9 @@ async def _execute_local_tools(self, tool_calls_list):
                     continue
 
                 if args_string:
-                    json_chunks = utils.split_concatenated_json(args_string)
-                    for chunk in json_chunks:
-                        try:
-                            parsed_args_list.append(json.loads(chunk))
-                        except json.JSONDecodeError as e:
-                            self.model_kwargs = {}
-                            self.io.tool_warning(
-                                f"Malformed JSON arguments in tool {tool_name}: {chunk}"
-                            )
-                            tool_responses.append(
-                                {
-                                    "role": "tool",
-                                    "tool_call_id": tool_call.id,
-                                    "content": (
-                                        f"Malformed JSON arguments in tool {tool_name}: {str(e)}"
-                                    ),
-                                }
-                            )
-                            continue
+                    from cecli.tools.utils.helpers import parse_tool_arguments
+
+                    parsed_args_list = [parse_tool_arguments(args_string)]
                 if not parsed_args_list and not args_string:
                     parsed_args_list.append({})
                 all_results_content = []

cecli/coders/base_coder.py

@@ -2645,7 +2645,16 @@ def _expand_concatenated_json(self, tool_calls):
                 expanded_tool_calls.append(tool_call)
                 continue
 
-            # We have concatenated JSON, so expand it into multiple tool calls.
+            from cecli.tools.utils.helpers import merge_glued_json_objects
+
+            merged = merge_glued_json_objects(json_chunks)
+            if merged is not None:
+                new_tool_call = copy_tool_call(tool_call)
+                new_tool_call.function.arguments = json.dumps(merged)
+                expanded_tool_calls.append(new_tool_call)
+                continue
+
+            # Non-object glued JSON: expand into multiple tool calls (legacy).
             for i, chunk in enumerate(json_chunks):
                 if not chunk.strip():
                     continue

cecli/tools/grep.py

@@ -7,7 +7,12 @@
 from cecli.helpers.hashline import strip_hashline
 from cecli.run_cmd import run_cmd_subprocess
 from cecli.tools.utils.base_tool import BaseTool
-from cecli.tools.utils.helpers import ToolError, grep_error_hint, normalize_search_operations
+from cecli.tools.utils.helpers import (
+    ToolError,
+    grep_error_hint,
+    normalize_search_operations,
+    parse_tool_arguments,
+)
 from cecli.tools.utils.output import color_markers, tool_footer, tool_header
 
 
@@ -242,9 +247,8 @@ def format_output(cls, coder, mcp_server, tool_response):
         """Format output for Grep tool."""
         color_start, color_end = color_markers(coder)
 
-        try:
-            params = json.loads(tool_response.function.arguments)
-        except json.JSONDecodeError:
+        params = parse_tool_arguments(tool_response.function.arguments or "")
+        if not params and (tool_response.function.arguments or "").strip():
             coder.io.tool_error("Invalid Tool JSON")
             return
 
@@ -255,7 +259,7 @@ def format_output(cls, coder, mcp_server, tool_response):
             searches = normalize_search_operations(params.get("searches", []))
         except ToolError as err:
             coder.io.tool_error(str(err))
-            tool_footer(coder=coder, mcp_server=mcp_server, tool_response=tool_response)
+            tool_footer(coder=coder, tool_response=tool_response)
             return
 
         if searches:

cecli/tools/utils/helpers.py

@@ -358,6 +358,74 @@ def _repair_local_model_json_text(text: str) -> str:
     return repaired
 
 
+def merge_glued_json_objects(chunks: list[str]) -> dict | None:
+    """
+    Merge consecutive JSON object strings from glued local-model tool args.
+
+    Example: ``{"limit": 15}{}{"path": "."}`` → ``{"limit": 15, "path": "."}``.
+    Returns ``None`` when chunks are not all mergeable objects (caller may split).
+    """
+    merged: dict = {}
+    saw_non_empty = False
+    for chunk in chunks:
+        text = chunk.strip()
+        if not text:
+            continue
+        obj = _try_parse_json_value(text)
+        if obj is None:
+            try:
+                obj = json.loads(text)
+            except json.JSONDecodeError:
+                return None
+        if isinstance(obj, list):
+            return None
+        if not isinstance(obj, dict):
+            return None
+        if obj:
+            merged.update(obj)
+            saw_non_empty = True
+    if saw_non_empty or merged == {}:
+        return merged
+    return None
+
+
+def parse_tool_arguments(args_string: str) -> dict:
+    """Parse tool-call arguments, merging glued ``{…}{} {…}`` object fragments."""
+    text = (args_string or "").strip()
+    if not text:
+        return {}
+    try:
+        parsed = json.loads(text)
+        if isinstance(parsed, dict):
+            return parsed
+    except json.JSONDecodeError:
+        pass
+
+    parsed = _try_parse_json_value(text)
+    if isinstance(parsed, dict):
+        return parsed
+
+    from cecli import utils as cecli_utils
+
+    chunks = cecli_utils.split_concatenated_json(text)
+    if len(chunks) <= 1:
+        if not chunks:
+            return {}
+        lone = _try_parse_json_value(chunks[0])
+        if isinstance(lone, dict):
+            return lone
+        try:
+            single = json.loads(chunks[0])
+        except json.JSONDecodeError:
+            return {}
+        return single if isinstance(single, dict) else {}
+
+    merged = merge_glued_json_objects(chunks)
+    if merged is not None:
+        return merged
+    return {}
+
+
 def _try_parse_json_value(text: str):
     """Parse JSON text, including repairs for common local-model tool-arg quirks."""
     text = text.strip()

tests/tools/test_tool_arguments.py

@@ -0,0 +1,72 @@
+"""Glued local-model tool JSON argument parsing."""
+
+import json
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import pytest
+
+from cecli.coders.base_coder import Coder
+from cecli.tools.grep import Tool as GrepTool
+from cecli.tools.utils.helpers import merge_glued_json_objects, parse_tool_arguments
+
+
+def test_parse_tool_arguments_merges_glued_objects_with_empty_fragments():
+    raw = '{"limit": 15}{}{"path": "."}'
+    assert parse_tool_arguments(raw) == {"limit": 15, "path": "."}
+
+
+def test_parse_tool_arguments_merges_grep_style_glued_args():
+    raw = (
+        '{"limit": 15}{}{"searches": [{"file_pattern": "*.md", '
+        '"pattern": "TODO|FIXME", "use_regex": true}]}'
+    )
+    out = parse_tool_arguments(raw)
+    assert out["limit"] == 15
+    assert out["searches"][0]["pattern"] == "TODO|FIXME"
+
+
+def test_merge_glued_returns_none_for_non_object_chunks():
+    assert merge_glued_json_objects(['["a"]', '{"b": 1}']) is None
+
+
+def test_expand_concatenated_json_merges_instead_of_splitting(monkeypatch):
+    """Dogfood: DeepSeek ``{…}{}{…}`` must not become three tool calls."""
+
+    class MiniCoder(Coder):
+        def __init__(self):
+            pass
+
+    coder = MiniCoder.__new__(MiniCoder)
+    tool_call = SimpleNamespace(
+        id="call-1",
+        function=SimpleNamespace(
+            name="ls",
+            arguments='{"limit": 15}{}{"path": "."}',
+        ),
+    )
+    expanded = coder._expand_concatenated_json([tool_call])
+    assert len(expanded) == 1
+    assert json.loads(expanded[0].function.arguments) == {"limit": 15, "path": "."}
+    assert expanded[0].id == "call-1"
+
+
+def test_grep_format_output_empty_searches_does_not_crash_tool_footer():
+    coder = SimpleNamespace(
+        io=SimpleNamespace(tool_error=Mock(), tool_output=Mock(), tool_warning=Mock()),
+        verbose=False,
+        pretty=False,
+        tui=lambda: None,
+    )
+    tool_response = SimpleNamespace(
+        function=SimpleNamespace(
+            name="Grep",
+            arguments='{"limit": 15}{}{"searches": []}',
+        ),
+    )
+    GrepTool.format_output(
+        coder,
+        mcp_server=SimpleNamespace(name="Local"),
+        tool_response=tool_response,
+    )
+    assert coder.io.tool_error.called