utim-cli 2.3.22__tar.gz → 2.3.24__tar.gz

{utim_cli-2.3.22 → utim_cli-2.3.24}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [2.3.24] - 2026-09-07
+
+### ⚡ Performance
+- Fixed latency issues
+
+## [2.3.23] - 2026-09-07
+
+### 🛠️ Minor Bug Fixes and Enhancement
+- Minor bug fixes and enhancement
+
 ## [2.3.22] - 2026-09-06
 
 ### 🛡️ Seamless Rate-Limit Failover to Paid Slugs

{utim_cli-2.3.22/utim_cli.egg-info → utim_cli-2.3.24}/PKG-INFO

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

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

{utim_cli-2.3.22 → utim_cli-2.3.24}/utim/__init__.py

@@ -1,4 +1,4 @@
-"""
+"""
 UTIM Developer SDK
 ------------------
 Unified autonomous coding agent SDK.
@@ -14,7 +14,7 @@ Quickstart:
 try:
     from utim_cli._version import VERSION as __version__
 except ImportError:
-    __version__ = "2.3.22"
+    __version__ = "2.3.24"
 
 # Developer-friendly core classes (similar to `import genai` / `import openai`)
 from utim_cli.sdk.session import UtimSession as Session

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

utim_cli-2.3.24/utim_cli/_chip_test.py

@@ -0,0 +1,22 @@
+_PASTE_CHIP_THRESHOLD = 3000
+_PASTE_CHIP_SEQ = [0]
+_PASTE_CHIPS = {}
+
+
+def _make_paste_chip(data):
+    if len(data) >= _PASTE_CHIP_THRESHOLD:
+        _PASTE_CHIP_SEQ[0] += 1
+        n = _PASTE_CHIP_SEQ[0]
+        token = f"[Pasted text #{n} {len(data)} chars]"
+        _PASTE_CHIPS[token] = data
+        return token
+    return None
+
+
+# Test cases
+print("2921 chars ->", repr(_make_paste_chip("x" * 2921)))  # user example
+print("3000 chars ->", repr(_make_paste_chip("x" * 3000)))  # at threshold
+print("3001 chars ->", repr(_make_paste_chip("x" * 3001)))  # just over
+print("100 chars  ->", repr(_make_paste_chip("x" * 100)))   # small
+print()
+print("Chips created so far:", list(_PASTE_CHIPS.keys()))

{utim_cli-2.3.22 → utim_cli-2.3.24}/utim_cli/_version.py

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

{utim_cli-2.3.22 → utim_cli-2.3.24}/utim_cli/config.py

@@ -666,6 +666,71 @@ class Config:
         # Fallback – raise informative error later when used
         return ""
 
+    # ── API Key Exhaustion Tracking (24-hour cooldown) ────────────────────────
+    
+    def mark_api_key_exhausted(self, api_key: str, duration_hours: int = 24) -> None:
+        """Mark an API key as exhausted due to rate limiting/429 errors.
+        
+        Args:
+            api_key: The API key that got exhausted
+            duration_hours: How long to exclude this key (default 24 hours)
+        """
+        if not api_key:
+            return
+        exhausted = self.get("_api_key_exhausted", {})
+        exhausted[api_key] = time.time() + (duration_hours * 3600)
+        self.set("_api_key_exhausted", exhausted)
+        logger.info(f"API key marked exhausted for {duration_hours}h: {api_key[:8]}...")
+    
+    def is_api_key_exhausted(self, api_key: str) -> bool:
+        """Check if an API key is currently exhausted (rate-limited).
+        
+        Args:
+            api_key: The API key to check
+            
+        Returns:
+            True if exhausted and within cooldown period, False otherwise
+        """
+        if not api_key:
+            return False
+        exhausted = self.get("_api_key_exhausted", {})
+        expiry = exhausted.get(api_key, 0)
+        if time.time() < expiry:
+            return True
+        # Clean up expired entry
+        if api_key in exhausted:
+            del exhausted[api_key]
+            self.set("_api_key_exhausted", exhausted)
+        return False
+    
+    def get_available_api_keys(self, keys: List[str]) -> List[str]:
+        """Filter a list of API keys, excluding exhausted ones.
+        
+        Args:
+            keys: List of API keys to filter
+            
+        Returns:
+            List of non-exhausted API keys
+        """
+        return [k for k in keys if k and not self.is_api_key_exhausted(k)]
+    
+    def get_exhaustion_countdown(self, api_key: str) -> Optional[int]:
+        """Get remaining seconds until an API key can be used again.
+        
+        Args:
+            api_key: The API key to check
+            
+        Returns:
+            Seconds remaining, or None if not exhausted
+        """
+        if not api_key:
+            return None
+        exhausted = self.get("_api_key_exhausted", {})
+        expiry = exhausted.get(api_key, 0)
+        remaining = int(expiry - time.time())
+        return remaining if remaining > 0 else None
+
+
 # Global config instance
 config = Config()
 # Convenience constant for direct access

