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

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

@@ -1,5 +1,15 @@
 # Changelog
 
+## [2.3.25] - 2026-09-07
+
+### 🛠️ Bug Fixes
+- Fixed usage dialog glitches
+
+## [2.3.24] - 2026-09-07
+
+### ⚡ Performance
+- Fixed latency issues
+
 ## [2.3.23] - 2026-09-07
 
 ### 🛠️ Minor Bug Fixes and Enhancement

{utim_cli-2.3.23/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.23
+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.23 → utim_cli-2.3.25}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "2.3.23"
+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.23 → utim_cli-2.3.25}/utim/__init__.py

@@ -1,4 +1,4 @@
-"""
+"""
 UTIM Developer SDK
 ------------------
 Unified autonomous coding agent SDK.
@@ -14,7 +14,7 @@ Quickstart:
 try:
     from utim_cli._version import VERSION as __version__
 except ImportError:
-    __version__ = "2.3.22"
+    __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.23 → 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.23"
+    __version__ = "2.3.25"
 
 
 import builtins, os, pathlib, urllib.parse, re

{utim_cli-2.3.23 → 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.23"
+VERSION = "2.3.25"
 
 

{utim_cli-2.3.23 → utim_cli-2.3.25}/utim_cli/orchestrator.py

@@ -848,7 +848,7 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
                     msg, was_streamed = self._call_llm(
                         send_msgs,
                         override_tools=override_tools or getattr(self, "_subagent_tool_override", None),
-                        silent=True  # Suppress "⏳ Model" rate-limit messages during fallback flows
+                        silent=False,
                     )
                     reasoning_duration = time.time() - t_llm_start
 

{utim_cli-2.3.23 → 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,19 +2158,14 @@ 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
+                        # If primary model is rate-limited and fallback models exist, race them
+                        if current_is_primary and fallback_list:
+                            raise _ServerUnavailableError(f"Rate-limited on model '{current_model}'")
+
+                        # Non-free model with no fallback: show message and return
                         rate_limit_display = (
                             f"⏳ **Model Rate Limited**: `{current_model}` is currently experiencing high demand and is temporarily rate-limited by the provider.\n\n"
                             f"- **What to do:** Please wait a moment before retrying, or switch to a different model with `/model` or `Ctrl+M`.\n"

{utim_cli-2.3.23 → 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.23 → utim_cli-2.3.25}/utim_cli/server/key_rotator.py

@@ -1891,12 +1891,7 @@ class ApinexKeyRotator:
         return max(self.TOTAL_RPM_PER_KEY, len(self._keys) * self.TOTAL_RPM_PER_KEY)
 
     def _get_active_key_locked(self, now: float) -> Optional[KeyEntry]:
-        """Find the current active unexhausted APINEX key.
-
-        Pins to the current key for all requests until it returns 402.
-        When 402 occurs, that key is marked exhausted until 00:00 UTC (5:30 AM IST)
-        and rotation advances to the next key until all keys are exhausted.
-        """
+        """Find the next active unexhausted APINEX key using round-robin rotation."""
         if not self._keys:
             return None
         n = len(self._keys)
@@ -1909,7 +1904,7 @@ class ApinexKeyRotator:
                 continue
             if k.is_in_cooldown(now):
                 continue
-            self._current_key_idx = idx
+            self._current_key_idx = (idx + 1) % n
             return k
 
         # Fallback: if all non-exhausted keys are currently in cooldown, return the first unexhausted key
@@ -1918,13 +1913,17 @@ class ApinexKeyRotator:
             k = self._keys[idx]
             if (k.exhausted_until > 0 and now < k.exhausted_until) or k.credits_exhausted or k.paid_exhausted:
                 continue
+            self._current_key_idx = (idx + 1) % n
             return k
         return None
 
     def has_available_keys(self) -> bool:
         with self._lock:
             now = time.time()
-            return self._get_active_key_locked(now) is not None
+            return any(
+                not ((k.exhausted_until > 0 and now < k.exhausted_until) or k.credits_exhausted or k.paid_exhausted)
+                for k in self._keys
+            )
 
     def get_all_unexhausted_keys(self, now: Optional[float] = None) -> List[KeyEntry]:
         """Return all APINEX keys that are not 402 daily quota exhausted."""
@@ -1940,6 +1939,7 @@ class ApinexKeyRotator:
             return unexhausted
 
     def acquire_key(self, purpose: str = "user") -> KeyEntry:
+        """Acquire the next available APINEX key using round-robin rotation and load balancing."""
         with self._lock:
             if not self._keys:
                 self._refresh_keys()
@@ -1953,36 +1953,46 @@ class ApinexKeyRotator:
             for k in self._keys:
                 k.prune_expired(now)
 
-            active_key = self._get_active_key_locked(now)
-            if active_key is None:
-                raise HTTPException(
-                    status_code=503,
-                    detail=(
-                        f"All {len(self._keys)} APINEX API keys have exhausted their daily quota (402) "
-                        f"until 00:00 UTC (5:30 AM IST). Service will resume at 00:00 UTC."
-                    ),
+            candidates = [
+                k for k in self._keys
+                if k.has_capacity(
+                    purpose=purpose,
+                    now=now,
+                    user_limit=self.USER_RPM_PER_KEY,
+                    reflection_limit=self.REFLECTION_RPM_PER_KEY,
+                    total_limit=self.TOTAL_RPM_PER_KEY,
+                    daily_limit=self.DAILY_RPD_PER_KEY,
                 )
+            ]
 
-            if not active_key.has_capacity(
-                purpose=purpose,
-                now=now,
-                user_limit=self.USER_RPM_PER_KEY,
-                reflection_limit=self.REFLECTION_RPM_PER_KEY,
-                total_limit=self.TOTAL_RPM_PER_KEY,
-                daily_limit=self.DAILY_RPD_PER_KEY,
-            ):
-                total_rpm = active_key.current_total_rpm(now)
+            if not candidates:
+                if all((k.exhausted_until > 0 and now < k.exhausted_until) or k.credits_exhausted or k.paid_exhausted for k in self._keys):
+                    raise HTTPException(
+                        status_code=503,
+                        detail=(
+                            f"All {len(self._keys)} APINEX API keys have exhausted their daily quota (402) "
+                            f"until 00:00 UTC (5:30 AM IST). Service will resume at 00:00 UTC."
+                        ),
+                    )
+                total_rpm = sum(k.current_total_rpm(now) for k in self._keys)
                 raise HTTPException(
                     status_code=429,
                     detail=(
-                        f"APINEX capacity limit reached on current key ({total_rpm}/{self.TOTAL_RPM_PER_KEY} RPM, "
-                        f"max 15 RPM/key). Please wait a few seconds before retrying."
+                        f"APINEX capacity limit reached ({total_rpm}/{self.max_total_rpm} RPM across "
+                        f"{len(self._keys)} keys, max 15 RPM/key). Please wait a few seconds before retrying."
                     ),
                     headers={"Retry-After": "5"},
                 )
 
-            active_key.record_request(purpose=purpose, now=now)
-            return active_key
+            start_idx = self._rr_idx % len(self._keys)
+            ordered = sorted(
+                candidates,
+                key=lambda k: (k.active_requests, (self._keys.index(k) - start_idx) % len(self._keys)),
+            )
+            chosen = ordered[0]
+            self._rr_idx = (self._keys.index(chosen) + 1) % len(self._keys)
+            chosen.record_request(purpose=purpose, now=now)
+            return chosen
 
     def release_key(
         self,
@@ -2016,7 +2026,6 @@ class ApinexKeyRotator:
                 if self._keys and key_entry in self._keys:
                     curr_idx = self._keys.index(key_entry)
                     self._current_key_idx = (curr_idx + 1) % len(self._keys)
-                    self._get_active_key_locked(now)
 
             self._try_dequeue_locked(now)
 
@@ -2067,25 +2076,32 @@ class ApinexKeyRotator:
         for k in self._keys:
             k.prune_expired(now)
 
-        active_key = self._get_active_key_locked(now)
-        if active_key is None:
-            return False
-
         dequeued_any = False
         remaining: List[QueuedRequest] = []
         for req in self._waiting_queue:
             if req.is_cancelled:
                 continue
-            if active_key.has_capacity(
-                purpose=req.purpose,
-                now=now,
-                user_limit=self.USER_RPM_PER_KEY,
-                reflection_limit=self.REFLECTION_RPM_PER_KEY,
-                total_limit=self.TOTAL_RPM_PER_KEY,
-                daily_limit=self.DAILY_RPD_PER_KEY,
-            ):
-                active_key.record_request(purpose=req.purpose, now=now)
-                req.chosen_key = active_key
+            candidates = [
+                k for k in self._keys
+                if k.has_capacity(
+                    purpose=req.purpose,
+                    now=now,
+                    user_limit=self.USER_RPM_PER_KEY,
+                    reflection_limit=self.REFLECTION_RPM_PER_KEY,
+                    total_limit=self.TOTAL_RPM_PER_KEY,
+                    daily_limit=self.DAILY_RPD_PER_KEY,
+                )
+            ]
+            if candidates:
+                start_idx = self._rr_idx % len(self._keys)
+                ordered = sorted(
+                    candidates,
+                    key=lambda k: (k.active_requests, (self._keys.index(k) - start_idx) % len(self._keys)),
+                )
+                chosen = ordered[0]
+                self._rr_idx = (self._keys.index(chosen) + 1) % len(self._keys)
+                chosen.record_request(purpose=req.purpose, now=now)
+                req.chosen_key = chosen
                 req.event.set()
                 req.notify_event.set()
                 dequeued_any = True
@@ -2175,18 +2191,29 @@ class ApinexKeyRotator:
                 )
 
             if not self._waiting_queue:
-                if active_key.has_capacity(
-                    purpose=purpose,
-                    now=now,
-                    user_limit=self.USER_RPM_PER_KEY,
-                    reflection_limit=self.REFLECTION_RPM_PER_KEY,
-                    total_limit=self.TOTAL_RPM_PER_KEY,
-                    daily_limit=self.DAILY_RPD_PER_KEY,
-                ):
-                    active_key.record_request(purpose=purpose, now=now)
-                    if active_key.async_client is None:
-                        self._init_clients(active_key)
-                    ready_item = {"status": "ready", "client": active_key.async_client, "key_entry": active_key}
+                candidates = [
+                    k for k in self._keys
+                    if k.has_capacity(
+                        purpose=purpose,
+                        now=now,
+                        user_limit=self.USER_RPM_PER_KEY,
+                        reflection_limit=self.REFLECTION_RPM_PER_KEY,
+                        total_limit=self.TOTAL_RPM_PER_KEY,
+                        daily_limit=self.DAILY_RPD_PER_KEY,
+                    )
+                ]
+                if candidates:
+                    start_idx = self._rr_idx % len(self._keys)
+                    ordered = sorted(
+                        candidates,
+                        key=lambda k: (k.active_requests, (self._keys.index(k) - start_idx) % len(self._keys)),
+                    )
+                    chosen = ordered[0]
+                    self._rr_idx = (self._keys.index(chosen) + 1) % len(self._keys)
+                    chosen.record_request(purpose=purpose, now=now)
+                    if chosen.async_client is None:
+                        self._init_clients(chosen)
+                    ready_item = {"status": "ready", "client": chosen.async_client, "key_entry": chosen}
 
         if ready_item is not None:
             yield ready_item

{utim_cli-2.3.23 → utim_cli-2.3.25}/utim_cli/server/models.py

@@ -3217,7 +3217,10 @@ def get_model_catalog(user_tier: str = "all") -> dict:
             payload[key] = [it for it in payload[key] if _is_free_item(it)]
     else:
         # Non-free users:
-        # APINEX models are free gateway models (zero cost) — they remain available on paid plans too.
+        # APINEX models are free gateway models for free tier users — exclude them from paid tier catalogs
+        if not is_all_user:
+            for key in ("main_agent", "plan_project", "subagent_text", "analyze_image", "image_gen", "all_text"):
+                payload[key] = [it for it in payload[key] if str(it.get("provider", "")).lower() != "apinex"]
 
         # Paid plan: look up the Plan row's `allowed_models`
         try:

{utim_cli-2.3.23 → utim_cli-2.3.25}/utim_cli/server/routes/completion_routes.py

@@ -93,9 +93,9 @@ def is_model_allowed(model_id: str, allowed_models_str: str, bonus_balance: floa
         or (entry and getattr(entry, "provider", "").lower() == "apinex")
     )
 
-    # 1. APINEX models: free gateway models — allowed on ALL plans (free + paid)
+    # 1. APINEX models: free gateway models allowed on free plan (or with bonus credits/all)
     if is_apinex_model:
-        return True
+        return is_free_plan or bonus_balance > 0.0 or allowed_models_str == "all"
 
     if bonus_balance > 0.0:
         return True
@@ -1407,9 +1407,8 @@ async def completions(
                             detail="All OpenRouter API keys have exhausted paid credits (402) until 00:00 UTC (5:30 AM IST). Free models may still be available.",
                         )
 
-                # ── 4. Non-free paid model 429: handle upstream vs daily quota ──
+                # ── 4. Non-free paid model 429: rotate across remaining paid keys in the pool ──
                 elif stream is None and key_entry and hasattr(key_entry, "key_id") and key_entry.key_id != "nvidia" and _is_429:
-                    mark_model_rate_limited(req.model_id, cooldown_seconds=25.0)
                     if _is_upstream_429:
                         _purpose_str = "reflection" if is_refl else "user"
                         global_key_rotator.unrecord_key(key_entry, purpose=_purpose_str)
@@ -1419,23 +1418,47 @@ async def completions(
                             status_code=429,
                             upstream_provider_429=True,
                         )
-                        key_entry = None
-                        raise HTTPException(
-                            status_code=429,
-                            detail=(
-                                f"Model '{req.model_id}' is temporarily rate-limited by the provider. "
-                                f"Please wait ~25s before retrying, or switch to a different model with /model."
-                            ),
-                            headers={"Retry-After": "25"},
-                        )
                     else:
                         global_key_rotator.demote_key_to_last(key_entry)
                         global_key_rotator.release_key(key_entry, success=False, status_code=429, is_daily_quota_429=False)
-                        key_entry = None
+                    key_entry = None
+
+                    # Rotate across remaining available paid keys before giving up
+                    cand_paid_keys = [k for k in global_key_rotator._keys if not k.is_paid_exhausted(time.time())]
+                    for p_key in cand_paid_keys:
+                        if p_key.is_in_cooldown(time.time()):
+                            continue
+                        try:
+                            p_key.record_request(purpose=purpose, now=time.time())
+                            stream = await p_key.async_client.chat.completions.create(**kwargs)
+                            if stream:
+                                client = p_key.async_client
+                                key_entry = p_key
+                                logger.info(f"Paid model '{req.model_id}' succeeded after rotating to key {p_key.env_var}")
+                                break
+                        except Exception as p_err:
+                            p_st = getattr(p_err, "status_code", None)
+                            p_s = str(p_err).lower()
+                            if p_st == 402 or "402" in p_s or "payment required" in p_s:
+                                global_key_rotator.release_key(p_key, success=False, status_code=402)
+                                continue
+                            elif p_st == 429 or "429" in p_s or "rate" in p_s:
+                                global_key_rotator.demote_key_to_last(p_key)
+                                global_key_rotator.release_key(p_key, success=False, status_code=429)
+                                continue
+                            else:
+                                global_key_rotator.release_key(p_key, success=False)
+                                break
+
+                    if stream is None:
+                        mark_model_rate_limited(req.model_id, cooldown_seconds=20.0)
                         raise HTTPException(
                             status_code=429,
-                            detail="Provider temporary rate limit reached. Please wait a moment and retry your request.",
-                            headers={"Retry-After": "15"},
+                            detail=(
+                                f"Model '{req.model_id}' is temporarily rate-limited across all provider keys. "
+                                f"Please wait ~20s before retrying, or switch to a different model with /model."
+                            ),
+                            headers={"Retry-After": "20"},
                         )
 
                 # 2. Sequential fallback attempts for 400 Bad Request / parameter incompatibilities

{utim_cli-2.3.23 → 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
 }