cecli-dev 1.1.0rc1__tar.gz → 1.1.0rc4__tar.gz

{cecli_dev-1.1.0rc1 → cecli_dev-1.1.0rc4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.1.0rc1
+Version: 1.1.0rc4
 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.1.0rc1 → cecli_dev-1.1.0rc4}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.1.0rc1'
-__version_tuple__ = version_tuple = (1, 1, 0, 'rc1')
+__version__ = version = '1.1.0rc4'
+__version_tuple__ = version_tuple = (1, 1, 0, 'rc4')
 
-__commit_id__ = commit_id = 'g50ae7d861'
+__commit_id__ = commit_id = 'gc405e1f0a'

{cecli_dev-1.1.0rc1 → cecli_dev-1.1.0rc4}/cecli/coders/agent_coder.py

@@ -27,7 +27,6 @@ from cecli.helpers.similarity import (
 )
 from cecli.helpers.skills import SkillsManager
 from cecli.hooks import HookIntegration
-from cecli.llm import litellm
 from cecli.mcp import LocalServer, McpServerManager
 from cecli.tools.utils.base_tool import BaseTool
 from cecli.tools.utils.registry import ToolRegistry
@@ -364,16 +363,12 @@ class AgentCoder(Coder):
             }
             try:
                 session = await server.connect()
-                call_result = await litellm.experimental_mcp_client.call_openai_tool(
-                    session=session, openai_tool=tool_call_dict
-                )
+                call_result = await self.call_mcp_tool_from_session(session, tool_call_dict)
             except Exception as e:
                 if server.is_session_expired_error(e):
                     try:
                         session = await server.reconnect()
