utim-cli 2.3.16__tar.gz → 2.3.17__tar.gz

{utim_cli-2.3.16 → utim_cli-2.3.17}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [2.3.17] - 2026-08-31
+
+### ✨ Premium Model Visibility for Bonus-Credit Users
+- Free-plan users with bonus credits can now see premium models in the model catalog (server-side `/models/catalog` and client-side TUI gating)
+- Added bonus-credit detection helper with caching and graceful offline fallback
+- Bonus credits are deducted exclusively when premium completions finish; visibility switches back automatically once the balance is exhausted
+
 ## [2.3.16] - 2026-08-29
 
 ### 🛠️ Minor Enhancements and Bug Fixes

{utim_cli-2.3.16/utim_cli.egg-info → utim_cli-2.3.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.3.16
+Version: 2.3.17
 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.16 → utim_cli-2.3.17}/pyproject.toml

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

{utim_cli-2.3.16 → utim_cli-2.3.17}/utim/__init__.py

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

{utim_cli-2.3.16 → utim_cli-2.3.17}/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.16"
+    __version__ = "2.3.17"
 
 
 import builtins, os, pathlib, urllib.parse, re

{utim_cli-2.3.16 → utim_cli-2.3.17}/utim_cli/_version.py

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

{utim_cli-2.3.16 → utim_cli-2.3.17}/utim_cli/orchestrator_llm_transport.py

@@ -380,15 +380,42 @@ class LLMTransportMixin:
                 table_buf = []
                 code_block_buf = []
 
+                # ── Stream paint throttling (UI lag fix) ──────────────────────
+                # Batch streamed markdown lines and repaint at a capped rate.
+                # Previously every line triggered console.print -> patch_stdout
+                # -> full prompt_toolkit re-render; during fast streams that
+                # meant dozens of full repaints/sec competing with the spinner
+                # thread's invalidates (typing stutters, multi-second freezes).
+                _pending_md = []            # batched markdown lines awaiting print
+                _last_md_flush = [0.0]      # monotonic ts of last streamed paint
+                _MD_FLUSH_INTERVAL = 0.12   # max ~8 stream repaints/sec
+
+                def _flush_pending_md(force=False):
+                    import time as _t
+                    now = _t.monotonic()
+                    if _pending_md and (force or (now - _last_md_flush[0]) >= _MD_FLUSH_INTERVAL):
+                        text = "\n".join(_pending_md)
+                        _pending_md.clear()
+                        if text.strip():
+                            self.console.print(Markdown(text))
+                        else:
+                            self.console.print()
+                        _last_md_flush[0] = now
+                        try:
+                            from utim_cli.state import STATE
+                            STATE["last_stream_paint"] = _t.time()
+                        except Exception:
+                            pass
+
                 def stream_markdown_line(part_text):
-                    if not part_text.strip():
-                        self.console.print()
-                        return
-                    self.console.print(Markdown(part_text))
+                    _pending_md.append(part_text)
+                    _flush_pending_md()
 
                 def flush_table():
                     if not table_buf:
                         return
+                    # Keep ordering: paint any pending prose before the table.
+                    _flush_pending_md(force=True)
                     table_text = "\n".join(table_buf)
                     table_buf.clear()
                     self.console.print(Markdown(table_text))
@@ -396,6 +423,8 @@ class LLMTransportMixin:
                 def flush_code_block():
                     if not code_block_buf:
                         return
+                    # Keep ordering: paint any pending prose before the block.
+                    _flush_pending_md(force=True)
                     code_text = "\n".join(code_block_buf)
                     code_block_buf.clear()
                     self.console.print(Markdown(code_text))
@@ -585,8 +614,18 @@ class LLMTransportMixin:
                 # Stream complete for winner
                 if is_this_winner:
                     flush_table()
+                    # Force out any batched (throttled) markdown lines so no
+                    # stream text is left unrendered at end of stream.
+                    try:
+                        _flush_pending_md(force=True)
+                    except Exception:
+                        pass
                     if _line_buf and not silent:
                         process_stream_part(_line_buf)
+                        try:
+                            _flush_pending_md(force=True)
+                        except Exception:
+                            pass
                         _line_buf = ""
 
                     final_content = collapse_repeating_patterns(final_content)
