utim-cli 1.48.2__tar.gz → 1.48.4__tar.gz

{utim_cli-1.48.2 → utim_cli-1.48.4}/CHANGELOG.md

@@ -1,8 +1,18 @@
 # Changelog
 
-## [1.48.2] - 2026-07-23
+## [1.48.4] - 2026-07-25
+
+- **Minor Bug Fixes**: Under-the-hood optimization and resolution of minor dependency issues.
+
+## [1.48.3] - 2026-07-25
 
 ### Fixed
+- **Blender 3D Tools**: Fully restored normal functionality and re-enabled the local Blender asset generation workflow and agent scripts.
+- **Windows Shell Sanitization**: Resolved issues with Unix commands like `mkdir -p` and `rm -rf` failing on native Windows PowerShell by introducing automatic translation to `New-Item` and `Remove-Item`.
+- **Command Redirection Safeguards**: Automatically blocks Bash-style here-docs (`<<`) on Windows with a helpful prompt to guide models to use proper file-write tools.
+- **UI Abort and Confirmation Fixes**: Removed the 30-second background timeout on confirmation dialogs to prevent thread synchronization freeze states. Fixed signal-handling bugs so pressing Ctrl+C or Esc immediately cancels active HTTP streams and releases the CLI layout.
+
+## [1.48.2] - 2026-07-23
 - **Minor Bug Fixes**: Under-the-hood optimization and resolution of minor dependency issues.
 
 ## [1.48.1] - 2026-07-23

