cecli-dev 1.2.1__tar.gz → 1.2.2rc1__tar.gz

{cecli_dev-1.2.1 → cecli_dev-1.2.2rc1}/PKG-INFO

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

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.1'
-__version_tuple__ = version_tuple = (1, 2, 1)
+__version__ = version = '1.2.2rc1'
+__version_tuple__ = version_tuple = (1, 2, 2, 'rc1')
 
-__commit_id__ = commit_id = 'g9eedb354e'
+__commit_id__ = commit_id = 'ga04dfe1c7'

{cecli_dev-1.2.1 → cecli_dev-1.2.2rc1}/cecli/coders/base_coder.py

@@ -4310,13 +4310,9 @@ class Coder(metaclass=UsageMeta):
             cache_write_tokens = getattr(completion.usage, "cache_creation_input_tokens", 0) or 0
             self.message_cached_tokens += cache_hit_tokens
 
-            if hasattr(completion.usage, "cache_read_input_tokens") or hasattr(
-                completion.usage, "cache_creation_input_tokens"
-            ):
-                self.message_tokens_sent += prompt_tokens
-                self.message_tokens_sent += cache_write_tokens
-            else:
-                self.message_tokens_sent += prompt_tokens
+            # ``prompt_tokens`` is normalized to the full input (including any
+            # cache read/write) for anthropic usage, so no separate add here.
+            self.message_tokens_sent += prompt_tokens
 
         else:
             prompt_tokens = self.get_active_model().token_count(messages)

{cecli_dev-1.2.1 → cecli_dev-1.2.2rc1}/cecli/helpers/conversation/manager.py

@@ -367,6 +367,7 @@ class ConversationManager:
                 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

{cecli_dev-1.2.1 → cecli_dev-1.2.2rc1}/cecli/helpers/llms/config.py

@@ -40,10 +40,28 @@ def resolve_model_config(model: str) -> Dict[str, Any]:
     cfg = get_default_config(model)
     llm_block = cfg.get("llm") or {}
     api_block = cfg.get("api") or {}
-    provider = llm_block.get("litellm_provider") or (
-        model.split("/", 1)[0] if "/" in model else None
-    )
+    agent_block = dict(cfg.get("agent") or {})
+    prefix = model.split("/", 1)[0] if "/" in model else None
+    provider = llm_block.get("litellm_provider") or prefix
     route = model.split("/", 1)[1] if "/" in model else model
+    is_claude = "claude" in route.lower()
+
+    # Providers with dedicated routing semantics (authenticated session, AWS
+    # SigV4 signing, dedicated endpoint templates) win over the metadata
+    # record's ``litellm_provider`` for every model under their prefix, so a
+    # ``github_copilot/`` / ``bedrock/`` / ``bedrock_mantle/`` model never
+    # falls back to a bare (anthropic/openai) record (e.g.
+    # ``github_copilot/claude-sonnet-4-5`` resolving to the bare
+    # ``claude-sonnet-4-5`` anthropic entry).
+    if prefix in ("github_copilot", "bedrock", "bedrock_mantle"):
+        provider = prefix
+
+    # Anthropic models hosted by a third-party provider (openrouter, deepseek,
+    # ...) authenticate against THAT provider, not anthropic: ``{provider}/claude-*``
+    # must route through the provider prefix even when the record lookup lands
+    # on the bare anthropic entry (e.g. ``openrouter/claude-sonnet-5``).
+    elif prefix and prefix != "anthropic" and is_claude:
+        provider = prefix
 
     mpm = ModelProviderManager()
     pcfg = mpm.get_provider_config(provider) or {}
@@ -88,6 +106,12 @@ def resolve_model_config(model: str) -> Dict[str, Any]:
         # Mantle is an OpenAI-compatible chat wire (SigV4-signed via the chat
         # family's signer hook); see providers/bedrock_mantle.py.
         family = "chat"
+    elif is_claude and provider != "anthropic":
+        # A claude model on a non-anthropic provider uses that provider's
+        # OpenAI-compatible chat completions wire (openrouter, deepseek,
+        # azure_ai, ...); only native anthropic (or copilot's anthropic-native
+        # /v1/messages proxy, handled above) speaks the messages API.
+        family = "chat"
     elif mode == "responses" or "/v1/responses" in endpoints:
         family = "responses"
     elif provider == "anthropic":