@@ -714,11 +753,10 @@ class LLMTransportMixin:
 
                     if not is_custom and free_bonus_balance <= 0.0 and models_allowed != ["all"] and chosen_model not in models_allowed and not chosen_model.endswith(":free"):
                         if quota.get("plan") == "free" or quota.get("display_name") == "Free":
-                            self.console.print(f"\n[bold red]✗ Monthly free quota exhausted and no bonus credits remaining.[/bold red]")
-                            self.console.print(f"  Model '{chosen_model}' requires bonus credits or an upgraded plan.")
-                            self.console.print("  Top up at [bold]utim.dev/pricing[/bold] or run [bold]utim upgrade[/bold].\n")
                             fallback_model = DEFAULT_MODEL
-                            self.console.print(f"  Falling back to: [bold]{fallback_model}[/bold]")
+                            self.console.print(f"\n[bold yellow]⚠ Bonus credits exhausted — '{chosen_model}' is gated on the Free plan.[/bold yellow]")
+                            self.console.print(f"  Auto-switching to the free model [bold]{fallback_model}[/bold] so you can keep working.")
+                            self.console.print("  Top up bonus credits at [bold]utim.dev/pricing[/bold] or run [bold]utim upgrade[/bold].\n")
                             if override_model:
                                 override_model = fallback_model
                             else:
@@ -1805,10 +1843,25 @@ class LLMTransportMixin:
                         if _has_bonus:
                             # Bonus credits still active — server may have stale state, skip to next fallback
                             break
-                        self.console.print(f"\n[bold red]✗ Model '{current_model}' requires bonus credits or an upgraded plan.[/bold red]")
+                        # Bonus exhausted (or plan-gated): auto-degrade to the free
+                        # default model instead of aborting the user's turn.
+                        _free_fallback = DEFAULT_MODEL
+                        if current_model != _free_fallback and not current_model.endswith(":free"):
+                            self.console.print(f"\n[bold yellow]⚠ Model '{current_model}' needs bonus credits and your bonus balance is empty.[/bold yellow]")
+                            self.console.print(f"  Auto-switching to the free model [bold]{_free_fallback}[/bold] so you can keep working.")
+                            self.console.print("  Top up bonus credits at [bold]utim.dev/pricing[/bold] or run [bold]utim upgrade[/bold].\n")
+                            # Splice the free fallback in as the very next model to try.
+                            _head = models_to_try[:model_idx + 1]
+                            _tail = [m for m in models_to_try[model_idx + 1:] if m != _free_fallback]
+                            models_to_try[:] = _head + [_free_fallback] + _tail
+                            if not override_model and model_idx == 0:
+                                self.model_id = _free_fallback
+                                self.model_source = "utim"
+                                config.set("main_model_source", "utim")
+                            break  # attempt loop → outer loop picks up _free_fallback next
+                        self.console.print(f"\n[bold red]✗ Model '{current_model}' is unavailable on your current plan.[/bold red]")
                         self.console.print("  Top up at [bold]utim.dev/pricing[/bold] or run [bold]utim upgrade[/bold].")
-                        self.console.print("  [bold yellow]Tip: Your bonus credits are exhausted. You can still access all free models! [/bold yellow]")
-                        self.console.print("  [yellow]   Press Ctrl+M or type /model to switch to a free model, or run 'utim reset'.[/yellow]\n")
+                        self.console.print("  [yellow]Tip: free models like 'poolside/laguna-s-2.1:free' always work — press Ctrl+M or type /model to pick one.[/yellow]\n")
                         raise _FatalClientError(f"Model '{current_model}' requires bonus credits or an upgraded plan.")
                     if code == 429:
                         # ── OpenRouter / provider rate-limit hit ───────────────────────

{utim_cli-2.3.16 → utim_cli-2.3.17}/utim_cli/server/auth.py

@@ -677,17 +677,39 @@ def _resolve_user_plan_name(user) -> str:
 
     Safe to call without a DB session — falls back to ``"free"`` on any error
     so that catalog gating cannot leak paid models to anonymous callers.
