cecli-dev 1.0.4__tar.gz → 1.1.0__tar.gz

{cecli_dev-1.0.4 → cecli_dev-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.0.4
+Version: 1.1.0
 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.0.4 → cecli_dev-1.1.0}/cecli/__init__.py

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

{cecli_dev-1.0.4 → cecli_dev-1.1.0}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.4'
-__version_tuple__ = version_tuple = (1, 0, 4)
+__version__ = version = '1.1.0'
+__version_tuple__ = version_tuple = (1, 1, 0)
 
-__commit_id__ = commit_id = 'g906b4a888'
+__commit_id__ = commit_id = 'g33493d1c4'

{cecli_dev-1.0.4 → cecli_dev-1.1.0}/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
@@ -89,7 +88,6 @@ class AgentCoder(Coder):
         self.file_read_cache = set()
         self.tool_call_count = 0
         self.turn_count = 0
-        self.max_reflections = 15
         self.use_enhanced_context = True
         self._last_edited_file = None
         self._cur_message_divider = None
@@ -365,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.0.4 → cecli_dev-1.1.0}/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}")
 
@@ -1886,6 +1886,7 @@ class Coder(metaclass=UsageMeta):
             ConversationService.get_chunks(self).flush_removals()
             self.last_user_message = user_message
             self.error_code = None
+            self.num_tool_calls = 0
             # Trim memory in the background so it doesn't delay the response
             coroutines.fire_and_forget(asyncio.to_thread(trim_memory))
             # Fire memorizer after each user request
@@ -3109,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
 
