utim-cli 2.3.13__tar.gz → 2.3.14__tar.gz

{utim_cli-2.3.13 → utim_cli-2.3.14}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [2.3.14] - 2026-08-28
+
+### ⚡ Request Queue & Scaled Free Capacity
+- Added request queue visual, Increased global free user request cap from 20RPM - 60RPM
+- Increase per user Rpm cap from 10-30RPM
+- Added a new fun feature "/personality"
+
 ## [2.3.13] - 2026-08-28
 
 ### 🐞 Minor Bug Fixes

{utim_cli-2.3.13/utim_cli.egg-info → utim_cli-2.3.14}/PKG-INFO

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

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

{utim_cli-2.3.13 → utim_cli-2.3.14}/utim/__init__.py

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

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

{utim_cli-2.3.13 → utim_cli-2.3.14}/utim_cli/_version.py

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

{utim_cli-2.3.13 → utim_cli-2.3.14}/utim_cli/ask_helper.py

@@ -389,7 +389,7 @@ def execute_ask_helper(
                     },
                     stream=False,
                     timeout=(15, 300),
-                    is_reflection=True,
+                    is_reflection=False,
                 )
                 if resp.status_code == 429:
                     continue

{utim_cli-2.3.13 → utim_cli-2.3.14}/utim_cli/auth.py

@@ -321,7 +321,7 @@ class _AuthCallbackHandler(http.server.BaseHTTPRequestHandler):
 
 # ── Public login() function ───────────────────────────────────────────────────
 
-def login(restart: bool = True) -> None:
+def login(restart: bool = False) -> None:
     """
     Sign in via the Device Authorization Flow.
     
@@ -504,8 +504,8 @@ def login(restart: bool = True) -> None:
             raw_print(f"  Signed in as {BLUE}{body.get('email', '')}{RESET}")
             if "credits" in body:
                 raw_print(f"  Credits: {body.get('credits', 0):,.0f} UTIM")
-            raw_print(f"  {DIM}Restarting UTIM CLI…{RESET}")
             if restart:
+                raw_print(f"  {DIM}Restarting UTIM CLI…{RESET}")
                 restart_process()
             # If restart wasn't called, fall through and let the main loop exit.
 

{utim_cli-2.3.13 → utim_cli-2.3.14}/utim_cli/brain.py

@@ -353,6 +353,13 @@ def store_brain_memory(
     if not content or not content.strip():
         return ""
 
+    try:
+        from utim_cli.tools import is_user_paid
+        if not is_user_paid():
+            return ""
+    except Exception:
+        pass
+
     pid = project_id or _project_id()
     now = datetime.now().isoformat()
     clean_title = title or content[:60].replace("\n", " ").strip()
@@ -444,6 +451,13 @@ def retrieve_brain_memories(
     if not query:
         return []
 
+    try:
+        from utim_cli.tools import is_user_paid
+        if not is_user_paid():
+            return []
+    except Exception:
+        pass
+
     pid = project_id or _project_id()
 
     # ── Stage 1: Forward pass ─────────────────────────────────────────────
@@ -696,6 +710,13 @@ def index_project_architecture(workspace: str = "."):
     If yes, store an updated architecture memory in the brain.
     Maintains exactly one deterministic architecture memory per project.
     """
+    try:
+        from utim_cli.tools import is_user_paid
+        if not is_user_paid():
+            return
+    except Exception:
+        pass
+
     pid  = _project_id(workspace)
     snap = _snapshot_project_architecture(workspace)
     snap_hash = hashlib.sha1(snap.encode()).hexdigest()
@@ -776,13 +797,19 @@ _watcher_lock    = threading.Lock()
 
 def start_brain_watcher():
     """
-    Start the background brain watcher daemon thread.
-    Safe to call multiple times — only one thread is ever started.
+    Start the background daemon watcher if not already running.
+    Safe to call multiple times.
     """
     global _watcher_started
     with _watcher_lock:
         if _watcher_started:
             return
+        try:
+            from utim_cli.tools import is_user_paid
+            if not is_user_paid():
+                return
+        except Exception:
+            pass
         _watcher_started = True
 
     # One-time cleanup of legacy duplicate records on startup