@@ -100,6 +124,14 @@ def resolve_model_config(model: str) -> Dict[str, Any]:
     extra_headers = dict(pcfg.get("default_headers") or {})
     extra_body = dict(api_block.get("extra_body") or {})
 
+    # 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).
+    if family == "messages":
+        agent_block["cache_control"] = True
+        agent_block["caches_by_default"] = False
+
     return {
         "model": model,
         "provider": provider,
@@ -112,6 +144,7 @@ def resolve_model_config(model: str) -> Dict[str, Any]:
         "extra_query": dict(pcfg.get("extra_query") or {}),
         "api_block": api_block,
         "llm_block": llm_block,
+        "agent_block": agent_block,
     }
 
 

{cecli_dev-1.2.1 → cecli_dev-1.2.2rc1}/cecli/helpers/llms/domains/chat.py

@@ -5,12 +5,20 @@ is extracted via :func:`cecli.helpers.llms.utils.extract_reasoning` which
 handles the three wild shapes (reasoning_content / reasoning /
 reasoning_details). Reasoning tokens reported without streamed text are marked
 redacted (``Message.reasoning_redacted``).
+
+At request time the ``OPENAI_API_BASE`` / ``OPENAI_API_KEY`` env vars
+(docs/llms/openai-compat.md) can redirect the wire to any OpenAI-compatible
+endpoint: ``OPENAI_API_BASE`` wins over the resolved base and
+``OPENAI_API_KEY`` replaces the provider key when the base is a well-formed
+http(s) URL.
 """
 
 from __future__ import annotations
 
 import json
-from typing import Any, AsyncIterator, Dict, List, Optional
+import os
+from typing import Any, AsyncIterator, Dict, List, Optional, Tuple
+from urllib.parse import urlparse
 
 from ..runtime import VERIFY_SSL, make_client
 from ..types import (
@@ -94,12 +102,18 @@ async def chat_complete(
     headers: Dict[str, str],
     kwargs: Dict[str, Any],
 ) -> CompletionResponse:
-    url = f"{resolved['api_base']}/chat/completions"
+    env = _openai_env_override()
+    base = env[0] if env else resolved["api_base"]
+    url = f"{base}/chat/completions"
     payload = chat_payload(resolved, messages, tools, False, kwargs)
     hdrs = {"Content-Type": "application/json", **headers}
     body: Optional[bytes] = None
     signer = resolved.get("_signer")
 
+    if env and env[1]:
+        key = env[1]
+        hdrs["Authorization"] = f"Bearer {key}"
+
     if signer:
         url, hdrs, body = signer(url, payload, hdrs, key)
 
@@ -127,12 +141,18 @@ async def chat_stream(
     headers: Dict[str, str],
     kwargs: Dict[str, Any],
 ) -> AsyncIterator[CompletionChunk]:
-    url = f"{resolved['api_base']}/chat/completions"
+    env = _openai_env_override()
+    base = env[0] if env else resolved["api_base"]
+    url = f"{base}/chat/completions"
     payload = chat_payload(resolved, messages, tools, True, kwargs)
     hdrs = {"Content-Type": "application/json", **headers}
     body: Optional[bytes] = None
     signer = resolved.get("_signer")
 
+    if env and env[1]:
+        key = env[1]
+        hdrs["Authorization"] = f"Bearer {key}"
+
     if signer:
         url, hdrs, body = signer(url, payload, hdrs, key)
 
@@ -364,6 +384,30 @@ def _map_reasoning_content(msg: Dict[str, Any]) -> str:
     return "\n".join(texts)
 
 
+def _openai_env_override() -> Optional[Tuple[str, Optional[str]]]:
+    """Return (api_base, api_key) from the OPENAI_API_* env vars when the base
+    is a well-formed http(s) URL (docs/llms/openai-compat.md).
+
+    Lets a custom OpenAI-compatible endpoint take over the chat completions
+    wire at request time: the env base wins over the resolved provider base and
+    OPENAI_API_KEY replaces the provider's own key for that request. A base
+    that is not a well-formed URL (no http(s) scheme / host, e.g.
+    ``localhost:8000``) is ignored so unrelated OPENAI_API_* leftovers cannot
+    hijack requests.
+    """
+    raw = os.environ.get("OPENAI_API_BASE")
+
+    if not raw:
+        return None
+
+    parsed = urlparse(raw.strip())
+
+    if parsed.scheme not in ("http", "https") or not parsed.netloc:
+        return None
+
+    return (raw.strip().rstrip("/"), os.environ.get("OPENAI_API_KEY") or None)
+
+
 __all__ = [
     "chat_payload",
     "chat_complete",

{cecli_dev-1.2.1 → cecli_dev-1.2.2rc1}/cecli/helpers/llms/domains/messages.py

@@ -33,6 +33,9 @@ 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],
@@ -58,6 +61,7 @@ def anthropic_payload(
         payload["tools"] = [anthropic_tool(t) for t in tools]
 
     api_block = resolved.get("api_block") or {}
+    agent_block = resolved.get("agent_block") or {}
 
     # Caller/system overrides ride in ``kwargs["extra_body"]`` (models.py's
     # ``set_reasoning_effort`` / ``set_thinking_tokens``). Merge them into the
@@ -90,6 +94,16 @@ def anthropic_payload(
     extra_body.pop("reasoning_effort", None)
     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.
+    if agent_block.get("cache_control") and not agent_block.get("caches_by_default"):
+        _apply_anthropic_cache_control(payload)
+
     return payload
 
 
@@ -465,11 +479,20 @@ def _finish_reason(stop_reason: Optional[str]) -> Optional[str]:
 
 
 def _anthropic_usage(usage_raw: Dict[str, Any]) -> Usage:
-    """Build a normalized Usage from an Anthropic usage block."""
+    """Build a normalized Usage from an Anthropic usage block.
+
+    Anthropic's ``input_tokens`` excludes cached input, so ``prompt_tokens``
+    is normalized to the full input (``input_tokens + cache_read +
+    cache_creation``) to match the OpenAI-style semantics
+    ``base_coder.calculate_and_show_tokens_and_cost`` expects: its hit-rate
+    and cost math rely on ``prompt_tokens`` being the total input
+    (``cache_creation + cache_read + input == total``).
+    """
     input_tokens = usage_raw.get("input_tokens") or 0
     output_tokens = usage_raw.get("output_tokens") or 0
     cache_read = usage_raw.get("cache_read_input_tokens") or 0
     cache_creation = usage_raw.get("cache_creation_input_tokens") or 0
+    prompt_tokens = input_tokens + cache_read + cache_creation
 
     details: Dict[str, Any] = {}
     output_details = usage_raw.get("output_tokens_details") or {}
@@ -484,9 +507,9 @@ def _anthropic_usage(usage_raw: Dict[str, Any]) -> Usage:
         details["service_tier"] = service_tier
 
     return Usage(
-        prompt_tokens=input_tokens or None,
+        prompt_tokens=prompt_tokens or None,
         completion_tokens=output_tokens or None,
-        total_tokens=(input_tokens + cache_read + cache_creation) or None,
+        total_tokens=prompt_tokens or None,
         cache_read_input_tokens=usage_raw.get("cache_read_input_tokens"),
         cache_creation_input_tokens=usage_raw.get("cache_creation_input_tokens"),
         completion_tokens_details=details or None,
@@ -586,6 +609,140 @@ 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
+    )
+
+
 __all__ = [
     "anthropic_payload",
     "anthropic_message",

{cecli_dev-1.2.1 → cecli_dev-1.2.2rc1}/cecli/helpers/llms/litellm_compat.py

@@ -936,7 +936,12 @@ class _LiteLLMFacade:
         )
 
     def completion_cost(self, completion_response: Optional[Any] = None, **kwargs: Any) -> float:
-        """Estimate cost from usage tokens and cecli's own model metadata."""
+        """Estimate cost from usage tokens and cecli's own model metadata.
+
+        Mirrors ``base_coder.compute_costs_from_tokens`` so normalized usage
+        (``prompt_tokens`` = full input including cache read/write) is billed
+        with the cache discounts instead of the plain input price.
+        """
         usage = getattr(completion_response, "usage", None)
         if not usage:
             return 0.0
