cecli-dev 1.2.2rc2__py3-none-any.whl → 1.2.3rc2__py3-none-any.whl

cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.2rc2'
-__version_tuple__ = version_tuple = (1, 2, 2, 'rc2')
+__version__ = version = '1.2.3rc2'
+__version_tuple__ = version_tuple = (1, 2, 3, 'rc2')
 
-__commit_id__ = commit_id = 'gfedaa5649'
+__commit_id__ = commit_id = 'ga5ff62c22'

cecli/helpers/conversation/manager.py

@@ -358,18 +358,6 @@ class ConversationManager:
             with safe_open(".cecli/logs/conversation.log", "w") as f:
                 json.dump(messages_dict, f, indent=4, default=lambda o: "<not serializable>")
 
-        # Add cache control headers when getting all messages (for LLM consumption)
-        # Only add cache control if the coder has add_cache_headers = True
-        if tag is None:
-            if (
-                coder
-                and hasattr(coder, "add_cache_headers")
-                and coder.add_cache_headers
-                and hasattr(coder, "main_model")
-                and not coder.main_model.caches_by_default
-                and not getattr(coder.main_model, "uses_messages_api", False)
-            ):
-                messages_dict = self._add_cache_control(messages_dict)
         return messages_dict
 
     def clear_tag(self, tag: str, ratio: float = 0) -> None:

cecli/helpers/llms/config.py

@@ -28,6 +28,14 @@ PROVIDER_DEFAULTS: Dict[str, Dict[str, Any]] = {
     "github_copilot": {"api_base": "https://api.githubcopilot.com", "api_key_env": None},
     "meta": {"api_base": "https://api.meta.ai/v1", "api_key_env": "META_API_KEY"},
     "chutes": {"api_base": "https://llm.chutes.ai/v1/", "api_key_env": "CHUTES_API_KEY"},
+    "opencode-go": {
+        "api_base": "https://opencode.ai/zen/go/v1",
+        "api_key_env": "OPENCODE_GO_API_KEY",
+    },
+    "opencode-zen": {
+        "api_base": "https://opencode.ai/zen/zen/v1",
+        "api_key_env": "OPENCODE_ZEN_API_KEY",
+    },
 }
 
 

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/models.py

@@ -142,7 +142,6 @@ with importlib.resources.open_text("cecli.resources", "model-settings.yml") as f
 
 
 class ModelInfoManager:
-    MODEL_INFO_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json"
     CACHE_TTL = 60 * 60 * 24
 
     def __init__(self):
@@ -177,28 +176,6 @@ class ModelInfoManager:
             pass
         self._cache_loaded = True
 
-    def _update_cache(self):
-        try:
-            import requests
-
-            response = requests.get(self.MODEL_INFO_URL, timeout=5, verify=self.verify_ssl)
-            if response.status_code == 200:
-                # Use json.dumps(response.json()) instead of response.text for
-                # compatibility with mocked responses in tests
-                parsed = response.json()
-                self._raw_content = json.dumps(parsed)
-                try:
-                    parsed = response.json()
-                    self.cache_file.write_text(json.dumps(parsed, indent=4))
-                except OSError:
-                    pass
-        except Exception as ex:
-            print(str(ex))
-            try:
-                self.cache_file.write_text("{}")
-            except OSError:
-                pass
-
     def _get_entry_from_raw(self, key):
         """Parse a single model entry from raw JSON string without loading the entire dict."""
         return get_entry_from_raw(self._raw_content, key)
@@ -208,8 +185,6 @@ class ModelInfoManager:
         if data:
             return data
         self._load_cache()
-        if not self._raw_content:
-            self._update_cache()
         if not self._raw_content:
             return dict()
         info = self._get_entry_from_raw(model)