cecli-dev 1.2.3rc4__tar.gz → 1.3.0rc1__tar.gz

{cecli_dev-1.2.3rc4 → cecli_dev-1.3.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.2.3rc4
+Version: 1.3.0rc1
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -43,6 +43,7 @@ Requires-Dist: PyYAML>=6.0.2
 Requires-Dist: tomli>=2.3.0; python_version <= "3.10"
 Requires-Dist: tomlkit>=0.14.0
 Requires-Dist: diff-match-patch>=20241021
+Requires-Dist: tqdm>3.0.0
 Requires-Dist: pyperclip>=1.9.0
 Requires-Dist: pydub>=0.25.1
 Requires-Dist: sounddevice>=0.5.2

{cecli_dev-1.2.3rc4 → cecli_dev-1.3.0rc1}/cecli/__init__.py

@@ -1,6 +1,6 @@
 from packaging import version
 
-__version__ = "1.2.0.dev"
+__version__ = "1.3.0.dev"
 safe_version = __version__
 
 try:

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

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.3rc4'
-__version_tuple__ = version_tuple = (1, 2, 3, 'rc4')
+__version__ = version = '1.3.0rc1'
+__version_tuple__ = version_tuple = (1, 3, 0, 'rc1')
 
-__commit_id__ = commit_id = 'g0cce57c1b'
+__commit_id__ = commit_id = 'gee851b36f'

{cecli_dev-1.2.3rc4 → cecli_dev-1.3.0rc1}/cecli/coders/base_coder.py

@@ -42,6 +42,7 @@ from cecli.helpers import command_parser, command_queue, coroutines, nested, res
 from cecli.helpers.conversation import ConversationService, MessageTag
 from cecli.helpers.file_system import FileSystemService
 from cecli.helpers.io_proxy import IOProxy
+from cecli.helpers.loop_detect import LoopDetectedError, LoopDetector
 from cecli.helpers.memory_control import trim_memory
 from cecli.helpers.observations.service import ObservationService
 from cecli.helpers.profiler import TokenProfiler
@@ -250,6 +251,8 @@ class Coder(metaclass=UsageMeta):
     cost_multiplier = 1
     stop_on_empty = True
     error_code = None
+    _output_loop_detected = False
+    _output_loop_message = ""
 
     # Task coordination state variables
     input_running = False
@@ -3649,6 +3652,8 @@ class Coder(metaclass=UsageMeta):
         self.got_reasoning_content = False
         self.ended_reasoning_content = False
         self.empty_response = False
+        self._output_loop_detected = False
+        self._output_loop_message = ""
 
         self._streaming_buffer_length = 0
         self.io.reset_streaming_response()
@@ -3857,11 +3862,14 @@ class Coder(metaclass=UsageMeta):
     async def show_send_output_stream(self, completion):
         received_content = False
         chunk_index = 0
+        content_detector = LoopDetector()
+        tool_detector = LoopDetector()
+        loop_detected = False
+
+        stream = coroutines.interruptible_async_generator(completion, self.interrupt_event)
 
         try:
-            async for chunk in coroutines.interruptible_async_generator(
-                completion, self.interrupt_event
-            ):
+            async for chunk in stream:
                 if self.args.debug:
                     with safe_open(".cecli/logs/chunks.log", "a") as f:
                         print(chunk, file=f)
@@ -3902,6 +3910,8 @@ class Coder(metaclass=UsageMeta):
                                             tool_call_chunk.function.arguments
                                         )
 
+                                        tool_detector.push(tool_call_chunk.function.arguments)
+
                     except (AttributeError, IndexError):
                         # Handle cases where the response structure doesn't match expectations
                         pass
@@ -3965,6 +3975,9 @@ class Coder(metaclass=UsageMeta):
                 chunk._hidden_params["created_at"] = chunk_index
                 self.partial_response_chunks.append(chunk)
 
+                if text:
+                    content_detector.push(text)
+
                 if self.show_pretty():
                     # Use simplified streaming - just call the method with full content
                     content_to_show = self.live_incremental_response(False)
@@ -3985,6 +3998,30 @@ class Coder(metaclass=UsageMeta):
         except (asyncio.CancelledError, KeyboardInterrupt):
             raise KeyboardInterrupt
 
+        except LoopDetectedError as e:
+            self._output_loop_detected = True
+            self._output_loop_message = str(e)
+            loop_detected = True
+
+        if loop_detected:
+            self.io.tool_warning(
+                f"Output loop detected while streaming: {self._output_loop_message}"
+            )
+            # Explicitly close the async generators so the wrapper's interrupt
+            # task and the underlying provider generator are cleaned up instead
+            # of being left suspended after we stop consuming them.
+            if hasattr(stream, "aclose"):
+                try:
+                    await stream.aclose()
+                except Exception:
+                    pass
+            if hasattr(completion, "aclose"):
+                try:
+                    await completion.aclose()
+                except Exception:
+                    pass
+            return
+
         if (
             self.show_pretty()
             and nested.getter(self.args, "show_thinking")
@@ -4130,22 +4167,45 @@ class Coder(metaclass=UsageMeta):
                 self.tool_reflection = True
                 self.partial_response_tool_calls = extracted_calls
 
+        if self._output_loop_detected:
+            # A repeating output loop was caught while streaming; turn it into an
+            # assistant message so the model can adjust and drop any tool calls.
+            marker = "\n\n[SYSTEM CANCEL: OUTPUT LOOP DETECTED]\n"
+            self.partial_response_content += marker
+            self.partial_response_tool_calls = []
+            self.partial_response_function_call = dict()
+
+            # The assistant message stored in the conversation is built from the
+            # response object (via model_dump()), so the marker has to be written
+            # there too, otherwise it never reaches the model to react to.
+            message = response.choices[0].message
+            message.content = (message.content or "") + marker
+            message.tool_calls = []
+            if hasattr(message, "function_call"):
+                message.function_call = None
+
         self.partial_response_consolidated = (response, func_err, content_err)
         return response, func_err, content_err
 
     def _build_tool_calls_from_chunks(self):
-        """Rebuild tool calls from the raw streaming chunks, keyed by delta index.
-
-        Streaming deltas for parallel tool calls arrive interleaved and may start
-        at any index (not necessarily 0).  Indexing into a dict by the delta's
-        tool-call ``index`` before converting it back to a list ensures every
-        parallel call is preserved, correctly ordered, and keeps its
-        provider-specific fields (e.g. thought signatures) attached.
+        """Rebuild tool calls from the raw streaming chunks.
+
+        Parallel tool calls arrive interleaved and may start at any index.
+        Most providers key fragments by a per-call ``index`` (openai / anthropic /
+        gemini), but some (e.g. deepseek) reuse index0 for every call and only
+        distinguish them by the ``id`` announced on the first fragment.  Keying
+        by id when present -- and remembering the index -> key mapping so later
+        id-less fragments resolve to the right call -- preserves every parallel
+        call instead of collapsing them onto one, keeps them ordered by first
+        appearance, and retains provider-specific fields (e.g. thought
+        signatures) attached.
         """
         ChatCompletionMessageToolCall = litellm.types.utils.ChatCompletionMessageToolCall
         Function = litellm.types.utils.Function
 
         tool_calls_dict = {}
+        index_lookup = {}
+        last_key = None
 
         for chunk in self.partial_response_chunks:
             try:
@@ -4160,22 +4220,39 @@ class Coder(metaclass=UsageMeta):
                     if nested.getter(tool_call, "function") is None:
                         continue
 
+                    tool_id = nested.getter(tool_call, "id") or ""
                     index = nested.getter(tool_call, "index")
-                    if index is None:
-                        index = len(tool_calls_dict)
+
+                    if tool_id:
+                        key = ("id", tool_id)
+
+                        if index is not None:
+                            index_lookup[index] = key
+
+                        last_key = key
+                    elif index is not None and index in index_lookup:
+                        key = index_lookup[index]
+                    elif index is not None:
+                        key = ("index", index)
+                        index_lookup[index] = key
+                    elif last_key is not None:
+                        key = last_key
+                    else:
+                        key = ("slot", len(tool_calls_dict))
 
                     entry = tool_calls_dict.setdefault(
-                        index,
+                        key,
                         {
                             "id": None,
                             "name": None,
                             "type": "function",
                             "arguments": [],
                             "provider_specific_fields": {},
+                            "_order": len(tool_calls_dict),
                         },
                     )
 
-                    entry["id"] = nested.getter(tool_call, "id") or entry["id"]
+                    entry["id"] = tool_id or entry["id"]
                     entry["type"] = nested.getter(tool_call, "type") or entry["type"]
                     entry["name"] = nested.getter(tool_call, "function.name") or entry["name"]
 
@@ -4192,8 +4269,8 @@ class Coder(metaclass=UsageMeta):
                 continue
 
         tool_calls = []
-        for index in sorted(tool_calls_dict.keys()):
-            data = tool_calls_dict[index]
+        for key in sorted(tool_calls_dict.keys(), key=lambda k: tool_calls_dict[k]["_order"]):
+            data = tool_calls_dict[key]
             if not (data["id"] and data["name"]):
                 continue
 

{cecli_dev-1.2.3rc4 → cecli_dev-1.3.0rc1}/cecli/helpers/agents/defaults/memorizer.md

@@ -76,4 +76,4 @@ Before this number hits at most 10, update what you can and yield. Do not delibe
 Important facts will be easy to search for and extract from the given context.
 
 Always prefer **concrete, reusable** facts over vague prose.
-Focus on extracting clear results and aids for navigating, modifying, and extending the project in the future.
+Focus on extracting aids for navigating, modifying, and extending the project in the future.

{cecli_dev-1.2.3rc4 → cecli_dev-1.3.0rc1}/cecli/helpers/conversation/integration.py

@@ -1,5 +1,6 @@
 import json
 import random
+import time
 import weakref
 from typing import Any, Dict, List
 
@@ -959,13 +960,23 @@ class ConversationChunks:
         if not block:
             return
 
+        if not hasattr(coder, "_last_child_agent_hash") or not coder._last_child_agent_hash:
+            coder._last_child_agent_hash = ""
+
+        message_hash = xxhash.xxh3_128_hexdigest(block.encode("utf-8"))
+
+        if message_hash == coder._last_child_agent_hash:
+            return  # No change in sub-agent states, skip adding message
+
+        coder._last_child_agent_hash = message_hash
+
         ConversationService.get_manager(coder).add_message(
             message_dict={"role": "user", "content": block},
             tag=MessageTag.STATIC,
-            priority=DEFAULT_TAG_PRIORITY[MessageTag.REMINDER] + 25,  # After post_message blocks
-            mark_for_delete=0,
-            hash_key=("sub_agent_states",),
-            force=True,
+            priority=DEFAULT_TAG_PRIORITY[
+                MessageTag.CUR
+            ],  # Inject on change in normal message sequence
+            hash_key=("sub_agent_states", str(time.monotonic_ns())),
         )
 
     def defer_removal(self, file_path: str):

{cecli_dev-1.2.3rc4 → cecli_dev-1.3.0rc1}/cecli/helpers/hashline.py

@@ -1341,28 +1341,43 @@ def _honor_cancellations(resolved_ops):
 
 def _deduplicate_ranges(resolved_ops):
     """
-    Deduplicate operations that start on the same line.
-    If multiple operations start on the same line, keep only the latest one.
-    This handles cases where a model might generate multiple operations for the same line while "thinking"
+    Deduplicate operations that target the same line and operation type.
+
+    Inserts are anchored after their target line, so an insert and a replace
+    sharing a start index are independent operations and must both be retained.
+    Multiple operations of the same type still keep only the latest one.
+
+    Returns:
+        tuple: (deduplicated_ops, dropped_ops) where dropped_ops describes the
+        operations that were removed so callers can surface them as failures.
     """
     deduplicated_ops = []
-    # Group operations by start_idx
-    start_idx_to_ops = {}
-    # Loop to group operations by their start index
+    dropped = []
+    ops_by_key = {}
+
     for op in resolved_ops:
-        start_idx = op["start_idx"]
-        if start_idx not in start_idx_to_ops:
-            start_idx_to_ops[start_idx] = []
-        start_idx_to_ops[start_idx].append(op)
-
-    # For each start_idx, keep only the operation with the highest original index (latest in the list)
-    # Loop to select only the latest operation per start index
-    for start_idx, ops in start_idx_to_ops.items():
-        # Sort by original index descending and take the first one
+        key = (op["start_idx"], op["op"]["operation"])
+        ops_by_key.setdefault(key, []).append(op)
+
+    for ops in ops_by_key.values():
         ops.sort(key=lambda x: x["index"], reverse=True)
-        deduplicated_ops.append(ops[0])
+        kept = ops[0]
+        deduplicated_ops.append(kept)
+
+        for dropped_op in ops[1:]:
+            dropped.append(
+                {
+                    "index": dropped_op["index"],
+                    "error": (
+                        f"Edit {dropped_op['index'] + 1} targets the same start line and "
+                        f"operation type as Edit {kept['index'] + 1} and was not applied"
+                    ),
+                    "operation": dropped_op["op"],
+                    "failure_type": "not_applied",
+                }
+            )
 
-    return deduplicated_ops
+    return deduplicated_ops, dropped
 
 
 def _honor_special_markers(resolved_ops):
@@ -1376,9 +1391,21 @@ def _honor_special_markers(resolved_ops):
        starting between beginning of file and that end hash.
     3. If an operation has a normal start hash and "000@" as end hash,
        remove any operations ending between that start hash and end of file.
+
+    Returns:
+        tuple: (remaining_ops, dropped_ops) where dropped_ops describes the
+        operations removed by the special markers so callers can surface them
+        as failures instead of silently discarding them.
     """
     if not resolved_ops:
-        return resolved_ops
+        return resolved_ops, []
+
+    def _drop(op, reason):
+        return {
+            "index": op["index"],
+            "error": f"Edit {op['index'] + 1} {reason}",
+            "operation": op["op"],
+        }
 
     # Check for full file replacement (@000 to 000@)
     for op in resolved_ops:
@@ -1388,7 +1415,12 @@ def _honor_special_markers(resolved_ops):
 
         if start_hash == "@000" and end_hash == "000@":
             # This operation replaces the entire file, keep only this one
-            return [op]
+            dropped = [
+                _drop(other, "was superseded by a full-file replacement (@000..000@)")
+                for other in resolved_ops
+                if other is not op
+            ]
+            return [op], dropped
 
     # Track which operations have special markers
     has_special_marker = [False] * len(resolved_ops)
@@ -1399,8 +1431,8 @@ def _honor_special_markers(resolved_ops):
         if start_hash == "@000" or end_hash == "000@":
             has_special_marker[i] = True
 
-    # Mark operations for removal
-    ops_to_remove = set()
+    # Mark operations for removal, along with the reason they were removed
+    ops_to_remove = {}
 
     for i, op in enumerate(resolved_ops):
         original_op = op["op"]
@@ -1416,7 +1448,10 @@ def _honor_special_markers(resolved_ops):
                 if j != i and not has_special_marker[j]:
                     other_start_idx = other_op["start_idx"]
                     if other_start_idx <= end_idx:
-                        ops_to_remove.add(j)
+                        ops_to_remove.setdefault(
+                            j,
+                            "was superseded by an operation starting at the top of the file (@000)",
+                        )
         elif end_hash == "000@":
             # Operation ends at end of file
             # Remove any operations ending at or after this operation's start_idx
@@ -1426,26 +1461,39 @@ def _honor_special_markers(resolved_ops):
                 if j != i and not has_special_marker[j]:
                     other_end_idx = other_op["end_idx"]
                     if other_end_idx >= start_idx:
-                        ops_to_remove.add(j)
+                        ops_to_remove.setdefault(
+                            j,
+                            "was superseded by an operation ending at the bottom of the file (000@)",
+                        )
 
     # Filter out operations marked for removal
     result = []
+    dropped = []
     for i, op in enumerate(resolved_ops):
         if i not in ops_to_remove:
             result.append(op)
+        else:
+            dropped.append(_drop(op, ops_to_remove[i]))
 
-    return result
+    return result, dropped
 
 
 def _merged_contained_ranges(resolved_ops):
     """
     Discard inner ranges that are completely contained within outer ranges.
     This prevents redundant operations and potential errors.
+
+    Returns:
+        tuple: (optimized_ops, dropped_ops) where dropped_ops describes the
+        contained operations that were removed so callers can surface them
+        as failures instead of silently discarding them.
     """
     optimized_ops = []
+    dropped = []
     # Loop to remove operations that are completely contained within other operations
     for i, op_a in enumerate(resolved_ops):
         keep_op = True
+        container = None
 
         # Check if this operation is contained within any other operation
         for j, op_b in enumerate(resolved_ops):
@@ -1466,13 +1514,25 @@ def _merged_contained_ranges(resolved_ops):
                     # Keep both operations if they have different types
                     continue
                 # op_a is inside op_b, discard op_a
+                container = op_b
                 keep_op = False
                 break
 
         if keep_op:
             optimized_ops.append(op_a)
+        else:
+            dropped.append(
+                {
+                    "index": op_a["index"],
+                    "error": (
+                        f"Edit {op_a['index'] + 1} range is contained within "
+                        f"Edit {container['index'] + 1} and was not applied"
+                    ),
+                    "operation": op_a["op"],
+                }
+            )
 
-    return optimized_ops
+    return optimized_ops, dropped
 
 
 def sort_ranges(op):
@@ -2002,13 +2062,6 @@ def apply_hashline_operations(
 
     if not normalized_operations:
         return original_content, [], failed_ops
-    # Convert insert operations without @000 marker to inclusive replace operations
-    for op in normalized_operations:
-        if op["operation"] == "insert":
-            start_hash_fragment, _, _ = parse_hashline(op["start_line_hash"])
-            if start_hash_fragment != "@000" and start_hash_fragment != "000@":
-                op["operation"] = "replace"
-                op["end_line_hash"] = op["start_line_hash"]
 
     # Apply hashline to original content once
     # This converts content to hashed lines for line tracking
@@ -2029,6 +2082,9 @@ def apply_hashline_operations(
                     # Genesis anchor - if empty, insert at 0. If not empty, insert at -1
                     # so that hashed_lines.insert(found_start + 1, text) inserts at 0.
                     found_start = 0 if not hashed_lines else -1
+                elif start_hash_fragment == "000@":
+                    # Bottom-of-file anchor - insert after the last line
+                    found_start = len(hashed_lines) - 1 if hashed_lines else -1
                 else:
                     # Try exact match first for insert operations
                     found_start = find_hashline_by_exact_match(
@@ -2100,14 +2156,23 @@ def apply_hashline_operations(
 
     # Honor cancellations: remove operations that are cancelled by later cancel operations
     resolved_ops = _honor_cancellations(resolved_ops)
-    # Deduplicate: if multiple operations start on the same line, keep only the latest one
-    # This handles cases where a model might generate multiple operations for the same line while "thinking"
-    resolved_ops = _deduplicate_ranges(resolved_ops)
+    # Deduplicate: if multiple operations start on the same line, keep only the latest one.
+    # This handles cases where a model might generate multiple operations for the same line while "thinking".
+    # Dropped operations are surfaced as failures instead of being silently discarded.
+    resolved_ops, dropped = _deduplicate_ranges(resolved_ops)
+    for drop in dropped:
+        failed_ops.append(drop)
+
     # Honor special markers: handle @000 and 000@ special markers for whole-file or partial-file operations
-    resolved_ops = _honor_special_markers(resolved_ops)
-    # Optimize: discard inner ranges that are completely contained within outer ranges
-    # This prevents redundant operations and potential errors
-    resolved_ops = _merged_contained_ranges(resolved_ops)
+    resolved_ops, dropped = _honor_special_markers(resolved_ops)
+    for drop in dropped:
+        failed_ops.append(drop)
+
+    # Optimize: discard inner ranges that are completely contained within outer ranges.
+    # This prevents redundant operations and potential errors.
+    resolved_ops, dropped = _merged_contained_ranges(resolved_ops)
+    for drop in dropped:
+        failed_ops.append(drop)
     # Merge contiguous replace operations
     resolved_ops = _merge_replace_operations(resolved_ops)
 
@@ -2140,19 +2205,22 @@ def apply_hashline_operations(
             op = resolved["op"]
             start_idx = resolved["start_idx"]
             end_idx = resolved["end_idx"]
+            changed = True
 
             if op["operation"] == "insert":
                 text = op["text"]
-                if text and not text.endswith("\n"):
-                    text += "\n"
-                # Special handling for empty hashed_lines (genesis anchor case)
-                if hashed_lines:
-                    if not hashed_lines[start_idx].endswith("\n"):
-                        hashed_lines[start_idx] += "\n"
-                    hashed_lines.insert(start_idx + 1, text)
+                if not text:
+                    changed = False
                 else:
-                    # Empty content with genesis anchor - just add the text
-                    hashed_lines.append(text)
+                    if not text.endswith("\n"):
+                        text += "\n"
+                    # Special handling for empty hashed_lines (genesis anchor case)
+                    if hashed_lines:
+                        if not hashed_lines[start_idx].endswith("\n"):
+                            hashed_lines[start_idx] += "\n"
+                        hashed_lines.insert(start_idx + 1, text)
+                    else:
+                        hashed_lines.append(text)
             elif op["operation"] == "delete":
                 del hashed_lines[start_idx : end_idx + 1]
             elif op["operation"] == "replace":
@@ -2161,6 +2229,13 @@ def apply_hashline_operations(
                     end_idx = len(hashed_lines) - 1
 
                 text = op["text"]
+                # Snapshot the pre-edit range content so no-op replacements are
+                # not counted as successful edits. Normalize line endings because
+                # the apply path enforces a trailing newline on replacement lines.
+                before_range = [
+                    strip_hashline(line).rstrip("\r\n")
+                    for line in hashed_lines[start_idx : end_idx + 1]
+                ]
                 if text:
                     # Split text into lines, preserving trailing newline behavior
                     # If text doesn't end with newline, we add one to ensure proper line separation
@@ -2207,12 +2282,31 @@ def apply_hashline_operations(
 
                 else:
                     # Empty text - replace with nothing (delete)
+                    replacement_lines = []
                     hashed_lines[start_idx : end_idx + 1] = []
 
-            if "merged_indices" in resolved:
-                successful_ops.extend(resolved["merged_indices"])
+                replacement_content = [line.rstrip("\r\n") for line in replacement_lines]
+                if before_range == replacement_content:
+                    changed = False
+
+            if changed:
+                if "merged_indices" in resolved:
+                    successful_ops.extend(resolved["merged_indices"])
+                else:
+                    successful_ops.append(resolved["index"])
             else:
-                successful_ops.append(resolved["index"])
+                # No-op edit: report it as failed so the caller's success count
+                # reflects edits that actually changed the file
+                indices = resolved.get("merged_indices") or [resolved["index"]]
+                for idx in indices:
+                    failed_ops.append(
+                        {
+                            "index": idx,
+                            "error": "Edit resulted in no changes to the file content",
+                            "operation": op,
+                            "failure_type": "no_change",
+                        }
+                    )
         except Exception as e:
             failed_ops.append(
                 {"index": resolved["index"], "error": str(e), "operation": resolved["op"]}

{cecli_dev-1.2.3rc4 → cecli_dev-1.3.0rc1}/cecli/helpers/hashpos/hashpos.py

@@ -76,7 +76,7 @@ class HashPos:
 
     # Loose prefix for robust stripping: Matches a tilde-wrapped 4-char string containing non-ASCII
     _LOOSE_PREFIX_RE = re.compile(
-        rf"^{HASH_DELIMITER}(?=.{{0,3}}[^\x00-\x7f]).{{4}}{HASH_DELIMITER}"
+        rf"^[{HASH_DELIMITER}]?(?=.{{0,3}}[^\x00-\x7f]).{{4}}{HASH_DELIMITER}"
     )
 
     def __init__(self, source_text: str = ""):

{cecli_dev-1.2.3rc4 → cecli_dev-1.3.0rc1}/cecli/helpers/llms/config.py

@@ -143,8 +143,8 @@ def resolve_model_config(model: str) -> Dict[str, Any]:
 
     # Effective cache flags for the domain adapters. Anthropic messages-API
     # models never cache "by default": prompt caching only happens when the
-    # request carries explicit ``cache_control`` breakpoints, so the messages
-    # domain injects them (agent.cache_control True + caches_by_default False).
+    # request asks for it, so the messages domain requests top-level automatic
+    # caching (agent.cache_control True + caches_by_default False).
     if family == "messages":
         agent_block["cache_control"] = True
         agent_block["caches_by_default"] = False

{cecli_dev-1.2.3rc4 → cecli_dev-1.3.0rc1}/cecli/helpers/llms/domains/chat.py

@@ -274,14 +274,18 @@ def parse_chat_chunk(data: Dict[str, Any]) -> Optional[CompletionChunk]:
 
     # Tool-call deltas arrive as fragments keyed by provider ``index``: the
     # first fragment carries id+name, later fragments only argument deltas.
-    # Preserve that contract -- consumers (base_coder / stream_chunk_builder)
-    # merge fragments by index and concatenate the ``_fragment`` JSON.
+    # Preserve the raw index AND the id -- consumers (base_coder /
+    # stream_chunk_builder) key by id when present and fall back to the index,
+    # so parallel calls that reuse index0 (e.g. deepseek) are not collapsed.
     for tc in delta.get("tool_calls") or []:
         fn = tc.get("function") or {}
         args_raw = fn.get("arguments") or ""
         tool_calls.append(
             ToolCall(
-                id=tc.get("id", ""), name=fn.get("name", ""), arguments={"_fragment": args_raw}
+                id=tc.get("id", ""),
+                name=fn.get("name", ""),
+                index=tc.get("index"),
+                arguments={"_fragment": args_raw},
             )
         )