@@ -3208,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
@@ -3439,11 +3463,17 @@ class Coder(metaclass=UsageMeta):
         to be `None` when `tool_calls` are present.
         """
         msg = dict(role="assistant")
-        response = (
-            self.partial_response_chunks[0]
-            if not self.stream
-            else litellm.stream_chunk_builder(self.partial_response_chunks)
-        )
+
+        # Prefer the response already produced by consolidate_chunks(): it carries
+        # the provider-specific fields (e.g. reasoning_items) that we preserved
+        # across all chunks, which a fresh litellm.stream_chunk_builder() pass
+        # alone would drop or truncate.
+        if self.partial_response_consolidated:
+            response = self.partial_response_consolidated[0]
+        elif not self.stream:
+            response = self.partial_response_chunks[0]
+        else:
+            response = litellm.stream_chunk_builder(self.partial_response_chunks)
 
         try:
             # Use response_dict as a regular dictionary
@@ -3962,63 +3992,51 @@ class Coder(metaclass=UsageMeta):
                 if getattr(last_chunk, "usage", None):
                     response.usage = last_chunk.usage
 
-        # Collect provider-specific fields from chunks to preserve them
-        # We need to track both by ID (primary) and index (fallback) since
-        # early chunks might not have IDs established yet
-        provider_specific_fields_by_id = {}
-        provider_specific_fields_by_index = {}
-
+        # Collect message-level provider-specific fields (e.g. `reasoning_items`
+        # for reasoning models) from ALL chunks.  litellm's stream_chunk_builder()
+        # merges these with last-wins semantics for list fields, silently dropping
+        # every reasoning item except the final one.  Reasoning models depend on the
+        # full ordered item list being present in the assistant message so that
+        # exact-prefix prompt caching keeps working across turns, so we collect the
+        # fields ourselves and concatenate list-valued entries.
+        message_provider_specific_fields = {}
         for chunk in self.partial_response_chunks:
             try:
-                if chunk.choices and chunk.choices[0].delta and chunk.choices[0].delta.tool_calls:
-                    for tool_call in chunk.choices[0].delta.tool_calls:
-                        if (
-                            hasattr(tool_call, "provider_specific_fields")
-                            and tool_call.provider_specific_fields
-                        ):
-                            # Ensure provider_specific_fields is a dictionary
-                            psf = tool_call.provider_specific_fields
-                            if not isinstance(psf, dict):
-                                continue
-
-                            # Try to use ID first
-                            if hasattr(tool_call, "id") and tool_call.id:
-                                tool_id = tool_call.id
-                                if tool_id not in provider_specific_fields_by_id:
-                                    provider_specific_fields_by_id[tool_id] = {}
-                                # Merge provider-specific fields for this tool ID
-                                provider_specific_fields_by_id[tool_id].update(psf)
-                            # Also track by index as fallback
-                            elif hasattr(tool_call, "index"):
-                                tool_index = tool_call.index
-                                if tool_index not in provider_specific_fields_by_index:
-                                    provider_specific_fields_by_index[tool_index] = {}
-                                provider_specific_fields_by_index[tool_index].update(psf)
+                if chunk.choices and chunk.choices[0].delta:
+                    psf = getattr(chunk.choices[0].delta, "provider_specific_fields", None)
+                    if psf and isinstance(psf, dict):
+                        for key, value in psf.items():
+                            if isinstance(value, list):
+                                message_provider_specific_fields.setdefault(key, []).extend(value)
+                            elif value is not None:
+                                message_provider_specific_fields[key] = value
             except (AttributeError, IndexError):
                 continue
 
+        if message_provider_specific_fields:
+            message_psf = getattr(response.choices[0].message, "provider_specific_fields", None)
+            if not isinstance(message_psf, dict):
+                message_psf = {}
+            message_psf.update(message_provider_specific_fields)
+            response.choices[0].message.provider_specific_fields = message_psf
+
         try:
-            if response.choices[0].message.tool_calls:
-                for i, tool_call in enumerate(response.choices[0].message.tool_calls):
-                    # Add provider-specific fields if we collected any for this tool
-                    tool_id = tool_call.id
-
-                    # Try ID first
-                    if tool_id in provider_specific_fields_by_id:
-                        # Add provider-specific fields directly to the tool call object
-                        tool_call.provider_specific_fields = provider_specific_fields_by_id[tool_id]
-                    # Fall back to index
-                    elif i in provider_specific_fields_by_index:
-                        # Add provider-specific fields directly to the tool call object
-                        tool_call.provider_specific_fields = provider_specific_fields_by_index[i]
-
-                    # Only append to partial_response_tool_calls if it's empty
-                    if len(self.partial_response_tool_calls) == 0:
-                        self.partial_response_tool_calls.append(tool_call)
-
-                self.partial_response_function_call = (
-                    response.choices[0].message.tool_calls[0].function
-                )
+            message_tool_calls = response.choices[0].message.tool_calls
+            if message_tool_calls and len(message_tool_calls):
+                if self.stream:
+                    built_tool_calls = self._build_tool_calls_from_chunks()
+                    if built_tool_calls:
+                        response.choices[0].message.tool_calls = built_tool_calls
+                        self.partial_response_tool_calls = built_tool_calls
+                    else:
+                        # Fall back to litellm's merged list, keeping every call
+                        self.partial_response_tool_calls = list(message_tool_calls)
+                else:
+                    # Non-streaming: the single response chunk already carries the
+                    # full tool_calls list
+                    self.partial_response_tool_calls = list(message_tool_calls)
+
+                self.partial_response_function_call = self.partial_response_tool_calls[0].function
         except AttributeError as e:
             func_err = e
 
@@ -4074,6 +4092,85 @@ class Coder(metaclass=UsageMeta):
         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.
+        """
+        from litellm.types.utils import ChatCompletionMessageToolCall, Function
+
+        tool_calls_dict = {}
+
+        for chunk in self.partial_response_chunks:
+            try:
+                if not (chunk.choices and chunk.choices[0].delta):
+                    continue
+
+                delta = chunk.choices[0].delta
+                for tool_call in delta.tool_calls or []:
+                    if tool_call is None:
+                        continue
+
+                    if nested.getter(tool_call, "function") is None:
+                        continue
+
+                    index = nested.getter(tool_call, "index")
+                    if index is None:
+                        index = len(tool_calls_dict)
+
+                    entry = tool_calls_dict.setdefault(
+                        index,
+                        {
+                            "id": None,
+                            "name": None,
+                            "type": "function",
+                            "arguments": [],
+                            "provider_specific_fields": {},
+                        },
+                    )
+
+                    entry["id"] = nested.getter(tool_call, "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"]
+
+                    arguments = nested.getter(tool_call, "function.arguments")
+                    if arguments:
+                        entry["arguments"].append(arguments)
+
+                    psf = nested.getter(tool_call, "provider_specific_fields")
+                    if not psf:
+                        psf = nested.getter(tool_call, "function.provider_specific_fields")
+                    if psf and isinstance(psf, dict):
+                        entry["provider_specific_fields"].update(psf)
+            except (AttributeError, IndexError):
+                continue
+
+        tool_calls = []
+        for index in sorted(tool_calls_dict.keys()):
+            data = tool_calls_dict[index]
+            if not (data["id"] and data["name"]):
+                continue
+
+            function = Function(
+                arguments="".join(data["arguments"]) or "{}",
+                name=data["name"],
+            )
+            params = {
+                "id": data["id"],
+                "function": function,
+                "type": data["type"] or "function",
+            }
+            if data["provider_specific_fields"]:
+                params["provider_specific_fields"] = data["provider_specific_fields"]
+
+            tool_calls.append(ChatCompletionMessageToolCall(**params))
+
+        return tool_calls
+
     def stream_wrapper(self, content, final):
         if not hasattr(self, "_streaming_buffer_length"):
             self._streaming_buffer_length = 0
@@ -4174,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)} ↓"
 
