utim-cli 1.44.2__tar.gz → 1.44.4__tar.gz

{utim_cli-1.44.2/utim_cli.egg-info → utim_cli-1.44.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: utim-cli
-Version: 1.44.2
+Version: 1.44.4
 Summary: UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal.
 License: MIT
 Project-URL: Homepage, https://utim.dev
@@ -37,6 +37,7 @@ Requires-Dist: tree-sitter-typescript>=0.21.0
 Requires-Dist: mcp>=0.1.0
 Requires-Dist: nest-asyncio>=1.5.0
 Requires-Dist: python-multipart>=0.0.7
+Requires-Dist: slowapi>=0.1.9
 Provides-Extra: search
 Requires-Dist: scrapy>=2.11.0; extra == "search"
 Requires-Dist: scrapy-playwright>=0.0.34; extra == "search"

{utim_cli-1.44.2 → utim_cli-1.44.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "1.44.2"
+version = "1.44.4"
 description = "UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -39,6 +39,7 @@ dependencies = [
     "mcp>=0.1.0",
     "nest-asyncio>=1.5.0",
     "python-multipart>=0.0.7",
+    "slowapi>=0.1.9",
 ]
 
 [project.urls]

{utim_cli-1.44.2 → utim_cli-1.44.4}/utim_cli/agent.py

@@ -3,7 +3,7 @@ import json
 import sys
 import time
 from openai import OpenAI
-from .tools import UTIM_TOOLS, TOOL_FUNCTIONS
+from .tools import get_tools
 from rich.console import Console
 from rich.live import Live
 from rich.spinner import Spinner
@@ -193,11 +193,15 @@ class ReActAgent:
             except Exception as e:
                 return f"Error executing MCP tool {tool_name}: {str(e)}"
 
-        if tool_name not in TOOL_FUNCTIONS:
-            return f"Unknown tool: {tool_name}"
-
+        utim_tools, tool_functions = get_tools()
+        if tool_name not in tool_functions:
+            # If not a standard tool, check MCP
+            if hasattr(self, 'orchestrator') and self.orchestrator and tool_name in self.orchestrator.mcp_tool_names:
+                return self.orchestrator._execute_mcp_tool(tool_name, arguments)
+            return f"Error: Tool '{tool_name}' not found."
+            
         try:
-            result = TOOL_FUNCTIONS[tool_name](**arguments)
+            result = tool_functions[tool_name](**arguments)
             self._render_tool_panel(tool_name, arguments, result)
             return str(result)
         except Exception as e:
@@ -212,17 +216,12 @@ class ReActAgent:
             tool_calls = []
             current_tool_call = None
 
-            mcp_tools = []
-            try:
-                from utim_cli.mcp_client import mcp_manager
-                mcp_tools = mcp_manager.get_tools()
-            except Exception:
-                pass
+            utim_tools, tool_functions = get_tools()
 
             # Filter disabled tools
             from utim_cli.config import config
             disabled = config.get("disabled_tools", [])
-            all_tools = [t for t in (UTIM_TOOLS + mcp_tools) if t["function"]["name"] not in disabled]
+            all_tools = [t for t in utim_tools if t["function"]["name"] not in disabled]
 
             kwargs = {
                 "model": self.model_id,
@@ -314,7 +313,8 @@ class ReActAgent:
 
         headers = ["Tool", "Description"]
         all_tools = []
-        for tool_def in UTIM_TOOLS:
+        utim_tools, _ = get_tools()
+        for tool_def in utim_tools:
             fn = tool_def["function"]
             all_tools.append((fn["name"], fn["description"], "standard"))
 

{utim_cli-1.44.2 → utim_cli-1.44.4}/utim_cli/auth.py

@@ -112,8 +112,17 @@ def login() -> None:
     console.print(f"  [bold {BLUE}]{auth_url}[/bold {BLUE}]\n")
     webbrowser.open(auth_url)
 
-    # Block until the callback arrives
-    httpd.serve_forever()
+    # Block until the callback arrives with a 5-minute timeout
+    import time
+    httpd.timeout = 1.0
+    start_time = time.time()
+    while not _AuthCallbackHandler.received:
+        if time.time() - start_time > 300:
+            console.print(f"  [bold red]✗ Authentication timed out (5 minutes).[/bold red]\n")
+            httpd.server_close()
+            return
+        httpd.handle_request()
+        
     httpd.server_close()
 
     data = _AuthCallbackHandler.received

{utim_cli-1.44.2 → utim_cli-1.44.4}/utim_cli/blender_agent.py

@@ -46,6 +46,7 @@ import subprocess
 import time
 import uuid
 from typing import Any, Dict, List, Optional
+from utim_cli.constants import DEFAULT_MODEL
 
 # ---------------------------------------------------------------------------
 # Configuration
@@ -56,8 +57,6 @@ _OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions"
 # Vision models (must support image_url content parts)
 _VISION_MODELS: List[str] = [
     "google/gemma-4-31b-it:free",
-    "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free",
-    "nvidia/nemotron-nano-12b-v2-vl:free",
     "google/gemma-4-26b-a4b-it:free",
     "nvidia/llama-nemotron-embed-vl-1b-v2:free",
     "nvidia/llama-nemotron-rerank-vl-1b-v2:free",
@@ -66,12 +65,34 @@ _VISION_MODELS: List[str] = [
 
 _CODE_MODELS: List[str] = [
     "poolside/laguna-m.1:free",
-    "cohere/north-mini-code:free",
-    "qwen/qwen3-coder:free",
-    "nvidia/nemotron-3-ultra-550b-a55b:free",
+    DEFAULT_MODEL,
     "openrouter/free"
 ]
 
+
+def _get_vision_models() -> List[str]:
+    """Return vision model list, with user override prepended if configured."""
+    try:
+        from utim_cli.config import config
+        override = config.get("subagent_model_blender_vision")
+        if override and override not in ("__non_agent__", "__none__"):
+            return [override] + [m for m in _VISION_MODELS if m != override]
+    except Exception:
+        pass
+    return _VISION_MODELS
+
+
+def _get_code_models() -> List[str]:
+    """Return code model list, with user override prepended if configured."""
+    try:
+        from utim_cli.config import config
+        override = config.get("subagent_model_blender_code")
+        if override and override not in ("__non_agent__", "__none__"):
+            return [override] + [m for m in _CODE_MODELS if m != override]
+    except Exception:
+        pass
+    return _CODE_MODELS
+
 MAX_RETRIES = 3  # Script fix-and-retry attempts
 
 # ---------------------------------------------------------------------------
@@ -562,7 +583,7 @@ def _phase1_vision(image_path: str, scene_brief: Dict[str, Any]) -> Dict[str, An
     raw = _llm_call(
         system=_VISION_SYSTEM_PROMPT,
         user_text=brief_text,
-        models=_VISION_MODELS,
+        models=_get_vision_models(),
         image_b64=image_b64,
         image_mime=mime_type,
         max_tokens=8192,
@@ -674,7 +695,7 @@ def _phase2_generate_script(
     raw_script = _llm_call(
         system=_CODE_SYSTEM_PROMPT,
         user_text=user_prompt,
-        models=_CODE_MODELS,
+        models=_get_code_models(),
         max_tokens=16384,
     )
 
@@ -854,7 +875,7 @@ def _phase3_execute(
                 raw_fixed = _llm_call(
                     system=_FIX_SYSTEM_PROMPT,
                     user_text=fix_prompt,
-                    models=_CODE_MODELS,
+                    models=_get_code_models(),
                     max_tokens=16384,
                 )
                 current_script = _clean_and_patch_script(

{utim_cli-1.44.2 → utim_cli-1.44.4}/utim_cli/config.py

@@ -1,35 +1,49 @@
 import json
-import shutil
+import logging
 import os
 import pathlib
+import shutil
 from typing import Any, Dict, Optional
 
+logger = logging.getLogger("utim.config")
+
 class Config:
     def __init__(self):
         self.global_dir = pathlib.Path.home() / ".utim"
         self.local_dir = pathlib.Path(".utim").resolve()
-        self._data: Dict[str, Any] = self._load()
+        self._global_data: Dict[str, Any] = {}
+        self._local_data: Dict[str, Any] = {}
+        self._load()
 
-    def _load(self) -> Dict[str, Any]:
-        data = {}
+    def _load(self):
         # Load global config
         global_config = self.global_dir / "config.json"
         if global_config.exists():
             try:
                 with open(global_config, "r", encoding="utf-8") as f:
-                    data.update(json.load(f))
-            except Exception:
-                pass
+                    self._global_data = json.load(f)
+            except json.JSONDecodeError as e:
+                logger.warning(f"Global config corrupted at {global_config}: {e}. Using defaults.")
+            except Exception as e:
+                logger.error(f"Cannot read global config: {e}")
         
         # Load local config if exists
         local_config = self.local_dir / "config.json"
         if local_config.exists():
             try:
                 with open(local_config, "r", encoding="utf-8") as f:
-                    data.update(json.load(f))
-            except Exception:
-                pass
-        return data
+                    self._local_data = json.load(f)
+            except json.JSONDecodeError as e:
+                logger.warning(f"Local config corrupted at {local_config}: {e}. Using defaults.")
+            except Exception as e:
+                logger.error(f"Cannot read local config: {e}")
+
+    @property
+    def _data(self) -> Dict[str, Any]:
+        """Returns a merged view (local overrides global)."""
+        merged = dict(self._global_data)
+        merged.update(self._local_data)
+        return merged
 
     def save(self):
         # Save to global config directory
@@ -37,24 +51,30 @@ class Config:
         global_config = self.global_dir / "config.json"
         try:
             with open(global_config, "w", encoding="utf-8") as f:
-                json.dump(self._data, f, indent=4)
-        except Exception:
-            pass
+                json.dump(self._global_data, f, indent=4)
+        except Exception as e:
+            logger.error(f"Cannot write global config: {e}")
 
-        # Save to local config directory if it exists
-        if self.local_dir.exists():
+        # Save to local config directory if we have local data
+        if self._local_data:
+            self.local_dir.mkdir(parents=True, exist_ok=True)
             local_config = self.local_dir / "config.json"
             try:
                 with open(local_config, "w", encoding="utf-8") as f:
-                    json.dump(self._data, f, indent=4)
-            except Exception:
-                pass
+                    json.dump(self._local_data, f, indent=4)
+            except Exception as e:
+                logger.error(f"Cannot write local config: {e}")
 
     def get(self, key: str, default: Any = None) -> Any:
+        if key == "disabled_tools" and "disabled_tools" not in self._data:
+            return ["blender_create_object", "blender_agent_create_from_image"]
         return self._data.get(key, default)
 
-    def set(self, key: str, value: Any):
-        self._data[key] = value
+    def set(self, key: str, value: Any, local: bool = False):
+        if local:
+            self._local_data[key] = value
+        else:
+            self._global_data[key] = value
         self.save()
 
     @property
@@ -70,7 +90,8 @@ class Config:
         return self.get("name")
 
     def clear(self):
-        self._data = {}
+        self._global_data = {}
+        self._local_data = {}
         self.save()
 
     # ── Custom / Bring-Your-Own-Model support ─────────────────────────────────
@@ -92,14 +113,28 @@ class Config:
 
     @custom_models.setter
     def custom_models(self, value: list):
-        self._data["custom_models"] = value
-        self.save()
+        self.set("custom_models", value)
 
     def add_custom_model(self, entry: dict) -> None:
         """Append or replace a custom model entry keyed on model_id."""
         models = self.custom_models
         models = [m for m in models if m.get("model_id") != entry["model_id"]]
-        models.append(entry)
+        
+        api_key = entry.get("api_key")
+        use_keyring = False
+        if api_key:
+            try:
+                import keyring
+                keyring.set_password("utim_cli", entry["model_id"], api_key)
+                use_keyring = True
+            except Exception as e:
+                logger.warning(f"Keyring not available, storing key in plain text: {e}")
+                
+        entry_to_save = dict(entry)
+        if use_keyring:
+            entry_to_save.pop("api_key", None)
+            
+        models.append(entry_to_save)
         self.custom_models = models
 
     def remove_custom_model(self, model_id: str) -> bool:
@@ -108,26 +143,55 @@ class Config:
         new = [m for m in models if m.get("model_id") != model_id]
         if len(new) == len(models):
             return False
+            
+        try:
+            import keyring
+            keyring.delete_password("utim_cli", model_id)
+        except Exception:
+            pass
+            
         self.custom_models = new
         return True
 
     def remove_custom_provider(self, provider_name: str, base_url: str) -> int:
         """Remove all custom models associated with a provider. Returns count removed."""
         models = self.custom_models
-        new = [
-            m for m in models 
-            if m.get("provider_name") != provider_name or m.get("base_url") != base_url
-        ]
-        removed_count = len(models) - len(new)
-        if removed_count > 0:
+        new = []
+        removed = 0
+        try:
+            import keyring
+            has_keyring = True
+        except ImportError:
+            has_keyring = False
+            
+        for m in models:
+            if m.get("provider_name") == provider_name and m.get("base_url") == base_url:
+                removed += 1
+                if has_keyring:
+                    try:
+                        keyring.delete_password("utim_cli", m["model_id"])
+                    except Exception:
+                        pass
+            else:
+                new.append(m)
+                
+        if removed > 0:
             self.custom_models = new
-        return removed_count
+        return removed
 
     def get_custom_model(self, model_id: str) -> Optional[dict]:
         """Return the custom model entry for *model_id*, or None."""
         for m in self.custom_models:
             if m.get("model_id") == model_id:
-                return m
+                m_ret = dict(m)
+                try:
+                    import keyring
+                    key = keyring.get_password("utim_cli", model_id)
+                    if key:
+                        m_ret["api_key"] = key
+                except Exception:
+                    pass
+                return m_ret
         return None
 
     @property
@@ -147,8 +211,6 @@ class Config:
             return [m.strip() for m in models.split(",")]
         return [
             "poolside/laguna-m.1:free",
-            "qwen/qwen3-coder:free",
-            "nvidia/nemotron-3-ultra-550b-a55b:free",
             "openrouter/free"
         ]
 

utim_cli-1.44.4/utim_cli/constants.py

@@ -0,0 +1,13 @@
+import os
+
+DEFAULT_MODEL = "cohere/north-mini-code: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")
+
+SUBAGENT_DEFAULTS = {
+    "web_search": DEFAULT_MODEL,
+    "plan_project": DEFAULT_MODEL,
+    "project_res": DEFAULT_MODEL,
+    "generate_image": "nvidia/nemotron-3-nano-30b-a3b:free",
+    "blender_create_object": DEFAULT_MODEL,
+}

{utim_cli-1.44.2 → utim_cli-1.44.4}/utim_cli/context_pruner.py

@@ -11,12 +11,13 @@ from typing import List, Dict, Tuple, Optional, Set
 import requests
 import json
 import hashlib
+from utim_cli.constants import DEFAULT_MODEL
 
 # Fallback models for compression operations - ordered by reliability and quality
 COMPRESSION_FALLBACK_MODELS = [
     "openai/gpt-oss-20b:free",
     "poolside/laguna-xs.2:free",
-    "cohere/north-mini-code:free",
+    DEFAULT_MODEL,
     "openrouter/free"
 ]
 

{utim_cli-1.44.2 → utim_cli-1.44.4}/utim_cli/orchestrator.py

@@ -22,10 +22,12 @@ import subprocess
 import sys
 import threading
 import time
+from datetime import datetime
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import Any, Dict, List, Optional, Tuple
 
 import requests
+from utim_cli.constants import DEFAULT_MODEL
 # openai SDK removed — we call OpenRouter directly via requests (no Rust/jiter needed)
 from rich.console import Console
 from rich.live import Live
@@ -35,8 +37,7 @@ from rich.rule import Rule
 from rich.spinner import Spinner
 from rich.text import Text
 
-from .billing import CreditManager
-from .tools import TOOL_FUNCTIONS, UTIM_TOOLS
+from .tools import get_tools
 import utim_cli.tools as _tools_module   # for injecting cancel_event
 from .config import config
 
@@ -261,11 +262,10 @@ class Orchestrator:
             mcp_manager.start()
         except Exception:
             pass
-        self.credits = CreditManager()
         self.server_url = "https://api.utim.dev"
         self.session_id: Optional[str] = None
         # Primary model — falls back through config.fallback_models on failure
-        self.model_id: str = "cohere/north-mini-code:free"
+        self.model_id: str = DEFAULT_MODEL
         self._current_line_len = 0
         self.tool_results: List[Dict[str, Any]] = []
         self.turn_step_timings: List[Dict[str, Any]] = []
@@ -499,6 +499,7 @@ class Orchestrator:
                     timeout=5,
                 )
                 if resp.status_code == 200:
+                    quota = resp.json()
                     chosen_model = override_model if override_model else self.model_id
                     is_custom = bool(config.get_custom_model(chosen_model))
 
@@ -521,7 +522,7 @@ class Orchestrator:
                     is_custom = bool(config.get_custom_model(chosen_model))
 
                     if not is_custom and models_allowed != ["all"] and chosen_model not in models_allowed:
-                        fallback_model = "cohere/north-mini-code:free"  # default free fallback
+                        fallback_model = DEFAULT_MODEL  # default free fallback
                         self.console.print(f"\n[bold yellow]⚠ Model '{chosen_model}' is gated under your current '{quota['display_name']}' plan.[/bold yellow]")
                         self.console.print(f"  Downgrading to default allowed model: '{fallback_model}' for this request.")
                         if override_model:
@@ -568,7 +569,9 @@ class Orchestrator:
                 except Exception:
                     pass
 
-                all_tools = (override_tools if override_tools is not None else UTIM_TOOLS) + mcp_tools
+                from utim_cli.tools import get_tools
+                utim_tools, _ = get_tools()
+                all_tools = (override_tools if override_tools is not None else utim_tools) + mcp_tools
                 # Filter disabled tools
                 disabled = config.get("disabled_tools", [])
                 all_tools = [t for t in all_tools if t["function"]["name"] not in disabled]
@@ -1362,12 +1365,13 @@ class Orchestrator:
                 ))
                 return f"Error executing MCP tool {func_name}: {str(e)}"
 
-        if func_name not in TOOL_FUNCTIONS:
-            self.console.print(Panel(
-                Text(f"Unknown tool: {func_name}", style="red"),
-                border_style="red", padding=(0, 1),
-            ))
-            return f"Unknown tool: {func_name}"
+        from utim_cli.tools import get_tools
+        utim_tools, tool_functions = get_tools()
+        if func_name not in tool_functions:
+            # Check if it's an MCP tool
+            if func_name in self.mcp_tool_names:
+                return self._execute_mcp_tool(func_name, call_args)
+            return f"Error: The tool '{func_name}' does not exist or is not available in the current context."
 
         display_arg = self._get_display_arg(func_name, arguments)
 
@@ -1508,7 +1512,8 @@ class Orchestrator:
         _SILENT_TOOLS = {"manage_memory", "recall_experience", "store_experience"}
         if func_name in _SILENT_TOOLS:
             try:
-                result = TOOL_FUNCTIONS[func_name](**call_args)
+                utim_tools, tool_functions = get_tools()
+                result = tool_functions[func_name](**call_args)
             except Exception as exc:
                 result = f"Error executing {func_name}: {exc}"
             self.tool_results.append({
@@ -1560,7 +1565,13 @@ class Orchestrator:
             except Exception:
                 pass
 
-            result = TOOL_FUNCTIONS[func_name](**call_args)
+            try:
+                utim_tools, tool_functions = get_tools()
+                result = tool_functions[func_name](**call_args)
+                return result
+            except Exception as e:
+                import traceback
+                result = f"Error executing tool {func_name}: {e}\n{traceback.format_exc()}"
             
             # Restore the indicator to evaluating logic
             try:

{utim_cli-1.44.2 → utim_cli-1.44.4}/utim_cli/reflection.py

@@ -13,6 +13,7 @@ import sqlite3
 from typing import Dict, List, Optional
 from datetime import datetime
 import requests
+from utim_cli.constants import DEFAULT_MODEL
 
 
 MEMORY_FILE = ".utim_tmp/task_reflections.json"
@@ -74,7 +75,7 @@ Return ONLY a JSON object with the following structure:
         resp = requests.post(
             apiUrl,
             json={
-                "model": "cohere/north-mini-code:free",
+                "model": DEFAULT_MODEL,
                 "messages": [
                     {"role": "system", "content": "You are a reflection engine. Extract technical learnings, logical corrections, and time adaptations from completed work."},
                     {"role": "user", "content": prompt}