-                        call_result = await litellm.experimental_mcp_client.call_openai_tool(
-                            session=session, openai_tool=tool_call_dict
-                        )
+                        call_result = await self.call_mcp_tool_from_session(session, tool_call_dict)
                     except Exception as retry_exc:
                         self.io.tool_warning(
                             f"Executing {tool_name} on {server.name} failed after reconnect:\n"

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

@@ -851,12 +851,12 @@ class Coder(metaclass=UsageMeta):
         settings_items.append(f"{self.edit_format} (edit format)")
 
         # Thinking tokens
-        thinking_tokens = main_model.get_thinking_tokens()
+        thinking_tokens = self.get_active_model().get_thinking_tokens()
         if thinking_tokens:
             settings_items.append(f"{thinking_tokens} think tokens")
 
         # Reasoning effort
-        reasoning_effort = main_model.get_reasoning_effort()
+        reasoning_effort = self.get_active_model().get_reasoning_effort()
         if reasoning_effort:
             settings_items.append(f"reasoning {reasoning_effort}")
 
@@ -3110,19 +3110,14 @@ class Coder(metaclass=UsageMeta):
 
                         async def do_tool_call():
                             nonlocal session
-                            from litellm import experimental_mcp_client
 
                             try:
-                                return await experimental_mcp_client.call_openai_tool(
-                                    session=session,
-                                    openai_tool=new_tool_call,
-                                )
+                                return await self.call_mcp_tool_from_session(session, new_tool_call)
                             except Exception as e:
                                 if server.is_session_expired_error(e):
                                     session = await server.reconnect()
-                                    return await experimental_mcp_client.call_openai_tool(
-                                        session=session,
-                                        openai_tool=new_tool_call,
+                                    return await self.call_mcp_tool_from_session(
+                                        session, new_tool_call
                                     )
                                 raise
 
@@ -3209,6 +3204,34 @@ class Coder(metaclass=UsageMeta):
 
         return tool_responses
 
+    async def call_mcp_tool_from_session(self, session, tool_call):
+        """Call an MCP tool from an OpenAI-style tool call using the native SDK.
+
+        Accepts either a dict (``{"function": {"name": ..., "arguments": ...}}``)
+        or a tool-call object (e.g. litellm's ChatCompletionMessageToolCall) and
+        invokes the MCP session directly, avoiding litellm's lazily-imported
+        ``experimental_mcp_client`` submodule.
+        """
+        if isinstance(tool_call, dict):
+            function = tool_call.get("function", {})
+            name = function.get("name")
+            arguments = function.get("arguments", {})
+        else:
+            function = getattr(tool_call, "function", None)
+            name = getattr(function, "name", None)
+            arguments = getattr(function, "arguments", {})
+
+        if isinstance(arguments, str):
+            try:
+                arguments = json.loads(arguments)
+            except json.JSONDecodeError:
+                arguments = {}
+
+        if not isinstance(arguments, dict):
+            arguments = {}
+
+        return await session.call_tool(name=name, arguments=arguments)
+
     async def process_tool_calls(self, tool_call_response):
         """Simplified main entry point."""
         # Check if max tool calls exceeded
@@ -4248,15 +4271,12 @@ class Coder(metaclass=UsageMeta):
 
         self.message_tokens_received += completion_tokens
 
-        # Build the new streamlined format
-        tokens_parts = [format_tokens(prompt_tokens)]
-
-        if cache_hit_tokens:
-            tokens_parts.append(f"{format_tokens(cache_hit_tokens)}")
-        if cache_write_tokens:
-            tokens_parts.append(f"{format_tokens(cache_write_tokens)}")
-
-        tokens_str = "/".join(tokens_parts)
+        # Build tokens string as "{prompt} CH {hit_rate:.1f}% ↑ {completion} ↓"
+        if prompt_tokens > 0:
+            hit_rate = round(cache_hit_tokens / prompt_tokens * 100, 1) if cache_hit_tokens else 0.0
+        else:
+            hit_rate = 0.0
+        tokens_str = f"{format_tokens(prompt_tokens)} ◇ {hit_rate:.1f}%"
 
         tokens_report = f"{tokens_str} ↑ {format_tokens(completion_tokens)} ↓"
 
@@ -4271,12 +4291,17 @@ class Coder(metaclass=UsageMeta):
             + self.message_tokens_received
         )
         total_combined_cached = self.total_cached_tokens + self.message_cached_tokens
+        total_input_tokens = self.total_tokens_sent + self.message_tokens_sent
+        if total_input_tokens > 0:
+            total_hit_rate = (
+                round(total_combined_cached / total_input_tokens * 100, 1)
+                if total_combined_cached
+                else 0.0
+            )
+        else:
+            total_hit_rate = 0.0
 
-        total_stats = f"{format_tokens(total_combined_tokens)}"
-        if total_combined_cached:
-            total_stats += f"/{format_tokens(total_combined_cached)}"
-
-        total_stats += " ↑↓"
+        total_stats = f"{format_tokens(total_combined_tokens)} ◇ {total_hit_rate:.1f}% ↑↓"
 
         if not self.get_active_model().info.get("input_cost_per_token"):
             self.usage_report = tokens_report + " " + total_stats

{cecli_dev-1.1.0rc1 → cecli_dev-1.1.0rc4}/cecli/commands/add.py

@@ -132,7 +132,24 @@ class AddCommand(BaseCommand):
                         f" {active_model.name} does not support images."
                     )
                     continue
-                content = io.read_text(abs_file_path)
+                try:
+                    content = io.read_text(abs_file_path)
+                except (ValueError, UnicodeError, UnicodeDecodeError, OSError) as exc:
+                    # Binary or undecodable files (e.g. .git/objects/pack/*.rev)
+                    # raise ValueError("Could not determine text encoding ...")
+                    # from decoding.safe_open. Skip them gracefully instead of
+                    # crashing the session.
+                    msg = str(exc)
+                    if "Could not determine text encoding" in msg or isinstance(
+                        exc, (UnicodeError, UnicodeDecodeError)
+                    ):
+                        io.tool_warning(
+                            f"Skipping {matched_file}: not decodable as text "
+                            "(binary or unknown encoding)"
+                        )
+                    else:
+                        io.tool_error(f"Skipping {matched_file}: {exc}")
+                    continue
                 if content is None:
                     io.tool_error(f"Unable to read {matched_file}")
                 else:

{cecli_dev-1.1.0rc1 → cecli_dev-1.1.0rc4}/cecli/commands/reasoning_effort.py

