Update app.py

app.py

@@ -1,20 +1,21 @@
 #!/usr/bin/env python3
 """
 Multi-Model AI API — HuggingFace Spaces Edition
-With load balancing (multiple provider instances per model) and 10 req/s rate limiting.
+With load balancing, 10 req/s rate limiting, vision support, and multimodal fixes.
 """
 
-import re, os, json, uuid, time, random, string, logging, threading
+import re, os, json, uuid, time, random, string, logging, threading, base64
 from abc import ABC, abstractmethod
 from collections import deque
 from dataclasses import dataclass, field
 from typing import Any, Dict, Generator, List, Optional, Tuple, Union
+from io import BytesIO
 
 import requests
 from flask import Flask, request as freq, jsonify, Response, stream_with_context
 
 try:
-    from gradio_client import Client as GradioClient
+    from gradio_client import Client as GradioClient, handle_file
     HAS_GRADIO_CLIENT = True
 except ImportError:
     HAS_GRADIO_CLIENT = False
@@ -23,7 +24,7 @@ except ImportError:
 #  CONFIG & CONSTANTS
 # ═══════════════════════════════════════════════════════════════
 
-VERSION = "2.4.0-hf-lb"
+VERSION = "3.0.0-hf-lb"
 APP_NAME = "Multi-Model-AI-API"
 DEFAULT_SYSTEM_PROMPT = "You are a helpful, friendly AI assistant."
 DEFAULT_MODEL = "gpt-oss-120b"
@@ -38,6 +39,83 @@ USER_AGENTS = [
     "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:128.0) Gecko/20100101 Firefox/128.0",
 ]
 
+# ═══════════════════════════════════════════════════════════════
+#  MULTIMODAL HELPERS
+# ═══════════════════════════════════════════════════════════════
+
+def extract_text_and_images(content: Any) -> Tuple[str, List[str]]:
+    """
+    Parse OpenAI-style multimodal content.
+    Returns (text, [base64_or_url, ...])
+    Handles: str, list of {type, text/image_url}
+    """
+    if content is None:
+        return "", []
+    if isinstance(content, str):
+        return content.strip(), []
+
+    texts: List[str] = []
+    images: List[str] = []
+
+    if isinstance(content, list):
+        for block in content:
+            if not isinstance(block, dict):
+                texts.append(str(block))
+                continue
+            btype = block.get("type", "")
+            if btype == "text":
+                t = block.get("text", "")
+                if t:
+                    texts.append(t)
+            elif btype == "image_url":
+                img = block.get("image_url", {})
+                url = img.get("url", "") if isinstance(img, dict) else str(img)
+                if url:
+                    images.append(url)
+            elif btype == "image":
+                # Alternative format
+                src = block.get("source", {})
+                if isinstance(src, dict):
+                    data = src.get("data", "")
+                    if data:
+                        media = src.get("media_type", "image/jpeg")
+                        images.append(f"data:{media};base64,{data}")
+
+    return " ".join(texts).strip(), images
+
+
+def decode_image_to_bytes(image_url: str) -> Optional[Tuple[bytes, str]]:
+    """Convert image URL or data URI to (bytes, media_type)."""
+    try:
+        if image_url.startswith("data:"):
+            # data:image/jpeg;base64,/9j/...
+            header, data = image_url.split(",", 1)
+            media_type = header.split(";")[0].split(":")[1]
+            return base64.b64decode(data), media_type
+        else:
+            # Remote URL
+            r = requests.get(image_url, timeout=15)
+            r.raise_for_status()
+            ct = r.headers.get("content-type", "image/jpeg").split(";")[0]
+            return r.content, ct
+    except Exception as e:
+        log.warning(f"Failed to decode image: {e}")
+        return None
+
+
+def save_image_temp(image_url: str) -> Optional[str]:
+    """Save image to a temp file and return path (for gradio_client)."""
+    import tempfile
+    result = decode_image_to_bytes(image_url)
+    if not result:
+        return None
+    data, media_type = result
+    ext = media_type.split("/")[-1].replace("jpeg", "jpg")
+    with tempfile.NamedTemporaryFile(suffix=f".{ext}", delete=False) as f:
+        f.write(data)
+        return f.name
+
+
 # ═══════════════════════════════════════════════════════════════
 #  MODEL REGISTRY
 # ═══════════════════════════════════════════════════════════════
