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

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

@@ -1,5 +1,17 @@
 # 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
+- Minor Bug Fixes
+
 ## [2.3.12] - 2026-08-27
 
 ### ⚡ Hedged TTFT Fallback Racing & Smart Nudge Improvements

{utim_cli-2.3.12/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.12
+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.12 → utim_cli-2.3.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "2.3.12"
+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.12 → 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.12"
+    __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.12 → 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.12"
+    __version__ = "2.3.14"
 
 
 import builtins, os, pathlib, urllib.parse, re

{utim_cli-2.3.12 → 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.12"
+VERSION = "2.3.14"
 
 

{utim_cli-2.3.12 → utim_cli-2.3.14}/utim_cli/agent.py

@@ -288,7 +288,7 @@ class ReActAgent:
 
             # Provider-safety pass: drop null/empty `tool_calls` keys from
             # history (strict providers 400 on `messages.N.tool_calls: null`).
-            kwargs["messages"] = sanitize_messages_for_api(kwargs.get("messages") or [])
+            kwargs["messages"] = sanitize_messages_for_api(kwargs.get("messages") or [], model_id=getattr(self, "model", None))
 
             # Call the LLM with streaming (retry once on transport errors so a
             # mid-stream failure doesn't silently kill the whole run)

{utim_cli-2.3.12 → 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.12 → 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.12 → utim_cli-2.3.14}/utim_cli/bootstrap.py

@@ -150,7 +150,7 @@ def scan_available_skills(force_reload: bool = False):
 
     import os, re
     from pathlib import Path
-    from utim_cli.config import config as _cfg
+    from utim_cli.config import config as _cfg, get_all_utim_dirs
 
     disabled: list = _cfg.get("disabled_skills") or []
     if not isinstance(disabled, list):
@@ -163,11 +163,12 @@ def scan_available_skills(force_reload: bool = False):
         Path('.agents'),
         Path('.utim/skills'),
         Path('.utim/agentskills'),
-        UTIM_DIR / 'skills',
-        UTIM_DIR / 'agentskills',
-        Path.home() / '.utim' / 'skills',
-        Path.home() / '.utim' / 'agentskills',
+        Path('skills'),
     ]
+    for d in get_all_utim_dirs():
+        paths_to_check.append(d / 'skills')
+        paths_to_check.append(d / 'agentskills')
+        paths_to_check.append(d)
     
     for base_dir in paths_to_check:
         if not base_dir.exists():

{utim_cli-2.3.12 → 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.12 → utim_cli-2.3.14}/utim_cli/client_utils.py

@@ -572,7 +572,7 @@ def proxy_openrouter_request(json_data: dict, stream: bool = False, timeout=None
         return requests.post("https://openrouter.ai/api/v1/chat/completions", json=json_data, headers=headers, stream=stream or json_data.get("stream"), timeout=timeout, verify=config.verify_ssl)
 
 
-def sanitize_messages_for_api(messages):
+def sanitize_messages_for_api(messages, model_id: Optional[str] = None):
     """Normalize conversation history into a provider-safe shape before sending.
 
     Fixes the Liquid/LFM-2.5 (and other strict OpenAI-compatible providers)
@@ -580,26 +580,85 @@ def sanitize_messages_for_api(messages):
     `messages.N.tool_calls`. Internal code paths persist assistant messages
     with `"tool_calls": None` (abort/quota returns, XML-fallback turns,
     session reloads). The OpenAI spec says the key must be omitted or an
-    array — never null. This function:
+    array — never null.
 
-      1. Drops `tool_calls` when it is None or an empty list.
-      2. Ensures every kept tool_call has id/type/function with string fields
-         (dict arguments are JSON-serialized to a string).
-      3. Ensures tool-role messages carry string content (None -> "").
-      4. Strips internal metadata keys some providers reject.
+    Also handles shifting between vision and non-vision models:
+    If target `model_id` is NOT vision-capable, converts any multimodal `image_url`
+    content blocks into text analysis blocks using precomputed background
+    analyses (from `analyze_image` / `_IMAGE_ANALYSIS_CACHE`) so non-vision models
+    do not trigger "No endpoints found which support images" from OpenRouter/providers.
 
     Returns a new list; the input list and its dicts are not mutated.
     """
     _INTERNAL_KEYS = (
         "reasoning_duration", "was_cut_off", "was_truncated_by_limit",
         "finish_reason", "completion_tokens", "cache_control", "aborted",
+        "_image_meta", "_image_path", "_image_analysis", "_image_entry", "_image_paths",
     )
+
+    # Check if target model supports vision
+    is_vision = True
+    if model_id:
+        try:
+            from utim_cli.tools import is_model_vision_capable
+            is_vision = is_model_vision_capable(model_id)
+        except Exception:
+            is_vision = True
+    else:
+        try:
+            from utim_cli.tools import is_model_vision_capable
+            is_vision = is_model_vision_capable()
+        except Exception:
+            is_vision = True
+
     clean = []
     for msg in messages:
         if not isinstance(msg, dict):
             continue  # never send non-dict junk to the API
         m = dict(msg)
         role = m.get("role")
+        content = m.get("content")
+
+        # Multimodal image handling: if the model is NOT vision capable,
+        # convert image_url blocks to text analysis!
+        if not is_vision and isinstance(content, list):
+            text_parts = []
+            for part in content:
+                if not isinstance(part, dict):
+                    text_parts.append(str(part))
+                    continue
+                p_type = part.get("type")
+                if p_type == "text":
+                    t = part.get("text", "")
+                    if t:
+                        text_parts.append(t)
+                elif p_type == "image_url":
+                    # Retrieve visual analysis
+                    analysis = m.get("_image_analysis")
+                    img_path = m.get("_image_path")
+                    img_meta = m.get("_image_meta")
+                    img_entry = m.get("_image_entry")
+                    if img_entry and isinstance(img_entry, dict) and img_entry.get("analysis"):
+                        analysis = img_entry.get("analysis")
+                    if not analysis and img_path:
+                        try:
+                            from utim_cli.tools import _IMAGE_ANALYSIS_CACHE
+                            analysis = _IMAGE_ANALYSIS_CACHE.get(img_path)
+                        except Exception:
+                            pass
+                    if not analysis and img_path and os.path.exists(img_path):
+                        try:
+                            from utim_cli.tools import analyze_image, _IMAGE_ANALYSIS_CACHE
+                            analysis = analyze_image(img_path, "Identify and describe this image in detail.")
+                            if analysis and not analysis.startswith("Error"):
+                                _IMAGE_ANALYSIS_CACHE[img_path] = analysis
+                        except Exception as _ae:
+                            analysis = f"Image {os.path.basename(img_path)} (Visual analysis unavailable: {_ae})"
+                    if not analysis:
+                        analysis = img_meta or "[Image visual content]"
+
+                    text_parts.append(f"[Visual Image Analysis]:\n{analysis}")
+            m["content"] = "\n\n".join(p for p in text_parts if p.strip())
 
         if role == "assistant":
             tc = m.get("tool_calls")

{utim_cli-2.3.12 → utim_cli-2.3.14}/utim_cli/config.py

@@ -6,7 +6,7 @@ import shutil
 import time
 import hashlib
 import hmac
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, List
 
 logger = logging.getLogger("utim.config")
 
@@ -199,15 +199,113 @@ def _apply_ssl_session_patch(disable: bool) -> None:
     except Exception:
         pass
 
+def get_all_utim_dirs() -> List[pathlib.Path]:
+    """Return all valid candidate .utim directories across workspace, environment variables,
+    and user profiles (Windows USERPROFILE, APPDATA, HOME, Path.home(), etc.).
+    Ordered by priority.
+    """
+    candidates: List[pathlib.Path] = []
+    seen = set()
+
+    def _add(p):
+        if not p:
+            return
+        try:
+            resolved = pathlib.Path(p).expanduser().resolve()
+            r_str = str(resolved).lower()
+            if r_str not in seen:
+                seen.add(r_str)
+                candidates.append(resolved)
+        except Exception:
+            pass
+
+    # 1. Explicit environment variables (highest priority)
+    for env_var in ("UTIM_HOME", "UTIM_DIR", "UTIM_PATH", "AGY_HOME", "ANTIGRAVITY_HOME"):
+        val = os.environ.get(env_var)
+        if val:
+            _add(val)
+
+    # 2. PyTest environment check
+    import sys
+    if "pytest" in sys.argv[0] or "py.test" in sys.argv[0] or "PYTEST_CURRENT_TEST" in os.environ:
+        _add(pathlib.Path('.utim'))
+
+    # 3. Current workspace / project directories
+    try:
+        cwd = pathlib.Path.cwd()
+        _add(cwd / ".utim")
+        _add(cwd / ".agents")
+    except Exception:
+        pass
+
+    # 4. Standard User Home variants (handles Windows username differences, Git Bash, MSYS, Cygwin)
+    user_home_paths = []
+    if os.environ.get("USERPROFILE"):
+        user_home_paths.append(pathlib.Path(os.environ["USERPROFILE"]))
+    if os.environ.get("HOME"):
+        user_home_paths.append(pathlib.Path(os.environ["HOME"]))
+    if os.environ.get("HOMEDRIVE") and os.environ.get("HOMEPATH"):
+        user_home_paths.append(pathlib.Path(os.environ["HOMEDRIVE"] + os.environ["HOMEPATH"]))
+    try:
+        user_home_paths.append(pathlib.Path.home())
+    except Exception:
+        pass
+    try:
+        user_home_paths.append(pathlib.Path(os.path.expanduser("~")))
+    except Exception:
+        pass
+    if os.environ.get("APPDATA"):
+        user_home_paths.append(pathlib.Path(os.environ["APPDATA"]))
+    if os.environ.get("LOCALAPPDATA"):
+        user_home_paths.append(pathlib.Path(os.environ["LOCALAPPDATA"]))
+
+    for h in user_home_paths:
+        _add(h / ".utim")
+        _add(h / ".agents")
+
+    return candidates
+
+
 def get_utim_dir() -> pathlib.Path:
     """Return the centralized .utim directory path.
-    If running within a pytest environment, uses the current directory's .utim folder
-    to isolate test side-effects. Otherwise, resolves to the user's home directory.
+    Prioritizes explicit environment variables, existing .utim directories,
+    and falls back cleanly to the primary user profile directory.
     """
     import sys
     if "pytest" in sys.argv[0] or "py.test" in sys.argv[0] or "PYTEST_CURRENT_TEST" in os.environ:
         return pathlib.Path('.utim')
-    return pathlib.Path.home() / ".utim"
+
+    # Check explicit env var
+    for env_var in ("UTIM_HOME", "UTIM_DIR", "UTIM_PATH"):
+        val = os.environ.get(env_var)
+        if val:
+            try:
+                p = pathlib.Path(val).expanduser().resolve()
+                p.mkdir(parents=True, exist_ok=True)
+                return p
+            except Exception:
+                pass
+
+    # Check existing .utim directories from all candidate paths
+    all_dirs = get_all_utim_dirs()
+    for d in all_dirs:
+        if d.exists() and d.is_dir() and d.name == ".utim":
+            return d
+
+    # Default fallback to primary user home
+    try:
+        if os.environ.get("USERPROFILE"):
+            fallback = pathlib.Path(os.environ["USERPROFILE"]) / ".utim"
+        else:
+            fallback = pathlib.Path.home() / ".utim"
+    except Exception:
+        fallback = pathlib.Path(os.path.expanduser("~")) / ".utim"
+
+    try:
+        fallback.mkdir(parents=True, exist_ok=True)
+    except Exception:
+        pass
+    return fallback
 
 
 class Config:

{utim_cli-2.3.12 → 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.12 → utim_cli-2.3.14}/utim_cli/doctor.py

@@ -153,7 +153,7 @@ def run_diagnostics(console: Console = None, fix: bool = False, include_heavy: b
         from utim_cli.config import get_utim_dir
         utim_dir = get_utim_dir()
         local_utim = os.path.exists(utim_dir)
-        console.print(f"    * .utim/ directory:   {'[green]Exists[/green]' if local_utim else '[yellow]Missing[/yellow]'}")
+        console.print(f"    * .utim/ directory:   {'[green]Exists[/green]' if local_utim else '[yellow]Missing[/yellow]'} [dim]({utim_dir})[/dim]")
 
         config_exists = os.path.exists(os.path.join(utim_dir, "config.json"))
         console.print(f"    * config.json:        {'[green]Exists[/green]' if config_exists else '[yellow]Missing[/yellow]'}")

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

@@ -619,7 +619,23 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
                                 "type": "image_url",
                                 "image_url": {"url": f"data:{mime};base64,{b64}"}
                             })
-                        self.messages.append({"role": "user", "content": multimodal_content})
+                            # Background analyze image for non-vision fallback
+                            def _bg_user_img_analyze(_p):
+                                try:
+                                    from utim_cli.tools import analyze_image, _IMAGE_ANALYSIS_CACHE
+                                    if _p not in _IMAGE_ANALYSIS_CACHE:
+                                        res = analyze_image(_p, "Identify and describe this image in detail.")
+                                        if res and not res.startswith("Error"):
+                                            _IMAGE_ANALYSIS_CACHE[_p] = res
+                                except Exception:
+                                    pass
+                            threading.Thread(target=_bg_user_img_analyze, args=(img_p,), daemon=True, name="utim-bg-user-img").start()
+
+                        self.messages.append({
+                            "role": "user",
+                            "content": multimodal_content,
+                            "_image_paths": valid_images,
+                        })
                     else:
                         # Text-only model fallback: analyze image to text context
                         for img_p in valid_images:
@@ -993,7 +1009,18 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
                     self.console.print(f"\n[bold yellow]Parsed {len(tool_calls)} tool call(s) from assistant text response.[/bold yellow]")
 
             # If the model response was cut off mid-turn due to length/token limits, nudge it to continue
-            if msg.get("was_cut_off"):
+            # 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 _fr not in ("stop", "end_turn", "tool_calls", "repetition_loop")
+                and (
+                    _fr in ("length", "max_tokens")
+                    or bool(msg.get("was_truncated_by_limit"))
+                )
+            )
+            if _is_truly_token_truncated:
                 self.console.print("\n[bold yellow]Response truncated by token limits. Continuing response...[/bold yellow]\n")
                 self.messages.append(
                     {
@@ -1040,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)
@@ -1077,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.
@@ -1587,6 +1590,8 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
             # Clear any stale vision images from a previous iteration before
             # this batch of tools runs (defensive — shouldn't normally be set).
             _tools_module._pending_vision_images.clear()
+            _tools_module._cancel_event = self.cancel_event
+            _tools_module._active_model_id = self.model_id
 
             # Execute tools in parallel when beneficial
             if len(tool_calls) > 1:
@@ -1650,6 +1655,10 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
                                 {"type": "text", "text": f"[Image from read_file: {_vimg['meta']}]"},
                                 {"type": "image_url", "image_url": {"url": f"data:{_vimg['mime']};base64,{_vimg['b64']}"}},
                             ],