@@ -4197,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.0.4 → cecli_dev-1.1.0}/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.0.4 → cecli_dev-1.1.0}/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.0.4 → cecli_dev-1.1.0}/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.0.4 → cecli_dev-1.1.0}/cecli/help.py

@@ -58,11 +58,22 @@ def fname_to_url(filepath):
     if relevant_parts and relevant_parts[0].lower() == "_includes":
         return ""
     url_path = "/".join(relevant_parts)
+
+    # docmd renders each .md source to <path>/index.html, so the published
+    # URLs are directory-style (e.g. /docs/usage/) rather than .html files.
+    is_doc = False
     if url_path.lower().endswith(index.lower()):
         url_path = url_path[: -len(index)]
+        is_doc = True
     elif url_path.lower().endswith(md.lower()):
-        url_path = url_path[: -len(md)] + ".html"
+        url_path = url_path[: -len(md)]
+        is_doc = True
+
     url_path = url_path.strip("/")
+    if not url_path:
+        return "https://cecli.dev/"
+    if is_doc:
+        return f"https://cecli.dev/{url_path}/"
     return f"https://cecli.dev/{url_path}"
 
 

{cecli_dev-1.0.4 → cecli_dev-1.1.0}/cecli/helpers/hashline.py

@@ -382,6 +382,20 @@ def resolve_content_to_hashline_ids(
                     key=lambda idx: abs(idx - start_hint_line),
                 )
                 resolved_start = _resolve_to_hash_id(lines, resolved_start_idx, hp)
+            else:
+                # Fallback: the value may be line content whose whitespace was
+                # normalized (e.g. stripped indentation). Resolve it against a
+                # single unique line — mirroring apply_hashline_operations — so
+                # the preview resolves exactly like the actual edit.
+                unique_resolved = _try_resolve_as_unique_line(hp, first_line)
+                if unique_resolved is not None:
+                    resolved_start = unique_resolved
+                    try:
+                        candidates = hp.resolve_to_lines(normalize_hashline(unique_resolved))
+                        if candidates:
+                            resolved_start_idx = candidates[0]
+                    except (ContentHashError, ValueError):
+                        pass
     elif start_value is not None and _looks_like_content_id(start_value):
         # Already a content ID - try to resolve it to find the line position
         # for proximity matching with end_value
@@ -432,6 +446,14 @@ def resolve_content_to_hashline_ids(
                     key=lambda idx: abs(idx - resolved_start_idx),
                 )
                 resolved_end = _resolve_to_hash_id(lines, closest_idx, hp)
+            else:
+                # Fallback: the value may be line content whose whitespace was
+                # normalized (e.g. stripped indentation). Resolve it against a
+                # single unique line — mirroring apply_hashline_operations — so
+                # the preview resolves exactly like the actual edit.
+                unique_resolved = _try_resolve_as_unique_line(hp, first_line)
+                if unique_resolved is not None:
+                    resolved_end = unique_resolved
     elif end_value is not None and _looks_like_content_id(end_value):
         # Already a content ID - try to resolve it
         try:

{cecli_dev-1.0.4 → cecli_dev-1.1.0}/cecli/helpers/io_proxy.py

@@ -51,6 +51,9 @@ class IOProxy(Generic[T]):
         super().__setattr__("_coder", weakref.ref(coder))
         # Per-coder task storage: {coder_uuid: {attr_name: asyncio.Task}}
         super().__setattr__("_per_coder", {coder_uuid: {}})
+        # Last tool `type` emitted via tool_output — lives on the proxy,
+        # never on the shared target (like coder_uuid)
+        super().__setattr__("_last_type", None)
 
         # Register a per-coder input queue (TUI mode only)
         # Allows the TUI to push input directly to this coder's queue,
@@ -76,6 +79,7 @@ class IOProxy(Generic[T]):
         """Forward tool_output with coder_uuid injected."""
         if "coder_uuid" not in kwargs:
             kwargs["coder_uuid"] = self._coder_uuid
+        self._last_type = kwargs.get("type")
         return self._target.tool_output(*messages, **kwargs)
 
     def tool_error(self, message: str = "", strip: bool = True, **kwargs: Any) -> Any:
@@ -265,7 +269,7 @@ class IOProxy(Generic[T]):
 
     def __setattr__(self, name: str, value: Any) -> None:
         # Proxy-internal attributes — store on proxy instance only
-        if name in ("_target", "_coder_uuid", "_coder", "_per_coder"):
+        if name in ("_target", "_coder_uuid", "_coder", "_per_coder", "_last_type"):
             super().__setattr__(name, value)
         # Per-coder task attributes — isolate per-coder so coders don't
         # compete for the same promise on the shared InputOutput instance

cecli_dev-1.1.0/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.0/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.0/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"