@@ -65,7 +143,8 @@ class ModelDef:
     clean_analysis: bool = False
     lb_pool_size: int = 2
     lb_enabled: bool = True
-    is_beta: bool = False  # Beta flag for experimental models
+    is_beta: bool = False
+
 
 MODEL_REGISTRY: Dict[str, ModelDef] = {}
 
@@ -101,9 +180,8 @@ def _init_registry():
         supports_temperature=False, supports_streaming=False, supports_history=False,
         supports_thinking=False, max_tokens_default=700,
         extra_params={"max_new_tokens": 700},
-        lb_pool_size=1, lb_enabled=False,  # NO load balancing for translate
+        lb_pool_size=1, lb_enabled=False,
     ))
-    # ── NEW: Command-A Reasoning ──
     register_model(ModelDef(
         model_id="command-a-reasoning", display_name="Cohere Command-A Reasoning",
         provider_type="gradio_client", space_id="CohereLabs/command-a-reasoning",
@@ -153,7 +231,6 @@ def _init_registry():
         supports_thinking=False, max_tokens_default=4096,
         lb_pool_size=2, lb_enabled=True,
     ))
-    # ── NEW: Qwen2.5-Coder (BETA) ──
     register_model(ModelDef(
         model_id="qwen2.5-coder", display_name="Qwen2.5-Coder Artifacts (BETA)",
         provider_type="gradio_client", space_id="Qwen/Qwen2.5-Coder-Artifacts",
@@ -194,7 +271,7 @@ class Config:
     rate_limit_burst: int = 15
     pool_size: int = 2
     max_history_messages: int = 50
-    max_message_length: int = 10000
+    max_message_length: int = 32000
     default_temperature: float = 0.7
     include_thinking: bool = True
     log_sse_raw: bool = False
@@ -376,20 +453,15 @@ class ResponseCleaner:
 
     @classmethod
     def extract_qwen_coder_text(cls, result: Any) -> str:
-        """Extract text from Qwen2.5-Coder /generation_code response.
-        Returns tuple of (markdown, html). We want the markdown part."""
         if result is None:
             return ""
         if isinstance(result, str):
             return result.strip()
         if isinstance(result, tuple):
-            # /generation_code returns (markdown_str, html_str)
-            # We want the markdown part (index 0)
             if len(result) >= 1 and isinstance(result[0], str):
                 text = result[0].strip()
                 if text:
                     return text
-            # Fallback to second element if first is empty
             if len(result) >= 2 and isinstance(result[1], str):
                 return result[1].strip()
         if isinstance(result, (list, dict)):
@@ -568,7 +640,7 @@ class Metrics:
 metrics = Metrics()
 
 # ═══════════════════════════════════════════════════════════════
-#  RATE LIMITER — 10 requests per SECOND (token bucket)
+#  RATE LIMITER — token bucket (10 req/s)
 # ═══════════════════════════════════════════════════════════════
 
 class RateLimiter:
@@ -713,7 +785,7 @@ class ModelProvider(ABC):
 
     @abstractmethod
     def generate(self, message: str, history=None, system_prompt=None,
-                 temperature=None, max_tokens=None, **kwargs) -> str: ...
+                 temperature=None, max_tokens=None, images=None, **kwargs) -> str: ...
 
     def generate_stream(self, message: str, **kwargs) -> Generator[str, None, None]:
         yield self.generate(message, **kwargs)
@@ -795,7 +867,7 @@ class GptOssProvider(ModelProvider):
                 return False
 
     def generate(self, message, history=None, system_prompt=None,
-                 temperature=None, max_tokens=None, **kw):
+                 temperature=None, max_tokens=None, images=None, **kw):
         if not self.ready:
             self.initialize()
         sys_p = system_prompt or self.config.default_system_prompt
@@ -848,7 +920,7 @@ class GptOssProvider(ModelProvider):
                 if self.model_def.clean_analysis else full)
 
     def generate_stream(self, message, history=None, system_prompt=None,
-                        temperature=None, max_tokens=None, **kw):
+                        temperature=None, max_tokens=None, images=None, **kw):
         if not self.ready:
             self.initialize()
         sys_p = system_prompt or self.config.default_system_prompt