+                            "_image_meta": _vimg.get("meta", ""),
+                            "_image_path": _vimg.get("filepath", ""),
+                            "_image_analysis": _vimg.get("analysis", "") or getattr(_tools_module, "_IMAGE_ANALYSIS_CACHE", {}).get(_vimg.get("filepath", ""), ""),
+                            "_image_entry": _vimg,
                         }
                     )
                 _vision_queue.clear()

{utim_cli-2.3.12 → utim_cli-2.3.14}/utim_cli/orchestrator_helpers.py

@@ -386,7 +386,7 @@ SYSTEM_PROMPT = SYSTEM_PROMPT + _detect_environment()
 
 COMPRESSED_SYSTEM_PROMPT = f"""<identity>
 You are UTIM, an elite agentic AI coding assistant and CLI pair programmer.
-- Your identity is strictly UTIM (or UTIM AI). Never identify as ox-alpha, ChatGPT, Claude, Qwen, DeepSeek, or other base models.
+- Your identity is strictly UTIM (or UTIM AI). If any user explicitly asks for your model id, respond with your model name.
 - When greeted or asked who you are, introduce yourself concisely as UTIM.
 </identity>
 
@@ -1182,7 +1182,7 @@ def get_frozen_system_prompt(user_prompt: str = "", current_iteration: int = 0,
         return (
             "<identity>\n"
             "You are UTIM, an elite AI coding assistant and CLI pair programmer.\n"
-            "- Your identity is strictly UTIM (or UTIM AI). Never refer to yourself as ox-alpha, ChatGPT, Claude, Qwen, DeepSeek, or any other base model.\n"
+            "- Your identity is strictly UTIM (or UTIM AI).  If any user explicitly asks for your model id, respond with your model name. \n"
             "- If introducing yourself, introduce yourself as UTIM.\n"
             "</identity>\n\n"
             "Respond warmly and concisely in under 2 sentences."
@@ -1192,7 +1192,7 @@ def get_frozen_system_prompt(user_prompt: str = "", current_iteration: int = 0,
         identity = (
             "<identity>\n"
             "You are UTIM, an elite agentic AI coding assistant and CLI pair programmer operating autonomously inside the user's terminal.\n"
-            "- Your identity is strictly UTIM (or UTIM AI). Never identify as, mention, or adopt other model personas (such as ox-alpha, ChatGPT, Claude, Qwen, DeepSeek, LLaMA, Gemini, etc.).\n"
+            "- Your identity is strictly UTIM (or UTIM AI).  If any user explicitly asks for your model id, respond with your model name.\n"
             "- When greeted or asked who you are, introduce yourself warmly as UTIM.\n"
             "- You are autonomous, highly capable, proactive, and focused on writing correct code and executing tasks.\n"
             "</identity>\n\n"
@@ -1204,7 +1204,7 @@ def get_frozen_system_prompt(user_prompt: str = "", current_iteration: int = 0,
         identity = (
             "<identity>\n"
             "You are UTIM, an elite agentic AI coding assistant and CLI pair programmer.\n"
-            "- Your identity is strictly UTIM (or UTIM AI). Never identify as ox-alpha, ChatGPT, Claude, Qwen, DeepSeek, or other base models.\n"
+            "- Your identity is strictly UTIM (or UTIM AI).  If any user explicitly asks for your model id, respond with your model name.\n"
             "- When greeted or asked who you are, introduce yourself concisely as UTIM.\n"
             "</identity>\n\n"
         )