utim-cli 2.3.24__tar.gz → 2.3.25__tar.gz

{utim_cli-2.3.24 → utim_cli-2.3.25}/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [2.3.25] - 2026-09-07
+
+### 🛠️ Bug Fixes
+- Fixed usage dialog glitches
+
 ## [2.3.24] - 2026-09-07
 
 ### ⚡ Performance

{utim_cli-2.3.24/utim_cli.egg-info → utim_cli-2.3.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.3.24
+Version: 2.3.25
 Summary: UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal.
 License: Emend AI Proprietary EULA
 Project-URL: Homepage, https://utim.dev

{utim_cli-2.3.24 → utim_cli-2.3.25}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "2.3.24"
+version = "2.3.25"
 
 description = "UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal."
 readme = "README.md"

{utim_cli-2.3.24 → utim_cli-2.3.25}/utim/__init__.py

@@ -14,7 +14,7 @@ Quickstart:
 try:
     from utim_cli._version import VERSION as __version__
 except ImportError:
-    __version__ = "2.3.24"
+    __version__ = "2.3.25"
 
 # Developer-friendly core classes (similar to `import genai` / `import openai`)
 from utim_cli.sdk.session import UtimSession as Session

{utim_cli-2.3.24 → utim_cli-2.3.25}/utim_cli/__init__.py

@@ -5,7 +5,7 @@ try:
     from utim_cli._version import VERSION as __version__
 except ImportError:
     # Fallback during first-install / editable-install edge cases
-    __version__ = "2.3.24"
+    __version__ = "2.3.25"
 
 
 import builtins, os, pathlib, urllib.parse, re

{utim_cli-2.3.24 → utim_cli-2.3.25}/utim_cli/_version.py

@@ -11,6 +11,6 @@
 # from here so every surface stays in sync automatically.
 # ─────────────────────────────────────────────────────────────────────────────
 
-VERSION = "2.3.24"
+VERSION = "2.3.25"
 
 

{utim_cli-2.3.24 → utim_cli-2.3.25}/utim_cli/orchestrator_llm_transport.py

@@ -268,11 +268,6 @@ class LLMTransportMixin:
         if not race_candidates:
             return None
 
-        if not silent:
-            self.console.print(
-                f"\n[dim yellow]↪ Primary model unavailable — racing {len(race_candidates)} fallback models for lowest latency response…[/dim yellow]\n"
-            )
-
         winner_lock = threading.Lock()
         winner_model = [None]
         winner_result = [None]
@@ -1135,10 +1130,6 @@ class LLMTransportMixin:
                                 _exhausted_key = _api_key
                         
                         if _exhausted_key:
-                            remaining = config.get_exhaustion_countdown(_exhausted_key)
-                            remaining_str = f"{remaining // 3600}h {remaining % 3600 // 60}m" if remaining else "24h"
-                            if not silent:
-                                self.console.print(f"[dim]Skipping exhausted API key {_exhausted_key[:12]}... (cooldown: {remaining_str})[/dim]")
                             raise _ServerUnavailableError(f"API key exhausted: {_exhausted_key[:12]}...")
 
                         # Build auth headers or query params depending on provider
@@ -1610,17 +1601,8 @@ class LLMTransportMixin:
                                                     _paid_slug = current_model.rsplit(":free", 1)[0]
                                                     _remaining = models_to_try[model_idx + 1:]
                                                     if _paid_slug not in _remaining:
-                                                        if not silent:
-                                                            self.console.print(
-                                                                f"\n[dim yellow]↪ Free model rate-limited — trying paid version '{_paid_slug}'…[/dim yellow]"
-                                                            )
                                                         # Insert paid slug as the very next model, then break
                                                         models_to_try[model_idx + 1:model_idx + 1] = [_paid_slug]
-                                                    else:
-                                                        if not silent:
-                                                            self.console.print(
-                                                                f"\n[dim yellow]↪ Free model rate-limited — paid version already in queue, skipping…[/dim yellow]"
-                                                            )
                                                     break  # inner attempt loop → outer loop picks up injected paid slug
                                                 # Non-free model: nothing to fall back to — show message and return
                                                 rate_limit_display = (
@@ -1641,21 +1623,9 @@ class LLMTransportMixin:
                                                     "tool_calls": None,
                                                 }, False
                                             elif _is_provider_upstream:
-                                                if not silent:
-                                                    self.console.print(
-                                                        f"\n[dim yellow]↪ {_friendly_name}'s provider is having trouble — "
-                                                        f"switching to the next available model…[/dim yellow]"
-                                                    )
                                                 raise RuntimeError(f"__PROVIDER_ERROR__:{current_model}")
                                             else:
-                                                # Unknown error: show a concise message, not the raw blob
-                                                _short = err_msg.split("{'error'")[0].strip() or err_msg[:120]
-                                                if not silent:
-                                                    self.console.print(
-                                                        f"\n[bold red]Model error on {_friendly_name}: {_short}[/bold red]\n"
-                                                        f"[dim]Trying the next available model…[/dim]"
-                                                    )
-                                            raise RuntimeError(f"Server completion error ({current_model}): {err_msg}")
+                                                raise RuntimeError(f"Server completion error ({current_model}): {err_msg}")
                                         if "finish_reason" in chunk and chunk["finish_reason"]:
                                             _stream_finish_reason = chunk["finish_reason"]
                                         elif not _stream_finish_reason:
@@ -2188,24 +2158,11 @@ class LLMTransportMixin:
                             _paid_slug = current_model.rsplit(":free", 1)[0]
                             _remaining = models_to_try[model_idx + 1:]
                             if _paid_slug not in _remaining:
-                                if not silent:
-                                    self.console.print(
-                                        f"\n[dim yellow]↪ Free model rate-limited — trying paid version '{_paid_slug}'…[/dim yellow]"
-                                    )
                                 # Insert paid slug as the very next model, then break
                                 models_to_try[model_idx + 1:model_idx + 1] = [_paid_slug]
-                            else:
-                                if not silent:
-                                    self.console.print(
-                                        f"\n[dim yellow]↪ Free model rate-limited — paid version already in queue, skipping…[/dim yellow]"
-                                    )
                             break  # inner attempt loop → outer loop picks up injected paid slug
                         # If primary model is rate-limited and fallback models exist, race them
                         if current_is_primary and fallback_list:
-                            if not silent:
-                                self.console.print(
-                                    f"\n[dim yellow]⏳  Model '{current_model}' is temporarily rate-limited by the provider — racing fallback models…[/dim yellow]\n"
-                                )
                             raise _ServerUnavailableError(f"Rate-limited on model '{current_model}'")
 
                         # Non-free model with no fallback: show message and return

{utim_cli-2.3.24 → utim_cli-2.3.25}/utim_cli/orchestrator_tool_exec.py

@@ -659,6 +659,13 @@ class ToolExecutionMixin:
                 self.console.print(bl)
         rendered_text = capture.get()
         if print_to_console and getattr(self, "_subagent_depth", 0) == 0:
+            try:
+                from utim_cli.state import STATE
+                if STATE.get("dialog_active"):
+                    self.console.print(rendered_text, end="", markup=False, highlight=False)
+                    return rendered_text
+            except Exception:
+                pass
             if getattr(self.console, "file", None) is not sys.stdout and getattr(self.console, "file", None) is not sys.__stdout__:
                 # IMPORTANT: rendered_text is a *plain string* that was already
                 # produced by Rich (via capture.get()). It can legitimately

{utim_cli-2.3.24 → utim_cli-2.3.25}/utim_cli/state.py

@@ -13,4 +13,5 @@ STATE = {
     "tools_expanded": False,    # Toggle global tool results inline expand/collapse
     "thinking_topic": "",     # Dynamic topic for the spinner
     "is_verified": False,     # True if user has entered the secret code in this session
+    "dialog_active": False,   # True when any modal/dialog is full screen or running in terminal
 }

utim_cli-2.3.25/utim_cli/tui/compression_dialog.py

@@ -0,0 +1,188 @@
+"""
+/compression -- Interactive context compression level picker.
+
+Five levels from Very Low (almost verbatim, costs more) to Very High
+(aggressive summarisation, saves tokens but risks forgetting old context).
+The chosen level is persisted in config and immediately applied to
+context_pruner.build_compacted_history_message on the next turn.
+"""
+
+import re
+from typing import Tuple
+
+# -- Level definitions ---------------------------------------------------------
+# Each entry: (id, label, oldest_keep_ratio, newest_keep_ratio, merge_count, warning)
+COMPRESSION_LEVELS = [
+    (
+        "very_low",
+        "Very Low",
+        0.50, 0.95,
+        0,
+        "Can cost more because most of the context is kept; model has very low risk of forgetting.",
+        "yellow",
+    ),
+    (
+        "low",
+        "Low",
+        0.25, 0.85,
+        2,
+        "Mild compression on older turns; keeps context intact with minimal forgetting risk.",
+        "dim",
+    ),
+    (
+        "medium",
+        "Medium  [default]",
+        0.07, 0.70,
+        5,
+        "Balanced progressive compression (oldest ~7% to newest ~70% kept); merges turns 1-5.",
+        "dim",
+    ),
+    (
+        "high",
+        "High",
+        0.03, 0.50,
+        8,
+        "Aggressive compression; saves more tokens but might lose details from earlier turns.",
+        "yellow",
+    ),
+    (
+        "very_high",
+        "Very High",
+        0.01, 0.30,
+        12,
+        "Maximum compression; saves tokens, but might lose bit of context from previous turns when session is running long.",
+        "red",
+    ),
+]
+
+LEVEL_IDS = [l[0] for l in COMPRESSION_LEVELS]
+DEFAULT_LEVEL = "medium"
+
+
+def get_compression_level() -> str:
+    """Return the currently persisted compression level id (defaults to 'medium')."""
+    try:
+        from utim_cli.config import config
+        val = config.get("compression_level") or DEFAULT_LEVEL
+        return val if val in LEVEL_IDS else DEFAULT_LEVEL
+    except Exception:
+        return DEFAULT_LEVEL
+
+
+def set_compression_level(level_id: str) -> None:
+    """Persist the chosen compression level and notify context_pruner."""
+    try:
+        from utim_cli.config import config
+        config.set("compression_level", level_id)
+    except Exception:
+        pass
+    try:
+        from utim_cli.context_pruner import apply_compression_level
+        apply_compression_level(level_id)
+    except Exception:
+        pass
+
+
+def get_level_params(level_id: str) -> Tuple[float, float, int]:
+    """Return (oldest_ratio, newest_ratio, merge_count) for a level id."""
+    for lid, _, oldest, newest, merge, _, _ in COMPRESSION_LEVELS:
+        if lid == level_id:
+            return oldest, newest, merge
+    return 0.07, 0.70, 5   # medium fallback
+
+
+# -- TUI dialog ----------------------------------------------------------------
+
+def _dialog_compression(orchestrator=None) -> None:
+    """Open the interactive compression level picker using UTIM's full-screen list dialog."""
+    from utim_cli.utim import console, _run_list_dialog
+
+    current_level = get_compression_level()
+
+    # Build options list from COMPRESSION_LEVELS
+    options = []
+    for lid, label, oldest, newest, merge, warning, warn_color in COMPRESSION_LEVELS:
+        options.append({
+            "id": lid,
+            "label": label,
+            "oldest": oldest,
+            "newest": newest,
+            "merge": merge,
+            "warning": warning,
+            "warn_color": warn_color,
+        })
+    options.append({
+        "id": "cancel",
+        "label": "↩  Cancel",
+        "warning": "Exit without changing compression level",
+    })
+
+    def _render_row(i: int, row: dict, sel: bool):
+        bg = "bg:#313244 fg:#ffffff bold" if sel else ""
+        if row.get("id") == "cancel":
+            return [
+                (bg or "class:dim", "  ➔ " if sel else "     "),
+                (bg or "bold #f38ba8", f"{row['label']}\n"),
+                (bg or "class:dim", f"       {row['warning']}\n"),
+            ]
+
+        is_current = (row["id"] == current_level)
+        badge = "● ACTIVE " if is_current else "○         "
+        badge_style = bg or ("bold #a6e3a1" if is_current else "class:dim")
+
+        oldest_pct = int(row["oldest"] * 100)
+        newest_pct = int(row["newest"] * 100)
+        ratio_str = f"oldest {oldest_pct}% → newest {newest_pct}% kept"
+
+        warn_color = row.get("warn_color", "dim")
+        if warn_color == "red":
+            warn_style = bg or "bold #ff5555"
+        elif warn_color == "yellow":
+            warn_style = bg or "#ffb86c"
+        else:
+            warn_style = bg or "class:dim"
+        icon = "⚠ " if warn_color in ("red", "yellow") else "ℹ "
+
+        if row.get("merge", 0) > 0:
+            merge_txt = f"Merges oldest {row['merge']} turns into one block"
+        else:
+            merge_txt = "No turn merging (all turns kept individually)"
+
+        fragments = [
+            (badge_style, f"  {badge}"),
+            (bg or "bold #42bcf5", f"{row['label']:<20}"),
+            (bg or "class:dim", f"  [{ratio_str}]\n"),
+            (bg or "#a6adc8", f"              • {merge_txt}\n"),
+            (warn_style, f"              {icon}{row['warning']}\n"),
+        ]
+        return fragments
+
+    action, idx = _run_list_dialog(
+        options,
+        _render_row,
+        title="❯ Context Compression Level Picker",
+        legend=(
+            "↑↓ Navigate  •  Enter Apply  •  Esc / q Cancel  •  "
+            "Currently active level marked [bold #a6e3a1]● ACTIVE[/bold #a6e3a1]"
+        ),
+    )
+
+    if action != "select" or idx is None:
+        try:
+            console.print("\n  [dim]✗ Cancelled. No changes made.[/dim]\n")
+        except Exception:
+            pass
+        return
+
+    chosen = options[idx]
+    if chosen["id"] == "cancel":
+        console.print("\n  [dim]✗ Cancelled. No changes made.[/dim]\n")
+        return
+
+    set_compression_level(chosen["id"])
+
+    console.print(
+        f"\n  [bold #42bcf5]✓ Compression level set to[/bold #42bcf5] "
+        f"[bold white]{chosen['label']}[/bold white]  "
+        f"[dim](takes effect on next context window build)[/dim]\n"
+    )