+
+    Expiration-aware: an ``active`` subscription whose ``end_date`` has passed
+    (and which was never renewed) is treated as ``free`` — we do not rely on a
+    background job to flip the status to ``expired``.
     """
     try:
         from .db import SessionLocal, UserSubscription
-        sub = (
+        from datetime import datetime, timezone
+        subs = (
             SessionLocal()
             .query(UserSubscription)
             .filter(UserSubscription.user_id == user.id, UserSubscription.status == "active")
-            .first()
+            .all()
         )
-        if sub and sub.plan and getattr(sub.plan, "name", None):
-            return str(sub.plan.name).lower()
+        now = datetime.now(timezone.utc)
+        best = None
+        best_end = None
+        for sub in subs:
+            if not (sub.plan and getattr(sub.plan, "name", None)):
+                continue
+            end = getattr(sub, "end_date", None)
+            # Normalise tz-aware end_date to naive UTC (or vice-versa) so the
+            # comparison never raises TypeError on mixed aware/naive values.
+            if end is not None and getattr(end, "tzinfo", None) is not None:
+                end = end.astimezone(timezone.utc).replace(tzinfo=None)
+            # Skip subscriptions that already expired.
+            if end is not None and end < now.replace(tzinfo=None):
+                continue
+            if best is None or (end is not None and (best_end is None or end > best_end)):
+                best = sub
+                best_end = end
+        if best is not None:
+            return str(best.plan.name).lower()
     except Exception:
         pass
     return "free"

{utim_cli-2.3.16 → utim_cli-2.3.17}/utim_cli/server/concurrency.py

@@ -43,8 +43,8 @@ logger = logging.getLogger("utim.concurrency")
 
 # ── Thread-pool executor for sync DB calls ────────────────────────────────────
 # Size = number of DB connections we'll keep busy in parallel.
-# Must be <= pool_size + max_overflow defined in db.py (currently 25).
-_DB_POOL_WORKERS = 25
+# Must be <= pool_size + max_overflow defined in db.py (currently 30).
+_DB_POOL_WORKERS = 30
 _db_executor = ThreadPoolExecutor(
     max_workers=_DB_POOL_WORKERS,
     thread_name_prefix="utim-db",

{utim_cli-2.3.16 → utim_cli-2.3.17}/utim_cli/server/db.py

@@ -45,16 +45,21 @@ if _is_sqlite:
 else:
     # Postgres: tune the connection pool for high concurrency across multi-worker setups.
     #   pool_size=10      — base connections kept alive permanently per worker
-    #   max_overflow=15   — burst up to 25 simultaneous DB connections per worker
-    #   pool_timeout=10   — wait up to 10 s for a free connection before raising
+    #   max_overflow=20   — burst up to 30 simultaneous DB connections per worker
+    #   pool_timeout=30   — wait up to 30 s for a free connection before raising
+    #                       (was 10s — too short for billing bursts under high load)
     #   pool_recycle=1800 — recycle connections every 30 min (avoids "server closed connection")
+    #   pool_use_lifo=True — reuse freshly-returned connections first (keeps pool warm)
+    #
+    # NOTE: pool_size + max_overflow must be >= concurrency._DB_POOL_WORKERS (currently 25).
     engine = create_engine(
         DATABASE_URL,
         pool_pre_ping=True,
         pool_size=10,
-        max_overflow=15,
-        pool_timeout=10,
+        max_overflow=20,
+        pool_timeout=30,
         pool_recycle=1800,
+        pool_use_lifo=True,
         connect_args=_connect_args,
     )
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
@@ -986,13 +991,11 @@ def init_db(silent: bool = True) -> None:
             except Exception as node_exc:
                 _print(f"[DB INIT] Storage node seeding warning: {node_exc}")
 
-            # Seed and sync all models into model_registry table
-            try:
-                from .models import sync_models_to_db
-                sync_models_to_db()
-                _print("[DB INIT] Model registry sync completed.")
-            except Exception as model_sync_exc:
-                _print(f"[DB INIT] Model registry sync warning: {model_sync_exc}")
+            # NOTE: Model registry auto-sync on startup is intentionally DISABLED.
+            # sync_models_to_db() was previously called here but it overwrote the
+            # admin's manually curated model list with the hardcoded MODEL_REGISTRY
+            # on every deploy. Model management is now done exclusively via the
+            # admin panel — no automatic seeding on startup.
 
             # Seed guest user and guest subscription for persistent rewards preview
             try: