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

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

@@ -1,5 +1,17 @@
 # Changelog
 
+## [2.3.4] - 2026-08-22
+
+### ⚡ Performance & Polish
+- 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
+
+### 🚀 Performance & Polish
+- Token usage optimization and minor enhancements
+
 ## [2.3.2] - 2026-08-20
 
 ### 🚀 Performance & Fixes

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

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

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

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

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

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

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

@@ -25,47 +25,10 @@ from rich import box
 
 # ── Primary & Fallback Free Models ───────────────────────────────────────────
 
-PRIMARY_HELPER_MODEL = "openrouter/free"
-
-DEFAULT_FREE_FALLBACKS = [
-    "google/gemini-2.5-flash:free",
-    "meta-llama/llama-3.3-70b-instruct:free",
-    "cohere/north-mini-code:free",
-    "poolside/laguna-xs-2.1:free",
-    "nvidia/nemotron-3-ultra-550b-a55b:free",
-    "inclusionai/ling-3.0-flash:free",
-    "deepseek/deepseek-r1:free",
-    "openai/gpt-oss-20b:free",
-    "google/gemma-4-31b-it:free",
-    "google/gemma-4-26b-a4b-it:free",
-    "nvidia/nemotron-nano-12b-v2-vl:free",
-]
-
-
-def get_free_models_fallback_chain() -> List[str]:
-    """Returns prioritized list of free models starting with 'openrouter/free'."""
-    chain = [PRIMARY_HELPER_MODEL]
-    seen = {PRIMARY_HELPER_MODEL}
-
-    # Add dynamic live OpenRouter free models if available
-    try:
-        from utim_cli.tui.model_dialog import fetch_active_openrouter_free_models
-        live_free = fetch_active_openrouter_free_models()
-        if live_free:
-            for m in live_free:
-                if m not in seen:
-                    chain.append(m)
-                    seen.add(m)
-    except Exception:
-        pass
+from utim_cli.client_utils import get_free_models_fallback_chain
 
-    # Add default free fallbacks
-    for m in DEFAULT_FREE_FALLBACKS:
-        if m not in seen:
-            chain.append(m)
-            seen.add(m)
+PRIMARY_HELPER_MODEL = "openrouter/free"
 
-    return chain
 
 
 HELPER_SYSTEM_PROMPT = """You are the UTIM Sidecar Assistant, an embedded technical companion running alongside the active UTIM CLI session.
@@ -119,22 +82,12 @@ WEB_SEARCH_TOOL_SCHEMA = {
 
 def execute_sidecar_websearch(query: str) -> str:
     """
-    Executes a fast non-agent web search using search API proxies and fallback search engines.
-    Returns direct snippets, URLs, and summaries without spawning subagents.
+    Executes a web search using DuckDuckGo search and returns structured markdown research findings from .utim_tmp.
     """
     try:
-        from utim_cli.config import config
-        orig = config.get("subagent_model_web_search")
-        try:
-            config.set("subagent_model_web_search", "__non_agent__")
-            from utim_cli.tools import web_search
-            res = web_search(prompt=query, level="low")
-            return res or "No web results found."
-        finally:
-            if orig is not None:
-                config.set("subagent_model_web_search", orig)
-            else:
-                config.pop("subagent_model_web_search", None)
+        from utim_cli.tools import web_search
+        res = web_search(prompt=query, level="low")
+        return res or "No web results found."
     except Exception as e:
         return f"Web search error: {str(e)}"
 
@@ -427,7 +380,7 @@ def execute_ask_helper(
                         "max_tokens": 1000,
                     },
                     stream=False,
-                    timeout=30,
+                    timeout=(15, 300),
                     is_reflection=True,
                 )
                 if resp.status_code == 429:

{utim_cli-2.3.2 → utim_cli-2.3.4}/utim_cli/blender_agent.py

@@ -62,11 +62,10 @@ _VISION_MODELS: List[str] = [
     "openrouter/free"
 ]
 
-_CODE_MODELS: List[str] = [
-    DEFAULT_MODEL,
-    "cohere/north-mini-code:free",
-    "openrouter/free"
-]
+from utim_cli.client_utils import get_free_models_fallback_chain
+
+_CODE_MODELS: List[str] = get_free_models_fallback_chain()
+
 
 
 

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

@@ -57,12 +57,15 @@ def _sync_global_experience(api_key: str, current_folder: str):
     Since .utim is now global (~/.utim), there is no need to copy experience files
     between project folders — they are always available from the shared location.
     """
