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

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

@@ -1,5 +1,27 @@
 # Changelog
 
+## [2.3.22] - 2026-09-06
+
+### 🛡️ Seamless Rate-Limit Failover to Paid Slugs
+- **Client-Side Auto-Shift**: In `orchestrator_llm_transport.py`, when a free model (e.g. `poolside/laguna-s-2.1:free`) encounters an HTTP 429 or streaming rate-limit event, the client immediately switches to its paid slug (`poolside/laguna-s-2.1`) without terminating the conversation turn or showing an interrupting rate-limit error.
+- **Single Source of Truth**: Centralized `get_paid_slug()` in `utim_cli/constants.py` for uniform mapping across client transport and server completion routing.
+- **Laguna Paid Slug Registration**: Added `poolside/laguna-s-2.1` to the server model registry with complete tool, chat, and reasoning capabilities.
+- **Cost-Protected MiniMax Failover**: Ensured rate-limited MiniMax free models shift to the Laguna S 2.1 paid slug rather than expensive MiniMax paid tiers.
+- **Credit Rate Preservation**: Retained fixed free model pricing ($0.30 input / $0.50 output per 1M tokens) on server fallback turns.
+
+## [2.3.21] - 2026-09-06
+
+### 💰 Pricing Modifications
+- OpenRouter tier markup standardization and free model fallback credit preservation
+
+### 📦 Models Payload Fixes  
+- Upstream provider normalization and APINEX model mapping support
+
+### 🛡️ Rate Limit & Vision Tooling Fixes
+- MiniMax rate-limit fallback to Laguna and APINEX transparent image analysis
+
+*See [docs](docs.md) for detailed APINEX migration information and implementation notes.*
+
 ## [2.3.20] - 2026-09-04
 
 ### 🛠️ Minor Fixes and Enhancement

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

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

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

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

@@ -14,7 +14,7 @@ Quickstart:
 try:
     from utim_cli._version import VERSION as __version__
 except ImportError:
-    __version__ = "2.3.20"
+    __version__ = "2.3.22"
 
 # Developer-friendly core classes (similar to `import genai` / `import openai`)
 from utim_cli.sdk.session import UtimSession as Session

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

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

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

{utim_cli-2.3.20 → utim_cli-2.3.22}/utim_cli/client_utils.py

@@ -248,12 +248,14 @@ def fetch_remote_models_catalog(timeout: float = 3.0) -> dict:
                 for m in models_list:
                     caps = [c.lower() for c in (m.get("capabilities") or [])]
                     tags = [t.lower() for t in (m.get("tags") or [])]
+                    mid = str(m.get("model_id") or "")
                     is_img = bool(
                         m.get("is_image_gen")
                         or "image_generation" in caps
                         or "imagegen" in caps
                         or "image_output" in caps
-                        or "image" in tags
+                        or mid.lower().startswith("krea/")
+                        or ("image" in caps and not any(c in caps for c in ("chat", "vision", "text")))
                     )
                     is_vis = bool(m.get("is_vision") or "vision" in caps or "vision" in tags)
                     if is_img:
@@ -334,6 +336,9 @@ def _build_free_models_fallback_chain(now: float) -> list[str]:
                 (ModelDB.is_free == True) | (ModelDB.cost_input_per_1m == 0.0) | (ModelDB.model_id.like("%:free"))
             ).order_by(ModelDB.model_id.asc()).all()
             for r in free_rows:
+                caps = [str(c).lower() for c in (r.capabilities or [])]
+                if r.is_image_gen or "image_generation" in caps or "imagegen" in caps:
+                    continue
                 mid = r.model_id
                 if mid and mid not in seen and mid not in INVALID_DUMMY_IDS:
                     chain.append(mid)

utim_cli-2.3.22/utim_cli/constants.py