{utim_cli-1.48.2/utim_cli.egg-info → utim_cli-1.48.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 1.48.2
+Version: 1.48.4
 Summary: UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal.
 License: MIT
 Project-URL: Homepage, https://utim.dev

{utim_cli-1.48.2 → utim_cli-1.48.4}/pyproject.toml

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

{utim_cli-1.48.2 → utim_cli-1.48.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__ = "1.48.2"
+    __version__ = "1.48.4"
 
 import builtins, os, pathlib, urllib.parse, re
 

{utim_cli-1.48.2 → utim_cli-1.48.4}/utim_cli/_version.py

@@ -11,4 +11,4 @@
 # from here so every surface stays in sync automatically.
 # ─────────────────────────────────────────────────────────────────────────────
 
-VERSION = "1.48.2"
+VERSION = "1.48.4"

{utim_cli-1.48.2 → utim_cli-1.48.4}/utim_cli/blender_agent.py

@@ -1079,143 +1079,36 @@ def _phase3_execute(
         f"Last error:\n{last_error}"
     )
 
-
-# ---------------------------------------------------------------------------
-# Public entry point
-# ---------------------------------------------------------------------------
-
 def blender_agent_create_from_image(
-    image_path: str,
-    name: str,
+    image_path: Optional[str] = None,
+    prompt: Optional[str] = None,
+    name: Optional[str] = None,
     output_path: Optional[str] = None,
-    output_format: str = "blend",
+    output_format: str = "glb",
 ) -> str:
-    """Create a detailed 3-D model from an image using the 4-phase Blender pipeline.
-
-    Parameters
-    ----------
-    image_path:
-        Absolute or relative path to the source image (PNG, JPG, WEBP, BMP).
-    name:
-        Base name for the Blender object and the exported file (no extension).
-    output_path:
-        Directory where the exported file will be saved.
-        Defaults to ``blender_assets/`` in the current working directory.
-    output_format:
-        ``"blend"``, ``"obj"``, ``"glb"``, or ``"fbx"``. Defaults to ``"blend"``.
-
-    Returns
-    -------
-    str
-        A human-readable progress log including the path to the exported
-        file, or an error description.
-    """
-    return "Error: The Blender 3D tool is currently Under Maintenance."
-
-    output_dir = output_path or os.path.join(os.getcwd(), ".utim_tmp", "blender_assets")
-    assets_dir = pathlib.Path(output_dir).absolute()
-    assets_dir.mkdir(parents=True, exist_ok=True)
-
-    safe_name = re.sub(r"[^\w\-]", "_", name)
-    export_filename = f"{safe_name}_{uuid.uuid4().hex[:8]}.{output_format}"
-    export_path = str(assets_dir / export_filename)
-
-    tmp_dir = pathlib.Path(".utim_tmp/blender")
-    tmp_dir.mkdir(parents=True, exist_ok=True)
-
-    log_lines: List[str] = []
-
-    def _log(msg: str) -> None:
-        log_lines.append(msg)
-
-    # Time tracking
-    timings = {}
-    overall_start = time.time()
-
-    def _time_log(phase: str) -> float:
-        elapsed = time.time() - overall_start
-        timings[phase] = elapsed
-        return elapsed
-
-    # ── Phase 0: Local image analysis ────────────────────────────────────────
-    _log("[Blender Agent] Phase 0: Local image analysis...")
-    phase0_start = time.time()
-    scene_brief = _phase0_local_analysis(image_path)
-    _time_log("Phase 0")
-    _log(
-        f"  Resolution  : {scene_brief.get('width')}x{scene_brief.get('height')} px\n"
-        f"  Brightness  : {scene_brief.get('brightness')}\n"
-        f"  Dom. colours: {len(scene_brief.get('dominant_colors', []))} found"
-    )
+    """Create a detailed 3-D model from an image or text prompt using the direct Tripo API.
 
-    # ── Phase 1: Vision-LLM scene understanding ───────────────────────────────
-    _log("[Blender Agent] Phase 1: Vision-LLM scene analysis...")
-    phase1_start = time.time()
-    try:
-        scene_data, assembly_plan = _phase1_vision(image_path, scene_brief)
-    except Exception as exc:
-        _time_log("Phase 1")
-        return "\n".join(log_lines) + f"\n[Blender Agent] Phase 1 FAILED.\nReason: {exc}"
-    _time_log("Phase 1")
-
-    part_count = len(scene_data.get("parts", []))
-    tattoos = scene_data.get("face_details", {}).get("tattoos", [])
-    _log(
-        f"  Scene type  : {scene_data.get('scene_type', 'unknown')}\n"
-        f"  Subject     : {scene_data.get('subject_label', 'unknown')}\n"
-        f"  Description : {scene_data.get('description', '')[:120]}...\n"
-        f"  Parts found : {part_count}\n"
-        f"  Hair style  : {scene_data.get('hair', {}).get('style', 'n/a')}\n"
-        f"  Has tattoos : {len(tattoos) if isinstance(tattoos, list) else bool(tattoos)}\n"
-        f"  Clothing    : {len(scene_data.get('clothing', []))} item(s)\n"
-        f"  Objects     : {len(scene_data.get('objects', []))} background objects"
-    )
+    Saves the resulting model to the blender_assets/ folder inside .utim_tmp/ directory.
+    """
+    from utim_cli.tools import generate_3d_model
+    import os
+    import re
+    import uuid
 
-    # Save the scene description JSON alongside the script for inspection
-    json_path = tmp_dir / f"scene_{safe_name}.json"
-    json_path.write_text(json.dumps(scene_data, indent=2), encoding="utf-8")
-    _log(f"  Scene JSON  : {json_path}")
+    if not image_path and not prompt:
+        return "Error: Please provide either an image_path or a text prompt for 3D model generation."
 
-    # ── Phase 2: Blender script generation ───────────────────────────────────
-    _log("[Blender Agent] Phase 2: Generating Blender Python script...")
-    phase2_start = time.time()
-    try:
-        script = _phase2_generate_script(
-            scene_data=scene_data,
-            assembly_plan=assembly_plan,
-            image_path=image_path,
-            name=safe_name,
-            export_path=export_path,
-            export_format=output_format,
-        )
-    except Exception as exc:
-        _time_log("Phase 2")
-        return "\n".join(log_lines) + f"\n[Blender Agent] Phase 2 FAILED.\nReason: {exc}"
-    _time_log("Phase 2")
-
-    script_preview_path = tmp_dir / f"gen_{safe_name}_preview.py"
-    script_preview_path.write_text(script, encoding="utf-8")
-    _log(f"  Script saved: {script_preview_path}")
-
-    # ── Phase 3: Execute & validate ───────────────────────────────────────────
-    _log("[Blender Agent] Phase 3: Running Blender headless...")
-    phase3_start = time.time()
-    try:
-        final_path = _phase3_execute(
-            script=script,
-            scene_data=scene_data,
-            image_path=image_path,
-            name=safe_name,
-            export_path=export_path,
-            export_format=output_format,
-            tmp_dir=tmp_dir,
-        )
-    except Exception as exc:
-        _time_log("Phase 3")
-        return "\n".join(log_lines) + f"\n[Blender Agent] Phase 3 FAILED.\nReason: {exc}"
-    _time_log("Phase 3")
-
-    total_elapsed = time.time() - overall_start
-    _log(f"[Blender Agent] SUCCESS - exported to: {final_path}")
-    _log(f"[Blender Agent] Total elapsed time: {total_elapsed:.1f}s")
-    return "\n".join(log_lines)
+    task_type = "image_to_model" if image_path else "text_to_model"
+    safe_name = name or f"blender_{uuid.uuid4().hex[:8]}"
+    
+    # Map 'blend' or other formats to glb if needed
+    tripo_format = output_format if output_format in ("glb", "obj") else "glb"
+    res = generate_3d_model(
+        type=task_type,
+        prompt=prompt,
+        image_path=image_path,
+        name=safe_name,
+        output_format=tripo_format
+    )
+    
+    return f"[Blender Agent] Tripo direct API generation response:\n{res}"

{utim_cli-1.48.2 → utim_cli-1.48.4}/utim_cli/client_utils.py

@@ -258,7 +258,7 @@ def parse_xml_tool_calls(content: str) -> tuple[str | None, list[dict]]:
             
         args = {}
         # Pattern 1: <arg_key>key</arg_key>\s*<arg_value>value</arg_value>
-        arg_pattern = re.compile(r'<arg_key>([^<]+)</arg_key>\s*<arg_value>([^<]*)</arg_value>')
+        arg_pattern = re.compile(r'<arg_key>([^<]+)</arg_key>\s*<arg_value>([\s\S]*?)</arg_value>')
         for arg_match in arg_pattern.finditer(block):
             args[arg_match.group(1).strip()] = arg_match.group(2).strip()
             
@@ -269,9 +269,12 @@ def parse_xml_tool_calls(content: str) -> tuple[str | None, list[dict]]:
             
         # Standardize argument name for run_command
         if tool_name == "run_command":
-            for wrong_key in ["CommandLine", "cmd", "shell", "script"]:
+            for wrong_key in ["CommandLine", "commandLine", "command_line", "cmd_line", "cmd", "shell", "script"]:
                 if wrong_key in args and "command" not in args:
                     args["command"] = args.pop(wrong_key)
+            for path_key in ["cwd", "directory", "folder", "path"]:
+                if path_key in args and "dir_path" not in args:
+                    args["dir_path"] = args.pop(path_key)
             for bg_key in ["background", "is_background", "bg"]:
                 if bg_key in args:
                     val = args.pop(bg_key)

{utim_cli-1.48.2 → utim_cli-1.48.4}/utim_cli/orchestrator.py

@@ -714,18 +714,18 @@ def _get_dynamic_directives(is_compressed: bool, messages: Optional[List[Dict]]
             directives.append("2. **Planning/Autonomous**: No tools are currently enabled. Do NOT attempt to call any tools.")
 
         if has_plan_project and has_run_command:
-            directives.append("3. **Think-Create-Verify**: Formulate a plan in text (or use the `plan_project` tool for complex architectural parts). Verify with `run_command` (build/test/run), do not just read.")
+            directives.append("3. **Think-Create-Verify**: Start executing right away. You do NOT need to write a plan or preamble in text before calling tools. Output tool calls immediately, then explain results or check tests. Verify with `run_command` (build/test/run), do not just read.")
         elif has_plan_project:
-            directives.append("3. **Think-Create-Verify**: Formulate a plan in text (or use the `plan_project` tool for complex architectural parts) before writing.")
+            directives.append("3. **Think-Create-Verify**: Start executing right away. You do NOT need to write a plan or preamble in text before calling tools. Output tool calls immediately, then explain results or check tests.")
         elif has_run_command:
-            directives.append("3. **Think-Create-Verify**: Formulate a plan in text before writing. Verify with `run_command` (build/test/run), do not just read.")
+            directives.append("3. **Think-Create-Verify**: Start executing right away. You do NOT need to write a plan or preamble in text before calling tools. Output tool calls immediately, then explain results or check tests. Verify with `run_command` (build/test/run), do not just read.")
         else:
-            directives.append("3. **Think-Create-Verify**: Formulate a plan in text before writing.")
+            directives.append("3. **Think-Create-Verify**: Start executing right away. You do NOT need to write a plan or preamble in text before calling tools. Output tool calls immediately, then explain results or check tests.")
 
         directives.append(f"4. **Manifesto**: Safety and coding standards are in {_posix}/UTIM.md.")
         directives.append("5. **Output**: Be concise and professional. Summarize all changes and test results when complete. Speak colloquially and warmly. If you notice other code smells, potential bugs, or logical issues in the code snippets you read during execution, list them as proposed improvements in your final summary for the user instead of fixing them immediately.")
-        directives.append("6. **Execution**: Create and follow a detailed todo list to the end.")
-        directives.append("7. **Tool Calling**: Use native function-calling. No raw JSON, `<think>` tags, or raw tool markup in text responses.")
+        directives.append("6. **Execution**: Avoid announcing what you are going to do or writing text-only planning steps. Just invoke the appropriate tool call directly. You may explain your reasoning in the same message alongside the tool call if needed, but the tool call MUST be present if there is work to do.")
+        directives.append("7. **Tool Calling**: Use native function-calling. Avoid conversational preamble. Do not output raw JSON, `<think>` tags, or raw tool markup in text responses.")
         directives.append(f"8. **Premium Web Design**: Style web UIs per `{_posix}/DESIGN.md` (premium typography, HSL colors, glassmorphism, animations).")
         directives.append("9. **Hint Guidance**: Follow any `[Secret Hint Guidance: <instruction>]` prefix in the user prompt as a high-priority system directive.")
         directives.append("10. **Speed & Safety Balance**: Trust your edits. Do NOT waste tokens/time calling `read_file` or `view_file` immediately after writing or editing just to verify. Instead, verify safety instantly by running a compilation, build, or test command via `run_command`. Only re-read files if compilation/tests fail or return errors.")
@@ -750,18 +750,18 @@ def _get_dynamic_directives(is_compressed: bool, messages: Optional[List[Dict]]
             directives.append("2. **Planning/Autonomous Tooling**: No tools are currently enabled. Do NOT attempt to use any tools.")
 
         if has_plan_project and has_run_command:
-            directives.append("3. **Think-Create-Verify**: Formulate a technical plan in text (or use the `plan_project` tool if a highly detailed sub-plan is needed for complex sections). Track tasks, write code, and verify with execution (`run_command` -> build/test/run) rather than just reading files.")
+            directives.append("3. **Think-Create-Verify**: Start executing right away. You do NOT need to write a detailed plan or preamble in text before calling tools. Output tool calls immediately, then explain results or check tests. Verify with execution (`run_command` -> build/test/run) rather than just reading files.")
         elif has_plan_project:
-            directives.append("3. **Think-Create-Verify**: Formulate a technical plan in text (or use the `plan_project` tool if a highly detailed sub-plan is needed for complex sections) before taking any mutating actions.")
+            directives.append("3. **Think-Create-Verify**: Start executing right away. You do NOT need to write a detailed plan or preamble in text before calling tools. Output tool calls immediately, then explain results or check tests.")
         elif has_run_command:
-            directives.append("3. **Think-Create-Verify**: Formulate a technical plan in text before taking any mutating actions. Verify with execution (`run_command` -> build/test/run) rather than just reading files.")
+            directives.append("3. **Think-Create-Verify**: Start executing right away. You do NOT need to write a detailed plan or preamble in text before calling tools. Output tool calls immediately, then explain results or check tests. Verify with execution (`run_command` -> build/test/run) rather than just reading files.")
         else:
-            directives.append("3. **Think-Create-Verify**: Formulate a technical plan in text before taking any mutating actions.")
+            directives.append("3. **Think-Create-Verify**: Start executing right away. You do NOT need to write a detailed plan or preamble in text before calling tools. Output tool calls immediately, then explain results or check tests.")
 
         directives.append(f"4. **Manifesto Reference**: Detailed engineering rules, coding standards, and safety/sandbox instructions are in {_posix}/UTIM.md. Read/reference it only when specific guidance is needed.")
         directives.append("5. **Output**: Be concise and professional. Summarize all changes and test results when complete. Speak colloquially and warmly in the user's language. If you notice other code smells, potential bugs, or logical issues in the code snippets you read during execution, list them as proposed improvements in your final summary for the user instead of fixing them immediately.")
-        directives.append("6. **Execution**: When executing tools to get the project ready always create a todo list and follow them to the end. Add todos based on detailed steps.")
-        directives.append("7. **Tool Calling format**: You MUST use the native JSON-schema function-calling mechanism provided by the API to invoke tools. NEVER output raw JSON, <think to=...> tags, <|message|> tags, or other raw tool-call markup in your text response. Any tool usage must be strictly structured via the API.")
+        directives.append("6. **Execution**: Avoid announcing what you are going to do or writing text-only planning steps. Just invoke the appropriate tool call directly. You may explain your reasoning in the same message alongside the tool call if needed, but the tool call MUST be present if there is work to do.")
+        directives.append("7. **Tool Calling format**: You MUST use the native JSON-schema function-calling mechanism provided by the API to invoke tools. Avoid conversational preamble. NEVER output raw JSON, <think to=...> tags, <|message|> tags, or other raw tool-call markup in your text response. Any tool usage must be strictly structured via the API.")
         directives.append(f"8. **Premium Web Design**: When creating, updating, or styling web user interfaces, read/reference `{_posix}/DESIGN.md` to apply modern visual design conventions (such as premium typography, HSL color themes, glassmorphism, and smooth animations) instead of default browser styles or raw colors.")
         directives.append("9. **Secret Hint Guidance**: If a user message begins with `[Secret Hint Guidance: <instruction>]`, you MUST treat that instruction as a high-priority system-level override directive. Customize your reasoning, tool selection, explanation detail, and output formatting to strictly adhere to that instruction throughout the entire task execution.")
         directives.append("10. **Speed & Safety Balance**: Trust your edits. Do NOT waste tokens/time calling `read_file` or `view_file` immediately after writing or editing just to verify. Instead, verify safety instantly by running a compilation, build, or test command via `run_command`. Only re-read files if compilation/tests fail or return errors.")
@@ -2040,6 +2040,15 @@ class Orchestrator:
                         finally:
                             self.active_response = None
 
+                        if self.cancel_event.is_set():
+                            return {
+                                "role": "assistant",
+                                "content": "[Aborted by user]",
+                                "tool_calls": None,
+                                "was_cut_off": True,
+                                "aborted": True,
+                            }, False
+
                         # Flush any remaining text in _line_buf and table_buf
                         flush_table()
                         if _line_buf and not silent:
@@ -3084,10 +3093,21 @@ class Orchestrator:
                     ("edit_file", "path"):          "filepath",
                     ("edit_file", "file"):          "filepath",
                     ("edit_file", "filename"):      "filepath",
-                    # run_command: model sometimes uses 'cmd'
-                    ("run_command", "cmd"):         "command",
-                    ("run_command", "shell"):       "command",
-                    ("run_command", "script"):      "command",
+                    # run_command: model sometimes uses 'cmd' or 'CommandLine'
+                    ("run_command", "cmd"):              "command",
+                    ("run_command", "shell"):            "command",
+                    ("run_command", "script"):           "command",
+                    ("run_command", "CommandLine"):      "command",
+                    ("run_command", "commandLine"):      "command",
+                    ("run_command", "command_line"):     "command",
+                    ("run_command", "cmd_line"):         "command",
+                    ("run_command", "cwd"):              "dir_path",
+                    ("run_command", "directory"):        "dir_path",
+                    ("run_command", "folder"):           "dir_path",
+                    ("run_command", "path"):             "dir_path",
+                    ("run_command", "background"):       "is_background",
+                    ("run_command", "bg"):               "is_background",
+                    ("run_command", "run_in_background"):"is_background",
                     # web_search: model sometimes uses 'prompt'
                     ("web_search", "prompt"):       "query",
                     ("web_search", "text"):         "query",
@@ -4166,10 +4186,12 @@ class Orchestrator:
 
 
 
-    def run_task(self, user_message: str, max_iterations: int = 500) -> None:
+    def run_task(self, user_message: str, max_iterations: int = 35) -> None:
         """Append user_message to history and run the full ReAct loop until the
         model stops issuing tool calls or we hit max_iterations.
         """
+        from utim_cli.config import config
+        max_iterations = config.get("max_iterations", max_iterations)
         self.turn_step_timings = []
         self._tool_failure_counts = {}
 
@@ -4611,27 +4633,43 @@ class Orchestrator:
                         )
                         break
 
+                    # To prevent history pollution and break repeating patterns, check if the last
+                    # message in history was a previous nudge. If so, remove the previous nudge-and-response pair
+                    # so they don't multiply in the LLM's context.
+                    if len(self.messages) >= 2:
+                        last_user = self.messages[-1]
+                        if last_user.get("role") == "user" and any(marker in (last_user.get("content") or "") for marker in [
+                            "Stop announcing your intentions",
+                            "Stop describing plans",
+                            "You described what you were going to do",
+                            "You just executed tool(s)",
+                            "You stopped without writing anything"
+                        ]):
+                            self.messages.pop()  # Pop the previous user nudge
+                            if self.messages and self.messages[-1].get("role") == "assistant":
+                                self.messages.pop()  # Pop the previous lazy assistant response
+
                     # Build a context-aware continuation nudge
                     if _had_tools_this_turn:
                         tool_list = ", ".join(dict.fromkeys(reversed(_recent_tool_names)))  # dedupe, preserve order
                         nudge = (
                             f"You just executed tool(s) [{tool_list}]. You then wrote a short response without "
-                            f"calling any further tools. If the task is incomplete, you MUST output the required JSON tool calls. "
-                            f"Do NOT just tell me what you are going to do — actually DO IT by calling the tool. "
+                            f"calling any further tools. Stop describing plans or announcing intentions. "
+                            f"If the task is incomplete, you MUST output the required JSON tool calls to DO IT. "
                             f"If the task is truly complete, provide a comprehensive final summary."
                         )
                     elif _is_lazy_transition:
                         # First-step lazy: model announced what it would do but didn't call any tools
                         nudge = (
-                            "You described what you were going to do but did not actually do it. "
-                            "Stop announcing your intentions — immediately call the appropriate tool(s) right now. "
-                            "Do NOT write 'I will now...' or 'Let me...' and then stop. "
-                            "Just output the tool call directly."
+                            "Stop describing plans, listing todos, or announcing your intentions in text. "
+                            "You MUST immediately execute the appropriate tool call(s) right now. "
+                            "Do NOT write conversational filler, explanations, or 'I will now...' statements. "
+                            "Output the tool call JSON directly."
                         )
                     else:
                         nudge = (
                             "You stopped without writing anything or taking action. The user's request was: "
-                            f"\"{user_message[:200]}\". Please provide a substantive response or take action."
+                            f"\"{user_message[:200]}\". Stop describing plans — output the tool call JSON directly."
                         )
 
                     self.console.print(f"\n[dim yellow]⚠ Model provided lazy response without tools. Auto-nudging (attempt {_empty_response_streak}/3)...[/dim yellow]")
@@ -4894,9 +4932,33 @@ class Orchestrator:
                             "content": warning_text
                         })
                         self.console.print(f"\n[bold red]⚠️ Tool Loop Intercepted: Nudging agent to prevent repeated `{func_name}` failures.[/bold red]")
+
+                    # Also track general failures by tool name to catch cases where the model
+                    # changes arguments slightly but keeps failing the same tool type.
+                    if not hasattr(self, "_tool_name_failure_counts"):
+                        self._tool_name_failure_counts = {}
+                    
+                    name_count = self._tool_name_failure_counts.get(func_name, 0) + 1
+                    self._tool_name_failure_counts[func_name] = name_count
+                    
+                    if name_count >= 4:
+                        self._tool_name_failure_counts[func_name] = 0
+                        warning_text = (
+                            f"⚠️ [SYSTEM NOTICE] The tool `{func_name}` has failed 4 times with different arguments in this turn. "
+                            f"Your general approach with `{func_name}` is failing. Please check if your file paths are absolute, "
+                            f"if directories exist, or if command flags are correct. You MUST alter your strategy or verify "
+                            f"path structure before calling `{func_name}` again."
+                        )
+                        self.messages.append({
+                            "role": "user",
+                            "content": warning_text
+                        })
+                        self.console.print(f"\n[bold red]⚠️ Tool Type Failure Loop Intercepted: Nudging agent for `{func_name}` general failures.[/bold red]")
                 else:
-                    # Successful tool run clears the failure count for this fingerprint
+                    # Successful tool run clears the failure counts
                     self._tool_failure_counts.pop(fingerprint, None)
+                    if hasattr(self, "_tool_name_failure_counts"):
+                        self._tool_name_failure_counts.pop(func_name, None)
 
             # Attempt to compress context if requested or if token limit is breached.
             # turn_msg_start is passed so that after compression rewrites

{utim_cli-1.48.2 → utim_cli-1.48.4}/utim_cli/server/auth.py

@@ -163,6 +163,11 @@ def process_user_refills(db: Session, user_id: str) -> None:
         unused_credits = max(0.0, cycle_allowance - current_cycle_used)
         if due > 1:
             unused_credits += cycle_allowance * (due - 1)
+            
+        # Cap refills to remaining monthly plan credits after direct deductions
+        unallocated_deducted = getattr(sub, "unallocated_deducted", 0.0) or 0.0
+        remaining_pool = max(0.0, plan.credits_per_month - (sub.refills_processed * cycle_allowance) - unallocated_deducted)
+        unused_credits = min(unused_credits, remaining_pool)
         
         credit = db.query(Credit).filter(Credit.user_id == user_id).first()
         if not credit:

{utim_cli-1.48.2 → utim_cli-1.48.4}/utim_cli/server/db.py

@@ -88,7 +88,7 @@ class Plan(Base):
     __tablename__ = "plans"
 
     id = Column(String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
-    name = Column(String(50), unique=True, nullable=False)          # "free", "hobby", "pro", "team", "enterprise"
+    name = Column(String(50), unique=True, nullable=False)          # "free", "hobby", "pro", "max", "ultimate"
     display_name = Column(String(100), nullable=False)
     price_inr = Column(Integer, default=0, nullable=False)
     credits_per_month = Column(Integer, nullable=False)
@@ -118,6 +118,7 @@ class UserSubscription(Base):
     last_refill_at = Column(DateTime, nullable=True)
     # Overrides the default per-cycle credit allocation after a quota-share deduction
     refill_rate_override = Column(Float, nullable=True)
+    unallocated_deducted = Column(Float, default=0.0, nullable=False)
     created_at = Column(DateTime, default=datetime.datetime.utcnow, nullable=False)
     updated_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow, nullable=False)
 
@@ -630,12 +631,14 @@ def init_db(silent: bool = True) -> None:
         _run_migration("users", "referral_code", "ALTER TABLE users ADD COLUMN IF NOT EXISTS referral_code VARCHAR(50)", "postgres add referral_code")
         _run_migration("feedbacks", "chat_history", "ALTER TABLE feedbacks ADD COLUMN IF NOT EXISTS chat_history TEXT", "postgres add chat_history")
         _run_migration("user_subscriptions", "refill_rate_override", "ALTER TABLE user_subscriptions ADD COLUMN IF NOT EXISTS refill_rate_override FLOAT", "postgres add refill_rate_override")
+        _run_migration("user_subscriptions", "unallocated_deducted", "ALTER TABLE user_subscriptions ADD COLUMN IF NOT EXISTS unallocated_deducted FLOAT DEFAULT 0.0 NOT NULL", "postgres add unallocated_deducted")
     else:
         # SQLite: no IF NOT EXISTS on ADD COLUMN, swallow duplicate errors
         _run_migration("user_subscriptions", "refills_processed", "ALTER TABLE user_subscriptions ADD COLUMN refills_processed INTEGER DEFAULT 0 NOT NULL", "sqlite add refills_processed")
         _run_migration("user_subscriptions", "last_refill_at", "ALTER TABLE user_subscriptions ADD COLUMN last_refill_at TIMESTAMP", "sqlite add last_refill_at")
         _run_migration("user_subscriptions", "current_cycle_used", "ALTER TABLE user_subscriptions ADD COLUMN current_cycle_used FLOAT DEFAULT 0.0 NOT NULL", "sqlite add current_cycle_used")
         _run_migration("user_subscriptions", "refill_rate_override", "ALTER TABLE user_subscriptions ADD COLUMN refill_rate_override FLOAT", "sqlite add refill_rate_override")
+        _run_migration("user_subscriptions", "unallocated_deducted", "ALTER TABLE user_subscriptions ADD COLUMN unallocated_deducted FLOAT DEFAULT 0.0 NOT NULL", "sqlite add unallocated_deducted")
         _run_migration("credits", "bonus_balance", "ALTER TABLE credits ADD COLUMN bonus_balance FLOAT DEFAULT 0.0 NOT NULL", "sqlite add bonus_balance")
         _run_migration("credits", "bonus_limit", "ALTER TABLE credits ADD COLUMN bonus_limit FLOAT DEFAULT 0.0 NOT NULL", "sqlite add bonus_limit")
         _run_migration("credits", "free_monthly_used", "ALTER TABLE credits ADD COLUMN free_monthly_used FLOAT DEFAULT 0.0 NOT NULL", "sqlite add free_monthly_used")
@@ -693,24 +696,6 @@ def init_db(silent: bool = True) -> None:
                     allowed_models="all",
                     max_context_k=1024
                 ),