@@ -946,6 +973,13 @@ def get_brain_context_prompt(user_prompt: str = "") -> str:
     relevant brain project folder matching the project data/query, and injects
     direct clickable paths into the system prompt.
     """
+    try:
+        from utim_cli.tools import is_user_paid
+        if not is_user_paid():
+            return ""
+    except Exception:
+        pass
+
     try:
         pid, proj_dir = find_most_relevant_brain_project(user_prompt)
         brain_root = _brain_root()

{utim_cli-2.3.13 → utim_cli-2.3.14}/utim_cli/context_pruner.py

@@ -1496,7 +1496,7 @@ def _call_compression_model_with_fallback(messages: List[Dict], llm_key: str, ma
                     },
                     stream=False,
                     timeout=(15, 300),
-                    is_reflection=True
+                    is_reflection=False
                 )
                 if resp.status_code == 429:
                     # On 429 rate limit, immediately try fallback without blocking

{utim_cli-2.3.13 → utim_cli-2.3.14}/utim_cli/orchestrator.py

@@ -1010,14 +1010,14 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
 
             # If the model response was cut off mid-turn due to length/token limits, nudge it to continue
             # ONLY trigger when the response was genuinely truncated by token limits (never when finish_reason is "stop" or "end_turn")
+            _fr = msg.get("finish_reason") or "stop"
             _is_truly_token_truncated = (
                 not msg.get("aborted")
                 and not tool_calls
-                and msg.get("finish_reason") not in ("stop", "end_turn", "tool_calls", "repetition_loop")
+                and _fr not in ("stop", "end_turn", "tool_calls", "repetition_loop")
                 and (
-                    msg.get("was_truncated_by_limit")
-                    or msg.get("finish_reason") in ("length", "max_tokens")
-                    or (msg.get("was_cut_off") and msg.get("finish_reason") not in ("stop", "end_turn"))
+                    _fr in ("length", "max_tokens")
+                    or bool(msg.get("was_truncated_by_limit"))
                 )
             )
             if _is_truly_token_truncated:
@@ -1067,29 +1067,24 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
                     or (_attempted_tool_call and any(t in _MUTATION_TOOLS for t in _recent_tool_names))
                 )
 
-                # If the model stopped with empty OR trivially short response after running tools
-                _is_empty = not content.strip()
+                # If the model stopped with empty OR purely an unperformed action promise
+                _content_clean = content.strip()
+                _content_len = len(_content_clean)
+                _is_empty = (_content_len == 0)
                 _lower_content = content.lower()
                 _is_lazy_transition = False
                 is_planning = False
 
-                # ── Fix 3: Never lazy-nudge when a tool call was attempted ──────
-                # If we have parse failures, the model DID try to call a tool — it's
-                # not lazy. We handle it separately in the parse-failure block below.
-                if _attempted_tool_call and not tool_calls:
-                    # Tool call was attempted but failed to parse or reconstruct — skip lazy logic
-                    pass
+                # ── Fix: Never lazy-nudge when a tool call was attempted or already executed ──
+                if _attempted_tool_call or _had_tools_this_turn or tool_calls:
+                    # The model already executed tools or attempted tools this turn — it's reporting results
+                    _is_lazy_transition = False
                 else:
-                    _only_inspection_tools = _had_tools_this_turn and all(t in _INSPECTION_TOOLS for t in _recent_tool_names)
-                    _content_clean = content.strip()
-                    _content_len = len(_content_clean)
-                    _ends_with_cliffhanger = _content_clean.endswith(":") or _content_clean.endswith("...")
-
                     # Tail action promise: only genuine cliffhangers at the end of the text (e.g. "I will now edit foo.py:")
                     _ACTION_PROMISE_TAIL = [
-                        r"(?:i(?:'ll| will)|we(?:'ll| will))\s+(?:now\s+)?(?:update|edit|implement|create|fix|write|build|start|run)\b[^.\n]*[:\.\.\.]?$",
-                        r"let me\s+(?:now\s+)?(?:update|edit|implement|create|fix|write|build|start|run|check)\b[^.\n]*[:\.\.\.]?$",
-                        r"proceeding to\s+(?:implement|create|build|write|update|run)\b[^.\n]*[:\.\.\.]?$",
+                        r"^(?:i(?:'ll| will)|we(?:'ll| will))\s+(?:now\s+)?(?:update|edit|implement|create|fix|write|build|start|run)\b[^\n]*[:\.\.\.]?$",
+                        r"^let me\s+(?:now\s+)?(?:update|edit|implement|create|fix|write|build|start|run|check)\b[^\n]*[:\.\.\.]?$",
+                        r"^proceeding to\s+(?:implement|create|build|write|update|run)\b[^\n]*[:\.\.\.]?$",
                     ]
                     _has_tail_action_promise = any(
                         re.search(pat, _content_clean, re.IGNORECASE)
@@ -1104,31 +1099,12 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
                         "exit code 0", "exit_code: 0", "passes", "passing", "as requested", "here are the findings",
                         "here is the result", "here is the breakdown", "here is what i found",
                     ])
-                    _model_already_delivered = bool(_successful_mutations_this_turn)
 
-                    # Substantive responses (≥ 80 chars) that do not end in a dangling action cliffhanger
-                    # are treated as completed answers/findings and are NOT nudged.
-                    if _content_len >= 80 and not _has_tail_action_promise and not _ends_with_cliffhanger:
+                    # Only nudge if the ENTIRE message is a short (< 60 chars) unperformed action promise without tools
+                    if _content_len < 60 and _has_tail_action_promise and not _has_any_completion_marker and not is_planning:
+                        _is_lazy_transition = True
+                    else:
                         _is_lazy_transition = False
-                    elif _had_tools_this_turn:
-                        if _only_inspection_tools and not _attempted_mutations:
-                            # If the model inspected and returned a short uninformative cliffhanger without answering
-                            if _content_len < 40 and not _has_any_completion_marker and (_has_tail_action_promise or _ends_with_cliffhanger):
-                                _is_lazy_transition = True
-                            else:
-                                _is_lazy_transition = False
-                        elif is_planning:
-                            _is_lazy_transition = _content_len < 20
-                        else:
-                            # Nudge ONLY on genuine cliffhangers or empty promises
-                            _is_lazy_transition = (
-                                (_has_tail_action_promise or _ends_with_cliffhanger)
-                                or (_content_len < 30 and not _has_any_completion_marker and not _model_already_delivered)
-                            )
-                    elif not _had_tools_this_turn and not _is_empty and not is_planning and not tool_calls:
-                        # Model did not call any tools. Only nudge if it gave a short cliffhanger promising action.
-                        if _content_len < 100 and (_has_tail_action_promise or _ends_with_cliffhanger):
-                            _is_lazy_transition = True
 
                 # ── Fix 3/7: Handle tool-call parse failures explicitly ──────────
                 # The model emitted a tool call but the JSON was malformed/truncated.

{utim_cli-2.3.13 → utim_cli-2.3.14}/utim_cli/orchestrator_llm_transport.py

@@ -1193,9 +1193,11 @@ class LLMTransportMixin:
                                         try:
                                             if getattr(self, "_subagent_depth", 0) == 0:
                                                 from utim_cli.state import STATE
-                                                STATE["thinking_topic"] = _THINKING_PHASES[_phase_idx % len(_THINKING_PHASES)]
-                                                _phase_idx += 1
-                                                _last_phase_time = now
+                                                cur_top = STATE.get("thinking_topic", "")
+                                                if not str(cur_top).startswith("Request Queued"):
+                                                    STATE["thinking_topic"] = _THINKING_PHASES[_phase_idx % len(_THINKING_PHASES)]
+                                                    _phase_idx += 1
+                                                    _last_phase_time = now
                                         except Exception:
                                             pass
 
@@ -1240,7 +1242,23 @@ class LLMTransportMixin:
                                 if "type" in chunk:
                                     last_content_time = time.time()
                                     t = chunk["type"]
-                                    if t == "thinking_delta":
+                                    if t == "queue_status":
+                                        pos = chunk.get("position", 1)
+                                        status = chunk.get("status", "queued")
+                                        if status == "queued":
+                                            try:
+                                                from utim_cli.state import STATE
+                                                STATE["thinking_topic"] = f"Request Queued Position {pos}"
+                                            except Exception:
+                                                pass
+                                        elif status == "processing":
+                                            try:
+                                                from utim_cli.state import STATE
+                                                STATE["thinking_topic"] = "Formulating response..."
+                                            except Exception:
+                                                pass
+                                        continue
+                                    elif t == "thinking_delta":
                                         t_text = chunk.get("text", "")
                                         if t_text:
                                             if _rep_detector.append_and_check(t_text):
@@ -1339,6 +1357,10 @@ class LLMTransportMixin:
                                             if not silent:
                                                 self.console.print(f"\n[bold red]Model Error ({current_model}): {err_msg}[/bold red]\n")
                                             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:
+                                            _stream_finish_reason = "stop"
                                         final_content = chunk.get("content") or final_content
                                         if not final_content and chunk.get("reasoning"):
                                             final_content = chunk["reasoning"]
@@ -1347,6 +1369,7 @@ class LLMTransportMixin:
                                         if usage:
                                             in_t = usage.get("input_tokens", 0)
                                             out_t = usage.get("output_tokens", 0)
+                                            _stream_completion_tokens = out_t
                                             from utim_cli.server.models import estimate_cost
                                             cost = estimate_cost(current_model, in_t, out_t)
                                             from utim_cli.client_utils import update_session_usage
@@ -1679,22 +1702,20 @@ class LLMTransportMixin:
                             except Exception:
                                 pass
 
-                        # Heuristic abrupt-cutoff detector:
-                        # Only check if finish_reason was NOT an explicit completion ("stop" / "end_turn")
-                        if not was_cut_off and clean_content and not final_tool_calls and _stream_finish_reason not in ("stop", "end_turn"):
-                            _backtick_count = clean_content.count("```")
-                            if _backtick_count % 2 != 0:
-                                was_cut_off = True  # unclosed code fence
-
-                        # Truncation diagnosis: was the stream cut short by output token limit?
-                        _max_out = _get_model_max_output(current_model)
-                        _was_truncated_by_limit = (
-                            _stream_finish_reason in ("length", "max_tokens")
-                            or (
-                                _stream_completion_tokens > 0
-                                and _stream_completion_tokens >= _max_out - 5
+                        # If finish_reason is an explicit completion, response is NOT cut off
+                        if _stream_finish_reason in ("stop", "end_turn"):
+                            was_cut_off = False
+                            _was_truncated_by_limit = False
+                        else:
+                            # Truncation diagnosis: was the stream cut short by output token limit?
+                            _max_out = _get_model_max_output(current_model)
+                            _was_truncated_by_limit = (
+                                _stream_finish_reason in ("length", "max_tokens")
+                                or (
+                                    _stream_completion_tokens > 0
+                                    and _stream_completion_tokens >= _max_out - 5
+                                )
                             )
-                        )
 
                         final_msg = {
                             "role": "assistant",

{utim_cli-2.3.13 → utim_cli-2.3.14}/utim_cli/reflection.py

@@ -1374,14 +1374,29 @@ def get_buffered_interactions(limit: int = 5) -> List[Dict]:
     return []
 
 
+_REFLECTION_KEY_ROTATION_IDX: int = 0
+_REFLECTION_KEY_ROTATION_LOCK = threading.Lock()
+
 def _get_reflection_key() -> str:
     """
