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

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

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

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.6.2rc4'
-__version_tuple__ = version_tuple = (1, 6, 2, 'rc4')
+__version__ = version = '1.6.2rc5'
+__version_tuple__ = version_tuple = (1, 6, 2, 'rc5')
 
-__commit_id__ = commit_id = 'g59a3a0f3b'
+__commit_id__ = commit_id = 'g6fa4e52af'

cecli_dev-1.6.2rc5/cecli/helpers/llms/constants.py

@@ -0,0 +1,34 @@
+"""Shared constant values for the llms package.
+
+Only values that more than one module needs live here; single-use constants stay
+next to the code that reads them.
+"""
+
+from __future__ import annotations
+
+from typing import FrozenSet
+
+#: litellm/cecli runtime kwargs consumed by the shim or the pipeline (routing,
+#: auth, timeouts, cache plumbing) that must never be sent as request params.
+CONTROL_KWARGS: FrozenSet[str] = frozenset(
+    {
+        "model",
+        "messages",
+        "stream",
+        "tools",
+        "functions",
+        "api_base",
+        "base_url",
+        "api_key",
+        "extra_headers",
+        "headers",
+        "timeout",
+        "drop_params",
+        "allowed_openai_params",
+        "custom_llm_provider",
+        "cache_control_injection_points",
+        "logger_fn",
+    }
+)
+
+__all__ = ["CONTROL_KWARGS"]

{cecli_dev-1.6.2rc4 → cecli_dev-1.6.2rc5}/cecli/helpers/llms/domains/chat.py

@@ -106,10 +106,20 @@ async def chat_complete(
     headers: Dict[str, str],
     kwargs: Dict[str, Any],
 ) -> CompletionResponse:
-    env = _openai_env_override()
+    provider = resolved.get("_provider")
+
+    if provider is None or getattr(provider, "honors_openai_env_override", True):
+        env = _openai_env_override()
+    else:
+        env = None
+
     base = env[0] if env else resolved["api_base"]
-    url = f"{base}/chat/completions"
-    payload = chat_payload(resolved, messages, tools, False, kwargs)
+    url = provider.chat_url(resolved, base) if provider else f"{base}/chat/completions"
+    payload = (
+        provider.chat_payload(resolved, messages, tools, False, kwargs)
+        if provider
+        else chat_payload(resolved, messages, tools, False, kwargs)
+    )
     hdrs = {"Content-Type": "application/json", **headers}
     body: Optional[bytes] = None
     signer = resolved.get("_signer")