utim_cli-2.3.24/utim_cli/constants.py

@@ -0,0 +1,43 @@
+import os
+
+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")
+
+SUBAGENT_DEFAULTS = {
+    "web_search": DEFAULT_MODEL,
+    "plan_project": DEFAULT_MODEL,
+    "generate_image": "qwen/qwen-image-3",
+    "analyze_image": "google/gemma-4-31b-it:free",
+}
+
+APINEX_MODEL_IDS = {
+    "claude/opus-5",
+    "claude/sonnet-5",
+    "deepseek/v4-flash-0731",
+    "deepseek/v4-pro-0813",
+    "free/deepseek-v4-flash-0731",
+    "free/deepseek-v4-pro-0813",
+    "free/glm-5.3-flash",
+    "free/gemini-3.1-pro",
+    "free/gemini-3.7-flash",
+    "gemini/3.1-pro",
+    "gemini/3.7-flash",
+    "kimi/k3",
+    "gpt/5.6-luna",
+    "gpt/5.6-sol",
+    "gpt/5.6-terra",
+    "glm/5.3",
+    "glm/5.3-flash",
+    "grok/4.6",
+    "qwen/3.8-max",
+    "free/qwen-3.8-max",
+}
+
+
+import sys
+_IS_LEGACY_WIN = (sys.platform == "win32" and "WT_SESSION" not in os.environ)
+PROMPT_SYMBOL = ">" if _IS_LEGACY_WIN else "❯"
+ARROW_SYMBOL = "->" if _IS_LEGACY_WIN else "➔"
+
+

{utim_cli-2.3.22 → utim_cli-2.3.24}/utim_cli/context_pruner.py

@@ -36,6 +36,56 @@ def get_compression_fallback_models() -> List[str]:
     return COMPRESSION_FALLBACK_MODELS
 
 
+# ── Compression level runtime state ──────────────────────────────────────────
+# These are mutated by apply_compression_level() (called from /compression dialog)
+# and read by _progressive_keep_ratio() and build_compacted_history_message().
+#
+# Defaults match the "medium" preset:
+#   oldest_ratio=0.07, newest_ratio=0.70, merge_count=5
+_COMPRESSION_PARAMS: Dict[str, Any] = {
+    "oldest_ratio": 0.07,
+    "newest_ratio": 0.70,
+    "merge_count":  5,
+    "level_id":     "medium",
+}
+
+
+def apply_compression_level(level_id: str) -> None:
+    """Apply a named compression level by updating the runtime params dict.
+
+    Called immediately after the user picks a level in /compression dialog.
+    The change takes effect on the *next* call to build_compacted_history_message.
+    """
+    # Map level_id → (oldest_ratio, newest_ratio, merge_count)
+    LEVEL_MAP = {
+        "very_low":  (0.50, 0.95,  0),
+        "low":       (0.25, 0.85,  2),
+        "medium":    (0.07, 0.70,  5),
+        "high":      (0.03, 0.50,  8),
+        "very_high": (0.01, 0.30, 12),
+    }
+    if level_id not in LEVEL_MAP:
+        return
+    oldest, newest, merge = LEVEL_MAP[level_id]
+    _COMPRESSION_PARAMS["oldest_ratio"] = oldest
+    _COMPRESSION_PARAMS["newest_ratio"] = newest
+    _COMPRESSION_PARAMS["merge_count"]  = merge
+    _COMPRESSION_PARAMS["level_id"]     = level_id
+
+
+def _load_compression_level_from_config() -> None:
+    """Seed _COMPRESSION_PARAMS from persisted config on first use."""
+    try:
+        from utim_cli.config import config
+        level_id = config.get("compression_level") or "medium"
+        apply_compression_level(level_id)
+    except Exception:
+        pass
+
+
+
+
+
 
 
 