@@ -0,0 +1,99 @@
+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",
+}
+
+APINEX_TO_OPENROUTER_PAID: dict[str, str] = {
+    "gemini/3.7-flash": "google/gemini-2.5-flash",
+    "free/gemini-3.7-flash": "google/gemini-2.5-flash",
+    "gemini/3.1-pro": "google/gemini-2.5-pro",
+    "free/gemini-3.1-pro": "google/gemini-2.5-pro",
+    "deepseek/v4-flash-0731": "deepseek/deepseek-chat",
+    "free/deepseek-v4-flash-0731": "deepseek/deepseek-chat",
+    "deepseek/v4-pro-0813": "deepseek/deepseek-r1",
+    "free/deepseek-v4-pro-0813": "deepseek/deepseek-r1",
+    "claude/sonnet-5": "anthropic/claude-3.5-sonnet",
+    "claude/opus-5": "anthropic/claude-3-opus",
+    "gpt/5.6-luna": "openai/gpt-4o-mini",
+    "gpt/5.6-sol": "openai/gpt-4o",
+    "gpt/5.6-terra": "openai/gpt-4o",
+    "glm/5.3": "z-ai/glm-4",
+    "glm/5.3-flash": "z-ai/glm-4",
+    "free/glm-5.3-flash": "z-ai/glm-4",
+    "kimi/k3": "moonshotai/kimi-k2",
+    "grok/4.6": "x-ai/grok-2-1212",
+    "qwen/3.8-max": "qwen/qwen-2.5-72b-instruct",
+    "free/qwen-3.8-max": "qwen/qwen-2.5-72b-instruct",
+}
+
+
+def get_paid_slug(model_id: str) -> str:
+    """Return the paid equivalent slug for a free or gateway model.
+    - MiniMax models (e.g. minimax/minimax-m2.7:free, minimax/minimax-m3:free) are pricy,
+      so when hitting rate limits, the server falls back to Laguna S 2.1 paid slug
+      ('poolside/laguna-s-2.1') instead of expensive MiniMax paid slugs.
+    - If model ends with ':free', strip ':free' (provider/model:free -> provider/model).
+    - If APINEX model, map to corresponding OpenRouter paid model.
+    - If model starts with 'free/', check APINEX mapping or strip 'free/'.
+    - If 'openrouter/free', return standard high-capacity default ('google/gemini-2.5-flash').
+    """
+    clean_id = (model_id or "").strip()
+    clean_lower = clean_id.lower()
+
+    # MiniMax free models are pricy on their paid tier; route fallback to Laguna S 2.1 paid slug
+    if "minimax" in clean_lower:
+        return "poolside/laguna-s-2.1"
+
+    if clean_id.endswith(":free"):
+        return clean_id[:-5]
+    if clean_id in APINEX_TO_OPENROUTER_PAID:
+        return APINEX_TO_OPENROUTER_PAID[clean_id]
+    if clean_id.startswith("free/"):
+        unprefixed = clean_id[5:]
+        if unprefixed in APINEX_TO_OPENROUTER_PAID:
+            return APINEX_TO_OPENROUTER_PAID[unprefixed]
+        if unprefixed.endswith(":free"):
+            return unprefixed[:-5]
+        return unprefixed
+    if clean_id == "openrouter/free":
+        return "google/gemini-2.5-flash"
+    return clean_id
+
+
+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.20 → utim_cli-2.3.22}/utim_cli/orchestrator_llm_transport.py

@@ -30,7 +30,7 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import Any, Dict, List, Optional, Tuple
 
 import requests
-from utim_cli.constants import DEFAULT_MODEL
+from utim_cli.constants import DEFAULT_MODEL, get_paid_slug
 
 # openai SDK removed — we call OpenRouter directly via requests (no Rust/jiter needed)
 from rich.console import Console