@@ -14,7 +14,7 @@ class ReasoningEffortCommand(BaseCommand):
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):
         """Execute the reasoning-effort command with given parameters."""
-        model = coder.main_model
+        model = coder.get_active_model()
 
         if not args.strip():
             # Display current value if no args are provided

{cecli_dev-1.1.0rc1 → cecli_dev-1.1.0rc4}/cecli/commands/think_tokens.py

@@ -11,7 +11,7 @@ class ThinkTokensCommand(BaseCommand):
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):
         """Execute the think-tokens command with given parameters."""
-        model = coder.main_model
+        model = coder.get_active_model()
 
         if not args.strip():
             # Display current value if no args are provided

cecli_dev-1.1.0rc4/cecli/helpers/model_config/__init__.py

@@ -0,0 +1,10 @@
+"""Derive default per-model configuration from model metadata.
+
+The model config package turns a flat litellm-style model metadata file into the
+``{api, llm, agent}`` override blocks that :mod:`cecli.models` consumes,
+mirroring the ``model-overrides`` section of ``.cecli.conf.yml``.
+"""
+
+from .pipeline import ModelConfigPipeline, get_default_config
+
+__all__ = ["ModelConfigPipeline", "get_default_config"]

cecli_dev-1.1.0rc4/cecli/helpers/model_config/agent.py

@@ -0,0 +1,40 @@
+"""Derive the ``agent`` override block for a model.
+
+The agent block holds ModelSettings overrides. :mod:`cecli.models` applies each
+of these directly (``setattr``) the same way the ``agent`` section of a
+``model-overrides`` entry is applied.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, Optional
+
+from .identifiers import is_anthropic
+from .utils import supports_reasoning
+
+
+def derive_agent_config(provider: Optional[str], route: str, record: Optional[Dict]) -> Dict:
+    """Return the ``agent`` config block for a model.
+
+    Args:
+        provider: Provider portion of the model name (may be ``None``).
+        route: Model route (name after the provider prefix).
+        record: The matched model metadata record, or ``None`` for unknown models.
+
+    Returns:
+        A dict of ModelSettings overrides (caching, temperature handling).
+    """
+    reasoning = supports_reasoning(record)
+    record = record or {}
+    agent: Dict = {
+        "cache_control": is_anthropic(provider, route, record),
+        # ``cache_read_input_token_cost`` in the metadata is the determinant for
+        # whether a model supports prompt caching. Unknown models default to
+        # assuming caching support.
+        "caches_by_default": bool(record.get("cache_read_input_token_cost")) if record else True,
+    }
+
+    if reasoning or record.get("supports_adaptive_thinking"):
+        agent["use_temperature"] = False
+
+    return agent

cecli_dev-1.1.0rc4/cecli/helpers/model_config/api.py

@@ -0,0 +1,62 @@
+"""Derive the ``api`` override block for a model.
+
+The api block holds request-level parameters. :mod:`cecli.models` merges each
+of these keys into ``extra_params`` the same way the ``api`` section of a
+``model-overrides`` entry is applied.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, Optional
+
+from .identifiers import is_anthropic, is_claude_5_plus, is_gemini_2_5
+from .utils import supports_reasoning
+
+_THINKING_BUDGET_TOKENS = 2048
+#: Default thinking budget for Gemini 2.5 models (Gemini 2.5 Pro's default).
+_GEMINI_THINKING_BUDGET_TOKENS = 8192
+
+
+def derive_api_config(provider: Optional[str], route: str, record: Optional[Dict]) -> Dict:
+    """Return the ``api`` config block for a model.
+
+    Args:
+        provider: Provider portion of the model name (may be ``None``).
+        route: Model route (name after the provider prefix).
+        record: The matched model metadata record, or ``None`` for unknown models.
+
+    Returns:
+        A dict of request-level params (reasoning format, thinking, tool calls).
+    """
+    reasoning = supports_reasoning(record)
+    record = record or {}
+    gemini_2_5 = is_gemini_2_5(provider, route, record)
+    api: Dict = {}
+
+    if reasoning and not gemini_2_5:
+        effort = _default_reasoning_effort(record)
+
+        if effort:
+            api["reasoning_effort"] = effort
+
+    if is_anthropic(provider, route, record) and not is_claude_5_plus(provider, route, record):
+        # Claude 5+ uses adaptive thinking via ``reasoning_effort`` instead of
+        # the ``thinking.type.enabled`` budget block.
+        api["thinking"] = {"type": "enabled", "budget_tokens": _THINKING_BUDGET_TOKENS}
+    elif gemini_2_5:
+        # Gemini 2.5 configures thinking via a token budget; litellm maps the
+        # generic ``thinking`` param onto ``thinkingBudget`` + ``includeThoughts``.
+        api["thinking"] = {"type": "enabled", "budget_tokens": _GEMINI_THINKING_BUDGET_TOKENS}
+
+    if record.get("supports_parallel_function_calling", True):
+        api["parallel_tool_calls"] = True
+
+    return api
+
+
+def _default_reasoning_effort(record):
+    """Default reasoning effort for a reasoning-capable model.
+
+    Always ``medium``; the metadata effort flags are intentionally not used.
+    """
+    return "medium"