@@ -1246,8 +1296,13 @@ def summarize_single_turn_outcome(turn_msgs: List[Dict], tier: str = "medium") -
                         if cl and cl not in tool_outputs_summary and len(cl) < 80:
                             tool_outputs_summary.append(cl)
 
-    # 1. Extract clean sentences from assistant text
-    base_text = assistant_texts[-1] if assistant_texts else ""
+    # 1. Extract clean sentences from assistant text (combine across continuations if present)
+    if len(assistant_texts) >= 2:
+        base_text = " ".join(assistant_texts[-2:])
+    elif assistant_texts:
+        base_text = assistant_texts[-1]
+    else:
+        base_text = ""
     if not base_text and compression_notes:
         note = compression_notes[-1]
         m_goal = re.search(r'## Completed\s*\n(.*?)(?=\n##|\Z)', note, re.DOTALL)
@@ -1314,15 +1369,192 @@ def summarize_single_turn_outcome(turn_msgs: List[Dict], tier: str = "medium") -
         return "\n    " + "\n    ".join(detail_lines)
 
 
+def _progressive_keep_ratio(idx_0based: int, total_turns: int) -> float:
+    """Return the fraction of assistant text to keep for a given turn.
+
+    Progressive compression curve driven by the user-chosen compression level:
+      - idx=0  (oldest) → _COMPRESSION_PARAMS["oldest_ratio"]
+      - idx=N-1 (newest) → _COMPRESSION_PARAMS["newest_ratio"]
+      - Linear interpolation for all turns in between.
+
+    When there is only one turn the ratio is always newest_ratio (near-verbatim).
+    """
+    oldest = _COMPRESSION_PARAMS["oldest_ratio"]   # e.g. 0.07 for medium
+    newest = _COMPRESSION_PARAMS["newest_ratio"]   # e.g. 0.70 for medium
+    if total_turns <= 1:
+        return newest
+    t = idx_0based / (total_turns - 1)             # 0.0 → oldest, 1.0 → newest
+    return oldest + (newest - oldest) * t          # lerp
+
+
+def _compress_turn_text(text: str, keep_ratio: float) -> str:
+    """Truncate assistant text to ``keep_ratio`` of its original length at a
+    sentence/newline boundary so no sentence is split in half.
+
+    Continuity anchors (next step, todo, error, file paths) are always
+    preserved in full as a closing addendum even if they fall outside the
+    budget.
+    """
+    if not text:
+        return text
+    budget = max(80, int(len(text) * keep_ratio))
+    if len(text) <= budget:
+        return text
+
+    # Find the last sentence/newline boundary within budget
+    cut = budget
+    for sep in ("\n\n", "\n", ". ", "! ", "? "):
+        pos = text.rfind(sep, 0, budget)
+        if pos > 0:
+            cut = pos + len(sep)
+            break
+
+    kept = text[:cut].rstrip()
+
+    # Always append continuity anchors even if they were trimmed off
+    anchor_lines = []
+    for line in text[cut:].splitlines():
+        ls = line.strip()
+        if ls and re.search(
+            r"(?i)(next step|todo|to-do|pending|remaining|blocker|continue|error|"
+            r"exception|failed|fixed|modified|created|file:|path:|def |class )",
+            ls,
+        ):
+            anchor_lines.append(ls)
+    if anchor_lines:
+        kept = kept + "\n[…] " + " | ".join(anchor_lines[:3])
+
+    omitted = len(text) - len(kept)
+    if omitted > 30:
+        kept += f"\n[{omitted:,} chars omitted — {int((1 - keep_ratio) * 100)}% compressed]"
+
+    return kept
+
+
+def _merge_oldest_turns(turns: List, merge_count: int) -> str:
+    """Collapse the ``merge_count`` oldest turns into one dense merged entry.
+
+    Produces a single bullet block: what each user asked + one-line outcome.
+    """
+    lines = ["[Merged earliest turns — oldest context, highest compression]"]
+    for i, (prompt, msgs) in enumerate(turns[:merge_count], 1):
+        # User prompt: one line, word-boundary capped at 120 chars
+        prompt_lines = [l.strip() for l in prompt.splitlines() if l.strip()]
+        clean_prompt = prompt_lines[0] if prompt_lines else prompt.strip()
+        if len(clean_prompt) > 120:
+            clean_prompt = clean_prompt[:120].rsplit(" ", 1)[0] + "…"
+
+        outcome = summarize_single_turn_outcome(msgs, tier="low")
+        # Apply the lowest ratio (7%) to these merged entries
+        outcome = _compress_turn_text(outcome, keep_ratio=0.07)
+        lines.append(f"  • Turn {i}: \"{clean_prompt}\" → {outcome}")
+    return "\n".join(lines)
+
+
+
+def is_continuation_prompt(prompt_or_msg: Any) -> bool:
+    """Check if a prompt or user message is simply a continuation nudge or inquiry about
+    an abrupt stop (e.g. 'continue', 'why are u stopping', 'keep going', 'proceed'),
+    rather than a distinct new task.
+
+    When True, the compression pipeline folds this interaction into the parent task
+    turn instead of incrementing the turn count and prematurely pushing real tasks
+    into aggressive compression/merging.
+    """
+    if not prompt_or_msg:
+        return False
+
+    if isinstance(prompt_or_msg, dict):
+        if prompt_or_msg.get("role") != "user":
+            return False
+        content = prompt_or_msg.get("content") or ""
+    else:
+        content = prompt_or_msg
+
+    if isinstance(content, list):
+        content = " ".join(p.get("text", "") for p in content if isinstance(p, dict))
+    elif not isinstance(content, str):
+        content = str(content)
+
+    s = content.strip()
+    if not s:
+        return False
+
+    # 1. Automated continuation nudges & wrappers
+    if s.startswith(("CONTINUE:", "[CONTINUE", "[Continue", "<CONTINUATION_REQUEST", "CONTINUE ")):
+        return True
+    if "CONTINUE: Your last message" in s or "CONTINUE: Please continue" in s:
+        return True
+
+    # Strip surrounding quotes, punctuation and trailing emojis/whitespace
+    cleaned = re.sub(r'^[^\w]+|[^\w]+$', '', s).strip().lower()
+
+    # If the message is long (> 160 chars), it is likely a substantive new prompt with new instructions
+    if len(cleaned) > 160:
+        return False
+
+    # 2. Exact single-word or short continuation keywords
+    EXACT_CONTINUE_PHRASES = {
+        "c", "continue", "pls continue", "please continue", "continue please",
+        "pls continue the task", "please continue the task", "continue the task",
+        "continue task", "continue working", "continue execution", "continue generating",
+        "keep going", "please keep going", "pls keep going", "keep going please",
+        "go on", "please go on", "pls go on",
+        "proceed", "please proceed", "pls proceed",
+        "carry on", "please carry on", "pls carry on",
+        "resume", "please resume", "pls resume", "resume task", "resume working",
+        "keep at it", "keep working", "keep running",
+        "finish", "finish it", "finish this", "finish the task", "complete it", "complete this", "complete the task",
+        "dont stop", "don't stop", "do not stop", "stop stopping",
+        "more", "next", "go ahead",
+        "continue from where you left off", "continue from last step", "continue from before",
+        "please continue from where you left off", "pls continue from where you left off",
+    }
+    if cleaned in EXACT_CONTINUE_PHRASES:
+        return True
+
+    # 3. Questions asking why the model stopped / paused / cut off
+    STOP_INQUIRY_PATTERNS = [
+        r"^why\s+(?:did\s+(?:you|u|it)|are\s+(?:you|u)|have\s+you|is\s+it)\s+(?:stop(?:ped|ping)?|pause[d]?|halt(?:ed)?|cut\s*off)[\s\w?!.]*$",
+        r"^why\s+(?:stop(?:ped|ping)?|paused?|halted?|cut\s*off)[\s\w?!.]*$",
+        r"^(?:you|u|it)\s+(?:stopped|paused|halted|cut\s*off)[\s\w?!.]*$",
+        r"^(?:did\s+(?:you|u)|why\s+did\s+(?:you|u))\s+(?:freeze|crash|quit|give\s*up)[\s\w?!.]*$",
+        r"^(?:what\s+happened(?:\s+why\s+did\s+(?:you|u)\s+stop)?)[\s\w?!.]*$",
+        r"^(?:why\s+didn'?t\s+(?:you|u)\s+(?:finish|complete|continue))[\s\w?!.]*$",
+        r"^(?:why\s+did\s+(?:you|u)\s+not\s+(?:finish|complete|continue))[\s\w?!.]*$",
+    ]
+    for pat in STOP_INQUIRY_PATTERNS:
+        if re.search(pat, cleaned):
+            return True
+
+    # 4. General continue regex pattern
+    if re.match(r"^(?:please\s+|pls\s+)?(?:continue|keep\s+going|go\s+on|proceed|resume|carry\s+on)(?:\s+(?:the\s+task|working|generating|code|it|with\s+(?:this|it|the\s+task)|from\s+(?:where\s+you\s+left\s+off|here|before)))?[\s.!?]*$", cleaned):
+        return True
+
+    return False
+
+
 def build_compacted_history_message(past_messages: List[Dict]) -> Optional[Dict]:
-    """Consolidates all previous turns into a single milestone message with complete semantic sentences."""
+    """Consolidate all previous turns into a single milestone message using
+    **progressive compression** so the model retains rich recent context while
+    oldest turns are heavily summarised to save tokens.
+
+    Compression curve (per turn position 1..N):
+      • Turns 1–5 (oldest block) → merged into **one** combined entry at ~7%
+      • Turn 6 onwards → individual entries with keep-ratio interpolating
+        linearly from ~7% (oldest remaining) up to ~70% (Turn N, most recent).
+      • Turn N+1 is the live current turn and is NEVER touched here.
+
+    Continuity anchors (next-step hints, file paths, errors) are always
+    appended even if they fall outside the compression budget.
+    """
     if not past_messages:
         return None
 
-    # Partition past_messages into turns by user messages
-    turns = []
-    current_user_prompt = None
-    current_turn_msgs = []
+    # ── 1. Partition messages into (prompt, [msgs]) turns ─────────────────────
+    turns: List = []
+    current_user_prompt: Optional[str] = None
+    current_turn_msgs: List = []
 
     for m in past_messages:
         role = m.get("role", "")
@@ -1342,6 +1574,12 @@ def build_compacted_history_message(past_messages: List[Dict]) -> Optional[Dict]
                     current_turn_msgs.append(m)
                 continue
 
