cecli-dev 1.2.3rc1__tar.gz → 1.2.3rc3__tar.gz

{cecli_dev-1.2.3rc1 → cecli_dev-1.2.3rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.2.3rc1
+Version: 1.2.3rc3
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.2.3rc1 → cecli_dev-1.2.3rc3}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.3rc1'
-__version_tuple__ = version_tuple = (1, 2, 3, 'rc1')
+__version__ = version = '1.2.3rc3'
+__version_tuple__ = version_tuple = (1, 2, 3, 'rc3')
 
-__commit_id__ = commit_id = 'g719764cec'
+__commit_id__ = commit_id = 'g3477cad89'

{cecli_dev-1.2.3rc1 → cecli_dev-1.2.3rc3}/cecli/helpers/llms/domains/messages.py

@@ -45,9 +45,12 @@ def anthropic_payload(
     kwargs: Dict[str, Any],
 ) -> Dict[str, Any]:
     system = system_prompt(messages)
+    wire_messages = _coalesce_anthropic_messages(
+        [anthropic_message(m) for m in messages if m.get("role") != "system"]
+    )
     payload: Dict[str, Any] = {
         "model": resolved["route"],
-        "messages": [anthropic_message(m) for m in messages if m.get("role") != "system"],
+        "messages": wire_messages,
         "max_tokens": (
             kwargs.get("max_tokens") or resolved.get("llm_block", {}).get("max_tokens") or 4096
         ),
@@ -274,6 +277,7 @@ async def anthropic_stream(
                             "id": block.get("id", ""),
                             "name": block.get("name", ""),
                             "input": block.get("input") or {},
+                            "_input_raw": "",
                         }
 
                 elif evt == "content_block_delta":
@@ -291,7 +295,21 @@ async def anthropic_stream(
                         elif dtype == "signature_delta":
                             entry["signature"] = delta.get("signature")
 
+                        elif dtype == "input_json_delta":
+                            entry["_input_raw"] += delta.get("partial_json") or ""
+
                 elif evt == "content_block_stop":
+                    entry = blocks.get(current) if current is not None else None
+
+                    if entry is not None:
+                        raw = entry.pop("_input_raw", None)
+
+                        if raw is not None:
+                            try:
+                                entry["input"] = json.loads(raw)
+                            except json.JSONDecodeError:
+                                pass
+
                     current = None
 
                 chunk = parse_anthropic_chunk(json_obj)
@@ -743,6 +761,62 @@ def _is_tool_turn(msg: Dict[str, Any]) -> bool:
     )
 
 
+def _coalesce_anthropic_messages(wire_messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Merge consecutive user turns into a single user message.
+
+    The conversation manager emits one user message per tool result and can
+    inject file-context text as its own user message directly after the
+    results, so the raw wire list can contain several ``user`` messages in a
+    row. The Messages API requires alternating roles and, per the tool-use
+    spec, ``tool_result`` blocks must come first in the user message that
+    follows an assistant ``tool_use`` turn. Text runs (across messages) are
+    concatenated with ``"\n---\n"`` separators.
+    """
+    result: List[Dict[str, Any]] = []
+    pending: List[Dict[str, Any]] = []
+
+    def flush() -> None:
+        if not pending:
+            return
+
+        tool_results = [b for b in pending if b.get("type") == "tool_result"]
+        others = [b for b in pending if b.get("type") != "tool_result"]
+        content: List[Dict[str, Any]] = list(tool_results)
+        text_parts: List[str] = []
+
+        for block in others:
+            if block.get("type") == "text":
+                text_parts.append(block.get("text") or "")
+
+                continue
+
+            if text_parts:
+                content.append({"type": "text", "text": "\n---\n".join(text_parts)})
+                text_parts = []
+
+            content.append(block)
+
+        if text_parts:
+            content.append({"type": "text", "text": "\n---\n".join(text_parts)})
+
+        result.append({"role": "user", "content": content})
+        pending.clear()
+
+    for msg in wire_messages:
+        if msg.get("role") != "user":
+            flush()
+            result.append(msg)
+            continue
+
+        content = msg.get("content")
+        blocks = content if isinstance(content, list) else [{"type": "text", "text": content}]
+        pending.extend(blocks)
+
+    flush()
+
+    return result
+
+
 __all__ = [
     "anthropic_payload",
     "anthropic_message",

{cecli_dev-1.2.3rc1 → cecli_dev-1.2.3rc3}/cecli/prompts/agent.yml

@@ -31,8 +31,6 @@ main_system: |
   - **Unique Lines (`——`):** Lines that appear only once in the file are prefixed with `——`. To target these lines for edits, you can simply reference the exact literal text of the line, excluding the prefix.
   - **Duplicate Lines (e.g., `—“0车加—`):** Lines that appear multiple times are prefixed with an opaque identifier. You MUST include this exact identifier when targeting these lines to disambiguate which specific instance you want to edit.
 
-  Do not attempt to generate, guess, or calculate these identifiers yourself. Always use the exact line contents and prefixes provided from the most recent file read. 
-
   **Example File**
   ```
   ——#!/usr/bin/env python3
@@ -52,6 +50,9 @@ main_system: |
   —니0车加—        return None
   ```
 
+  Do not attempt to generate, guess, or calculate these identifiers yourself. Always use the exact line contents and prefixes provided from the most recent file read.  
+  This system removes the need to recite full file contents.
+
   ## Core Workflow
   1. **Plan**: Start by using `UpdateTodoList` to outline the task.
   2. **Explore**: Use discovery tools (`ExploreCode`, `Grep`, `Ls`) to research and gather understanding for you task. Modify search terms when errors are encountered.

{cecli_dev-1.2.3rc1 → cecli_dev-1.2.3rc3}/cecli/prompts/subagent.yml

@@ -16,8 +16,6 @@ main_system: |
   - **Unique Lines (`——`):** Lines that appear only once in the file are prefixed with `——`. To target these lines for edits, you can simply reference the exact literal text of the line, excluding the prefix.
   - **Duplicate Lines (e.g., `—“0车加—`):** Lines that appear multiple times are prefixed with an opaque identifier. You MUST include this exact identifier when targeting these lines to disambiguate which specific instance you want to edit.
 
-  Do not attempt to generate, guess, or calculate these identifiers yourself. Always use the exact line contents and prefixes provided from the most recent file read. 
-
   **Example File**
   ```
   ——#!/usr/bin/env python3
@@ -37,6 +35,9 @@ main_system: |
   —니0车加—        return None
   ```
 
+  Do not attempt to generate, guess, or calculate these identifiers yourself. Always use the exact line contents and prefixes provided from the most recent file read.  
+  This system removes the need to recite full file contents.
+
   ## Core Workflow
   1. **Plan**: Start by using `UpdateTodoList` to outline the task.
   2. **Explore**: Use discovery tools (`ExploreCode`, `Grep`, `Ls`) to research and gather understanding for you task. Modify search terms when errors are encountered.

{cecli_dev-1.2.3rc1 → cecli_dev-1.2.3rc3}/cecli/tools/read_file.py

@@ -50,8 +50,7 @@ class Tool(BaseTool):
                 "  - when range_start matches one location, range_end accepts '@C{num}' (context both sides), "
                 "    '@P{num}' (lines before the match), '@N{num}' (lines after the match)"
                 ""
-                "Identifiers are deterministic per line content, so adding or removing lines can re-prefix "
-                "identical lines elsewhere in the file; re-read after editing to get fresh identifiers."
+                "File edits may update prefixes of identical lines, requiring re-reading to get fresh identifiers."
                 ""
                 "Large structured ranges (line-number or boundary reads) return a structural outline "
                 "instead of full contents; read in smaller targeted ranges for full detail."

{cecli_dev-1.2.3rc1 → cecli_dev-1.2.3rc3}/cecli/tools/validations/validations.py

@@ -60,6 +60,12 @@ class ToolValidations:
         if not isinstance(params, (dict, list)):
             raise ToolError("Invalid Tool Input - Unparsable JSON")
 
+        # Mirror the execution path (responses.parse_tool_arguments): some models
+        # double-wrap the real params under a single "arguments"/"parameters"/"params"
+        # key. Unwrap so previews resolve the same args that will actually execute.
+        if isinstance(params, dict):
+            params = responses.coerce_tool_structure(params)
+
         # Apply basic structural corrections before declarative validations
         params = cls._basic_validations(params, schema)
 

{cecli_dev-1.2.3rc1 → cecli_dev-1.2.3rc3}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.2.3rc1
+Version: 1.2.3rc3
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.2.3rc1 → cecli_dev-1.2.3rc3}/cecli_dev.egg-info/SOURCES.txt

@@ -747,6 +747,8 @@ tests/helpers/test_llms_aws_sigv4.py
 tests/helpers/test_llms_cache_control.py
 tests/helpers/test_llms_github_copilot_auth.py
 tests/helpers/test_llms_hyperscalers.py
+tests/helpers/test_llms_messages_stream.py
+tests/helpers/test_llms_messages_wire.py
 tests/helpers/test_llms_providers_json.py
 tests/helpers/test_llms_reasoning_config.py
 tests/helpers/test_llms_reasoning_extract.py

{cecli_dev-1.2.3rc1 → cecli_dev-1.2.3rc3}/cecli_dev.egg-info/scm_file_list.json

@@ -1001,6 +1001,8 @@
     "tests/helpers/test_llms_cache_control.py",
     "tests/helpers/test_llms_github_copilot_auth.py",
     "tests/helpers/test_llms_hyperscalers.py",
+    "tests/helpers/test_llms_messages_stream.py",
+    "tests/helpers/test_llms_messages_wire.py",
     "tests/helpers/test_llms_providers_json.py",
     "tests/helpers/test_llms_reasoning_config.py",
     "tests/helpers/test_llms_reasoning_extract.py",

cecli_dev-1.2.3rc3/cecli_dev.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.2.3rc3",
+  "distance": 0,
+  "node": "g3477cad895e755095f1c9e5c4d569e814a8173c4",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-18"
+}

cecli_dev-1.2.3rc3/tests/basic/test_model_info_manager.py

@@ -0,0 +1,43 @@
+import os
+import tempfile
+from pathlib import Path
+from unittest import TestCase
+from unittest.mock import patch
+
+from cecli.models import ModelInfoManager
+
+
+class TestModelInfoManager(TestCase):
+    def setUp(self):
+        self.original_env = os.environ.copy()
+        self.manager = ModelInfoManager()
+        # Create a temporary directory for cache
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.manager.cache_dir = Path(self.temp_dir.name)
+        self.manager.cache_file = self.manager.cache_dir / "model_prices_and_context_window.json"
+        self.manager.cache_dir.mkdir(exist_ok=True)
+
+    def tearDown(self):
+        self.temp_dir.cleanup()
+        os.environ.clear()
+        os.environ.update(self.original_env)
+
+    def test_lazy_loading_cache(self):
+        # Create a cache file
+        self.manager.cache_file.write_text('{"test_model": {"max_tokens": 4096}}')
+
+        # Verify cache is not loaded on initialization
+        self.assertFalse(self.manager._cache_loaded)
+        self.assertIsNone(self.manager.content)
+
+        # Access content through get_model_from_cached_json_db
+        with patch.object(self.manager, "_load_cache", wraps=self.manager._load_cache) as mock_load:
+            result = self.manager.get_model_from_cached_json_db("test_model")
+
+            # Verify cache was loaded lazily on first access
+            self.assertTrue(self.manager._cache_loaded)
+            self.assertIsNotNone(self.manager._raw_content)
+            self.assertEqual(result, {"max_tokens": 4096})
+
+            # Verify _load_cache was called exactly once (lazy load on demand)
+            mock_load.assert_called_once()

cecli_dev-1.2.3rc3/tests/helpers/test_llms_messages_stream.py

@@ -0,0 +1,142 @@
+"""Streaming stash fidelity for anthropic tool_use input.
+
+Tool-call arguments arrive over SSE as ``input_json_delta`` partial_json
+fragments. ``anthropic_stream`` must accumulate them into the stashed
+``tool_use`` block so the next-turn replay (and prompt-cache prefix) keeps
+the exact ``input`` the model sent instead of ``{}``.
+
+No network: the family adapter's ``make_client`` is monkeypatched.
+"""
+
+import asyncio
+import json
+
+from cecli.helpers.llms.config import resolve_model_config
+from cecli.helpers.llms.domains import messages as messages_domain
+from cecli.helpers.llms.domains.messages import anthropic_payload, anthropic_stream
+
+
+def _sse(obj):
+    return f"data: {json.dumps(obj)}"
+
+
+class _FakeStreamClient:
+    """Stand-in for ``make_client`` supporting the stream() context manager."""
+
+    def __init__(self, lines):
+        self._lines = lines
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *args):
+        return None
+
+    def stream(self, *args, **kwargs):
+        return self
+
+    def raise_for_status(self):
+        pass
+
+    async def aiter_lines(self):
+        for line in self._lines:
+            yield line
+
+
+def _run(gen):
+    async def collect():
+        return [c async for c in gen]
+
+    return asyncio.new_event_loop().run_until_complete(collect())
+
+
+def _stream_tool_use_chunks(monkeypatch, partials):
+    lines = [
+        _sse(
+            {
+                "type": "content_block_start",
+                "index": 0,
+                "content_block": {
+                    "type": "tool_use",
+                    "id": "toolu_01",
+                    "name": "Local--ReadFile",
+                    "input": {},
+                },
+            }
+        ),
+    ]
+    lines += [
+        _sse(
+            {
+                "type": "content_block_delta",
+                "index": 0,
+                "delta": {"type": "input_json_delta", "partial_json": p},
+            }
+        )
+        for p in partials
+    ]
+    lines += [
+        _sse({"type": "content_block_stop", "index": 0}),
+        _sse(
+            {
+                "type": "message_delta",
+                "delta": {"stop_reason": "tool_use"},
+                "usage": {"input_tokens": 10, "output_tokens": 5},
+            }
+        ),
+    ]
+
+    client = _FakeStreamClient(lines)
+    monkeypatch.setattr(messages_domain, "make_client", lambda *a, **k: client)
+    resolved = resolve_model_config("claude-sonnet-5")
+
+    return _run(
+        anthropic_stream(resolved, [{"role": "user", "content": "hi"}], None, "key", {}, {})
+    )
+
+
+def _stashed_tool_use(chunks):
+    stash = next(
+        c.provider_specific_fields.get("anthropic")
+        for c in chunks
+        if c.provider_specific_fields.get("anthropic")
+    )
+
+    return next(b for b in stash if b["type"] == "tool_use")
+
+
+def test_streaming_stash_keeps_full_tool_use_input(monkeypatch):
+    chunks = _stream_tool_use_chunks(monkeypatch, ['{"r', 'ead": [', '{"file_path": "a.py"}]}'])
+    tool_use = _stashed_tool_use(chunks)
+
+    assert tool_use["id"] == "toolu_01"
+    assert tool_use["name"] == "Local--ReadFile"
+    assert tool_use["input"] == {"read": [{"file_path": "a.py"}]}
+    assert "_input_raw" not in tool_use
+
+
+def test_streamed_input_round_trips_into_next_payload(monkeypatch):
+    chunks = _stream_tool_use_chunks(monkeypatch, ['{"sear', 'ches": [', '".py"]}'])
+    stash = next(
+        c.provider_specific_fields.get("anthropic")
+        for c in chunks
+        if c.provider_specific_fields.get("anthropic")
+    )
+
+    messages = [
+        {"role": "user", "content": "search"},
+        {"role": "assistant", "provider_specific_fields": {"anthropic": stash}},
+        {"role": "tool", "tool_call_id": "toolu_01", "content": "ok"},
+    ]
+    resolved = resolve_model_config("claude-sonnet-5")
+    payload = anthropic_payload(resolved, messages, None, False, {})
+
+    tool_use = next(
+        b
+        for m in payload["messages"]
+        if m["role"] == "assistant"
+        for b in m["content"]
+        if b["type"] == "tool_use"
+    )
+
+    assert tool_use["input"] == {"searches": [".py"]}

cecli_dev-1.2.3rc3/tests/helpers/test_llms_messages_wire.py

@@ -0,0 +1,151 @@
+"""Wire-format tests for the anthropic messages domain.
+
+``anthropic_payload`` must produce a spec-compliant /v1/messages request body:
+
+- roles alternate (no consecutive user messages), with all ``tool_result``
+  blocks for a parallel tool call grouped into one user message and any
+  following text placed after them (tool-use spec ordering), and
+- consecutive user text turns are concatenated into a single ``text`` block
+  joined with ``"\n---\n"`` separators (the conversation manager injects
+  file-context text as its own user messages, so it rides along inline).
+
+No network: only the offline payload builder is exercised.
+"""
+
+from cecli.helpers.llms.config import resolve_model_config
+from cecli.helpers.llms.domains.messages import anthropic_payload
+
+SYS = "You are cecli, an agentic coding assistant. " * 30
+
+FILE_CONTEXT = (
+    "ID-Prefixed Context For:\ncecli/tools/__init__.py\n\n"
+    '{"file_path": "/home/cecli/cecli/tools/__init__.py", "results": [...]}'
+)
+
+FILE_CONTENT = (
+    "Original File Contents For:\ncecli/tools/utils/base_tool.py\n\n"
+    "from abc import ABC, abstractmethod\n...\n\n"
+    "Modifications will be communicated as diff messages.\n\n"
+)
+
+# Mirrors the conversation manager's sequence around a parallel tool call:
+# several tool results followed by injected file-context text, all as
+# consecutive user turns in the internal (OpenAI-style) message list.
+TRACE_LIKE = [
+    {"role": "system", "content": SYS},
+    {"role": "user", "content": "<context environment_info>Hello\n</context>"},
+    {"role": "assistant", "content": "Hello!"},
+    {"role": "user", "content": "Can you explain cecli/tools to me"},
+    {
+        "role": "assistant",
+        "provider_specific_fields": {
+            "anthropic": [
+                {"type": "thinking", "thinking": "", "signature": "sig1"},
+                {"type": "tool_use", "id": "t1", "name": "Local--ls", "input": {}},
+                {"type": "tool_use", "id": "t2", "name": "Local--ls", "input": {}},
+                {"type": "tool_use", "id": "t3", "name": "Local--ls", "input": {}},
+            ]
+        },
+    },
+    {"role": "tool", "tool_call_id": "t1", "content": '{"result": [1]}'},
+    {"role": "tool", "tool_call_id": "t2", "content": '{"result": [2]}'},
+    {"role": "tool", "tool_call_id": "t3", "content": '{"result": [3]}'},
+    {"role": "user", "content": FILE_CONTEXT},
+    {"role": "user", "content": FILE_CONTENT},
+]
+
+
+def _wire_roles(payload):
+    return [m["role"] for m in payload["messages"]]
+
+
+def _block_types(msg):
+    return [b.get("type") for b in msg["content"]]
+
+
+def _assert_alternating(roles):
+    assert all(roles[i] != roles[i + 1] for i in range(len(roles) - 1))
+
+
+def test_copilot_coalesces_turns_and_keeps_file_text_inline():
+    resolved = resolve_model_config("github_copilot/claude-sonnet-5")
+    payload = anthropic_payload(resolved, TRACE_LIKE, None, False, {})
+
+    _assert_alternating(_wire_roles(payload))
+
+    # No input_artifacts: file-context text rides inline in the history.
+    assert "input_artifacts" not in payload
+
+    # The three parallel tool results are grouped into one user message with
+    # the trailing file-context text after them, joined with "\n---\n".
+    tool_msg = next(
+        m for m in payload["messages"] if any(b.get("type") == "tool_result" for b in m["content"])
+    )
+    assert [b["tool_use_id"] for b in tool_msg["content"][:3]] == ["t1", "t2", "t3"]
+    assert _block_types(tool_msg) == ["tool_result"] * 3 + ["text"]
+    assert tool_msg["content"][3]["text"] == FILE_CONTEXT + "\n---\n" + FILE_CONTENT
+
+
+def test_direct_anthropic_coalesces_turns_and_keeps_file_text_inline():
+    resolved = resolve_model_config("claude-sonnet-5")
+    payload = anthropic_payload(resolved, TRACE_LIKE, None, False, {})
+
+    _assert_alternating(_wire_roles(payload))
+
+    # No input_artifacts extension for either provider: file text stays inline.
+    assert "input_artifacts" not in payload
+    tool_msg = next(
+        m for m in payload["messages"] if any(b.get("type") == "tool_result" for b in m["content"])
+    )
+    types = _block_types(tool_msg)
+    assert types[:3] == ["tool_result"] * 3
+    assert types[3:] == ["text"]
+    assert tool_msg["content"][3]["text"] == FILE_CONTEXT + "\n---\n" + FILE_CONTENT
+
+
+def test_new_user_question_after_tool_results_merges_text_after_results():
+    messages = [
+        {
+            "role": "assistant",
+            "provider_specific_fields": {
+                "anthropic": [{"type": "tool_use", "id": "t1", "name": "Local--ls", "input": {}}]
+            },
+        },
+        {"role": "tool", "tool_call_id": "t1", "content": "ok"},
+        {"role": "user", "content": "what next?"},
+    ]
+    resolved = resolve_model_config("github_copilot/claude-sonnet-5")
+    payload = anthropic_payload(resolved, messages, None, False, {})
+
+    user_msg = payload["messages"][-1]
+    assert _block_types(user_msg) == ["tool_result", "text"]
+    assert user_msg["content"][0]["tool_use_id"] == "t1"
+    assert user_msg["content"][1]["text"] == "what next?"
+
+
+def test_consecutive_text_users_merge_into_one():
+    messages = [
+        {"role": "user", "content": "first"},
+        {"role": "user", "content": "second"},
+    ]
+    resolved = resolve_model_config("github_copilot/claude-sonnet-5")
+    payload = anthropic_payload(resolved, messages, None, False, {})
+
+    assert _wire_roles(payload) == ["user"]
+    assert _block_types(payload["messages"][0]) == ["text"]
+    assert payload["messages"][0]["content"][0]["text"] == "first\n---\nsecond"
+
+
+def test_file_context_text_merges_with_previous_user_message():
+    messages = [
+        {"role": "user", "content": "<context>Hello\n</context>"},
+        {"role": "user", "content": FILE_CONTEXT},
+    ]
+    resolved = resolve_model_config("github_copilot/claude-sonnet-5")
+    payload = anthropic_payload(resolved, messages, None, False, {})
+
+    assert "input_artifacts" not in payload
+    assert _wire_roles(payload) == ["user"]
+    assert payload["messages"][0]["content"][0]["text"] == (
+        "<context>Hello\n</context>\n---\n" + FILE_CONTEXT
+    )

{cecli_dev-1.2.3rc1 → cecli_dev-1.2.3rc3}/tests/tools/test_edit_file_format_output.py

@@ -101,23 +101,28 @@ def coder_with_file(tmp_path):
     return coder, file_path
 
 
-def make_tool_response(edits):
+def make_tool_response(edits, wrap_arguments=False):
+    arguments = {"edits": edits}
+    if wrap_arguments:
+        # Some models mirror the OpenAI wire format and double-wrap the real
+        # params under a single top-level "arguments" key.
+        arguments = {"arguments": json.dumps(arguments)}
     return SimpleNamespace(
         id="test-id",
         type="function",
         function=SimpleNamespace(
             name="EditFile",
-            arguments=json.dumps({"edits": edits}),
+            arguments=json.dumps(arguments),
         ),
     )
 
 
-def preview_output(coder, edits):
+def preview_output(coder, edits, wrap_arguments=False):
     """Run format_output (as base_coder does before execute) and capture output."""
     edit_file.Tool.format_output(
         coder,
         mcp_server=SimpleNamespace(name="Local"),
-        tool_response=make_tool_response(edits),
+        tool_response=make_tool_response(edits, wrap_arguments=wrap_arguments),
     )
     return "\n".join(coder.io.outputs)
 
@@ -236,3 +241,29 @@ def test_format_output_mixed_selectors_in_batch(coder_with_file):
 
     result = edit_file.Tool.execute(coder, edits=edits)
     assert result.to_dict()["errors"] == []
+
+
+def test_format_output_unwraps_double_wrapped_arguments(coder_with_file):
+    """Double-wrapped {"arguments": "{\"edits\": [...]}"} previews a real diff.
+
+    The execution path unwraps this via responses.parse_tool_arguments, so the
+    preview (format_output) must resolve the same edits instead of rendering
+    nothing.
+    """
+    coder, _ = coder_with_file
+    edits = [
+        {
+            "file_path": "example.txt",
+            "operation": "replace",
+            "start_line": "@L2",
+            "end_line": "@L3",
+            "text": '    print("hello")  # edited',
+        }
+    ]
+
+    output = preview_output(coder, edits, wrap_arguments=True)
+    assert "Preview Unavailable" not in output
+    assert "@@" in output, f"expected a unified diff in preview output:\n{output}"
+
+    result = edit_file.Tool.execute(coder, edits=edits)
+    assert result.to_dict()["errors"] == []

{cecli_dev-1.2.3rc1 → cecli_dev-1.2.3rc3}/tests/tools/validations.py

@@ -311,6 +311,37 @@ class TestValidateParams:
         result = ToolValidations.validate_params(params, None)
         assert result == {"key": "value"}
 
+    def test_arguments_wrapper_string_value_unwrapped(self):
+        """A single top-level "arguments" wrapper (as JSON string) is unwrapped.
+
+        Mirrors the execution path (responses.parse_tool_arguments) so previews
+        resolve the same args that will actually run.
+        """
+        params = '{"arguments": "{"edits": [{"file_path": "a.txt"}]}"}'
+        result = ToolValidations.validate_params(
+            params,
+            {"edits": ["coerce_list"], "edits[]": ["coerce_dict"]},
+        )
+        assert result == {"edits": [{"file_path": "a.txt"}]}
+
+    def test_parameters_wrapper_dict_value_unwrapped(self):
+        """A single top-level "parameters" wrapper (as dict) is unwrapped."""
+        params = {"parameters": {"edits": [{"file_path": "a.txt"}]}}
+        result = ToolValidations.validate_params(
+            params,
+            {"edits": ["coerce_list"], "edits[]": ["coerce_dict"]},
+        )
+        assert result == {"edits": [{"file_path": "a.txt"}]}
+
+    def test_multi_key_params_not_unwrapped(self):
+        """Params with more than one key are never treated as a wrapper."""
+        params = {"edits": [{"file_path": "a.txt"}], "change_id": "x"}
+        result = ToolValidations.validate_params(
+            params,
+            {"edits": ["coerce_list"], "edits[]": ["coerce_dict"]},
+        )
+        assert result == {"edits": [{"file_path": "a.txt"}], "change_id": "x"}
+
     # ---- simple keys ----
 
     def test_simple_key_coerce_list(self):