cecli_dev-1.1.0rc4/cecli/helpers/model_config/formatters/__init__.py

@@ -0,0 +1,20 @@
+"""Provider-specific helper overrides for the model config pipeline."""
+
+from .reasoning import anthropic_reasoning, format_reasoning, gemini_reasoning, noop
+from .thinking import (
+    anthropic_5_thinking,
+    anthropic_thinking,
+    format_thinking,
+    gemini_thinking,
+)
+
+__all__ = [
+    "format_reasoning",
+    "anthropic_reasoning",
+    "gemini_reasoning",
+    "noop",
+    "format_thinking",
+    "anthropic_thinking",
+    "anthropic_5_thinking",
+    "gemini_thinking",
+]

cecli_dev-1.1.0rc4/cecli/helpers/model_config/formatters/reasoning.py

@@ -0,0 +1,83 @@
+"""Reasoning formatters for the model config pipeline.
+
+These helpers rewrite the generic reasoning effort shape onto the params
+litellm understands for a provider.  ``extra_params`` are the kwargs passed to
+``litellm.acompletion``, so a formatter exposes the effort as a top-level
+litellm param and lets litellm map it onto the provider's own field.  For
+example, Gemini uses ``thinkingConfig`` under the hood: litellm maps a
+top-level ``reasoning_effort`` to ``thinkingLevel`` (Gemini 3) or
+``thinkingBudget`` (Gemini 2.5).  ``set_reasoning_effort`` in
+:mod:`cecli.models` invokes the formatter chosen by the pipeline
+(``helpers.format_reasoning``) after it has applied the generic shape.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, Dict, Optional
+
+from ..identifiers import is_claude_5_plus, is_gemini
+
+
+def format_reasoning(provider: Optional[str], route: str, record: Optional[Dict]) -> Callable:
+    """Return the reasoning formatter for a model.
+
+    Args:
+        provider: Provider portion of the model name (may be ``None``).
+        route: Model route (name after the provider prefix).
+        record: The matched model metadata record, or ``None`` for unknown models.
+
+    Returns:
+        A callable that mutates ``extra_params`` in place.  Unknown models get
+        a noop so ``set_reasoning_effort`` keeps its default behavior.
+    """
+    if is_gemini(provider, route, record):
+        return gemini_reasoning
+
+    if is_claude_5_plus(provider, route, record):
+        return anthropic_reasoning
+
+    return noop
+
+
+def noop(extra_params: Dict) -> Dict:
+    """Default formatter: leave ``extra_params`` untouched."""
+    return extra_params
+
+
+def gemini_reasoning(extra_params: Dict) -> Dict:
+    """Gemini models configure thinking via litellm's ``reasoning_effort``.
+
+    litellm maps the top-level ``reasoning_effort`` kwarg onto Gemini's
+    ``thinkingConfig`` (``thinkingLevel`` for Gemini 3, ``thinkingBudget`` for
+    Gemini 2.5) and sets ``includeThoughts``, so the generic effort is lifted
+    out of ``extra_body``.
+    """
+    return _lift_reasoning_effort(extra_params)
+
+
+def anthropic_reasoning(extra_params: Dict) -> Dict:
+    """Claude 5+ models configure thinking via litellm's ``reasoning_effort``.
+
+    litellm maps the top-level ``reasoning_effort`` kwarg onto
+    ``thinking.type.adaptive`` + ``output_config.effort``, so the generic
+    effort is lifted out of ``extra_body`` and ``extra_body`` is dropped
+    (Anthropic does not accept extra inputs).
+    """
+    params = _lift_reasoning_effort(extra_params)
+    params.pop("extra_body", None)
+    return params
+
+
+def _lift_reasoning_effort(extra_params: Dict) -> Dict:
+    """Move the generic ``reasoning_effort`` out of ``extra_body`` to top level."""
+    extra_body = extra_params.get("extra_body")
+
+    if not isinstance(extra_body, dict):
+        return extra_params
+
+    effort = extra_body.pop("reasoning_effort", None)
+
+    if effort is not None:
+        extra_params["reasoning_effort"] = effort
+
+    return extra_params

cecli_dev-1.1.0rc4/cecli/helpers/model_config/formatters/thinking.py

@@ -0,0 +1,108 @@
+"""Thinking formatters for the model config pipeline.
+
+These helpers rewrite the generic thinking shape onto the params litellm
+understands for a provider.  ``extra_params`` are the kwargs passed to
+``litellm.acompletion``, so a formatter exposes thinking as a top-level litellm
+param and lets litellm map it onto the provider's own field.  For example:
+
+- Gemini uses ``thinkingConfig`` under the hood: litellm maps a top-level
+  anthropic-style ``thinking`` param to ``thinkingBudget`` (Gemini 2.5) or
+  ``thinkingLevel`` (Gemini 3) and sets ``includeThoughts``.
+- Anthropic consumes the top-level ``thinking`` kwarg directly; riding inside
+  ``extra_body`` makes the API reject it as extra inputs.
+
+``set_thinking_tokens`` in :mod:`cecli.models` invokes the formatter chosen by
+the pipeline (``helpers.format_thinking``) after it has applied the generic
+shape.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, Dict, Optional
+
+from ..identifiers import is_anthropic, is_claude_5_plus, is_gemini
+
+
+def format_thinking(provider: Optional[str], route: str, record: Optional[Dict]) -> Callable:
+    """Return the thinking formatter for a model.
+
+    Args:
+        provider: Provider portion of the model name (may be ``None``).
+        route: Model route (name after the provider prefix).
+        record: The matched model metadata record, or ``None`` for unknown models.
+
+    Returns:
+        A callable that mutates ``extra_params`` in place.  Unknown models get
+        a noop so ``set_thinking_tokens`` keeps its default behavior.
+    """
+    if is_gemini(provider, route, record):
+        return gemini_thinking
+
+    if is_anthropic(provider, route, record):
+        if is_claude_5_plus(provider, route, record):
+            # Claude 5+ cannot use thinking.type.enabled; remove it entirely.
+            return anthropic_5_thinking
+
+        return anthropic_thinking
+
+    return noop
+
+
+def noop(extra_params: Dict) -> Dict:
+    """Default formatter: leave ``extra_params`` untouched."""
+    return extra_params
+
+
+def gemini_thinking(extra_params: Dict) -> Dict:
+    """Gemini models configure thinking via litellm's ``thinking`` kwarg.
+
+    litellm maps the top-level anthropic-style ``thinking`` param onto
+    Gemini's ``thinkingConfig`` (``thinkingBudget`` for Gemini 2.5,
+    ``thinkingLevel`` for Gemini 3) and sets ``includeThoughts``, so the
+    generic shape is lifted out of ``extra_body``.
+    """
+    return _lift_thinking(extra_params)
+
+
+def anthropic_thinking(extra_params: Dict) -> Dict:
+    """Anthropic (pre-5) models consume the top-level ``thinking`` kwarg.
+
+    litellm maps the top-level anthropic-style ``thinking`` param into the
+    request body, so it must not ride inside ``extra_body`` (which the
+    Anthropic API rejects as extra inputs).
+    """
+    params = _lift_thinking(extra_params)
+    params.pop("extra_body", None)
+    return params
+
+
+def anthropic_5_thinking(extra_params: Dict) -> Dict:
+    """Claude 5+ models cannot use ``thinking.type.enabled``.
+
+    Thinking is instead controlled via ``reasoning_effort`` (which litellm maps
+    to ``thinking.type.adaptive`` + ``output_config.effort``), so any thinking
+    block is removed entirely and ``extra_body`` is dropped.
+    """
+    extra_params.pop("thinking", None)
+    extra_body = extra_params.get("extra_body")
+
+    if isinstance(extra_body, dict):
+        extra_body.pop("thinking", None)
+
+    extra_params.pop("extra_body", None)
+    return extra_params
+
+
+def _lift_thinking(extra_params: Dict) -> Dict:
+    """Move the generic ``thinking`` shape out of ``extra_body`` to top level."""
+    extra_body = extra_params.get("extra_body")
+
+    if not isinstance(extra_body, dict):
+        return extra_params
+
+    thinking = extra_body.pop("thinking", None)
+
+    if thinking is not None:
+        extra_params["thinking"] = thinking
+
+    return extra_params