+            # Check if this user message is just a continuation nudge of the previous task
+            if current_user_prompt is not None and is_continuation_prompt(content):
+                # Fold into current turn rather than starting an extra turn!
+                current_turn_msgs.append(m)
+                continue
+
             if current_user_prompt is not None:
                 turns.append((current_user_prompt, current_turn_msgs))
             current_user_prompt = content.strip()
@@ -1350,42 +1588,90 @@ def build_compacted_history_message(past_messages: List[Dict]) -> Optional[Dict]
             if current_user_prompt is not None:
                 current_turn_msgs.append(m)
 
+
     if current_user_prompt is not None:
         turns.append((current_user_prompt, current_turn_msgs))
 
     if not turns:
         return None
 
-    turn_entries = []
-    total_turns = len(turns)
+    # Seed _COMPRESSION_PARAMS from config on the very first call (lazy init)
+    if _COMPRESSION_PARAMS.get("level_id") == "medium":
+        _load_compression_level_from_config()
 
-    for idx, (prompt, msgs) in enumerate(turns, 1):
-        dist = total_turns - idx
-        tier = "high" if dist <= 1 else ("medium" if dist <= 4 else "low")
+    # ── 2. Decide merge boundary ───────────────────────────────────────────────
+    # Use the user-chosen merge count from _COMPRESSION_PARAMS.
+    # Clamped so we never merge all turns (always keep >= 1 individual entry).
+    total_turns = len(turns)
+    level_merge = _COMPRESSION_PARAMS.get("merge_count", 5)   # 0, 2, 5, 8, or 12
+    merge_count = min(level_merge, max(0, total_turns - 1))
+    if total_turns <= 3:
+        merge_count = 0   # too few turns — keep all individually
+
+    # ── 3. Build turn entries ──────────────────────────────────────────────────
+    turn_entries: List[str] = []
+
+    if merge_count > 0:
+        merged_block = _merge_oldest_turns(turns, merge_count)
+        turn_entries.append(merged_block)
+
+    # Individual turns after the merged block — apply progressive compression
+    individual_turns = turns[merge_count:]
+    ind_total = len(individual_turns)
+
+    for local_idx, (prompt, msgs) in enumerate(individual_turns):
+        # Global index within the full history (for labelling)
+        global_idx = merge_count + local_idx + 1    # 1-based
+
+        # Keep ratio grows from near-low to 70 % as turns approach N
+        keep_ratio = _progressive_keep_ratio(local_idx, ind_total)
+
+        # Summarisation tier mirrors the keep ratio
+        if keep_ratio >= 0.55:
+            tier = "high"
+        elif keep_ratio >= 0.25:
+            tier = "medium"
+        else:
+            tier = "low"
 
