utim-cli 2.1.1__tar.gz → 2.1.2__tar.gz

{utim_cli-2.1.1 → utim_cli-2.1.2}/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [2.1.2] - 2026-08-10
+
+### 🛠️ Fixes
+- **Fixed `grep_search` auto-regex promotion bug**: Queries containing regex metacharacters (`|`, `\`, `*`, etc.) were silently auto-promoted to regex mode even when `is_regex=False`, causing literal searches to fail with "No matches found." Now `is_regex=False` always means literal search, matching the documented "Literal-first semantics."
+- **Made ripgrep an automatic dependency**: Added `ripgrep>=0.13.0` to core dependencies in `pyproject.toml` and `requirements.txt`. The `_grep_find_ripgrep()` function now falls back to the `ripgrep` PyPI package (which bundles a prebuilt binary) when ripgrep isn't found on the system PATH, ensuring fast searches work out of the box.
+- **Increased context compression interval from 25 to 35 iterations**: Reduced compression frequency to conserve context resources and improve performance during long agent sessions.
+- **Reduced batch poll interval from 5s to 0.3s**: Improved responsiveness of batch status checks in `BatchAPIProcessor.poll_and_retrieve_results()`.
+- **Cleaned up network error messages in feedback dialog**: Stripped verbose `HTTPSConnectionPool` technical details from error messages, now showing clean messages like "Connection timed out. Please check your network and try again."
+
 ## [2.1.1] - 2026-08-06
 
 ### 🛠️ Fixes

utim_cli-2.1.2/LICENSE

@@ -0,0 +1,26 @@
+UTIM PROPRIETARY SOFTWARE END USER LICENSE AGREEMENT (EULA)
+
+Copyright (c) 2026 Emend AI. All Rights Reserved.
+
+IMPORTANT: READ THIS LICENSE AGREEMENT CAREFULLY BEFORE DOWNLOADING, INSTALLING, OR USING THE UTIM CLI SOFTWARE.
+
+1. PROPRIETARY SOFTWARE
+UTIM CLI ("Software") is proprietary commercial software developed and owned exclusively by Emend AI ("Licensor"). The Software is licensed, not sold, to you ("Licensee") under the terms and conditions of this Agreement.
+
+2. LICENSE GRANT
+Subject to compliance with this Agreement and payment of applicable subscription or usage fees:
+- Free Tier License: Licensor grants Licensee a limited, non-exclusive, non-transferable, revocable license to install and use the Software for personal, open-source learning, and non-commercial evaluation purposes.
+- Commercial Tier License: Paid subscribers (Hobby, Pro, Max, Ultimate Tiers) or users with active Bring Your Own Key (BYOK) configurations are granted a non-exclusive, non-transferable license to use the Software for commercial software engineering, corporate repositories, and professional client work.
+
+3. RESTRICTIONS
+Licensee shall NOT:
+- Reverse engineer, decompile, disassemble, modify, or attempt to discover the source code or underlying client orchestrator mechanisms of compiled Software binaries.
+- Circumvent rate limits, credit accounting controls, or 5-hour quota refill mechanisms.
+- Sublicense, resell, rent, lease, or distribute the Software to third parties without prior written authorization.
+- Create duplicate or automated accounts to harvest free promotional credit allocations.
+
+4. INTELLECTUAL PROPERTY
+All title, ownership, brand trademarks, domain adaptation engines, AST parsing logic, and intellectual property rights in and to the Software remain the exclusive property of Emend AI. Licensee retains 100% full ownership of all user prompts submitted and code files generated in their local workspaces.
+
+5. NO WARRANTY & LIMITATION OF LIABILITY
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. IN NO EVENT SHALL EMEND AI OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DIRECT, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES (INCLUDING DATA LOSS, REPOSITORY CORRUPTION, OR API BILLING COSTS) ARISING OUT OF THE USE OF OR INABILITY TO USE THE SOFTWARE.

{utim_cli-2.1.1/utim_cli.egg-info → utim_cli-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.1.1
+Version: 2.1.2
 Summary: UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal.
 License: MIT
 Project-URL: Homepage, https://utim.dev
@@ -31,6 +31,7 @@ Requires-Dist: rich>=13.0.0
 Requires-Dist: prompt_toolkit>=3.0.0
 Requires-Dist: nest-asyncio>=1.5.0
 Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: ripgrep>=0.13.0
 Provides-Extra: search
 Requires-Dist: scrapy>=2.11.0; extra == "search"
 Requires-Dist: scrapy-playwright>=0.0.34; extra == "search"

{utim_cli-2.1.1 → utim_cli-2.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "2.1.1"
+version = "2.1.2"
 description = "UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -33,6 +33,7 @@ dependencies = [
     "prompt_toolkit>=3.0.0",
     "nest-asyncio>=1.5.0",
     "sqlalchemy>=2.0.0",
+    "ripgrep>=0.13.0",
 ]
 
 [project.urls]
@@ -88,6 +89,8 @@ memory = [
 
 [project.scripts]
 utim = "utim_cli.utim:main_cli_entry"
+utimlite = "utim_cli.utim:main_cli_entry"
+
 
 [tool.setuptools.packages.find]
 include = ["utim_cli*"]

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

{utim_cli-2.1.1 → utim_cli-2.1.2}/utim_cli/_version.py

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

{utim_cli-2.1.1 → utim_cli-2.1.2}/utim_cli/blender_agent.py

@@ -63,12 +63,13 @@ _VISION_MODELS: List[str] = [
 ]
 
 _CODE_MODELS: List[str] = [
-    "poolside/laguna-m.1:free",
     DEFAULT_MODEL,
+    "cohere/north-mini-code:free",
     "openrouter/free"
 ]
 
 
+
 def _get_vision_models() -> List[str]:
     """Return vision model list, with user override prepended if configured."""
     try:

{utim_cli-2.1.1 → utim_cli-2.1.2}/utim_cli/client_utils.py

@@ -128,6 +128,7 @@ def proxy_openrouter_request(json_data: dict, stream: bool = False, timeout=None
     server_url = get_server_url()
     llm_key = os.getenv("OPENROUTER_API_KEY")
 
+
     if llm_key:
         # Direct path to OpenRouter — must always carry canonical attribution
         # headers so OpenRouter shows "UTIM CLI Agent" (NOT "unknown") in its
@@ -199,9 +200,25 @@ def proxy_openrouter_request(json_data: dict, stream: bool = False, timeout=None
         if "reasoning" in json_data:
             payload["reasoning"] = json_data["reasoning"]
         
-        # UTIM server completions is a streaming endpoint
-        resp = requests.post(f"{server_url}/completions", json=payload, headers=headers, stream=True, timeout=timeout, verify=config.verify_ssl)
-        resp.raise_for_status()
+        # UTIM server completions is a streaming endpoint with retry & connection protection
+        import time as _timemod
+        max_http_retries = 2
+        last_http_err = None
+        resp = None
+
+        for attempt in range(max_http_retries + 1):
+            try:
+                resp = requests.post(f"{server_url}/completions", json=payload, headers=headers, stream=True, timeout=timeout, verify=config.verify_ssl)
+                resp.raise_for_status()
+                last_http_err = None
+                break
+            except (requests.exceptions.ConnectionError, requests.exceptions.ChunkedEncodingError, requests.exceptions.Timeout) as _conn_err:
+                last_http_err = _conn_err
+                if attempt < max_http_retries:
+                    _timemod.sleep(1.0 * (attempt + 1))
+                    continue
+                else:
+                    raise RuntimeError(f"Connection to UTIM server failed: {str(_conn_err)}")
 
         if stream or json_data.get("stream"):
             def line_generator():

{utim_cli-2.1.1 → utim_cli-2.1.2}/utim_cli/config.py

@@ -492,10 +492,12 @@ class Config:
         if models:
             return [m.strip() for m in models.split(",")]
         return [
-            "poolside/laguna-m.1:free",
-            "openrouter/free"
+            "cohere/north-mini-code:free",
+            "openrouter/free",
+            "inclusionai/ling-3.0-flash:free",
         ]
 
+
     @property
     def keep_full_turns(self) -> int:
         # Number of recent turns to retain in memory

{utim_cli-2.1.1 → utim_cli-2.1.2}/utim_cli/constants.py

@@ -10,6 +10,8 @@ SUBAGENT_DEFAULTS = {
     "generate_image": "nvidia/nemotron-3-nano-30b-a3b:free",
 }
 
+
+
 import sys
 _IS_LEGACY_WIN = (sys.platform == "win32" and "WT_SESSION" not in os.environ)
 PROMPT_SYMBOL = ">" if _IS_LEGACY_WIN else "❯"

{utim_cli-2.1.1 → utim_cli-2.1.2}/utim_cli/context_pruner.py

@@ -16,11 +16,14 @@ from utim_cli.constants import DEFAULT_MODEL
 # Fallback models for compression operations - ordered by reliability and quality.
 # "openrouter/free" is the first fallback tried after the primary model.
 COMPRESSION_FALLBACK_MODELS = [
-    "openrouter/free",
-    "poolside/laguna-xs-2.1:free",
     "cohere/north-mini-code:free",
+    "openrouter/free",
+    "inclusionai/ling-3.0-flash:free",
 ]
 
+
+
+
 # Track what content has already been summarized to prevent duplicate summarization
 _summarized_content_hashes: Set[str] = set()
 
@@ -340,9 +343,10 @@ def _call_compression_model_with_fallback(messages: List[Dict], llm_key: str, ma
         if content_hash in _summarized_content_hashes:
             return "[Content previously summarized - skipped]"
         _summarized_content_hashes.add(content_hash)
-    
+
     # Prioritize primary model if provided, followed by fallback models
     models_to_try = list(COMPRESSION_FALLBACK_MODELS)
+
     if primary_model:
         if primary_model in models_to_try:
             models_to_try.remove(primary_model)

{utim_cli-2.1.1 → utim_cli-2.1.2}/utim_cli/orchestrator.py

@@ -172,8 +172,8 @@ def _get_compression_threshold(model_id: str, context_window: int) -> int:
 
 
 def _get_compression_interval(context_window: int = 0) -> int:
-    """Return the iteration gap for model context compression (every 25 iterations)."""
-    return 25
+    """Return the iteration gap for model context compression (every 35 iterations)."""
+    return 35
 
 
 from utim_cli.config import get_utim_dir
@@ -3769,8 +3769,8 @@ class Orchestrator:
             return 65_000
 
     def _get_dynamic_interval(self) -> int:
-        """Get iteration context compression interval (every 25 iterations)."""
-        return 25
+        """Get iteration context compression interval (every 35 iterations)."""
+        return 35
 
     
     def _get_iteration_budget(self) -> int:
@@ -5182,9 +5182,10 @@ class Orchestrator:
             t_tool_start = time.time()
 
             # ── Iteration-based auto-compression ─────────────────────────────
-            # Compress every 45 iterations to keep context lean regardless of
-            # model context window size.
-            COMPRESS_INTERVAL = 45
+            # Compress every N iterations (default 35) to keep context lean.
+            # The interval is dynamically determined by _get_dynamic_interval(),
+            # which returns 35 by default but can scale with the model's context window.
+            COMPRESS_INTERVAL = self._get_dynamic_interval()
             compression_instruction = ""  # kept for _compress_intra_turn API compat
 
             if iteration > 0 and iteration % COMPRESS_INTERVAL == 0:
@@ -5643,7 +5644,7 @@ class Orchestrator:
                     if hasattr(self, "_tool_name_failure_counts"):
                         self._tool_name_failure_counts.pop(func_name, None)
 
-            # Periodic iteration context compression (every 25 iterations)
+            # Periodic iteration context compression (every 35 iterations)
             interval = getattr(self, "_compression_interval", None) or self._get_dynamic_interval()
             if turn_iteration > 0 and turn_iteration % interval == 0:
                 try:

{utim_cli-2.1.1 → utim_cli-2.1.2}/utim_cli/reflection.py

@@ -12,10 +12,11 @@ from utim_cli.constants import DEFAULT_MODEL
 # These are free-tier models optimized for structured JSON output tasks.
 # Primary is tried first; fallbacks are used on rate-limit or error.
 REFLECTION_MODELS = [
-    "poolside/laguna-xs-2.1:free",
     "cohere/north-mini-code:free",
     "openrouter/free",
+    "inclusionai/ling-3.0-flash:free",
 ]
+
 REFLECTION_PRIMARY_MODEL = REFLECTION_MODELS[0]
 REFLECTION_MAX_TOKENS = 5000
 

utim_cli-2.1.2/utim_cli/server/batch_processor.py

@@ -0,0 +1,119 @@
+"""
+Offline / Background Batch API Processor for OpenAI / DeepInfra / OpenRouter /v1/batches.
+
+Handles:
+1. Packaging multiple JSON requests into a .jsonl batch file.
+2. Uploading the batch file to POST /v1/files.
+3. Creating a batch job via POST /v1/batches.
+4. Polling until completion and retrieving final output results.
+"""
+
+import os
+import json
+import time
+import requests
+import logging
+from typing import List, Dict, Any, Optional
+
+logger = logging.getLogger("utim.batch_processor")
+
+class BatchAPIProcessor:
+    """Manages true offline /v1/batches file jobs."""
+    
+    def __init__(self, api_key: str, base_url: str = "https://api.deepinfra.com/v1/openai"):
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+
+    def create_batch_job(self, requests_list: List[Dict[str, Any]], model_id: str) -> Optional[Dict[str, Any]]:
+        """Package requests into a .jsonl batch payload and submit to POST /v1/batches."""
+        jsonl_lines = []
+        for idx, req_payload in enumerate(requests_list):
+            item = {
+                "custom_id": f"request-{idx}-{int(time.time())}",
+                "method": "POST",
+                "url": "/v1/chat/completions",
+                "body": {
+                    "model": model_id,
+                    "messages": req_payload.get("messages", []),
+                    "max_tokens": req_payload.get("max_tokens", 1500),
+                    "temperature": req_payload.get("temperature", 0.2)
+                }
+            }
+            jsonl_lines.append(json.dumps(item))
+
+        jsonl_content = "\n".join(jsonl_lines)
+        print(f"📦 [BATCH FILE API] Packaging {len(requests_list)} requests into .jsonl payload for model '{model_id}'...")
+
+        # Step 1: Upload file to /v1/files
+        try:
+            files_url = f"{self.base_url}/files"
+            file_response = requests.post(
+                files_url,
+                headers={"Authorization": f"Bearer {self.api_key}"},
+                files={"file": ("batch_input.jsonl", jsonl_content.encode("utf-8"), "application/jsonl")},
+                data={"purpose": "batch"},
+                timeout=30
+            )
+            if file_response.status_code != 200:
+                print(f"❌ [BATCH FILE API ERROR] Failed to upload batch file: {file_response.text}")
+                return None
+
+            file_id = file_response.json().get("id")
+            print(f"✓ [BATCH FILE UPLOADED] File ID: {file_id}")
+
+            # Step 2: Create batch job via /v1/batches
+            batches_url = f"{self.base_url}/batches"
+            batch_payload = {
+                "input_file_id": file_id,
+                "endpoint": "/v1/chat/completions",
+                "completion_window": "24h"
+            }
+            batch_resp = requests.post(batches_url, json=batch_payload, headers=self.headers, timeout=30)
+            if batch_resp.status_code == 200:
+                batch_job = batch_resp.json()
+                print(f"🚀 [BATCH JOB CREATED] Job ID: {batch_job.get('id')} | Status: {batch_job.get('status')}")
+                return batch_job
+            else:
+                print(f"❌ [BATCH JOB CREATED ERROR]: {batch_resp.text}")
+                return None
+
+        except Exception as exc:
+            print(f"❌ [BATCH PROCESSOR EXCEPTION]: {exc}")
+            return None
+
+    def poll_and_retrieve_results(self, batch_id: str, poll_interval: float = 0.3, timeout: int = 300) -> Optional[List[Dict[str, Any]]]:
+        """Poll batch job until status is completed and download output file."""
+        start_time = time.time()
+        batch_url = f"{self.base_url}/batches/{batch_id}"
+
+        while time.time() - start_time < timeout:
+            resp = requests.get(batch_url, headers=self.headers, timeout=15)
+            if resp.status_code == 200:
+                job_data = resp.json()
+                status = job_data.get("status")
+                print(f"⏳ [BATCH POLLING] Job ID '{batch_id}' | Status: {status}")
+
+                if status == "completed":
+                    output_file_id = job_data.get("output_file_id")
+                    if output_file_id:
+                        file_content_url = f"{self.base_url}/files/{output_file_id}/content"
+                        content_resp = requests.get(file_content_url, headers=self.headers, timeout=30)
+                        if content_resp.status_code == 200:
+                            results = []
+                            for line in content_resp.text.strip().splitlines():
+                                if line:
+                                    results.append(json.loads(line))
+                            print(f"✓ [BATCH COMPLETED] Downloaded {len(results)} completed results!")
+                            return results
+                elif status in ["failed", "cancelled", "expired"]:
+                    print(f"❌ [BATCH JOB FAILED] Job ended with status: {status}")
+                    return None
+
+            time.sleep(poll_interval)
+        
+        print(f"⚠️ [BATCH TIMEOUT] Reached timeout of {timeout}s waiting for job '{batch_id}'")
+        return None

utim_cli-2.1.2/utim_cli/server/micro_batcher.py

@@ -0,0 +1,95 @@
+"""
+Model-Specific Micro-Batcher for UTIM Server.
+
+Batches requests specifically grouped by (model_id, is_reflection).
+Flushes when:
+1. Queue for specific model reaches max_batch_size (e.g. 4)
+2. Max wait timeout (e.g. 10.0s for testing) expires.
+"""
+
+import asyncio
+import time
+import logging
+from typing import Dict, Any, List, Optional, Tuple, Callable
+
+logger = logging.getLogger("utim.micro_batcher")
+
+class ModelSpecificMicroBatcher:
+    """Manages separate batch queues grouped by (model_id, is_reflection)."""
+    
+    def __init__(self, max_batch_size: int = 4, max_wait_seconds: float = 10.0):
+        self.max_batch_size = max_batch_size
+        self.max_wait_seconds = max_wait_seconds
+        # Key: (model_id, is_reflection) -> List[(payload, future)]
+        self.queues: Dict[Tuple[str, bool], List[Tuple[Any, asyncio.Future]]] = {}
+        self.flush_tasks: Dict[Tuple[str, bool], asyncio.Task] = {}
+        self.lock = asyncio.Lock()
+
+    async def submit(self, model_id: str, is_reflection: bool, payload: Any, processor_func: Callable) -> Any:
+        loop = asyncio.get_running_loop()
+        future = loop.create_future()
+        queue_key = (model_id, is_reflection)
+
+        async with self.lock:
+            if queue_key not in self.queues:
+                self.queues[queue_key] = []
+            
+            self.queues[queue_key].append((payload, future))
+            current_size = len(self.queues[queue_key])
+            
+            print(f"📦 [MICRO-BATCH QUEUE] Model: '{model_id}' | Queue Size: {current_size}/{self.max_batch_size}")
+
+            if current_size >= self.max_batch_size:
+                # Trigger A: Batch size limit reached!
+                print(f"⚡ [MICRO-BATCH TRIGGER A] Batch size {self.max_batch_size} reached for '{model_id}'! Processing batch immediately...")
+                if queue_key in self.flush_tasks and not self.flush_tasks[queue_key].done():
+                    self.flush_tasks[queue_key].cancel()
+                self.flush_tasks[queue_key] = asyncio.create_task(self._flush(queue_key, processor_func))
+            elif current_size == 1:
+                # Trigger B: First item, start max_wait_seconds timer
+                print(f"⏱️ [MICRO-BATCH TRIGGER B] First request in queue for '{model_id}'. Waiting up to {self.max_wait_seconds}s for batch to fill...")
+                self.flush_tasks[queue_key] = asyncio.create_task(self._wait_and_flush(queue_key, processor_func))
+
+        return await future
+
+    async def _wait_and_flush(self, queue_key: Tuple[str, bool], processor_func: Callable):
+        try:
+            await asyncio.sleep(self.max_wait_seconds)
+            async with self.lock:
+                if queue_key in self.queues and self.queues[queue_key]:
+                    print(f"⏰ [MICRO-BATCH TIMEOUT] {self.max_wait_seconds}s timeout expired for '{queue_key[0]}'. Processing batch of {len(self.queues[queue_key])} requests...")
+                    await self._flush(queue_key, processor_func)
+        except asyncio.CancelledError:
+            pass
+
+    async def _flush(self, queue_key: Tuple[str, bool], processor_func: Callable):
+        batch = self.queues.get(queue_key, [])[:self.max_batch_size]
+        if queue_key in self.queues:
+            self.queues[queue_key] = self.queues[queue_key][self.max_batch_size:]
+            if not self.queues[queue_key]:
+                del self.queues[queue_key]
+                
+        if not batch:
+            return
+
+        model_id = queue_key[0]
+        payloads = [item[0] for item in batch]
+        futures = [item[1] for item in batch]
+
+        print(f"🚀 [MICRO-BATCH EXECUTING] Processing batch of {len(payloads)} requests together for model '{model_id}'!")
+
+        try:
+            results = await processor_func(model_id, payloads)
+            for fut, res in zip(futures, results):
+                if not fut.done():
+                    fut.set_result(res)
+        except Exception as exc:
+            print(f"❌ [MICRO-BATCH ERROR] Failed to process batch for '{model_id}': {exc}")
+            for fut in futures:
+                if not fut.done():
+                    fut.set_exception(exc)
+
+
+# Global singleton instance (Max batch: 4, Wait timeout: 0.3s for instant flushing)
+global_micro_batcher = ModelSpecificMicroBatcher(max_batch_size=4, max_wait_seconds=0.3)
+

{utim_cli-2.1.1 → utim_cli-2.1.2}/utim_cli/server/models.py

@@ -87,6 +87,7 @@ def get_max_output_tokens(model_id: MODEL_ID, fallback: int = 128_000) -> int:
 
 MODEL_REGISTRY: dict[MODEL_ID, ModelEntry] = {
     "inclusionai/ling-3.0-flash:free": ModelEntry(
+
         model_id="inclusionai/ling-3.0-flash:free",
         provider="openrouter",
         cost_input_per_1k=0.000000,
@@ -97,6 +98,7 @@ MODEL_REGISTRY: dict[MODEL_ID, ModelEntry] = {
         max_output_tokens=32_768,
         description="InclusionAI Ling 3.0 Flash — ultra-fast free model for lightweight miniagents (<100KB).",
     ),
+
     "nvidia/nemotron-3-ultra-550b-a55b:free": ModelEntry(
         model_id="nvidia/nemotron-3-ultra-550b-a55b:free",
         provider="openrouter",
@@ -1502,16 +1504,8 @@ def estimate_cost(
             is_free = True
             
     if is_free:
-        if is_upgraded:
-            # Upgraded pricing: $0.002 per 1M input, $0.003 per 1M output
-            # Mapped to credits (1 USD = 1,000 credits):
-            # 0.002 credits per 1,000 input tokens, 0.003 credits per 1,000 output tokens
-            return (input_tokens / 1_000) * 0.002 + (output_tokens / 1_000) * 0.003
-        else:
-            # Free models pricing: $0.2 per 1M input, $0.3 per 1M output
-            # Mapped to credits (1 USD = 1,000 credits):
-            # 0.2 credits per 1,000 input tokens, 0.3 credits per 1,000 output tokens
-            return (input_tokens / 1_000) * 0.2 + (output_tokens / 1_000) * 0.3
+        return 0.0
+
         
     m = get_model(model_id)
     return (input_tokens / 1_000) * m.cost_input_per_1k + (
@@ -1519,6 +1513,8 @@ def estimate_cost(
     ) * m.cost_output_per_1k
 
 
+
+
 def route_model(task_description: str) -> MODEL_ID:
     """
     Simple heuristic router — can be swapped out for model-based routing later.

{utim_cli-2.1.1 → utim_cli-2.1.2}/utim_cli/server/router.py

@@ -30,10 +30,12 @@ from .attribution import attach_openrouter_headers
 from slowapi import _rate_limit_exceeded_handler
 from slowapi.errors import RateLimitExceeded
 from .routes import auth_router, credit_router, session_router, completion_router, quota_router, share_router, feedback_router, referral_router, quota_share_router, marketplace_router
+
 from .routes.security_routes import router as security_router
 from .models import list_models
 from .auth import get_admin_user
 
+
 # ── Logging ───────────────────────────────────────────────────────────────────
 
 configure_logging(level=os.environ.get("LOG_LEVEL", "INFO"))
@@ -158,6 +160,9 @@ app.include_router(quota_share_router)
 app.include_router(marketplace_router, prefix="/marketplace")
 app.include_router(security_router)
 
+
+
+
 # ── Support Chatbot Endpoint ──────────────────────────────────────────────────
 
 class SupportChatRequest(BaseModel):

{utim_cli-2.1.1 → utim_cli-2.1.2}/utim_cli/server/routes/__init__.py

@@ -11,3 +11,4 @@ from .marketplace_routes import router as marketplace_router
 
 __all__ = ["auth_router", "credit_router", "session_router", "completion_router", "quota_router", "share_router", "feedback_router", "referral_router", "quota_share_router", "marketplace_router"]
 
+