@@ -132,6 +132,30 @@ from .orchestrator_turn_history import TurnHistoryMixin  # noqa: E402
 Contains: _get_configured_model_source, _is_custom_model_selection,
 _resolve_model_endpoint, _call_llm. Behavior-identical; Orchestrator inherits.
 """
+
+# ── Effort → stall-timeout mapping (thinking-level based, NOT model-name based) ──
+# Reasoning models think longer at higher effort levels. The stream stall detector
+# (TTFT + inter-token) uses these per-effort durations instead of a single hard
+# 900s ceiling, so a stuck "none" call fails fast while "max" gets full headroom.
+_EFFORT_STALL_TIMEOUT_SECONDS = {
+    "none": 15,
+    "minimal": 45,
+    "low": 60,
+    "medium": 80,
+    "high": 100,
+    "xhigh": 180,
+    "max": 300,
+}
+_DEFAULT_STALL_TIMEOUT = 80  # matches "medium" (the default reasoning_effort)
+
+
+def _effort_stall_timeout(settings: dict) -> int:
+    """Return the stall-detection timeout (seconds) for the given model settings,
+    keyed by reasoning effort (thinking level), not by model name."""
+    effort = (settings or {}).get("reasoning_effort", "medium")
+    return _EFFORT_STALL_TIMEOUT_SECONDS.get(effort, _DEFAULT_STALL_TIMEOUT)
+
+
 class LLMTransportMixin:
     _PRE_THINK_PATTERNS = re.compile(
         r"^\s*(\*\s*Thinking\.\.\.?|\.\.\.(\s*thinking)?|thinking\.\.\.?)\s*$",
@@ -1032,6 +1056,8 @@ class LLMTransportMixin:
                     # Intentionally NOT reset by keep-alive pings (empty lines) so stall
                     # detection isn't fooled by the server sending blank heartbeats.
                     last_content_time = start_time
+                    # Per-effort stall timeout (thinking level, not model name).
+                    stall_timeout = _effort_stall_timeout(settings)
                     _api_key = config.get("api_key")
                     _openrouter_key = self._local_api_key
                     _browser_ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
@@ -1295,15 +1321,21 @@ class LLMTransportMixin:
                                 # Stall detection runs on EVERY iteration (including empty
                                 # keep-alive lines) so a true stream stall is always caught.
                                 if not final_content and not final_tool_calls:
-                                    # Hard 900-second timeout for Time-To-First-Token
-                                    # Models often need 60-300s to process large tool outputs before streaming
-                                    if now - start_time > 900:
-                                        raise requests.exceptions.Timeout("Hard TTFT timeout exceeded 900s")
+                                    # Effort-scaled Time-To-First-Token timeout. Models can
+                                    # need 60-300s to process large tool outputs, so this is
+                                    # keyed to reasoning effort (thinking level), not model name.
+                                    if now - start_time > stall_timeout:
+                                        raise requests.exceptions.Timeout(
+                                            f"Hard TTFT timeout exceeded {stall_timeout}s (effort)"
+                                        )
                                 else:
                                     # Inter-content stall detection: abort if no real content
-                                    # has arrived for 900 seconds (15 mins), even during keep-alive pings.
-                                    if now - last_content_time > 900:
-                                        raise requests.exceptions.Timeout("Inter-token stall timeout exceeded 900s")
+                                    # has arrived for `stall_timeout` seconds, even during
+                                    # keep-alive pings.
+                                    if now - last_content_time > stall_timeout:
+                                        raise requests.exceptions.Timeout(
+                                            f"Inter-token stall timeout exceeded {stall_timeout}s (effort)"
+                                        )
                                         
                                 if not raw_line:
                                     continue
@@ -1526,6 +1558,20 @@ class LLMTransportMixin:
                                                     "tool_calls": None,
                                                 }, False
                                             elif _is_rate_limit:
+                                                _paid_slug = get_paid_slug(current_model)
+                                                if _paid_slug != current_model:
+                                                    if not silent:
+                                                        self.console.print(
+                                                            f"\n[bold yellow]⏳  Model '{current_model}' is temporarily rate-limited. Shifting seamlessly to paid slug [bold]{_paid_slug}[/bold]...[/bold yellow]\n"
+                                                        )
+                                                    if _paid_slug not in models_to_try:
+                                                        models_to_try.insert(model_idx + 1, _paid_slug)
+                                                    if not override_model and model_idx == 0:
+                                                        self.model_id = _paid_slug
+                                                        self.model_source = "utim"
+                                                        config.set("main_model_source", "utim")
+                                                    raise RuntimeError(f"__RATE_LIMIT_SHIFT__:{current_model}:{_paid_slug}")
+
                                                 rate_limit_display = (
                                                     f"⏳ **Model Rate Limited**: `{current_model}` is currently experiencing high demand and is temporarily rate-limited by the provider.\n\n"
                                                     f"- **What to do:** Please wait a moment before retrying, or switch to a different model with `/model` or `Ctrl+M`.\n"
@@ -2083,6 +2129,20 @@ class LLMTransportMixin:
                                 "tool_calls": None,
                             }, False
 
+                        _paid_slug = get_paid_slug(current_model)
+                        if _paid_slug != current_model:
+                            if not silent:
+                                self.console.print(
+                                    f"\n[bold yellow]⏳  Model '{current_model}' is temporarily rate-limited. Shifting seamlessly to paid slug [bold]{_paid_slug}[/bold]...[/bold yellow]\n"
+                                )
+                            if _paid_slug not in models_to_try:
+                                models_to_try.insert(model_idx + 1, _paid_slug)
+                            if not override_model and model_idx == 0:
+                                self.model_id = _paid_slug
+                                self.model_source = "utim"
+                                config.set("main_model_source", "utim")
+                            break  # attempt loop → outer loop immediately tries _paid_slug next!
+
                         rate_limit_display = (
                             f"⏳ **Model Rate Limited**: `{current_model}` is currently experiencing high demand and is temporarily rate-limited by the provider.\n\n"
                             f"- **What to do:** Please wait a moment before retrying, or switch to a different model with `/model` or `Ctrl+M`.\n"

{utim_cli-2.3.20 → utim_cli-2.3.22}/utim_cli/server/auth.py

@@ -108,12 +108,11 @@ def extract_client_ip(request: Optional[Request]) -> str:
 
 # ── Helpers ───────────────────────────────────────────────────────────────────
 
-def process_user_refills(db: Session, user_id: str) -> None:
+def process_user_refills(db: Session, user_id: str, now: Optional[datetime.datetime] = None) -> None:
     """