@@ -134,6 +144,9 @@ async def chat_complete(
         resp.raise_for_status()
         data = resp.json()
 
+    if provider:
+        return provider.parse_chat_response(data, resolved)
+
     return normalize_chat_response(data, resolved["model"])
 
 
@@ -145,10 +158,20 @@ async def chat_stream(
     headers: Dict[str, str],
     kwargs: Dict[str, Any],
 ) -> AsyncIterator[CompletionChunk]:
-    env = _openai_env_override()
+    provider = resolved.get("_provider")
+
+    if provider is None or getattr(provider, "honors_openai_env_override", True):
+        env = _openai_env_override()
+    else:
+        env = None
+
     base = env[0] if env else resolved["api_base"]
-    url = f"{base}/chat/completions"
-    payload = chat_payload(resolved, messages, tools, True, kwargs)
+    url = provider.chat_url(resolved, base) if provider else f"{base}/chat/completions"
+    payload = (
+        provider.chat_payload(resolved, messages, tools, True, kwargs)
+        if provider
+        else chat_payload(resolved, messages, tools, True, kwargs)
+    )
     hdrs = {"Content-Type": "application/json", **headers}
     body: Optional[bytes] = None
     signer = resolved.get("_signer")
@@ -173,8 +196,12 @@ async def chat_stream(
             resp.raise_for_status()
             last_finish_reason = None
 
-            async for json_obj in sse_json_lines(resp):
-                chunk = parse_chat_chunk(json_obj)
+            lines = provider.chat_stream_json(resp) if provider else sse_json_lines(resp)
+
+            async for json_obj in lines:
+                chunk = (
+                    provider.parse_chat_chunk(json_obj) if provider else parse_chat_chunk(json_obj)
+                )
 
                 if not chunk:
                     continue

{cecli_dev-1.6.2rc4 → cecli_dev-1.6.2rc5}/cecli/helpers/llms/identifiers.py

@@ -54,6 +54,13 @@ def is_openrouter(provider: Optional[str], route: str, record: Optional[Dict[str
     return provider == "openrouter" or record_provider == "openrouter"
 
 
+def is_ollama(provider: Optional[str], route: str, record: Optional[Dict[str, Any]]) -> bool:
+    """True when the model is served through an Ollama provider slug."""
+    provider = (provider or "").lower()
+    record_provider = ((record or {}).get("litellm_provider") or "").lower()
+    return provider in ("ollama", "ollama_chat") or record_provider in ("ollama", "ollama_chat")
+
+
 def is_claude_5_plus(provider: Optional[str], route: str, record: Optional[Dict[str, Any]]) -> bool:
     """True for Claude 5+ models, which use adaptive thinking + output_config.
 
@@ -88,6 +95,7 @@ __all__ = [
     "is_github_copilot",
     "is_meta",
     "is_openrouter",
+    "is_ollama",
     "is_claude_5_plus",
     "gpt_version",
 ]

{cecli_dev-1.6.2rc4 → cecli_dev-1.6.2rc5}/cecli/helpers/llms/litellm_compat.py

@@ -29,6 +29,8 @@ from typing import Any, Dict, List, Optional
 from cecli.dump import dump  # noqa: F401
 from cecli.http import httpx
 
+from .constants import CONTROL_KWARGS
+from .identifiers import is_ollama
 from .runtime import log_error_response
 
 warnings.filterwarnings("ignore", category=UserWarning, module="pydantic")
@@ -801,16 +803,32 @@ class _LiteLLMFacade:
         if headers:
             extra_headers = {**headers, **extra_headers}
 
+        # Ollama's native runner options (num_ctx, keep_alive, top_p, ...) live
+        # outside the OpenAI parameter set, so forward every request-level kwarg
+        # the caller supplied except those this shim or the pipeline consume
+        # internally. Every other provider keeps the narrow whitelist below so
+        # unrelated runtime kwargs are not leaked into its request body.
+        provider, _, route = (model or "").partition("/")
         passthrough: Dict[str, Any] = {}
-        for key in (
-            "temperature",
-            "tool_choice",
-            "extra_body",
-            "prompt_cache_key",
-            "stream_options",
-        ):
-            if kwargs.get(key) is not None:
-                passthrough[key] = kwargs[key]
+
+        if is_ollama(provider, route, None):
+            for key, value in kwargs.items():
+                if key in CONTROL_KWARGS or value is None:
+                    continue
+
+                passthrough[key] = value
+
+            passthrough.pop("max_completion_tokens", None)
+        else:
+            for key in (
+                "temperature",
+                "tool_choice",
+                "extra_body",
+                "prompt_cache_key",
+                "stream_options",
+            ):
+                if kwargs.get(key) is not None:
+                    passthrough[key] = kwargs[key]
 
         # The model-config pipeline formatters (helpers.format_reasoning /
         # helpers.format_thinking) lift reasoning_effort/thinking OUT of

{cecli_dev-1.6.2rc4 → cecli_dev-1.6.2rc5}/cecli/helpers/llms/pipeline.py

@@ -56,6 +56,12 @@ async def acompletion(
     # payload (e.g. Bedrock Mantle's SigV4 path).
     resolved["_signer"] = getattr(provider, "sign_request", None)
 
+    # The chat domain reads the provider back off ``resolved`` so it can
+    # delegate endpoint/payload/parsing to providers that override the shared
+    # chat wire (e.g. Ollama's native /api/chat) without threading a new
+    # argument through every family entry point.
+    resolved["_provider"] = provider
+
     headers = dict(resolved.get("extra_headers") or {})
     headers.update(extra_headers or {})
 

{cecli_dev-1.6.2rc4 → cecli_dev-1.6.2rc5}/cecli/helpers/llms/providers/base.py

@@ -24,6 +24,9 @@ class ProviderAdapter:
       normalize fields a stricter provider rejects (e.g. Mistral rejects
       ``reasoning_content`` / ``provider_specific_fields`` / ``function_call`` and
       a null tool-call ``index``).
+    - :meth:`chat_url` / :meth:`chat_payload` / :meth:`chat_stream_json` /
+      :meth:`parse_chat_response` / :meth:`parse_chat_chunk` - override the
+      shared chat-family wire (e.g. Ollama's native ``/api/chat``).
     - :meth:`normalize` - post-process a family-normalized response
       (e.g. meta encrypted-reasoning marker).
     """
@@ -36,6 +39,10 @@ class ProviderAdapter:
     #: (Mistral) set this False so the chat payload's coercer skips them.
     echoes_reasoning_content: bool = True
 
+    #: Whether OPENAI_API_BASE/OPENAI_API_KEY may redirect this provider's chat
+    #: request (see domains/chat.py). Native wires (Ollama) opt out.
+    honors_openai_env_override: bool = True
+
     def resolve_api_base(self, resolved: Dict[str, Any]) -> str:
         """Return the api_base for a resolved config (default: as resolved)."""
         return resolved["api_base"]
@@ -73,6 +80,41 @@ class ProviderAdapter:
         """
         return messages
 
+    def chat_url(self, resolved: Dict[str, Any], base: str) -> str:
+        """Return the chat endpoint URL (default: OpenAI ``/chat/completions``)."""
+        return f"{base}/chat/completions"
+
+    def chat_payload(
+        self,
+        resolved: Dict[str, Any],
+        messages: List[Dict[str, Any]],
+        tools: Optional[List[Dict[str, Any]]],
+        stream: bool,
+        kwargs: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """Build the chat request body (default: OpenAI-compatible payload)."""
+        from ..domains.chat import chat_payload
+
+        return chat_payload(resolved, messages, tools, stream, kwargs)
+
+    def chat_stream_json(self, resp: Any) -> Any:
+        """Yield parsed JSON objects from a chat stream (default: SSE lines)."""
+        from ..utils import sse_json_lines
+
+        return sse_json_lines(resp)
+
+    def parse_chat_response(self, data: Dict[str, Any], resolved: Dict[str, Any]) -> Any:
+        """Normalize a chat response (default: OpenAI-compatible parser)."""
+        from ..domains.chat import normalize_chat_response
+
+        return normalize_chat_response(data, resolved["model"])
+
+    def parse_chat_chunk(self, data: Dict[str, Any]) -> Any:
+        """Normalize one streamed chat chunk (default: OpenAI-compatible parser)."""
+        from ..domains.chat import parse_chat_chunk
+
+        return parse_chat_chunk(data)
+
     def normalize(
         self,
         family: str,