-    Returns the active API key for reflection, prioritizing dedicated OPENROUTER_API_KEY2,
-    then logged-in UTIM credentials, and ambient OPENROUTER_API_KEY.
+    Returns an active API key for reflection, rotating among dedicated OPENROUTER_API_KEY2,
+    OPENROUTER_API_KEY3, OPENROUTER_API_KEY4, logged-in UTIM credentials, and ambient OPENROUTER_API_KEY.
     """
     try:
-        if os.getenv("OPENROUTER_API_KEY2"):
-            return os.getenv("OPENROUTER_API_KEY2")
+        # Collect all configured OpenRouter keys for reflection rotation
+        keys = []
+        for var in ["OPENROUTER_API_KEY2", "OPENROUTER_API_KEY3", "OPENROUTER_API_KEY4", "OPENROUTER_API_KEY"]:
+            val = os.getenv(var, "").strip()
+            if val and val not in keys:
+                keys.append(val)
+
+        if keys:
+            global _REFLECTION_KEY_ROTATION_IDX
+            with _REFLECTION_KEY_ROTATION_LOCK:
+                chosen = keys[_REFLECTION_KEY_ROTATION_IDX % len(keys)]
+                _REFLECTION_KEY_ROTATION_IDX = (_REFLECTION_KEY_ROTATION_IDX + 1) % len(keys)
+                return chosen
+
         from utim_cli.config import config
         api_key = config.get("api_key") or os.getenv("UTIM_API_KEY")
         source = config.get("main_model_source")
@@ -1410,6 +1425,13 @@ def _call_reflection_llm(prompt: str, llm_key: str = None, system: str = "", max
     """
     global _LAST_REFLECTION_CALL_TIME, _REFLECTION_COOLDOWN_UNTIL
 
+    try:
+        from utim_cli.tools import is_user_paid
+        if not is_user_paid():
+            return {}
+    except Exception:
+        pass
+
     now = time.time()
     if now < _REFLECTION_COOLDOWN_UNTIL:
         # Under active rate-limit cooldown — skip background reflection gracefully
@@ -2299,6 +2321,13 @@ class BackgroundReflectionDispatcher:
                           tool_results: List[Dict], elapsed_seconds: int,
                           iterations: int, hints: Optional[List[str]],
                           messages_snapshot: Optional[List[Dict]] = None):
+        try:
+            from utim_cli.tools import is_user_paid
+            if not is_user_paid():
+                return
+        except Exception:
+            pass
+
         self.start()
         while self._task_queue.qsize() >= 3:
             try: