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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.2.3rc1
+Version: 1.2.3rc2
 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.3rc2}/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.3rc2'
+__version_tuple__ = version_tuple = (1, 2, 3, 'rc2')
 
-__commit_id__ = commit_id = 'g719764cec'
+__commit_id__ = commit_id = 'ga5ff62c22'

{cecli_dev-1.2.3rc1 → cecli_dev-1.2.3rc2}/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.3rc2}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.2.3rc1
+Version: 1.2.3rc2
 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.3rc2}/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.3rc2}/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.3rc1 → cecli_dev-1.2.3rc2}/cecli_dev.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "1.2.3rc1",
+  "tag": "1.2.3rc2",
   "distance": 0,
-  "node": "g719764cece441d8fbf76096992ebe59b03157839",
+  "node": "ga5ff62c2279a65bcbec68fffb7f36d5e4ec8571b",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-17"

cecli_dev-1.2.3rc2/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.3rc2/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
+    )