+    if not api_key or str(api_key).startswith(("sk-or-", "sk-ant-", "sk-proj-", "Bearer ")):
+        return
+
     import requests
     from utim_cli.auth import SERVER_URL
 
     try:
         requests.post(
-            f"{SERVER_URL}/auth/last-folder",
+            f"{SERVER_URL}/api/auth/last-folder",
             headers={"X-API-Key": api_key},
             json={"folder_path": current_folder},
             timeout=5

{utim_cli-2.3.2 → utim_cli-2.3.4}/utim_cli/client_utils.py

@@ -2,8 +2,10 @@ from __future__ import annotations
 import os
 import json
 import math
+import threading
 import requests
 from utim_cli.config import config
+from utim_cli.constants import DEFAULT_MODEL
 
 class WrappedResponse:
     """A compatibility wrapper that mimics requests.Response for client callers."""
@@ -105,36 +107,152 @@ def get_server_model_catalog(timeout: float = 5.0) -> dict | None:
                 return _catalog_cache
     except Exception:
         pass
-    return None
+_FREE_MODELS_CACHE = []
+_LAST_FREE_MODELS_FETCH = 0.0
+_FREE_MODELS_LOCK = threading.Lock()  # single-flight guard for chain building
+
+
+def get_free_models_fallback_chain() -> list[str]:
+    """Returns prioritized fallback chain of free models for background processes,
+    starting with 'openrouter/free' as the primary model, followed by all currently
+    available free models from the server DB model_registry and resilient live backups.
+    """
+    global _FREE_MODELS_CACHE, _LAST_FREE_MODELS_FETCH
+    import time
+    now = time.time()
+    if _FREE_MODELS_CACHE and (now - _LAST_FREE_MODELS_FETCH) < 300:
+        return list(_FREE_MODELS_CACHE)
+    # Single-flight (stampede protection): only one thread builds the chain at a
+    # time; concurrent callers receive the current cache instead of duplicating
+    # the DB / catalog / OpenRouter lookups.
+    if not _FREE_MODELS_LOCK.acquire(blocking=False):
+        return list(_FREE_MODELS_CACHE)
+    try:
+        # Double-check after acquiring — another thread may have populated it.
+        now = time.time()
+        if _FREE_MODELS_CACHE and (now - _LAST_FREE_MODELS_FETCH) < 300:
+            return list(_FREE_MODELS_CACHE)
+        return _build_free_models_fallback_chain(now)
+    finally:
+        _FREE_MODELS_LOCK.release()
+
+
+def _build_free_models_fallback_chain(now: float) -> list[str]:
+    """Builds the fallback chain dynamically from the server model_registry DB with openrouter/free first."""
+    global _FREE_MODELS_CACHE, _LAST_FREE_MODELS_FETCH
+    chain = ["openrouter/free"]
+    seen = {"openrouter/free"}
+
+    INVALID_DUMMY_IDS = {
+        "free-model:free",
+        "inclusionai/ling-2.6-flash:free",
+        "muses/muse-spark-1.1:free",
+        "z-ai/glm-5.2:free",
+        "inclusionai/ling-3.0-flash:free",
+        "poolside/laguna-s-2.1:free",
+        "poolside/laguna-xs-2.1:free"
+    }
+
+    # 1. Query server DB model_registry table for all active free models
+    try:
+        from utim_cli.server.db import SessionLocal, ModelDB
+        db = SessionLocal()
+        try:
+            free_rows = db.query(ModelDB).filter(
+                ModelDB.is_active == True,
+                (ModelDB.is_free == True) | (ModelDB.cost_input_per_1m == 0.0) | (ModelDB.model_id.like("%:free"))
+            ).order_by(ModelDB.model_id.asc()).all()
+            for r in free_rows:
+                mid = r.model_id
+                if mid and mid not in seen and mid not in INVALID_DUMMY_IDS:
+                    chain.append(mid)
+                    seen.add(mid)
+        finally:
+            db.close()
+    except Exception:
+        pass
+
+    # 2. Query server /models/catalog endpoint
+    try:
+        catalog = fetch_remote_models_catalog(timeout=3.0)
+        if catalog and isinstance(catalog, dict):
+            for grp_key in ("all_text", "main_agent", "plan_project", "analyze_image"):
+                for m in catalog.get(grp_key, []):
+                    mid = m.get("id") or m.get("model_id")
+                    if mid and mid not in INVALID_DUMMY_IDS and (m.get("is_free") or mid.endswith(":free") or (m.get("cost_input_per_1k") == 0 and m.get("cost_output_per_1k") == 0)):
+                        if mid not in seen:
+                            chain.append(mid)
+                            seen.add(mid)
+    except Exception:
+        pass
+
+    # 3. Query dynamic OpenRouter live free models
+    try:
+        from utim_cli.tui.model_dialog import fetch_active_openrouter_free_models
+        live_free = fetch_active_openrouter_free_models()
+        if live_free:
+            for mid in live_free:
+                if mid and mid not in seen and mid not in INVALID_DUMMY_IDS:
+                    chain.append(mid)
+                    seen.add(mid)
+    except Exception:
+        pass
+
+    # 4. Standard resilient default free fallbacks
+    default_fallbacks = [
+        "google/gemini-2.5-flash:free",
+        "google/gemini-2.0-flash-exp:free",
+        "meta-llama/llama-3.3-70b-instruct:free",
+        "deepseek/deepseek-r1:free",
+        "qwen/qwen-2.5-coder-32b-instruct:free",
+        "mistralai/mistral-7b-instruct:free",
+        "openai/gpt-oss-20b:free",
+        "cohere/north-mini-code:free",
+    ]
+    for mid in default_fallbacks:
+        if mid not in seen and mid not in INVALID_DUMMY_IDS:
+            chain.append(mid)
+            seen.add(mid)
+
+    _FREE_MODELS_CACHE = chain
+    _LAST_FREE_MODELS_FETCH = now
+    return list(chain)
 
 
 def proxy_openrouter_request(json_data: dict, stream: bool = False, timeout=None, is_reflection: bool = False) -> WrappedResponse:
     """Routes LLM request to UTIM server /completions, or falls back to direct OpenRouter."""
     if timeout is None:
         timeout = (15, 900)
+    elif isinstance(timeout, (int, float)):
+        timeout = (min(int(timeout), 15), max(int(timeout), 300))
+    elif isinstance(timeout, (list, tuple)) and len(timeout) == 2:
+        timeout = (min(int(timeout[0]), 15), max(int(timeout[1]), 300))
     # Scrub payload for NaN/Infinity/non-JSON types BEFORE it leaves the
     # machine. Providers like Parasail do a strict parse and reject the whole
     # request (400 'Expecting value') if even one value is malformed.
     json_data = _sanitize_json(json_data)
-    # Ensure environment variables are loaded (orchestrator handles this, but tools.py is independent)
+    # Load local .env without overwriting already configured environment or auth variables
     _cwd_env = os.path.join(os.getcwd(), ".env")
     if os.path.isfile(_cwd_env):
         try:
             from dotenv import load_dotenv
-            load_dotenv(_cwd_env, override=True)
+            load_dotenv(_cwd_env, override=False)
         except Exception:
             pass
 
-    api_key = config.get("api_key")
+    api_key = config.get("api_key") or os.getenv("UTIM_API_KEY")
     server_url = get_server_url()
+    main_model_source = config.get("main_model_source")
     llm_key = os.getenv("OPENROUTER_API_KEY")
 
+    # If the user is logged into UTIM and hasn't explicitly selected direct openrouter source,
+    # route via UTIM Server FIRST to prevent ambient system environment variables from hijacking routing.
+    is_utim_key = bool(api_key) and not str(api_key).startswith(("sk-or-", "sk-ant-", "sk-proj-", "Bearer "))
+    use_utim_server = is_utim_key and main_model_source != "openrouter"
 
-    if llm_key:
-        # Direct path to OpenRouter — must always carry canonical attribution
-        # headers so OpenRouter shows "UTIM CLI Agent" (NOT "unknown") in its
-        # analytics. The user-agent and install-id are added by the global
-        # session patcher in config.py.
+    def _try_direct_openrouter():
+        if not llm_key:
+            return None
         headers = {
             "Authorization": f"Bearer {llm_key}",
             "Content-Type": "application/json",
@@ -142,20 +260,26 @@ def proxy_openrouter_request(json_data: dict, stream: bool = False, timeout=None
             "X-Title": "UTIM CLI Agent",
             "User-Agent": "UTIM-CLI/2.0 (+https://utim.dev)",
         }
-        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,
-        )
+        try:
+            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,
+            )
+        except Exception:
+            return None
+
+    if not use_utim_server and llm_key:
+        direct_resp = _try_direct_openrouter()
+        if direct_resp is not None:
+            return direct_resp
 
     if api_key:
-        # Path via UTIM server. We attach CLI identity headers (version,
-        # install-id) so the server can correlate calls and (when enforcement
-        # is on) verify the request signature. The session-level UA patch in
-        # config.py adds the User-Agent too.
+        # Path via UTIM server with CLI identity headers
+
         try:
             from utim_cli._version import VERSION as _CLI_VERSION
         except Exception:
@@ -223,7 +347,7 @@ def proxy_openrouter_request(json_data: dict, stream: bool = False, timeout=None
 
         if stream or json_data.get("stream"):
             def line_generator():
-                for line in resp.iter_lines(decode_unicode=True):
+                for line in resp.iter_lines(chunk_size=1, decode_unicode=True):
                     if line:
                         try:
                             data = json.loads(line)
@@ -234,6 +358,8 @@ def proxy_openrouter_request(json_data: dict, stream: bool = False, timeout=None
                                     }]
                                 }
                                 yield "data: " + json.dumps(chunk)
+                            elif data.get("type") == "ping":
+                                continue
                             elif data.get("type") == "done":
                                 if data.get("error"):
                                     yield "data: " + json.dumps({"error": {"message": data["error"]}})
@@ -242,7 +368,7 @@ def proxy_openrouter_request(json_data: dict, stream: bool = False, timeout=None
                                 if usage:
                                     in_tokens = usage.get("input_tokens", 0)
                                     out_tokens = usage.get("output_tokens", 0)
-                                    model_id = json_data.get("model") or "cohere/north-mini-code:free"
+                                    model_id = json_data.get("model") or DEFAULT_MODEL
                                     from utim_cli.server.models import estimate_cost
                                     cost = estimate_cost(model_id, in_tokens, out_tokens)
                                     update_session_usage("tools", in_tokens, out_tokens, cost)
@@ -266,12 +392,14 @@ def proxy_openrouter_request(json_data: dict, stream: bool = False, timeout=None
             in_tokens = 0
             out_tokens = 0
             server_error = None
-            for line in resp.iter_lines(decode_unicode=True):
+            for line in resp.iter_lines(chunk_size=1, decode_unicode=True):
                 if line:
                     try:
                         data = json.loads(line)
                         if data.get("type") == "content_delta" and data.get("text"):
                             content += data["text"]
+                        elif data.get("type") == "ping":
+                            continue
                         elif data.get("type") == "done":
                             if data.get("error"):
                                 server_error = data["error"]
@@ -287,7 +415,7 @@ def proxy_openrouter_request(json_data: dict, stream: bool = False, timeout=None
             if server_error:
                 raise RuntimeError(server_error)
             if in_tokens > 0 or out_tokens > 0:
-                model_id = json_data.get("model") or "cohere/north-mini-code:free"
+                model_id = json_data.get("model") or DEFAULT_MODEL
                 from utim_cli.server.models import estimate_cost
                 cost = estimate_cost(model_id, in_tokens, out_tokens)
                 update_session_usage("tools", in_tokens, out_tokens, cost)

{utim_cli-2.3.2 → utim_cli-2.3.4}/utim_cli/config.py

@@ -340,7 +340,9 @@ class Config:
         val = self._data.get(key, default)
         if val is None:
             if key == "api_key":
-                return os.getenv("UTIM_API_KEY") or os.getenv("OPENROUTER_API_KEY") or os.getenv("OPENAI_API_KEY") or os.getenv("ANTHROPIC_API_KEY")
+                return os.getenv("UTIM_API_KEY")
+            elif key == "openrouter_api_key":
+                return os.getenv("OPENROUTER_API_KEY")
             elif key == "email":
                 return os.getenv("UTIM_EMAIL")
         return val
@@ -492,6 +494,7 @@ class Config:
         if models:
             return [m.strip() for m in models.split(",")]
         return [
+            "poolside/laguna-s-2.1:free",
             "cohere/north-mini-code:free",
             "openrouter/free",
             "meta-llama/llama-3.3-70b-instruct:free",

{utim_cli-2.3.2 → utim_cli-2.3.4}/utim_cli/constants.py

@@ -1,6 +1,6 @@
 import os
 
-DEFAULT_MODEL = "cohere/north-mini-code:free"
+DEFAULT_MODEL = "poolside/laguna-s-2.1:free"
 SERVER_URL = os.getenv("UTIM_SERVER_URL", "https://api.utim.dev")
 OPENROUTER_BASE_URL = os.getenv("OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1")