-        # Extract first clean line/sentence of user prompt without slicing mid-word
+        # User prompt: truncate cleanly at word boundary
         prompt_lines = [l.strip() for l in prompt.splitlines() if l.strip()]
         clean_prompt = prompt_lines[0] if prompt_lines else prompt.strip()
-        if len(clean_prompt) > 200:
-            # Clean break at word boundary
-            clean_prompt = clean_prompt[:200].rsplit(' ', 1)[0]
+        # Prompt char budget also scales: 60 chars oldest → 200 chars newest
+        prompt_budget = max(60, int(60 + (200 - 60) * (local_idx / max(1, ind_total - 1))))
+        if len(clean_prompt) > prompt_budget:
+            clean_prompt = clean_prompt[:prompt_budget].rsplit(" ", 1)[0] + "…"
 
         outcome = summarize_single_turn_outcome(msgs, tier=tier)
+        outcome = _compress_turn_text(outcome, keep_ratio=keep_ratio)
 
+        pct_label = f"{int(keep_ratio * 100)}% kept"
         if tier == "high" and "\n" in outcome:
-            turn_entries.append(f"- **Turn {idx} (User)**: \"{clean_prompt}\"\n  ↳ **Assistant**:{outcome}")
+            turn_entries.append(
+                f"- **Turn {global_idx} (User)** [{pct_label}]: \"{clean_prompt}\"\n"
+                f"  ↳ **Assistant**:{outcome}"
+            )
         else:
-            turn_entries.append(f"- **Turn {idx} (User)**: \"{clean_prompt}\"\n  ↳ **Assistant**: {outcome}")
+            turn_entries.append(
+                f"- **Turn {global_idx} (User)** [{pct_label}]: \"{clean_prompt}\"\n"
+                f"  ↳ **Assistant**: {outcome}"
+            )
+
+    cur_oldest_pct = int(_COMPRESSION_PARAMS.get("oldest_ratio", 0.07) * 100)
+    cur_newest_pct = int(_COMPRESSION_PARAMS.get("newest_ratio", 0.70) * 100)
+    cur_level_id = str(_COMPRESSION_PARAMS.get("level_id", "medium")).replace("_", " ").upper()
 
     history_content = (
         "### SESSION HISTORY & PREVIOUS MILESTONES (COMPACTED CONTEXT)\n"
-        "The following user requests were completed earlier in this session:\n\n"
+        f"Turns are compressed progressively ({cur_level_id}): oldest ≈{cur_oldest_pct}% kept, newest ≈{cur_newest_pct}% kept.\n\n"
         + "\n\n".join(turn_entries)
     )
 
     return {"role": "user", "content": history_content}
 
 
+
+
 def is_compression_artifact_message(message: Dict) -> bool:
     """Check if message is a synthetic compression note/digest/summary rather than a genuine user instruction."""
     if not isinstance(message, dict):
@@ -1512,6 +1798,9 @@ def score_message_importance(message: Dict, llm_key: str = None) -> float:
         if is_compression_artifact_message(message):
             min_floor = 0.2
             score = 0.35  # Synthetic notes get low score to allow replacement on next pass
+        elif is_continuation_prompt(message):
+            min_floor = 0.3
+            score = 0.40  # Continuation prompts ('continue', 'why are u stopping') can be compressed/digested
         else:
             # Genuine user instructions must NEVER be below the compression threshold
             min_floor = 1.0  # Never compress genuine user instructions

{utim_cli-2.3.22 → utim_cli-2.3.24}/utim_cli/orchestrator.py

@@ -847,7 +847,8 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
                     t_llm_start = time.time()
                     msg, was_streamed = self._call_llm(
                         send_msgs,
-                        override_tools=override_tools or getattr(self, "_subagent_tool_override", None)
+                        override_tools=override_tools or getattr(self, "_subagent_tool_override", None),
+                        silent=False,
                     )
                     reasoning_duration = time.time() - t_llm_start
 
@@ -855,12 +856,19 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
                 except _ServerUnavailableError as exc:
                     _err_text = str(exc).lower()
                     if "rate limit" in _err_text or "rate-limit" in _err_text or "429" in _err_text or "too many requests" in _err_text:
-                        self.console.print(f"\n[bold yellow]⏳  Model is temporarily rate-limited by the provider.[/bold yellow]")
+                        # Mark the current API key as exhausted for 24 hours
+                        from utim_cli.config import config
+                        current_key = config.get("api_key", "")
+                        if current_key:
+                            config.mark_api_key_exhausted(current_key, duration_hours=24)
+                            self.console.print(f"\n[bold yellow]⏳  Rate-limited on API key {current_key[:12]}... — excluded for 24 hours.[/bold yellow]")
+                        else:
+                            self.console.print(f"\n[bold yellow]⏳  Model is temporarily rate-limited by the provider.[/bold yellow]")
                         self.console.print("  [dim]Please wait a moment before retrying, or switch models using [bold]/model[/bold] (Ctrl+M).[/dim]\n")
                         if len(self.messages) <= turn_msg_start + 1:
                             self.messages.append({
                                 "role": "assistant",
-                                "content": "⏳ **Model Rate Limited**: The model is temporarily rate-limited by the provider. Please wait a short moment and retry, or use `/model` to switch models."
+                                "content": "⏳ **Rate Limited**: The API key has been temporarily exhausted (24h cooldown). Please wait and retry, or use `/model` to switch models."
                             })
                         self._persist_messages()
                         return