-    Catch-up and process any pending 5-hour quota refills for the user's active subscription.
+    Catch-up and process any pending 5-hour quota refills and weekly rollovers for the user's active subscription.
     Max refills per 30-day billing cycle = 144.
     """
-    import datetime
     import uuid
     from .db import UserSubscription, Credit, Transaction
     
@@ -122,7 +121,8 @@ def process_user_refills(db: Session, user_id: str) -> None:
         UserSubscription.status == "active"
     ).first()
     
-    now = datetime.datetime.utcnow()
+    if now is None:
+        now = datetime.datetime.utcnow()
     
     if not sub or not sub.plan:
         return
@@ -155,29 +155,27 @@ def process_user_refills(db: Session, user_id: str) -> None:
             )
 
         refills_used = getattr(sub, 'refills_processed', getattr(sub, 'refills_used', 0)) or 0
-        if refills_used >= 144:
-            return  # Hit monthly cap of 144 refills (3000 credits max)
+        if refills_used >= 4:
+            return  # Hit monthly cap of 4 weekly refills (1000 credits monthly cap)
 
-        last_refill = sub.last_refill_at or sub.created_at
+        last_refill = sub.last_refill_at or sub.current_period_start or sub.created_at or now
         elapsed_seconds = (now - last_refill).total_seconds()
         
-        # Calculate how many 5-hour intervals have passed since last refill
-        INTERVAL_SECONDS = 5 * 3600  # 5 hours
+        # Calculate how many 7-day (weekly) intervals have passed since last refill
+        INTERVAL_SECONDS = 7 * 86400  # 7 days (weekly refill)
         intervals_passed = int(elapsed_seconds // INTERVAL_SECONDS)
         
         if intervals_passed > 0:
-            # Cap intervals to not exceed the 144 monthly limit
-            intervals_to_apply = min(intervals_passed, 144 - refills_used)
+            # Cap intervals to not exceed the 4 weekly refills monthly limit
+            intervals_to_apply = min(intervals_passed, 4 - refills_used)
             
             if intervals_to_apply > 0:
                 credit_row = db.query(Credit).filter(Credit.user_id == user_id).first()
                 if credit_row:
                     old_bal = credit_row.balance or 0.0
-                    # Add $0.50 (20 credits) per interval, capped at $2.50 (100 credits) max balance
-                    # If balance is already >= $2.50, balance stays same but refill interval updates
-                    amount_to_add = intervals_to_apply * 20.0
-                    new_bal = min(100.0, old_bal + amount_to_add)
-                    actual_added = new_bal - old_bal
+                    # Free plan: weekly quota of 250 credits. No stacking: resets to 250 credits max balance.
+                    new_bal = 250.0
+                    actual_added = max(0.0, new_bal - old_bal)
                     
                     credit_row.balance = new_bal
                     sub.refills_processed = refills_used + intervals_to_apply
@@ -193,12 +191,12 @@ def process_user_refills(db: Session, user_id: str) -> None:
                             kind="refill",
                             amount=actual_added,
                             balance_after=new_bal,
-                            description=f"Auto-refill: +{actual_added:.1f} credits ({intervals_to_apply} interval{'s' if intervals_to_apply > 1 else ''})"
+                            description=f"Weekly quota refill: +{actual_added:.1f} credits ({intervals_to_apply} week{'s' if intervals_to_apply > 1 else ''})"
                         )
                         db.add(tx)
                     
                     db.commit()
-                    logger.info("refill_processed", extra={"user_id": user_id, "intervals": intervals_to_apply, "new_balance": new_bal})
+                    logger.info("weekly_refill_processed", extra={"user_id": user_id, "intervals": intervals_to_apply, "new_balance": new_bal})
         return
 
     # ── PAID-PLAN BRANCH ────────────────────────────────────────────────────
@@ -294,6 +292,57 @@ def process_user_refills(db: Session, user_id: str) -> None:
         sub.last_refill_at = now
         db.commit()
 
+    # ── Weekly Quota Rollover into Quota Bank (Every 7 days) ─────────────────
+    # Any unused weekly allowance from completed 7-day periods rolls over into Quota Bank.
+    plan = sub.plan
+    if plan and plan.credits_per_month:
+        weekly_allowance = plan.credits_per_month / 4.0
+        period_start = sub.current_period_start or sub.created_at or now
+        if getattr(sub, "last_weekly_reset_at", None) is None:
+            sub.last_weekly_reset_at = period_start
+
+        elapsed_total_seconds = max(0.0, (now - period_start).total_seconds())
+        weeks_elapsed = int(elapsed_total_seconds // (7 * 86400))
+
+        last_weekly_reset = sub.last_weekly_reset_at or period_start
+        last_week_elapsed = max(0.0, (last_weekly_reset - period_start).total_seconds())
+        weeks_processed = int(last_week_elapsed // (7 * 86400))
+        weeks_due = weeks_elapsed - weeks_processed
+
+        if weeks_due > 0:
+            weekly_used = getattr(sub, "weekly_credits_used", 0.0) or 0.0
+            unused_weekly = max(0.0, weekly_allowance - weekly_used)
+            if weeks_due > 1:
+                unused_weekly += weekly_allowance * (weeks_due - 1)
+
+            credit = db.query(Credit).filter(Credit.user_id == user_id).first()
+            if not credit:
+                credit = Credit(user_id=user_id, balance=0.0, total_spent=0.0, total_topped_up=0.0)
+                db.add(credit)
+                db.flush()
+
+            max_limit = plan.credits_per_month * 2.0
+            old_balance = credit.balance or 0.0
+            new_balance = min(max_limit, old_balance + unused_weekly)
+
+            if new_balance > old_balance:
+                added_amount = new_balance - old_balance
+                credit.balance = new_balance
+                tx = Transaction(
+                    id=str(uuid.uuid4()),
+                    user_id=user_id,
+                    kind="weekly_rollover",
+                    amount=added_amount,
+                    balance_after=new_balance,
+                    description=f"Weekly quota rollover: +{added_amount:.1f} unused credits added to Quota Bank ({plan.name.title()} Plan)"
+                )
+                db.add(tx)
+
+            sub.weekly_credits_used = 0.0
+            sub.weekly_resets_used = 0
+            sub.last_weekly_reset_at = period_start + datetime.timedelta(seconds=weeks_elapsed * 7 * 86400)
+            db.commit()
+
     # If the subscription period has expired (current_period_end passed), auto-degrade to Free plan!
     if sub.current_period_end and now >= sub.current_period_end:
         # Auto-degrade: the paid period has ended and the user did not renew.
@@ -630,7 +679,7 @@ def create_user(
     db.add(user)
 
     # Create credit row for backward compatibility
-    credit = Credit(user_id=user.id, balance=100.0, total_topped_up=0.0)
+    credit = Credit(user_id=user.id, balance=250.0, total_topped_up=0.0)
     db.add(credit)
 
     # Provision Free plan subscription

{utim_cli-2.3.20 → utim_cli-2.3.22}/utim_cli/server/batch_processor.py

@@ -28,16 +28,21 @@ class BatchAPIProcessor:
             "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."""