-                Plan(
-                    id="team",
-                    name="team",
-                    display_name="Team",
-                    price_inr=3500,
-                    credits_per_month=45000,
-                    allowed_models="all",
-                    max_context_k=1024
-                ),
-                Plan(
-                    id="enterprise",
-                    name="enterprise",
-                    display_name="Enterprise",
-                    price_inr=5000,
-                    credits_per_month=80000,
-                    allowed_models="all",
-                    max_context_k=1024
-                ),
                 Plan(
                     id="ultimate",
                     name="ultimate",
@@ -724,6 +709,9 @@ def init_db(silent: bool = True) -> None:
             db.add_all(plans)
             db.commit()
         else:
+            # Delete legacy plans if present to prevent confusion
+            db.query(Plan).filter(Plan.id.in_(["team", "enterprise"])).delete(synchronize_session=False)
+
             # Update existing plan details
             pro_plan = db.query(Plan).filter(Plan.id == "pro").first()
             if pro_plan:
@@ -817,8 +805,8 @@ def get_max_bonus_limit(plan_id: str) -> float:
         return 50000.0
     elif pid == "pro":
         return 1500000.0
-    elif pid in ("max", "team"):
+    elif pid == "max":
         return 3000000.0
-    elif pid in ("ultimate", "enterprise"):
+    elif pid == "ultimate":
         return 4500000.0
     return 20000.0