@@ -945,9 +950,38 @@ class _LiteLLMFacade:
         info = self.get_model_info(model) if model else {}
         input_cost = info.get("input_cost_per_token") or 0.0
         output_cost = info.get("output_cost_per_token") or 0.0
-        return (usage.prompt_tokens or 0) * input_cost + (
-            usage.completion_tokens or 0
-        ) * output_cost
+        cache_hit_cost = (
+            info.get("input_cost_per_token_cache_hit")
+            or info.get("cache_read_input_token_cost")
+            or 0.0
+        )
+        prompt = usage.prompt_tokens or 0
+        completion = usage.completion_tokens or 0
+        cache_hit = (
+            getattr(usage, "cache_read_input_tokens", None)
+            or getattr(usage, "prompt_cache_hit_tokens", None)
+            or 0
+        )
+        cache_write = getattr(usage, "cache_creation_input_tokens", None) or 0
+
+        if cache_hit_cost:
+            return (
+                cache_hit * cache_hit_cost
+                + (prompt - cache_hit) * input_cost
+                + completion * output_cost
+            )
+
+        if cache_hit or cache_write:
+            # Hard-coded Anthropic adjustments, no-ops for other providers
+            # since their cache fields are zero.
+            return (
+                cache_write * input_cost * 1.25
+                + cache_hit * input_cost * 0.10
+                + (prompt - cache_hit) * input_cost
+                + completion * output_cost
+            )
+
+        return prompt * input_cost + completion * output_cost
 
     # -- model metadata ---------------------------------------------------
 