+    def create_batch_job(self, requests_list: List[Dict[str, Any]], model_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
+        """Package requests into a .jsonl batch payload and submit to POST /v1/batches.
+        Supports multi-model requests where each item in requests_list can specify its own model.
+        """
         jsonl_lines = []
+        models_in_batch = set()
         for idx, req_payload in enumerate(requests_list):
+            req_model = req_payload.get("model") or model_id or "openai/gpt-4o"
+            models_in_batch.add(req_model)
             item = {
-                "custom_id": f"request-{idx}-{int(time.time())}",
+                "custom_id": req_payload.get("custom_id", f"request-{idx}-{int(time.time())}"),
                 "method": "POST",
                 "url": "/v1/chat/completions",
                 "body": {
-                    "model": model_id,
+                    "model": req_model,
                     "messages": req_payload.get("messages", []),
                     "max_tokens": req_payload.get("max_tokens", 1500),
                     "temperature": req_payload.get("temperature", 0.2)
@@ -46,7 +51,8 @@ class BatchAPIProcessor:
             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}'...")
+        model_desc = model_id if len(models_in_batch) == 1 and model_id else f"multi-model ({len(models_in_batch)} models: {list(models_in_batch)[:3]})"
+        print(f"[BATCH FILE API] Packaging {len(requests_list)} requests into .jsonl payload for {model_desc}...")
 
         # Step 1: Upload file to /v1/files
         try:
@@ -85,7 +91,7 @@ class BatchAPIProcessor:
             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]]]:
