utim-cli 2.3.4__tar.gz → 2.3.6__tar.gz

{utim_cli-2.3.4 → utim_cli-2.3.6}/CHANGELOG.md

@@ -1,11 +1,24 @@
 # Changelog
 
+## [2.3.6] - 2026-08-25
+
+### 🐞 Small Bug Fix
+- **Vision image fallback on friend laptops**: Fixed silent exception swallowing in the vision-tool flow that prevented image attachments from reaching the model on certain environments (notably a friend's laptop where the read-file path differed). The fallback now properly surfaces the analyze_image path so vision-enabled models always receive the image payload.
+- **Universal core-dependency auto-installation**: UTIM no longer requires users to manually install core dependencies before first run. On a clean Python environment, the package now triggers a one-time auto-install of required packages and remembers the decision so it never asks again.
+- **OS-aware dependency resolution (incl. Termux)**: Optional dependencies are now selected per-platform. Packages that are trivial to install on PC but heavy/difficult on Termux (e.g. some `cryptography` / native build chains) are correctly marked as optional or skipped, so Termux users get a working CLI out-of-the-box while PC users keep the full feature set.
+- **CLI startup safety net**: The `ensure_core_deps()` import-guard in `utim_cli/__init__.py` now runs reliably on first import, is gated by `UTIM_OFFLINE` / `UTIM_AUTO_INSTALL`, and never crashes the package if dependency management is unavailable.
+
+## [2.3.5] - 2026-08-25
+
+### ⚡ Performance & Fixes
+- **Latency Optimisation**: Micro-batching threshold tuning, zero-delay streaming, and asynchronous background reflection pipeline dispatch.
+- **Model Hallucination & Token Bloat Fix**: Multi-level periodic pattern and stream repetition interceptor that truncates duplicate reasoning and loop hallucinations in real-time, preventing context bloat.
+- Minor bug fixes
+
 ## [2.3.4] - 2026-08-22
 
-### ⚡ Performance & Polish
+### ⚡ Performance
 - Latency optimizations: Zero-buffer stream reading, asynchronous background experience caching, parallel multi-tool file inspection execution, and micro-batching bypass for interactive sessions.
-- Dynamic fallback model resolution from server model registry with `openrouter/free` priority.
-- Configured reasoning capability toggling across server admin interface and CLI model selector.
 
 ## [2.3.3] - 2026-08-20
 

{utim_cli-2.3.4/utim_cli.egg-info → utim_cli-2.3.6}/PKG-INFO

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

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

{utim_cli-2.3.4 → utim_cli-2.3.6}/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.4"
+    __version__ = "2.3.6"
 
 
 import builtins, os, pathlib, urllib.parse, re
@@ -113,3 +113,29 @@ try:
 
 except Exception:
     pass
+
+# ── Startup safety net: ensure core dependencies are present ──
+# This runs once per Python process when the utim_cli package is first imported.
+# Behavior:
+#   * UTIM_OFFLINE=1           -> skip (assumed pre-installed)
+#   * UTIM_AUTO_INSTALL=0      -> skip (CI / locked-down envs)
+#   * non-interactive stdout  -> skip (can't prompt)
+#   * anything else            -> call ensure_core_deps() which may prompt the
+#                                 user the first time and install silently thereafter.
+#   * any exception in dep mgmt is swallowed (we never want __init__ to crash)
+try:
+    import os as _os_init
+    import sys as _sys_init
+    if _os_init.environ.get("UTIM_OFFLINE") != "1" and _os_init.environ.get("UTIM_AUTO_INSTALL") != "0":
+        # Only run the check once per process
+        _already_checked = getattr(_sys_init.modules.get("utim_cli"), "_core_deps_checked", False)
+        if not _already_checked:
+            _sys_init.modules["utim_cli"]._core_deps_checked = True
+            try:
+                from utim_cli.dependency_manager import ensure_core_deps
+                ensure_core_deps(verbose=False)  # quiet by default
+            except Exception:
+                # Never let dep-checking block CLI startup
+                pass
+except Exception:
+    pass

{utim_cli-2.3.4 → utim_cli-2.3.6}/utim_cli/_version.py

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

{utim_cli-2.3.4 → utim_cli-2.3.6}/utim_cli/agent.py

@@ -286,45 +286,73 @@ class ReActAgent:
             if all_tools:
                 kwargs["tools"] = all_tools
 
-            # Call the LLM with streaming
-            stream = self.client.chat.completions.create(**kwargs)
+            # 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 [])
+
+            # Call the LLM with streaming (retry once on transport errors so a
+            # mid-stream failure doesn't silently kill the whole run)
+            try:
+                stream = self.client.chat.completions.create(**kwargs)
+            except Exception as e:
+                if getattr(self, "_stream_retries", 0) >= 2:
+                    self.console.print(f"[red]Stream failed repeatedly: {e}[/red]")
+                    break
+                self._stream_retries = getattr(self, "_stream_retries", 0) + 1
+                self.console.print(f"[yellow]Stream error ({e}) — retrying...[/yellow]")
+                time.sleep(1.5)
+                continue
 
             # Collect streaming chunks
-            for chunk in stream:
-                delta = chunk.choices[0].delta
-
-                if delta.content:
-                    assistant_content += delta.content
-
-                if delta.tool_calls:
-                    for tc in delta.tool_calls:
-                        tc_index = tc.index if tc.index is not None else 0
-                        if current_tool_call is None or tc_index != current_tool_call.get("index"):
-                            # Flush the previous buffered tool call (check index, not id)
-                            if current_tool_call is not None:
-                                tool_calls.append(current_tool_call)
-                            current_tool_call = {
-                                "index": tc_index,
-                                "id": tc.id or "",
-                                "type": tc.type or "function",
-                                "function": {
-                                    "name": tc.function.name if tc.function else "",
-                                    "arguments": tc.function.arguments if tc.function else "",
-                                },
-                            }
-                        else:
-                            # Same tool call — accumulate the argument chunks
-                            if tc.id and not current_tool_call["id"]:
-                                current_tool_call["id"] = tc.id
-                            if tc.function and tc.function.arguments:
-                                current_tool_call["function"]["arguments"] += tc.function.arguments
+            finish_reason = ""
+            empty_stream = True
+            try:
+                for chunk in stream:
+                    if not chunk.choices:
+                        continue
+                    empty_stream = False
+                    delta = chunk.choices[0].delta
+
+                    if delta.content:
+                        assistant_content += delta.content
+
+                    if delta.tool_calls:
+                        for tc in delta.tool_calls:
+                            tc_index = tc.index if tc.index is not None else 0
+                            if current_tool_call is None or tc_index != current_tool_call.get("index"):
+                                # Flush the previous buffered tool call (check index, not id)
+                                if current_tool_call is not None:
+                                    tool_calls.append(current_tool_call)
+                                current_tool_call = {
+                                    "index": tc_index,
+                                    "id": tc.id or "",
+                                    "type": tc.type or "function",
+                                    "function": {
+                                        "name": tc.function.name if tc.function else "",
+                                        "arguments": tc.function.arguments if tc.function else "",
+                                    },
+                                }
+                            else:
+                                # Same tool call — accumulate the argument chunks
+                                if tc.id and not current_tool_call["id"]:
+                                    current_tool_call["id"] = tc.id
+                                if tc.function and tc.function.arguments:
+                                    current_tool_call["function"]["arguments"] += tc.function.arguments
+
+                    fr = chunk.choices[0].finish_reason
+                    if fr:
+                        finish_reason = fr
+            except Exception as e:
+                self.console.print(f"[yellow]Stream interrupted mid-response ({e}).[/yellow]")
+                finish_reason = finish_reason or "aborted"
+            self._stream_retries = 0
 
             # Flush the last buffered tool call
             if current_tool_call is not None:
                 tool_calls.append(current_tool_call)
 
             # Parse XML-style tool calls if present in the text content
-            from .client_utils import parse_xml_tool_calls
+            from .client_utils import parse_xml_tool_calls, sanitize_messages_for_api
             parsed_content, parsed_tool_calls = parse_xml_tool_calls(assistant_content)
             if parsed_tool_calls:
                 assistant_content = parsed_content or ""
@@ -338,8 +366,37 @@ class ReActAgent:
                 if not tool_calls:
                     self.console.print()
 
-            # If no tool calls, we are done
+            # If no tool calls, normally we are done — but check WHY the stream
+            # ended, because some models stop abruptly on token budget
+            # (finish_reason="length") or return a transiently empty response.
             if not tool_calls:
+                if finish_reason == "stop":
+                    # Clean, intentional completion from the model — this is
+                    # the normal exit path.
+                    self._empty_retries = 0
+                    break
+
+                if finish_reason in ("length", "max_tokens"):
+                    # Model hit its output cap mid-task. Keep it going instead
+                    # of silently ending the turn.
+                    self.console.print("[dim](output limit hit — continuing automatically)[/dim]")
+                    self.messages.append({
+                        "role": "assistant",
+                        "content": assistant_content or "",
+                    })
+                    self.messages.append({
+                        "role": "user",
+                        "content": "[system] Your previous response was cut off by the output token limit. Continue exactly where you left off without repeating what you already said.",
+                    })
+                    continue
+
+                if (not assistant_content.strip()) and empty_stream:
+                    # Provider glitch: completely empty completion. Retry once.
+                    if getattr(self, "_empty_retries", 0) < 1:
+                        self._empty_retries = 1
+                        self.console.print("[dim](empty response from model — retrying)[/dim]")
+                        continue
+                self._empty_retries = 0
                 break
 
             # Save the assistant message with tool_calls

{utim_cli-2.3.4 → utim_cli-2.3.6}/utim_cli/ask_helper.py

@@ -31,7 +31,11 @@ PRIMARY_HELPER_MODEL = "openrouter/free"
 
 
 
-HELPER_SYSTEM_PROMPT = """You are the UTIM Sidecar Assistant, an embedded technical companion running alongside the active UTIM CLI session.
+HELPER_SYSTEM_PROMPT = """<identity>
+You are the UTIM Sidecar Assistant, an embedded technical companion running alongside the active UTIM CLI session.
+- Your identity is strictly the UTIM Sidecar Assistant. Never identify as ox-alpha, ChatGPT, Claude, Qwen, DeepSeek, or other base models.
+</identity>
+
 Your mission is to provide real-time architectural insights, explain active agent operations, assess codebase states, and answer developer questions clearly and factually.
 
 ### OPERATIONAL DIRECTIVES:

{utim_cli-2.3.4 → utim_cli-2.3.6}/utim_cli/bootstrap.py

@@ -131,16 +131,25 @@ def _write_utim_md():
         from utim_cli.logger import log_error
         log_error("bootstrap", f"Failed to create UTIM.md at {md_path}", e)
 
-def scan_available_skills():
+_SKILLS_CACHE = {}
+_SKILLS_CACHE_TS = 0.0
+_SKILLS_CACHE_TTL = 300.0  # seconds
+
+def scan_available_skills(force_reload: bool = False):
     """
     Scans ~/.utim/skills, .utim/skills, and .agents/skills for directories containing SKILL.md.
     Skills listed in config['disabled_skills'] are excluded.
     Returns:
         dict: A dictionary mapping skill_name to dict containing path, name, description, and keywords.
     """
-    import os
+    global _SKILLS_CACHE, _SKILLS_CACHE_TS
+    import time
+    now = time.time()
+    if not force_reload and _SKILLS_CACHE and (now - _SKILLS_CACHE_TS) < _SKILLS_CACHE_TTL:
+        return _SKILLS_CACHE
+
+    import os, re
     from pathlib import Path
-    import yaml
     from utim_cli.config import config as _cfg
 
     disabled: list = _cfg.get("disabled_skills") or []
@@ -163,16 +172,17 @@ def scan_available_skills():
     for base_dir in paths_to_check:
         if not base_dir.exists():
             continue
-        for name in os.listdir(base_dir):
+        try:
+            entries = os.listdir(base_dir)
+        except Exception:
+            continue
+        for name in entries:
             skill_dir = base_dir / name
             if skill_dir.is_dir():
                 skill_md = skill_dir / 'SKILL.md'
                 if skill_md.exists():
                     # Avoid duplicates
-                    if name in skills:
-                        continue
-                    # Skip disabled skills
-                    if name in disabled:
+                    if name in skills or name in disabled:
                         continue
                         
                     description = ""
@@ -180,14 +190,17 @@ def scan_available_skills():
                     content = ""
                     try:
                         with open(skill_md, 'r', encoding='utf-8') as f:
-                            content = f.read()
+                            content = f.read(2048)  # Fast bounded read for frontmatter
                         if content.startswith('---'):
                             parts = content.split('---', 2)
                             if len(parts) >= 3:
-                                ydata = yaml.safe_load(parts[1])
-                                if ydata:
-                                    description = ydata.get('description', '')
-                                    frontmatter_name = ydata.get('name', name)
+                                fm = parts[1]
+                                desc_m = re.search(r'^description:\s*(.+)$', fm, re.MULTILINE)
+                                if desc_m:
+                                    description = desc_m.group(1).strip().strip('"\'')
+                                name_m = re.search(r'^name:\s*(.+)$', fm, re.MULTILINE)
+                                if name_m:
+                                    frontmatter_name = name_m.group(1).strip().strip('"\'')
                     except Exception:
                         pass
                         
@@ -212,13 +225,24 @@ def scan_available_skills():
                         if len(w) > 2 and w not in stop_words:
                             words.add(w)
                             
+                    size_bytes = 0
+                    try:
+                        size_bytes = skill_md.stat().st_size
+                    except Exception:
+                        size_bytes = len(content.encode('utf-8')) if content else 0
+
                     skills[name] = {
                         "path": skill_md,
-                        "name": frontmatter_name,
+                        "name": name,
+                        "folder_name": name,
+                        "frontmatter_name": frontmatter_name,
                         "description": description,
                         "keywords": list(words),
-                        "content": content
+                        "content": content,
+                        "size_bytes": size_bytes,
                     }
+    _SKILLS_CACHE = skills
+    _SKILLS_CACHE_TS = now
     return skills