cecli_dev-1.1.0rc4/cecli/helpers/model_config/identifiers.py

@@ -0,0 +1,77 @@
+"""Model identifier helpers for the model config pipeline.
+
+These predicates classify a model by family/provider from its name prefix,
+route, and metadata record.  Centralizing them keeps the config modules
+(api.py, llm.py, agent.py) and formatters free of repeated provider matching.
+"""
+
+from __future__ import annotations
+
+import re
+
+
+def _haystack(provider, route, record):
+    """Lowercased, space-joined provider/route/record-provider for matching."""
+    provider = (provider or "").lower()
+    route = (route or "").lower()
+    record_provider = ((record or {}).get("litellm_provider") or "").lower()
+    return " ".join([provider, route, record_provider])
+
+
+def is_anthropic(provider, route, record):
+    """True when the model is an Anthropic-family model (Claude)."""
+    haystack = _haystack(provider, route, record)
+    return "anthropic" in haystack or "claude" in (route or "").lower()
+
+
+def is_gemini(provider, route, record):
+    """True when the model is a Gemini-series model."""
+    return "gemini" in _haystack(provider, route, record)
+
+
+def is_gemini_2_5(provider, route, record):
+    """True when the model is a Gemini 2.5-series model."""
+    return "gemini-2.5" in (route or "").lower()
+
+
+def is_claude_5_plus(provider, route, record):
+    """True for Claude 5+ models, which use adaptive thinking + output_config.
+
+    Claude 5+ does not accept ``thinking.type.enabled``; thinking is controlled
+    via ``thinking.type.adaptive`` and ``output_config.effort`` (which litellm
+    derives from a top-level ``reasoning_effort`` param).
+    """
+    route = (route or "").lower()
+    match = re.search(r"claude[^\d]*(\d+)", route)
+
+    if not match:
+        return False
+
+    return int(match.group(1)) >= 5
+
+
+def is_github_copilot(provider, route, record):
+    """True when the model is served through GitHub Copilot."""
+    provider = (provider or "").lower()
+    record_provider = ((record or {}).get("litellm_provider") or "").lower()
+    return provider == "github_copilot" or record_provider == "github_copilot"
+
+
+def is_meta(provider, route, record):
+    """True when the model is a Meta-provider model."""
+    provider = (provider or "").lower()
+    record_provider = ((record or {}).get("litellm_provider") or "").lower()
+    return provider == "meta" or record_provider == "meta"
+
+
+def gpt_version(route):
+    """Return the leading ``gpt-`` model version, or 0 when not a gpt model.
+
+    e.g. ``gpt-5.6-luna`` -> 5.6, ``gpt-5`` -> 5, ``claude-3`` -> 0.
+    """
+    match = re.match(r"^gpt-(\d+(?:\.\d+)?)", (route or "").lower())
+
+    if not match:
+        return 0
+
+    return float(match.group(1))