cecli_dev-1.2.2rc1/cecli/helpers/model_config/agent.py

@@ -0,0 +1,73 @@
+"""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 _uses_anthropic_messages_api(
+    provider: Optional[str], route: str, record: Optional[Dict]
+) -> bool:
+    """True when the model speaks the Anthropic /v1/messages wire format.
+
+    Only the native Anthropic provider (explicit prefix, or a bare claude
+    name that resolves to the anthropic record) and GitHub Copilot's
+    anthropic-native proxy (``github_copilot/claude-*``) route through the
+    messages family. Other claude routes (openrouter, deepseek, bedrock,
+    ...) use chat completions / converse and keep their own caching
+    semantics.
+    """
+    if provider == "anthropic":
+        return True
+
+    if provider == "github_copilot":
+        return "claude" in (route or "").lower()
+
+    if provider is None:
+        return (record or {}).get("litellm_provider") == "anthropic"
+
+    return False
+
+
+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)
+    uses_messages_api = _uses_anthropic_messages_api(provider, route, record)
+    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.
+        #
+        # 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.
+        "caches_by_default": (
+            not uses_messages_api
+            and (bool(record.get("cache_read_input_token_cost")) if record else True)
+        ),
+        "uses_messages_api": uses_messages_api,
+    }
+
+    if reasoning or record.get("supports_adaptive_thinking"):
+        agent["use_temperature"] = False
+
+    return agent

{cecli_dev-1.2.1 → cecli_dev-1.2.2rc1}/cecli/helpers/model_config/pipeline.py

@@ -29,7 +29,10 @@ RESOURCE_FILE = "model-metadata.json"
 
 #: Suffix segments dropped when looking for a nearby model family.
 #: ``gpt-5.6-luna`` -> ``gpt-5.6`` -> ``gpt-5`` -> ``gpt``
-_TRAILING_SEGMENT_RE = re.compile(r"[-.][^.]+$")
+#: ``claude-sonnet-4-5`` -> ``claude-sonnet-4`` -> ``claude-sonnet`` -> ``claude``
+#: ``[^.-]`` (no dots, no hyphens) ensures exactly one trailing ``-X`` / ``.X``
+#: segment is dropped per pass instead of collapsing the whole remainder.
+_TRAILING_SEGMENT_RE = re.compile(r"[-.][^.-]+$")
 
 #: Lazily loaded raw text of the bundled metadata file (never json.loads-ed).
 _BUNDLED_RAW_CACHE: Optional[str] = None

{cecli_dev-1.2.1 → cecli_dev-1.2.2rc1}/cecli/io.py

@@ -1741,39 +1741,42 @@ class InputOutput:
 
         # 2. Define the Notification component
         notif_cmd = None
-        if system == "Darwin":
-            if shutil.which("terminal-notifier"):
-                notif_cmd = f"terminal-notifier -title 'cecli' -message '{NOTIFICATION_MESSAGE}'"
-            else:
-                notif_cmd = f'osascript -e \'display notification "{NOTIFICATION_MESSAGE}" with title "cecli"\''
-
-        elif system == "Linux":
-            for cmd in ["notify-send", "zenity"]:
-                if shutil.which(cmd):
-                    if cmd == "notify-send":
-                        notif_cmd = f"notify-send 'cecli' '{NOTIFICATION_MESSAGE}'"
-                    elif cmd == "zenity":
-                        notif_cmd = f"zenity --notification --text='{NOTIFICATION_MESSAGE}'"
-                    break
+        if self.notifications:
+            if system == "Darwin":
+                if shutil.which("terminal-notifier"):
+                    notif_cmd = (
+                        f"terminal-notifier -title 'cecli' -message '{NOTIFICATION_MESSAGE}'"
+                    )
+                else:
+                    notif_cmd = f'osascript -e \'display notification "{NOTIFICATION_MESSAGE}" with title "cecli"\''
+
+            elif system == "Linux":
+                for cmd in ["notify-send", "zenity"]:
+                    if shutil.which(cmd):
+                        if cmd == "notify-send":
+                            notif_cmd = f"notify-send 'cecli' '{NOTIFICATION_MESSAGE}'"
+                        elif cmd == "zenity":
+                            notif_cmd = f"zenity --notification --text='{NOTIFICATION_MESSAGE}'"
+                        break
 
-        elif system == "Windows":
-            ps_body = (
-                ' "try {{ Add-Type -AssemblyName System.Runtime.WindowsRuntime; $null ='
-                " [Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications,"
-                " ContentType = WindowsRuntime] }} catch {{}}; "
-                "$template ="
-                " [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent"
-                "([Windows.UI.Notifications.ToastTemplateType]::ToastText02); "
-                "$toastXml = $template.GetXml(); "
-                "$toastXml.GetElementsByTagName('text')[0].AppendChild"
-                "($template.CreateTextNode('cecli')) > $null; "
-                "$toastXml.GetElementsByTagName('text')[1].AppendChild"
-                f"($template.CreateTextNode('{NOTIFICATION_MESSAGE}')) > $null; "
-                "$toast = [Windows.UI.Notifications.ToastNotification]::new($toastXml); "
-                "[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('cecli')"
-                '.Show($toast)"'
-            )
-            notif_cmd = f"powershell -WindowStyle Hidden -Command {ps_body}"
+            elif system == "Windows":
+                ps_body = (
+                    ' "try {{ Add-Type -AssemblyName System.Runtime.WindowsRuntime; $null ='
+                    " [Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications,"
+                    " ContentType = WindowsRuntime] }} catch {{}}; "
+                    "$template ="
+                    " [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent"
+                    "([Windows.UI.Notifications.ToastTemplateType]::ToastText02); "
+                    "$toastXml = $template.GetXml(); "
+                    "$toastXml.GetElementsByTagName('text')[0].AppendChild"
+                    "($template.CreateTextNode('cecli')) > $null; "
+                    "$toastXml.GetElementsByTagName('text')[1].AppendChild"
+                    f"($template.CreateTextNode('{NOTIFICATION_MESSAGE}')) > $null; "
+                    "$toast = [Windows.UI.Notifications.ToastNotification]::new($toastXml); "
+                    "[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('cecli')"
+                    '.Show($toast)"'
+                )
+                notif_cmd = f"powershell -WindowStyle Hidden -Command {ps_body}"
 
         # 3. Concatenate them based on bell preference
         if notif_cmd:
@@ -1802,8 +1805,10 @@ class InputOutput:
 
                 # Determine if this is a terminal bell command that should not be suppressed
                 is_bell_cmd = (
-                    "\\a" in self.notifications_command or "\a" in self.notifications_command
-                ) and re.search(r"(?:echo|print)", self.notifications_command, re.IGNORECASE)
+                    "\\a" in self.notifications_command
+                    or "\a" in self.notifications_command
+                    or "bel" in self.notifications_command
+                ) and re.search(r"(?:echo|print|tput)", self.notifications_command, re.IGNORECASE)
 
                 kwargs = {
                     "shell": True,

{cecli_dev-1.2.1 → cecli_dev-1.2.2rc1}/cecli/models.py

@@ -116,6 +116,7 @@ class ModelSettings:
     extra_params: Optional[dict] = None
     cache_control: bool = False
     caches_by_default: bool = False
+    uses_messages_api: bool = False
     use_system_prompt: bool = True
     use_temperature: Union[bool, float] = True
     streaming: bool = True