@@ -933,19 +1005,31 @@ class GradioClientProvider(ModelProvider):
                 return False
 
     def generate(self, message, history=None, system_prompt=None,
-                 temperature=None, max_tokens=None, **kw):
+                 temperature=None, max_tokens=None, images=None, **kw):
         if not self.ready:
             self.initialize()
         if not self._client:
             raise APIError(f"{self.model_def.model_id} not initialized")
 
         mid = self.model_def.model_id
+        images = images or []
+
         try:
             if mid == "command-a-vision":
                 max_new = (max_tokens
                            or self.model_def.extra_params.get("max_new_tokens", 700))
+                # Build multimodal message
+                msg_payload: Any
+                if images:
+                    img_path = save_image_temp(images[0])
+                    if img_path:
+                        msg_payload = {"text": message, "files": [handle_file(img_path)]}
+                    else:
+                        msg_payload = {"text": message, "files": []}
+                else:
+                    msg_payload = {"text": message, "files": []}
                 result = self._client.predict(
-                    message={"text": message, "files": []},
+                    message=msg_payload,
                     max_new_tokens=max_new,
                     api_name=self.model_def.api_name,
                 )
@@ -960,7 +1044,6 @@ class GradioClientProvider(ModelProvider):
                 )
 
             elif mid == "command-a-reasoning":
-                # Cohere Command-A Reasoning with thinking budget
                 thinking_budget = kw.get(
                     "thinking_budget",
                     self.model_def.extra_params.get("thinking_budget", 500),
@@ -979,8 +1062,14 @@ class GradioClientProvider(ModelProvider):
                            or self.model_def.extra_params.get("max_tokens", 12800))
                 top_p = kw.get("top_p",
                                self.model_def.extra_params.get("top_p", 0.9))
+                # Vision support
+                if images:
+                    img_path = save_image_temp(images[0])
+                    files = [handle_file(img_path)] if img_path else []
+                else:
+                    files = []
                 result = self._client.predict(
-                    message={"text": message, "files": []},
+                    message={"text": message, "files": files},
                     max_tokens=max_tok, temperature=temp, top_p=top_p,
                     api_name=self.model_def.api_name,
                 )
@@ -1019,14 +1108,22 @@ class GradioClientProvider(ModelProvider):
                 return ResponseCleaner.extract_chatgpt_text(result)
 
             elif mid == "qwen3-vl":
-                result = self._client.predict(
-                    input_value={"files": None, "text": message},
-                    api_name="/add_message",
-                )
+                # Vision support
+                if images:
+                    img_path = save_image_temp(images[0])
+                    files = [handle_file(img_path)] if img_path else []
+                    result = self._client.predict(
+                        input_value={"files": files, "text": message},
+                        api_name="/add_message",
+                    )
+                else:
+                    result = self._client.predict(
+                        input_value={"files": None, "text": message},
+                        api_name="/add_message",
+                    )
                 return ResponseCleaner.extract_qwen_text(result)
 
             elif mid == "qwen2.5-coder":
-                # First set the system prompt to override artifacts behavior
                 sys_override = self.model_def.extra_params.get(
                     "system_prompt_override", ""
                 )
@@ -1062,33 +1159,27 @@ class GradioClientProvider(ModelProvider):
             raise APIError(f"{mid} error: {e}", "PROVIDER_ERROR")
 
     def _extract_reasoning(self, result: Any) -> str:
-        """Extract response from Command-A Reasoning.
-        The API returns str | float | bool | list | dict from the Json component."""
         if result is None:
             return ""
         if isinstance(result, str):
             return result.strip()
         if isinstance(result, dict):
-            # Try common response keys
             for key in ("response", "output", "answer", "text", "content", "result"):
                 if key in result:
                     val = result[key]
                     if isinstance(val, str):
                         return val.strip()
                     return str(val)
-            # Check for thinking + response structure
             thinking = result.get("thinking", "")
             response = result.get("response", result.get("output", ""))
             if thinking and response:
                 return f"<thinking>\n{thinking}\n</thinking>\n{response}"
             if response:
                 return str(response).strip()
-            # Fallback: serialize entire dict
             return json.dumps(result, ensure_ascii=False, indent=2)
         if isinstance(result, (list, tuple)):
             if len(result) == 1:
                 return str(result[0]).strip()
-            # Try to find text in list elements
             texts = []
             for item in result:
                 if isinstance(item, str) and item.strip():
@@ -1120,7 +1211,6 @@ class GradioClientProvider(ModelProvider):
         return ResponseCleaner.clean_glm(str(result), include_thinking)
 
 
-# Factory
 def create_provider(model_id: str, config: Config,
                     instance_id: int = 0) -> ModelProvider:
     if model_id not in MODEL_REGISTRY:
@@ -1253,7 +1343,7 @@ class LoadBalancedProviderPool:
                 inst.record_failure()
                 log.warning(
                     f"[LB] Failover instance {inst.instance_id} "
-                    f"for '{self.model_id}' also failed: {e}"
+                    f"for '{self.model_id}' failed: {e}"
                 )
 
         raise APIError(
@@ -1336,7 +1426,7 @@ class LoadBalancedProviderPool:
         }
 
 # ═══════════════════════════════════════════════════════════════
-#  MULTI-MODEL CLIENT (with load balancing)
+#  MULTI-MODEL CLIENT
 # ═══════════════════════════════════════════════════════════════
 
 class MultiModelClient:
@@ -1415,7 +1505,7 @@ class MultiModelClient:
 
     def send_message(
         self,
-        message: str,
+        message: Any,  # str OR list (multimodal)
         *,
         stream: bool = False,
         model: Optional[str] = None,
@@ -1424,14 +1514,27 @@ class MultiModelClient:
         temperature: Optional[float] = None,
         max_tokens: Optional[int] = None,
         include_thinking: Optional[bool] = None,
+        images: Optional[List[str]] = None,
         **kwargs,
     ) -> Union[str, Generator]:
         model_id = model or self._current_model
         if model_id not in MODEL_REGISTRY:
             raise ModelNotFoundError(model_id)
         mdef = MODEL_REGISTRY[model_id]
-        message = message.strip()
-        if not message:
+
+        # ── Normalise multimodal content ──────────────────────
+        if isinstance(message, list):
+            text, extracted_images = extract_text_and_images(message)
+            if not images:
+                images = extracted_images
+            message = text
+
+        if isinstance(message, str):
+            message = message.strip()
+        else:
+            message = str(message).strip()
+
+        if not message and not images:
             raise APIError("Empty message", "INVALID_INPUT", 400)
         if len(message) > self.config.max_message_length:
             raise APIError("Message too long", "INVALID_INPUT", 400)
@@ -1479,6 +1582,7 @@ class MultiModelClient:
                         system_prompt=eff_sys,
                         temperature=eff_temp,
                         max_tokens=max_tokens,
+                        images=images,
                         **extra,
                     )
                     return self._wrap_stream(gen, conv, start, model_id)
@@ -1490,6 +1594,7 @@ class MultiModelClient:
                     system_prompt=eff_sys,
                     temperature=eff_temp,
                     max_tokens=max_tokens,
+                    images=images,
                     **extra,
                 )
                 dur = (time.monotonic() - start) * 1000
@@ -1581,7 +1686,7 @@ class SessionPool:
             return c
 
 # ═══════════════════════════════════════════════════════════════
-#  MODEL ALIAS RESOLVER
+#  ALIAS RESOLVER
 # ═══════════════════════════════════════════════════════════════
 
 ALIASES = {
@@ -1602,6 +1707,8 @@ ALIASES = {
 
 
 def resolve_alias(model_id: str) -> str:
+    if not model_id:
+        return config.default_model
     return ALIASES.get(model_id.lower(), model_id)
 
 # ═══════════════════════════════════════════════════════════════
@@ -1634,18 +1741,19 @@ def index():
         "name": APP_NAME,
         "version": VERSION,
         "default_model": config.default_model,
-        "features": ["load_balancing", "10_req_per_second_limit", "failover"],
+        "features": ["load_balancing", "10_req_per_second_limit", "failover", "vision"],
         "models": list(MODEL_REGISTRY.keys()),
         "beta_models": [mid for mid, mdef in MODEL_REGISTRY.items() if mdef.is_beta],
+        "vision_models": [mid for mid, mdef in MODEL_REGISTRY.items() if mdef.supports_vision],
         "endpoints": {
             "POST /chat": "Chat with any model",
             "POST /chat/stream": "Streaming chat",
-            "POST /v1/chat/completions": "OpenAI-compatible",
+            "POST /v1/chat/completions": "OpenAI-compatible (supports vision)",
             "GET /v1/models": "List models",
             "POST /models/init": "Init a model",
-            "GET /health": "Health check (incl. LB status)",
+            "GET /health": "Health check",
             "GET /metrics": "Metrics",
-            "GET /lb/status": "Load balancer detailed status",
+            "GET /lb/status": "Load balancer status",
         },
     })
 
@@ -1653,16 +1761,26 @@ def index():
 @app.route("/chat", methods=["POST"])
 def chat():
     data = freq.get_json(force=True, silent=True) or {}
-    message = data.get("message", "").strip()
-    if not message:
+    raw_message = data.get("message", "")
+    images = data.get("images", [])
+
+    # Support multimodal content directly in message field
+    if isinstance(raw_message, list):
+        text, extracted = extract_text_and_images(raw_message)
+        images = images or extracted
+        message = text
+    else:
+        message = str(raw_message).strip()
+
+    if not message and not images:
         return jsonify({"ok": False, "error": "'message' required"}), 400
+
     model_id = resolve_alias(data.get("model", config.default_model))
     include_thinking = data.get("include_thinking", config.include_thinking)
     client = pool.acquire()
     if data.get("new_conversation"):
         client.new_conversation(data.get("system_prompt"), model_id)
 
-    # Pass extra params for specific models
     extra = {}
     if model_id == "command-a-reasoning" and "thinking_budget" in data:
         extra["thinking_budget"] = data["thinking_budget"]
@@ -1673,6 +1791,7 @@ def chat():
         temperature=data.get("temperature"),
         max_tokens=data.get("max_tokens"),
         include_thinking=include_thinking,
+        images=images or None,
         **extra,
     )
     thinking, clean = ThinkingParser.split(result)
@@ -1694,9 +1813,19 @@ def chat():
 @app.route("/chat/stream", methods=["POST"])
 def chat_stream():
     data = freq.get_json(force=True, silent=True) or {}
-    message = data.get("message", "").strip()
-    if not message:
+    raw_message = data.get("message", "")
+    images = data.get("images", [])
+
+    if isinstance(raw_message, list):
+        text, extracted = extract_text_and_images(raw_message)
+        images = images or extracted
+        message = text
+    else:
+        message = str(raw_message).strip()
+
+    if not message and not images:
         return jsonify({"ok": False, "error": "'message' required"}), 400
+
     model_id = resolve_alias(data.get("model", config.default_model))
     include_thinking = data.get("include_thinking", config.include_thinking)
     client = pool.acquire()
@@ -1718,6 +1847,7 @@ def chat_stream():
                     temperature=data.get("temperature"),
                     max_tokens=data.get("max_tokens"),
                     include_thinking=include_thinking,
+                    images=images or None,
                     **extra,
                 ):
                     yield f"data: {json.dumps({'chunk': chunk})}\n\n"
@@ -1728,6 +1858,7 @@ def chat_stream():
                     temperature=data.get("temperature"),
                     max_tokens=data.get("max_tokens"),
                     include_thinking=include_thinking,
+                    images=images or None,
                     **extra,
                 )
                 yield f"data: {json.dumps({'chunk': result})}\n\n"
@@ -1772,6 +1903,7 @@ def list_models():
 def openai_compat():
     if freq.method == "OPTIONS":
         return "", 200
+
     data = freq.get_json(force=True, silent=True) or {}
     messages = data.get("messages", [])
     do_stream = data.get("stream", False)
@@ -1783,20 +1915,38 @@ def openai_compat():
     if model_id not in MODEL_REGISTRY:
         return jsonify({
             "error": {
-                "message": f"Model '{model_id}' not found",
+                "message": f"Model '{model_id}' not found. Available: {list(MODEL_REGISTRY.keys())}",
                 "type": "invalid_request_error",
+                "available_models": list(MODEL_REGISTRY.keys()),
             }
         }), 404
+
     if not messages:
         return jsonify({"error": {"message": "messages required"}}), 400
 
-    user_msg = system_prompt = None
+    # ── Extract user message, system prompt, and images ───────
+    user_msg: str = ""
+    system_prompt: Optional[str] = None
+    images: List[str] = []
+
     for msg in messages:
-        if msg.get("role") == "system":
-            system_prompt = msg.get("content")
-        if msg.get("role") == "user":
-            user_msg = msg.get("content", "")
-    if not user_msg:
+        role = msg.get("role", "")
+        content = msg.get("content", "")
+
+        if role == "system":
+            system_prompt = content if isinstance(content, str) else str(content)
+
+        if role == "user":
+            if isinstance(content, list):
+                text, imgs = extract_text_and_images(content)
+                user_msg = text
+                images.extend(imgs)
+            elif isinstance(content, str):
+                user_msg = content
+            else:
+                user_msg = str(content)
+
+    if not user_msg and not images:
         return jsonify({"error": {"message": "No user message"}}), 400
 
     rid = f"chatcmpl-{uuid.uuid4().hex[:29]}"
@@ -1804,15 +1954,21 @@ def openai_compat():
     client = pool.acquire()
     client.new_conversation(system_prompt, model_id)
 
+    # Replay history (all but the last user message)
     for msg in messages[:-1]:
         role = msg.get("role")
         content = msg.get("content", "")
         if role in ("user", "assistant") and content:
-            client.active_conversation.add_message(role, content)
+            text = (
+                extract_text_and_images(content)[0]
+                if isinstance(content, list)
+                else str(content)
+            )
+            if text:
+                client.active_conversation.add_message(role, text)
 
     mdef = MODEL_REGISTRY[model_id]
 
-    # Extra params
     extra = {}
     if model_id == "command-a-reasoning" and "thinking_budget" in data:
         extra["thinking_budget"] = data["thinking_budget"]
@@ -1825,14 +1981,15 @@ def openai_compat():
                     for chunk in client.send_message(
                         user_msg, stream=True, model=model_id,
                         temperature=temperature, max_tokens=max_tokens,
-                        include_thinking=include_thinking, **extra,
+                        include_thinking=include_thinking,
+                        images=images or None, **extra,
                     ):
                         yield f"data: {json.dumps({'id': rid, 'object': 'chat.completion.chunk', 'created': created, 'model': model_id, 'choices': [{'index': 0, 'delta': {'content': chunk}, 'finish_reason': None}]})}\n\n"
                 else:
                     result = client.send_message(
                         user_msg, model=model_id, temperature=temperature,
-                        max_tokens=max_tokens,
-                        include_thinking=include_thinking, **extra,
+                        max_tokens=max_tokens, include_thinking=include_thinking,
+                        images=images or None, **extra,
                     )
                     yield f"data: {json.dumps({'id': rid, 'object': 'chat.completion.chunk', 'created': created, 'model': model_id, 'choices': [{'index': 0, 'delta': {'content': result}, 'finish_reason': None}]})}\n\n"
                 yield f"data: {json.dumps({'id': rid, 'object': 'chat.completion.chunk', 'created': created, 'model': model_id, 'choices': [{'index': 0, 'delta': {}, 'finish_reason': 'stop'}]})}\n\n"
@@ -1845,7 +2002,8 @@ def openai_compat():
 
     result = client.send_message(
         user_msg, model=model_id, temperature=temperature,
-        max_tokens=max_tokens, include_thinking=include_thinking, **extra,
+        max_tokens=max_tokens, include_thinking=include_thinking,
+        images=images or None, **extra,
     )
     return jsonify({
         "id": rid,
@@ -1943,7 +2101,7 @@ def init_model_ep():
 
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
-    log.info(f"Starting Multi-Model AI API v{VERSION} on port {port}")
+    log.info(f"Starting {APP_NAME} v{VERSION} on port {port}")
     log.info(f"Models: {list(MODEL_REGISTRY.keys())}")
     log.info(f"Rate limit: {config.rate_limit_rps} req/s (burst: {config.rate_limit_burst})")
     for mid, mdef in MODEL_REGISTRY.items():
@@ -1952,6 +2110,7 @@ if __name__ == "__main__":
             if mdef.lb_enabled
             else "LB OFF (single instance)"
         )
+        vision_str = " [VISION]" if mdef.supports_vision else ""
         beta_str = " [BETA]" if mdef.is_beta else ""
-        log.info(f"  {mid}: {lb_str}{beta_str}")
+        log.info(f"  {mid}: {lb_str}{vision_str}{beta_str}")
     app.run(host="0.0.0.0", port=port, threaded=True)