+    def poll_and_retrieve_results(self, batch_id: str, poll_interval: float = 0.5, 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}"
@@ -117,3 +123,56 @@ class BatchAPIProcessor:
         
         print(f"[BATCH TIMEOUT] Reached timeout of {timeout}s waiting for job '{batch_id}'")
         return None
+
+    async def dispatch_concurrent_batch(
+        self,
+        requests_list: List[Dict[str, Any]],
+        default_model: Optional[str] = None,
+        timeout: float = 60.0,
+    ) -> List[Dict[str, Any]]:
+        """
+        Concurrently dispatches a batch of multi-model requests to OpenRouter / upstream API at once.
+        Does NOT wait for one request to complete before sending the next.
+        """
+        import httpx
+        import asyncio
+
+        limits = httpx.Limits(max_keepalive_connections=20, max_connections=100)
+        async with httpx.AsyncClient(limits=limits, timeout=timeout) as client:
+            async def _send_one(req_payload: Dict[str, Any]) -> Dict[str, Any]:
+                model = req_payload.get("model") or default_model or "openai/gpt-4o"
+                url = f"{self.base_url}/chat/completions"
+                headers = {
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Content-Type": "application/json",
+                    "HTTP-Referer": "https://utim.ai",
+                    "X-Title": "UTIM CLI",
+                }
+                body: Dict[str, Any] = {
+                    "model": model,
+                    "messages": req_payload.get("messages", []),
+                    "max_tokens": req_payload.get("max_tokens", 1500),
+                    "temperature": req_payload.get("temperature", 0.7),
+                }
+                for k, v in req_payload.items():
+                    if k not in body and k not in ("custom_id",):
+                        body[k] = v
+
+                try:
+                    resp = await client.post(url, json=body, headers=headers)
+                    return {
+                        "custom_id": req_payload.get("custom_id"),
+                        "model": model,
+                        "status_code": resp.status_code,
+                        "data": resp.json() if resp.status_code == 200 else resp.text,
+                    }
+                except Exception as e:
+                    return {
+                        "custom_id": req_payload.get("custom_id"),
+                        "model": model,
+                        "status_code": 500,
+                        "error": str(e),
+                    }
+
+            tasks = [_send_one(req) for req in requests_list]
+            return await asyncio.gather(*tasks)