cecli-dev 1.2.3rc4__tar.gz → 1.2.3rc5__tar.gz

{cecli_dev-1.2.3rc4 → cecli_dev-1.2.3rc5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.2.3rc4
+Version: 1.2.3rc5
 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.3rc4 → cecli_dev-1.2.3rc5}/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.2.3rc5'
+__version_tuple__ = version_tuple = (1, 2, 3, 'rc5')
 
-__commit_id__ = commit_id = 'g0cce57c1b'
+__commit_id__ = commit_id = 'ge39a10435'

{cecli_dev-1.2.3rc4 → cecli_dev-1.2.3rc5}/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.2.3rc5}/cecli/helpers/llms/domains/messages.py

@@ -33,9 +33,6 @@ from ..utils import split_data_url, sse_json_lines, system_prompt
 
 DEFAULT_TIMEOUT = 120.0
 
-#: Anthropic allows at most 4 ``cache_control`` breakpoints per request.
-MAX_CACHE_BREAKPOINTS = 4
-
 
 def anthropic_payload(
     resolved: Dict[str, Any],
@@ -98,14 +95,13 @@ def anthropic_payload(
     extra_body.pop("thinking", None)
     payload.update(extra_body)
 
-    # Anthropic prompt caching is a byte-exact prefix match: it only happens
-    # when the request carries explicit ``cache_control`` breakpoints. The
-    # model config flags messages-API models ``cache_control`` True and
-    # ``caches_by_default`` False (see config.resolve_model_config), so the
-    # messages domain owns the marking here rather than the conversation
-    # manager.
+    # Anthropic prompt caching: request automatic caching via the top-level
+    # ``cache_control`` field. The model config flags messages-API models
+    # ``cache_control`` True and ``caches_by_default`` False (see
+    # config.resolve_model_config), so the messages domain requests it here
+    # rather than managing explicit per-block breakpoints.
     if agent_block.get("cache_control") and not agent_block.get("caches_by_default"):
-        _apply_anthropic_cache_control(payload)
+        payload["cache_control"] = {"type": "ephemeral"}
 
     return payload
 
@@ -627,140 +623,6 @@ def _anthropic_user_blocks(content: List[Dict[str, Any]]) -> List[Dict[str, Any]
     return blocks
 
 
-def _apply_anthropic_cache_control(payload: Dict[str, Any]) -> None:
-    """Attach ephemeral ``cache_control`` breakpoints to a copy of the stream.
-
-    Anthropic prompt caching is a byte-exact prefix match: a breakpoint on the
-    last content block of a message caches every token up to and including it.
-    Following the conversation manager's placement (``manager.py
-    _add_cache_control``), we mark the three stable boundaries of a multi-turn
-    exchange:
-
-    - the last system block at the start of the stream (which also covers the
-      tool definitions rendered before it), and
-    - the last content block of the two most recent non-tool user/assistant
-      turns.
-
-    The message stream is copied and only the key messages are replaced, so
-    caller-owned lists are never mutated. Anthropic allows at most
-    ``MAX_CACHE_BREAKPOINTS`` breakpoints per request, so the marking stops
-    early once that budget (including any caller-supplied markers) is
-    exhausted.
-    """
-    import copy
-
-    budget = MAX_CACHE_BREAKPOINTS - _count_cache_breakpoints(payload)
-
-    if budget <= 0:
-        return
-
-    system = payload.get("system")
-
-    if isinstance(system, str):
-        payload["system"] = [
-            {"type": "text", "text": system, "cache_control": {"type": "ephemeral"}}
-        ]
-        budget -= 1
-
-    elif isinstance(system, list) and system:
-        system = list(system)
-        last = system[-1]
-
-        if isinstance(last, dict):
-            last = copy.deepcopy(last)
-            system[-1] = last
-
-        if _mark_cache_breakpoint(last):
-            budget -= 1
-
-        payload["system"] = system
-
-    messages = payload.get("messages") or []
-    result = list(messages)
-    marked = 0
-
-    for i in range(len(result) - 1, -1, -1):
-        if marked >= 2 or budget <= 0:
-            break
-
-        msg = result[i]
-
-        if _is_tool_turn(msg):
-            continue
-
-        content = msg.get("content")
-
-        if isinstance(content, str):
-            msg = copy.deepcopy(msg)
-            msg["content"] = [
-                {"type": "text", "text": content, "cache_control": {"type": "ephemeral"}}
-            ]
-            result[i] = msg
-            marked += 1
-            budget -= 1
-
-        elif isinstance(content, list) and content:
-            msg = copy.deepcopy(msg)
-            blocks = list(msg["content"])
-
-            if _mark_cache_breakpoint(blocks[-1]):
-                marked += 1
-                budget -= 1
-
-            msg["content"] = blocks
-            result[i] = msg
-
-    payload["messages"] = result
-
-
-def _count_cache_breakpoints(payload: Dict[str, Any]) -> int:
-    """Count existing ``cache_control`` markers in a payload (system + messages)."""
-    count = 0
-    system = payload.get("system")
-
-    if isinstance(system, list):
-        count += sum(isinstance(block, dict) and "cache_control" in block for block in system)
-
-    for tool in payload.get("tools") or []:
-        if isinstance(tool, dict) and "cache_control" in tool:
-            count += 1
-
-    for msg in payload.get("messages") or []:
-        content = msg.get("content")
-
-        if isinstance(content, list):
-            count += sum(isinstance(block, dict) and "cache_control" in block for block in content)
-
-    return count
-
-
-def _mark_cache_breakpoint(block: Any) -> bool:
-    """Add an ephemeral breakpoint to ``block`` unless it already has one."""
-    if not isinstance(block, dict) or "cache_control" in block:
-        return False
-
-    block["cache_control"] = {"type": "ephemeral"}
-
-    return True
-
-
-def _is_tool_turn(msg: Dict[str, Any]) -> bool:
-    """True when a wire message is a tool turn (transient content).
-
-    Matches the conversation manager's placement, which skips tool messages
-    and assistant tool-call turns when choosing cache breakpoints.
-    """
-    content = msg.get("content")
-
-    if not isinstance(content, list) or not content:
-        return False
-
-    return any(
-        isinstance(block, dict) and block.get("type") in ("tool_result", "tool_use")
-        for block in content
-    )
-
-
 def _coalesce_anthropic_messages(wire_messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     """Merge consecutive user turns into a single user message.
 

{cecli_dev-1.2.3rc4 → cecli_dev-1.2.3rc5}/cecli/helpers/model_config/agent.py

@@ -57,9 +57,9 @@ def derive_agent_config(provider: Optional[str], route: str, record: Optional[Di
         # assuming caching support.
         #
         # Anthropic messages-API models never cache "by default": prompt
-        # caching only happens when the request carries explicit
-        # ``cache_control`` breakpoints (injected by the llms messages
-        # domain), so keep ``caches_by_default`` off for them.
+        # caching only happens when the request asks for it (the llms
+        # messages domain requests top-level automatic caching), so keep
+        # ``caches_by_default`` off for them.
         "caches_by_default": (
             not uses_messages_api
             and (bool(record.get("cache_read_input_token_cost")) if record else True)

{cecli_dev-1.2.3rc4 → cecli_dev-1.2.3rc5}/cecli_dev.egg-info/PKG-INFO

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

@@ -1,7 +1,7 @@
 {
-  "tag": "1.2.3rc4",
+  "tag": "1.2.3rc5",
   "distance": 0,
-  "node": "g0cce57c1b8208c7067fb545241fa84b5bf17f790",
+  "node": "ge39a10435929175aa20c7cdc45ce7b6e39253c1f",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-19"

cecli_dev-1.2.3rc5/tests/helpers/test_llms_cache_control.py

@@ -0,0 +1,121 @@
+"""Cache-control tests for the anthropic messages domain.
+
+``anthropic_payload`` must request automatic caching via the top-level
+``cache_control`` field for messages-API models (the model config flags them
+``cache_control`` True + ``caches_by_default`` False), while chat-family
+models keep their own caching semantics and receive no such field.
+
+No network: only the offline payload builder and helpers are exercised.
+"""
+
+from cecli.helpers.llms.config import resolve_model_config
+from cecli.helpers.llms.domains.messages import (
+    _anthropic_usage,
+    anthropic_payload,
+)
+
+SYS = "You are cecli, an agentic coding assistant. " * 30
+
+MULTI_TURN = [
+    {"role": "system", "content": SYS},
+    {"role": "user", "content": "first question"},
+    {"role": "assistant", "content": "first answer"},
+    {"role": "user", "content": "second question"},
+    {
+        "role": "assistant",
+        "content": "I'll check",
+        "tool_calls": [
+            {"id": "t1", "type": "function", "function": {"name": "read", "arguments": "{}"}}
+        ],
+    },
+    {"role": "tool", "tool_call_id": "t1", "content": "result of tool"},
+    {"role": "assistant", "content": "second answer"},
+    {"role": "user", "content": "current question"},
+]
+
+
+def _content_blocks(payload):
+    """All content blocks in the payload (system + messages), flattened."""
+    blocks = []
+
+    system = payload.get("system")
+
+    if isinstance(system, list):
+        blocks.extend(system)
+
+    for msg in payload.get("messages") or []:
+        content = msg.get("content")
+
+        if isinstance(content, list):
+            blocks.extend(content)
+
+    return blocks
+
+
+def test_messages_api_requests_top_level_cache_control():
+    resolved = resolve_model_config("github_copilot/claude-sonnet-5")
+    payload = anthropic_payload(resolved, MULTI_TURN, None, False, {})
+
+    assert resolved["family"] == "messages"
+    assert payload["cache_control"] == {"type": "ephemeral"}
+    assert all("cache_control" not in block for block in _content_blocks(payload))
+
+
+def test_single_turn_requests_top_level_cache_control():
+    resolved = resolve_model_config("claude-sonnet-5")
+    payload = anthropic_payload(resolved, [{"role": "user", "content": "hi"}], None, False, {})
+
+    assert payload["cache_control"] == {"type": "ephemeral"}
+
+
+def test_chat_family_claude_keeps_own_caching_semantics():
+    resolved = resolve_model_config("openrouter/claude-sonnet-5")
+    payload = anthropic_payload(
+        resolved,
+        [{"role": "system", "content": SYS}, {"role": "user", "content": "hi"}],
+        None,
+        False,
+        {},
+    )
+
+    # Chat-family claude keeps its own caching semantics: no top-level field.
+    assert resolved["family"] == "chat"
+    assert "cache_control" not in payload
+
+
+def test_anthropic_usage_normalizes_full_input():
+    """Prompt tokens include cached input so hit-rate and cost math stay sane.
+
+    Anthropic's ``input_tokens`` excludes cached input; the cache read and write
+    tokens arrive in separate fields. ``base_coder.calculate_and_show_tokens_and_cost``
+    expects ``prompt_tokens`` to be the total input (cache_creation + cache_read
+    + input), otherwise the cache hit-rate blows up (e.g. a 9249-token cache read
+    against a 2-token ``input_tokens`` shows a ~462450% hit rate).
+    """
+    usage = _anthropic_usage(
+        {
+            "input_tokens": 2,
+            "output_tokens": 20,
+            "cache_read_input_tokens": 9249,
+            "cache_creation_input_tokens": 77,
+            "output_tokens_details": {"thinking_tokens": 0},
+        }
+    )
+
+    assert usage.prompt_tokens == 2 + 9249 + 77
+    assert usage.completion_tokens == 20
+    assert usage.total_tokens == 2 + 9249 + 77
+    assert usage.cache_read_input_tokens == 9249
+    assert usage.cache_creation_input_tokens == 77
+    assert usage.completion_tokens_details == {"reasoning_tokens": 0}
+
+
+def test_anthropic_usage_without_cache_keys_keeps_openai_shape():
+    """A usage block with no cache fields still normalizes to plain counts."""
+    usage = _anthropic_usage({"input_tokens": 10, "output_tokens": 5})
+
+    assert usage.prompt_tokens == 10
+    assert usage.completion_tokens == 5
+    assert usage.total_tokens == 10
+    assert usage.cache_read_input_tokens is None
+    assert usage.cache_creation_input_tokens is None

cecli_dev-1.2.3rc4/tests/helpers/test_llms_cache_control.py

@@ -1,192 +0,0 @@
-"""Cache-control breakpoint injection tests for the anthropic messages domain.
-
-``anthropic_payload`` must attach ephemeral ``cache_control`` breakpoints at the
-stable boundaries of a multi-turn exchange (last system block + the two most
-recent non-tool user/assistant turns), following the conversation manager's
-placement, while:
-
-- never mutating caller-owned message dicts (key messages are replaced with
-  copies), and
-- never exceeding Anthropic's 4-breakpoint per-request limit, even when the
-  caller already supplied markers (so breakpoints never pile up between turns).
-
-No network: only the offline payload builder and helpers are exercised.
-"""
-
-from cecli.helpers.llms.config import resolve_model_config
-from cecli.helpers.llms.domains.messages import (
-    MAX_CACHE_BREAKPOINTS,
-    _anthropic_usage,
-    _apply_anthropic_cache_control,
-    _count_cache_breakpoints,
-    anthropic_payload,
-)
-
-SYS = "You are cecli, an agentic coding assistant. " * 30
-
-MULTI_TURN = [
-    {"role": "system", "content": SYS},
-    {"role": "user", "content": "first question"},
-    {"role": "assistant", "content": "first answer"},
-    {"role": "user", "content": "second question"},
-    {
-        "role": "assistant",
-        "content": "I'll check",
-        "tool_calls": [
-            {"id": "t1", "type": "function", "function": {"name": "read", "arguments": "{}"}}
-        ],
-    },
-    {"role": "tool", "tool_call_id": "t1", "content": "result of tool"},
-    {"role": "assistant", "content": "second answer"},
-    {"role": "user", "content": "current question"},
-]
-
-
-def _block_cache_control(block):
-    return block.get("cache_control") if isinstance(block, dict) else None
-
-
-def _last_block(msg):
-    content = msg["content"]
-    return content[-1] if isinstance(content, list) else content
-
-
-def _resolve_no_inject():
-    """Resolved config with auto-injection disabled (for helper-level tests)."""
-    resolved = resolve_model_config("github_copilot/claude-sonnet-5")
-    return dict(resolved, agent_block={"cache_control": False, "caches_by_default": True})
-
-
-def test_messages_api_injects_system_and_last_two_turns():
-    resolved = resolve_model_config("github_copilot/claude-sonnet-5")
-    payload = anthropic_payload(resolved, MULTI_TURN, None, False, {})
-
-    assert resolved["family"] == "messages"
-    assert isinstance(payload["system"], list)
-    assert _block_cache_control(payload["system"][-1]) == {"type": "ephemeral"}
-
-    # Tool-result and tool-use turns are skipped; only the last two non-tool
-    # turns (assistant "second answer", user "current question") carry a
-    # breakpoint.
-    marked = [
-        i
-        for i, msg in enumerate(payload["messages"])
-        if _block_cache_control(_last_block(msg)) == {"type": "ephemeral"}
-    ]
-    assert marked == [5, 6]
-    assert _count_cache_breakpoints(payload) == 3
-
-
-def test_single_turn_marks_last_block_only():
-    resolved = resolve_model_config("claude-sonnet-5")
-    payload = anthropic_payload(resolved, [{"role": "user", "content": "hi"}], None, False, {})
-
-    assert _block_cache_control(_last_block(payload["messages"][0])) == {"type": "ephemeral"}
-    assert _count_cache_breakpoints(payload) == 1
-
-
-def test_chat_family_claude_not_injected():
-    resolved = resolve_model_config("openrouter/claude-sonnet-5")
-    payload = anthropic_payload(
-        resolved,
-        [{"role": "system", "content": SYS}, {"role": "user", "content": "hi"}],
-        None,
-        False,
-        {},
-    )
-
-    # Chat-family claude keeps its own caching semantics: no injection.
-    assert resolved["family"] == "chat"
-    assert isinstance(payload["system"], str)
-    assert _count_cache_breakpoints(payload) == 0
-
-
-def test_apply_does_not_mutate_input_messages():
-    payload = anthropic_payload(_resolve_no_inject(), MULTI_TURN, None, False, {})
-    before = list(payload["messages"])
-    _apply_anthropic_cache_control(payload)
-
-    # Original wire message dicts are untouched; marked messages were replaced
-    # with copies.
-    for msg in before:
-        content = msg["content"]
-
-        if isinstance(content, list):
-            for block in content:
-                assert "cache_control" not in block
-
-
-def test_breakpoint_budget_never_exceeds_four():
-    for pre in range(0, MAX_CACHE_BREAKPOINTS + 1):
-        payload = anthropic_payload(_resolve_no_inject(), MULTI_TURN, None, False, {})
-
-        for i in range(pre):
-            content = payload["messages"][i]["content"]
-
-            if isinstance(content, str):
-                payload["messages"][i]["content"] = [
-                    {"type": "text", "text": content, "cache_control": {"type": "ephemeral"}}
-                ]
-            else:
-                content[-1]["cache_control"] = {"type": "ephemeral"}
-
-        _apply_anthropic_cache_control(payload)
-
-        assert _count_cache_breakpoints(payload) <= MAX_CACHE_BREAKPOINTS
-
-
-def test_breakpoints_do_not_pile_up_across_turns():
-    resolved = resolve_model_config("github_copilot/claude-sonnet-5")
-    history = [
-        {"role": "user", "content": "q1"},
-        {"role": "assistant", "content": "a1"},
-    ]
-
-    for turn in range(3):
-        history.append({"role": "user", "content": f"q{turn + 2}"})
-        history.append({"role": "assistant", "content": f"a{turn + 2}"})
-        payload = anthropic_payload(
-            resolved, [{"role": "system", "content": SYS}] + history, None, False, {}
-        )
-
-        # Always exactly system + the two most recent non-tool turns; older
-        # history never accumulates extra breakpoints.
-        assert _count_cache_breakpoints(payload) == 3
-
-
-def test_anthropic_usage_normalizes_full_input():
-    """Prompt tokens include cached input so hit-rate and cost math stay sane.
-
-    Anthropic's ``input_tokens`` excludes cached input; the cache read and write
-    tokens arrive in separate fields. ``base_coder.calculate_and_show_tokens_and_cost``
-    expects ``prompt_tokens`` to be the total input (cache_creation + cache_read
-    + input), otherwise the cache hit-rate blows up (e.g. a 9249-token cache read
-    against a 2-token ``input_tokens`` shows a ~462450% hit rate).
-    """
-    usage = _anthropic_usage(
-        {
-            "input_tokens": 2,
-            "output_tokens": 20,
-            "cache_read_input_tokens": 9249,
-            "cache_creation_input_tokens": 77,
-            "output_tokens_details": {"thinking_tokens": 0},
-        }
-    )
-
-    assert usage.prompt_tokens == 2 + 9249 + 77
-    assert usage.completion_tokens == 20
-    assert usage.total_tokens == 2 + 9249 + 77
-    assert usage.cache_read_input_tokens == 9249
-    assert usage.cache_creation_input_tokens == 77
-    assert usage.completion_tokens_details == {"reasoning_tokens": 0}
-
-
-def test_anthropic_usage_without_cache_keys_keeps_openai_shape():
-    """A usage block with no cache fields still normalizes to plain counts."""
-    usage = _anthropic_usage({"input_tokens": 10, "output_tokens": 5})
-
-    assert usage.prompt_tokens == 10
-    assert usage.completion_tokens == 5
-    assert usage.total_tokens == 10
-    assert usage.cache_read_input_tokens is None
-    assert usage.cache_creation_input_tokens is None