Update app.py

app.py

@@ -1,287 +1,161 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-multimodal gpt-oss 120b — Gradio app:
-- Florence-2 (VLM) вызывается через NIM API (сервер, без WebGPU/wasm).
-- LLM-стриминг через NVIDIA Integrate (OpenAI-совместимый API).
-
-Что есть:
-- Автогенерация подписи к изображению (<MORE_DETAILED_CAPTION>) на сервере Florence-2,
-  результат сразу используется как визуальный контекст для LLM.
-- Раннер всех 14 задач Florence-2 с загрузкой изображения, текст-подсказкой и (при необходимости)
-  координатами региона в нормализованных 0..999 координатах.
-- Вывод JSON/TXT + галерея изображений результатов (если модель вернёт предикты-изображения).
+Минималистичный визуальный чат как в мессенджерах:
+- Внизу — компактная строка ввода с маленькой кнопкой добавления изображений.
+- Авто-подпись к изображению (<MORE_DETAILED_CAPTION>) через NVIDIA Florence-2 (NIM API).
+- Ответ LLM (стриминг) через NVIDIA Integrate (OpenAI-совместимый API).
+- Без WebGPU/wasm, без громоздких панелей.
+
+Требуется в Secrets HF Space: NV_API_KEY
 """
 
 import os
 import io
 import json
-import time
-import traceback
 import zipfile
 import mimetypes
+import traceback
 from typing import Any, Dict, List, Optional, Tuple
 
 import requests
 import gradio as gr
-from PIL import Image
 from openai import OpenAI
 
 # --------------------- Конфигурация ---------------------
-NV_API_KEY = os.environ.get("NV_API_KEY")  # ОБЯЗАТЕЛЬНО прописать в Secrets HF Spaces
+NV_API_KEY = os.environ.get("NV_API_KEY")
 NV_BASE_URL = os.environ.get("NV_BASE_URL", "https://integrate.api.nvidia.com/v1")
-# Официальный Florence-2 VLM endpoint (NIM API)
 NV_VLM_URL = os.environ.get("NV_VLM_URL", "https://ai.api.nvidia.com/v1/vlm/microsoft/florence-2")
-# Эндпоинт загрузки ассетов (NVCF assets)
 NVCF_ASSETS_URL = "https://api.nvcf.nvidia.com/v2/nvcf/assets"
 
 if not NV_API_KEY:
-    raise RuntimeError(
-        "NV_API_KEY не задан. В Hugging Face Space зайди в Settings → Secrets и добавь NV_API_KEY."
-    )
+    raise RuntimeError("NV_API_KEY не задан. В HF Space: Settings → Secrets → NV_API_KEY")
 
-# OpenAI-совместимый клиент для LLM (NVIDIA Integrate)
 llm = OpenAI(base_url=NV_BASE_URL, api_key=NV_API_KEY)
 
-# --------------------- Florence-2: задачи ---------------------
-# Отображаемые названия -> токены задач Florence-2
-FLORENCE_TASKS = [
-    ("Caption", "<CAPTION>"),
-    ("Detailed Caption", "<DETAILED_CAPTION>"),
-    ("More Detailed Caption", "<MORE_DETAILED_CAPTION>"),
-    ("Object Detection (OD)", "<OD>"),
-    ("Dense Region Caption", "<DENSE_REGION_CAPTION>"),
-    ("Region Proposal", "<REGION_PROPOSAL>"),
-    ("Caption to Phrase Grounding", "<CAPTION_TO_PHRASE_GROUNDING>"),
-    ("Referring Expression Segmentation", "<REFERRING_EXPRESSION_SEGMENTATION>"),
-    ("Region to Segmentation", "<REGION_TO_SEGMENTATION>"),
-    ("Open Vocabulary Detection", "<OPEN_VOCABULARY_DETECTION>"),
-    ("Region to Category", "<REGION_TO_CATEGORY>"),
-    ("Region to Description", "<REGION_TO_DESCRIPTION>"),
-    ("OCR", "<OCR>"),
-    ("OCR with Region", "<OCR_WITH_REGION>"),
-]
-TASK_LABEL_TO_TOKEN = {label: token for (label, token) in FLORENCE_TASKS}
-
-# Какие задачи требуют текстовую подсказку
-TEXT_REQUIRED_TASKS = {
-    "<CAPTION_TO_PHRASE_GROUNDING>",
-    "<REFERRING_EXPRESSION_SEGMENTATION>",
-    "<OPEN_VOCABULARY_DETECTION>",
-}
-# Какие задачи требуют регион (нормализованные 0..999 координаты)
-REGION_REQUIRED_TASKS = {
-    "<REGION_TO_SEGMENTATION>",
-    "<REGION_TO_CATEGORY>",
-    "<REGION_TO_DESCRIPTION>",
-    "<OCR_WITH_REGION>",
-}
-
-# --------------------- Вспомогательные функции ---------------------
-def guess_mime_from_path(path: str) -> str:
-    mime, _ = mimetypes.guess_type(path)
-    if mime is None:
-        # По умолчанию JPEG
-        return "image/jpeg"
-    return mime
+# --------------------- Florence-2 utils ---------------------
+def _guess_mime(path: str) -> str:
+    return mimetypes.guess_type(path)[0] or "image/jpeg"
 
-def nvcf_upload_asset(image_path: str, description: str = "User Image") -> str:
-    """
-    Загружает бинарный ассет (изображение) в NVCF и возвращает asset_id.
-    """
-    content_type = guess_mime_from_path(image_path)
-    auth_resp = requests.post(
+def nvcf_upload_asset(image_path: str, description: str = "Chat image") -> str:
+    # 1) авторизация на загрузку
+    auth = requests.post(
         NVCF_ASSETS_URL,
         headers={
             "Authorization": f"Bearer {NV_API_KEY}",
             "Content-Type": "application/json",
             "accept": "application/json",
         },
-        json={"contentType": content_type, "description": description},
+        json={"contentType": _guess_mime(image_path), "description": description},
         timeout=30,
     )
-    auth_resp.raise_for_status()
-    up_url = auth_resp.json().get("uploadUrl")
-    asset_id = str(auth_resp.json().get("assetId"))
-
+    auth.raise_for_status()
+    up_url = auth.json()["uploadUrl"]
+    asset_id = str(auth.json()["assetId"])
+    # 2) загрузка бинарника
     with open(image_path, "rb") as f:
-        put_resp = requests.put(
+        put = requests.put(
             up_url,
             data=f,
             headers={
                 "x-amz-meta-nvcf-asset-description": description,
-                "content-type": content_type,
+                "content-type": _guess_mime(image_path),
             },
             timeout=300,
         )
-    put_resp.raise_for_status()
+    put.raise_for_status()
     return asset_id
 
-def build_region_prompt(x1: int, y1: int, x2: int, y2: int) -> str:
-    """
-    Формат региона (нормализованные координаты 0..999):
-    <loc_x1><loc_y1><loc_x2><loc_y2>
-    """
-    for v in [x1, y1, x2, y2]:
-        if not (0 <= int(v) <= 999):
-            raise ValueError("Координаты должны быть в диапазоне 0..999")
-    return f"<loc_{int(x1)}><loc_{int(y1)}><loc_{int(x2)}><loc_{int(y2)}>"
-
-def build_vlm_content(
-    task_token: str,
-    asset_id: str,
-    text_prompt: Optional[str] = None,
-    region: Optional[Tuple[int, int, int, int]] = None,
-) -> str:
-    """
-    Собирает content-строку для Florence-2:
-    "<TASK_PROMPT><text_prompt (only when needed)><img>"
-    Для задач REGION_* вместо text_prompt подставляется формат координат.
-    """
-    parts = [task_token]
-    if region is not None:
-        parts.append(build_region_prompt(*region))
-    if (text_prompt is not None) and (text_prompt.strip()):
-        parts.append(text_prompt.strip())
-    parts.append(f'<img src="data:image/jpeg;asset_id,{asset_id}" />')
-    return "".join(parts)
-
-def call_florence_vlm(content: str, asset_id: str) -> Tuple[str, List[Image.Image], Dict[str, str]]:
+def _vlm_content_more_detailed_caption(asset_id: str) -> str:
+    # Формат: "<TASK_PROMPT><img>"
+    return f'<MORE_DETAILED_CAPTION><img src="data:image/jpeg;asset_id,{asset_id}" />'
+
+def _parse_vlm_response(resp: requests.Response) -> str:
     """
-    Вызывает Florence-2 VLM.
-    Возвращает: (primary_text, images_list, text_files_dict)
-      - primary_text: лучший извлечённый текстовый ответ/описание
-      - images_list: список PIL.Image (если вернуло изображения)
-      - text_files_dict: словарь {filename: text/json_str} из архива
+    Возвращает извлечённый текст (caption/ocr/description), если доступен.
+    Florence-2 может отдавать JSON или ZIP с файлами.
     """
-    payload = {"messages": [{"role": "user", "content": content}]}
-    headers = {
-        "Authorization": f"Bearer {NV_API_KEY}",
-        "Accept": "application/json, application/zip, */*",
-        "Content-Type": "application/json",
-        # Пробрасываем asset_id в заголовки:
-        "NVCF-INPUT-ASSET-REFERENCES": asset_id,
-        "NVCF-FUNCTION-ASSET-IDS": asset_id,
-    }
-
-    resp = requests.post(NV_VLM_URL, headers=headers, json=payload, timeout=300)
-    if not resp.ok:
-        # Попробуем дать более содержательное сообщение
-        try:
-            return f"[VLM HTTP {resp.status_code}] {resp.text}", [], {}
-        except Exception:
-            resp.raise_for_status()
-
     ct = (resp.headers.get("content-type") or "").lower()
     data = resp.content
 
-    # Хелперы для парсинга
-    def _extract_primary_from_json(obj: Any) -> Optional[str]:
-        # Рекурсивно ищем информативные текстовые значения
-        keys_priority = ["more_detailed_caption", "detailed_caption", "caption", "text", "ocr", "description"]
+    def extract_text_from_json(obj: Any) -> Optional[str]:
+        keys = ["more_detailed_caption", "detailed_caption", "caption", "text", "ocr", "description"]
         def walk(o):
-            results = []
+            res = []
             if isinstance(o, dict):
-                # приоритет по ключам
-                for k in keys_priority:
+                for k in keys:
                     if k in o and isinstance(o[k], str) and o[k].strip():
-                        results.append(o[k].strip())
-                # иначе рекурсивно
+                        res.append(o[k].strip())
                 for v in o.values():
-                    results.extend(walk(v))
+                    res.extend(walk(v))
             elif isinstance(o, list):
                 for it in o:
-                    results.extend(walk(it))
+                    res.extend(walk(it))
             elif isinstance(o, str):
                 if o.strip():
-                    results.append(o.strip())
-            return results
-
+                    res.append(o.strip())
+            return res
         arr = walk(obj)
         return arr[0] if arr else None
 
-    def _to_images_and_texts_from_zip(zbytes: bytes) -> Tuple[str, List[Image.Image], Dict[str, str]]:
-        images: List[Image.Image] = []
-        texts: Dict[str, str] = {}
-        primary_text: Optional[str] = None
-
-        with zipfile.ZipFile(io.BytesIO(zbytes), "r") as z:
-            for name in z.namelist():
-                try:
-                    with z.open(name) as f:
-                        raw = f.read()
-                except Exception:
-                    continue
-
-                lower = name.lower()
-                if lower.endswith((".png", ".jpg", ".jpeg", ".bmp", ".webp")):
-                    try:
-                        img = Image.open(io.BytesIO(raw)).convert("RGBA")
-                        images.append(img)
-                    except Exception:
-                        pass
-                elif lower.endswith(".json"):
-                    try:
-                        obj = json.loads(raw.decode("utf-8", errors="ignore"))
-                        texts[name] = json.dumps(obj, ensure_ascii=False, indent=2)
-                        if primary_text is None:
-                            cand = _extract_primary_from_json(obj)
-                            if cand:
-                                primary_text = cand
-                    except Exception:
-                        texts[name] = raw.decode("utf-8", errors="ignore")
-                elif lower.endswith(".txt"):
-                    txt = raw.decode("utf-8", errors="ignore").strip()
-                    texts[name] = txt
-                    if primary_text is None and txt:
-                        primary_text = txt
-
-        if primary_text is None:
-            # Если ничего "осмысленного" не нашли — соберём обзор
-            if texts:
-                primary_text = next(iter(texts.values()))
-            elif images:
-                primary_text = f"[Получено {len(images)} изображений-результатов]"
-            else:
-                primary_text = "[Результат пуст]"
-
-        return primary_text, images, texts
-
-    # Если JSON:
-    if "application/json" in ct and not (data[:2] == b"PK"):
+    # JSON
+    if "application/json" in ct and not data.startswith(b"PK"):
         try:
             obj = resp.json()
-            primary_text = _extract_primary_from_json(obj) or json.dumps(obj, ensure_ascii=False, indent=2)
-            return primary_text, [], {"response.json": json.dumps(obj, ensure_ascii=False, indent=2)}
+            return extract_text_from_json(obj) or json.dumps(obj, ensure_ascii=False)
         except Exception:
-            # fallback: попробовать как zip
             pass
 
-    # Иначе пробуем как ZIP
-    if data[:2] == b"PK" or "zip" in ct or "octet-stream" in ct:
-        return _to_images_and_texts_from_zip(data)
+    # ZIP
+    if data.startswith(b"PK") or "zip" in ct or "octet-stream" in ct:
+        try:
+            with zipfile.ZipFile(io.BytesIO(data), "r") as z:
+                primary = None
+                for name in z.namelist():
+                    with z.open(name) as f:
+                        raw = f.read()
+                    if name.lower().endswith(".json"):
+                        try:
+                            obj = json.loads(raw.decode("utf-8", errors="ignore"))
+                            primary = extract_text_from_json(obj) or primary
+                        except Exception:
+                            pass
+                    elif name.lower().endswith(".txt") and primary is None:
+                        txt = raw.decode("utf-8", errors="ignore").strip()
+                        if txt:
+                            primary = txt
+                return primary or "[Нет текстового результата]"
+        except Exception:
+            pass
 
-    # В самом худшем случае — отдать как текст
+    # Фоллбэк: текст
     try:
-        text = data.decode("utf-8", errors="ignore")
+        return data.decode("utf-8", errors="ignore")
     except Exception:
-        text = f"[Не удалось декодировать ответ: {len(data)} bytes]"
-    return text, [], {"raw.txt": text}
+        return "[Не удалось разобра��ь ответ Florence-2]"
 
-def florence_more_detailed_caption(image_path: str) -> Tuple[str, str]:
+def get_more_detailed_caption(image_path: str) -> Tuple[str, str]:
     """
-    Получает <MORE_DETAILED_CAPTION> для изображения.
-    Возвращает (caption_text, asset_id).
+    Возвращает (caption, asset_id) для заданного изображения.
     """
-    asset_id = nvcf_upload_asset(image_path, "Auto caption image")
-    content = build_vlm_content("<MORE_DETAILED_CAPTION>", asset_id)
-    caption_text, _, _ = call_florence_vlm(content, asset_id)
-    return caption_text, asset_id
+    asset_id = nvcf_upload_asset(image_path)
+    content = _vlm_content_more_detailed_caption(asset_id)
+    payload = {"messages": [{"role": "user", "content": content}]}
+    headers = {
+        "Authorization": f"Bearer {NV_API_KEY}",
+        "Accept": "application/json, application/zip, */*",
+        "Content-Type": "application/json",
+        "NVCF-INPUT-ASSET-REFERENCES": asset_id,
+        "NVCF-FUNCTION-ASSET-IDS": asset_id,
+    }
+    resp = requests.post(NV_VLM_URL, headers=headers, json=payload, timeout=300)
+    if not resp.ok:
+        raise RuntimeError(f"VLM HTTP {resp.status_code}: {resp.text}")
+    caption = _parse_vlm_response(resp)
+    return caption, asset_id
 
+# --------------------- LLM streaming utils ---------------------
 def _extract_text_from_stream_chunk(chunk: Any) -> str:
-    """
-    Универсально извлекает текстовые фрагменты из чанка стриминга LLM.
-    """
     try:
         if hasattr(chunk, "choices"):
             choices = getattr(chunk, "choices")
@@ -304,74 +178,105 @@ def _extract_text_from_stream_chunk(chunk: Any) -> str:
         pass
     return ""
 
-# --------------------- LLM чат ---------------------
-def chat_stream(image, user_message: str, history: Optional[List[List[str]]], caption_text: str):
+# --------------------- Чат-логика ---------------------
+def respond(
+    message: Dict[str, Any],
+    chat_history: List[List[str]],
+    last_caption: str,
+    last_asset_id: str
+):
     """
-    Основной generator для стриминга ответов LLM.
-    caption_text — подпись, сгенерированная Florence-2 на сервере.
+    message: MultimodalTextbox -> {"text": str, "files": [<paths or dicts>]}
+    Возвращает generator с потоковым ответом LLM.
     """
-    history = history or []
-
-    if not user_message:
-        yield history, (caption_text or "")
-        return
-
-    if not image:
-        history.append([user_message, "Пожалуйста, загрузите изображение или выберите из галереи."])
-        yield history, (caption_text or "")
-        return
-
-    caption = caption_text or ""
-
-    system_prompt = (
-        "You are 'multimodal gpt-oss 120b', a helpful multimodal assistant. "
-        "Use the provided 'More Detailed Caption' as authoritative visual context. "
-        "If something is not visible or certain, say so explicitly.\n\n"
-        "Image Caption START >>>\n"
-        f"{caption}\n"
-        "<<< Image Caption END.\n"
-        "Answer the user's question based on the caption and general knowledge. "
-        "Be concise unless asked for details."
-    )
-
-    history.append([user_message, ""])
-    yield history, caption
+    text = (message or {}).get("text", "") if isinstance(message, dict) else str(message or "")
+    files = (message or {}).get("files", []) if isinstance(message, dict) else []
+
+    def first_image_path(files) -> Optional[str]:
+        for f in files:
+            if isinstance(f, dict) and f.get("path"):
+                # gradio dict
+                mt = f.get("mime_type") or _guess_mime(f["path"])
+                if mt.startswith("image/"):
+                    return f["path"]
+            elif isinstance(f, str):
+                if _guess_mime(f).startswith("image/"):
+                    return f
+        return None
+
+    img_path = first_image_path(files)
+
+    # Сформируем видимое сообщение пользователя (эстетично и лаконично)
+    parts = []
+    if text and text.strip():
+        parts.append(text.strip())
+    if img_path:
+        parts.append("🖼️ [изображение]")
+    user_visible = "\n".join(parts) if parts else "🖐️"
+
+    chat_history = chat_history or []
+    chat_history.append([user_visible, ""])
+    yield {"text": "", "files": []}, chat_history, last_caption, last_asset_id
+
+    # Капшен изображения (если есть новое)
+    caption = last_caption or ""
+    asset_id = last_asset_id or ""
+    try:
+        if img_path:
+            caption, asset_id = get_more_detailed_caption(img_path)
+    except Exception as e:
+        caption = f"[Ошибка автокапшена: {e}]"
+
+    # Системный промпт
+    if caption:
+        system_prompt = (
+            "You are a helpful multimodal assistant.\n"
+            "Use the provided 'More Detailed Caption' as authoritative visual context.\n"
+            "If something is not visible or uncertain, say so.\n\n"
+            "Image Caption START >>>\n"
+            f"{caption}\n"
+            "<<< Image Caption END."
+        )
+    else:
+        system_prompt = (
+            "You are a helpful assistant. The user might have sent text-only message. "
+            "If they refer to an image but no caption is available, ask to attach an image."
+        )
 
+    # Стрим LLM
     assistant_accum = ""
     try:
         stream = llm.chat.completions.create(
             model="openai/gpt-oss-120b",
             messages=[
                 {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_message}
+                {"role": "user", "content": text or "Describe the attached image."}
             ],
-            temperature=0.8,
+            temperature=0.7,
             top_p=1.0,
-            max_tokens=1024,
+            max_tokens=768,
             stream=True,
         )
-
         for chunk in stream:
             piece = _extract_text_from_stream_chunk(chunk)
             if not piece:
                 continue
             assistant_accum += piece
-            history[-1][1] = assistant_accum
-            yield history, caption
+            chat_history[-1][1] = assistant_accum
+            yield {"text": "", "files": []}, chat_history, caption, asset_id
 
     except Exception as e:
-        print(f"Streaming error: {e}")
-        traceback.print_exc()
+        # Фоллбэк без стрима
         try:
             resp = llm.chat.completions.create(
                 model="openai/gpt-oss-120b",
                 messages=[
                     {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": user_message}
+                    {"role": "user", "content": text or "Describe the attached image."}
                 ],
-                temperature=0.8,
+                temperature=0.7,
                 top_p=1.0,
-                max_tokens=1024,
+                max_tokens=768,
                 stream=False,
             )
             final_text = ""
@@ -389,228 +294,81 @@ def chat_stream(image, user_message: str, history: Optional[List[List[str]]], ca
                     final_text = str(resp)
             else:
                 final_text = str(resp)
-            history[-1][1] = final_text
-            yield history, caption
+            chat_history[-1][1] = final_text
+            yield {"text": "", "files": []}, chat_history, caption, asset_id
         except Exception as e2:
-            history[-1][1] = f"[Ошибка LLM: {e2}]"
-            yield history, caption
-
-    yield history, caption
-
-# --------------------- UI вспомогательные колбэки ---------------------
-def on_image_change(image_path: Optional[str]):
-    """
-    При изменении изображения: считаем подпись Florence-2 (<MORE_DETAILED_CAPTION>).
-    Возвращаем: caption_text, asset_id, (width, height) — последние два в state.
-    """
-    if not image_path:
-        return gr.update(value=""), "", None
-    try:
-        caption, asset_id = florence_more_detailed_caption(image_path)
-        # Размеры изображения — могут пригодиться
-        try:
-            im = Image.open(image_path)
-            size = (im.width, im.height)
-        except Exception:
-            size = None
-        return caption, asset_id, size
-    except Exception as e:
-        return f"[Ошибка автокапшена: {e}]", "", None
-
-def update_task_inputs(selected_label: str):
-    """
-    Управляет видимостью полей text prompt / region по выбранной задаче.
-    """
-    token = TASK_LABEL_TO_TOKEN.get(selected_label, "")
-    need_text = token in TEXT_REQUIRED_TASKS
-    need_region = token in REGION_REQUIRED_TASKS
-
-    return (
-        gr.update(visible=need_text),            # text prompt
-        gr.update(visible=need_region),          # x1
-        gr.update(visible=need_region),          # y1
-        gr.update(visible=need_region),          # x2
-        gr.update(visible=need_region),          # y2
-        gr.update(visible=True),                 # run button
-    )
-
-def run_florence_task(
-    image_path: Optional[str],
-    asset_id: str,
-    selected_label: str,
-    text_prompt: str,
-    x1: int, y1: int, x2: int, y2: int
-):
-    """
-    Запуск произвольной задачи Florence-2 на текущем изображении.
-    Возвращает: галерея изображений, текстовый результат.
-    """
-    if not image_path:
-        return [], "[Ошибка] Загрузите изображение."
-    try:
-        token = TASK_LABEL_TO_TOKEN.get(selected_label, "<MORE_DETAILED_CAPTION>")
-
-        # Если asset_id пуст — загрузим прямо сейчас
-        if not asset_id:
-            asset_id = nvcf_upload_asset(image_path, f"Task: {selected_label}")
-
-        region = None
-        if token in REGION_REQUIRED_TASKS:
-            region = (int(x1), int(y1), int(x2), int(y2))
-
-        # Для задач, где текст обязателен, пустую строку лучше не подставлять
-        effective_text = text_prompt if (token in TEXT_REQUIRED_TASKS) else None
-
-        content = build_vlm_content(token, asset_id, text_prompt=effective_text, region=region)
-        primary_text, imgs, texts = call_florence_vlm(content, asset_id)
-
-        # Галерея изображений: список (numpy/PIL/urls) — PIL подходит
-        gallery_items = imgs
+            chat_history[-1][1] = f"[Ошибка LLM: {e2}]"
+            yield {"text": "", "files": []}, chat_history, caption, asset_id
+
+# --------------------- Интерфейс ---------------------
+messenger_css = """
+:root {
+  --radius-xl: 16px;
+  --radius-lg: 14px;
+}
+.gradio-container { max-width: 800px !important; margin: auto; }
+#title { text-align: center; padding: 8px 0 10px; font-size: 20px; }
+#chat-wrap { border: 1px solid rgba(0,0,0,0.06); border-radius: var(--radius-xl); overflow: hidden; }
+#chat { height: 560px; }
+#bottom-bar { position: sticky; bottom: 0; background: var(--body-background-fill); border-top: 1px solid rgba(0,0,0,0.06); padding: 8px; display: flex; gap: 8px; align-items: center; }
+#send { min-width: 44px; max-width: 44px; height: 44px; border-radius: 999px; }
+#msg .mm-wrap { border: 1px solid rgba(0,0,0,0.08); border-radius: 999px; }
+.gr-chatbot { border-radius: 0 !important; }
+.gr-chatbot .wrap.svelte-1cl0v3x { padding: 12px !important; } /* мягкие отступы (селектор может отличаться по версии) */
+"""
 
-        # Сформируем сводный текст
-        dump_parts = [f"# Task: {selected_label} ({token})", f"## Content:\n{content}\n", "## Primary text:\n" + str(primary_text)]
-        if texts:
-            dump_parts.append("## Files:")
-            for k, v in texts.items():
-                dump_parts.append(f"\n--- {k} ---\n{v}")
-        result_text = "\n".join(dump_parts)
+theme = gr.themes.Soft(
+    primary_hue="cyan",
+    neutral_hue="slate",
+).set(
+    body_text_color_subdued="#6b7280",
+    button_large_radius="999px",
+    button_small_radius="999px",
+    block_radius="16px",
+)
 
-        return gallery_items, result_text
+with gr.Blocks(theme=theme, css=messenger_css, analytics_enabled=False) as demo:
+    gr.Markdown("✨ <div id='title'>Элегантный визуальный чат</div>")
 
-    except Exception as e:
-        return [], f"[Ошибка Florence-2: {e}]"
-
-# --------------------- Примеры для галереи ---------------------
-EXAMPLE_IMAGES = [
-    "https://raw.githubusercontent.com/gradio-app/gradio/main/test/test_files/bus.png",
-    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/cats.png",
-    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/cheetah.jpg",
-    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/flowers.png",
-]
-
-# --------------------- UI ---------------------
-css = """
-.gradio-container { max-width: 1100px; margin: auto; }
-#title { text-align: center; }
-"""
+    caption_state = gr.State(value="")
+    asset_state = gr.State(value="")
 
-with gr.Blocks(css=css, analytics_enabled=False) as demo:
-    gr.Markdown("<h2 id='title'>🖼️ multimodal gpt-oss 120b — визуальный чат (Florence-2 через NIM API, без WebGPU)</h2>")
+    with gr.Group(elem_id="chat-wrap"):
+        chatbot = gr.Chatbot(
+            label="",
+            height=560,
+            elem_id="chat"
+        )
 
-    # Состояние: asset_id и размер картинки
-    asset_state = gr.State(value="")
-    img_size_state = gr.State(value=None)
-
-    with gr.Row():
-        with gr.Column(scale=4):
-            image_input = gr.Image(label="Загрузите картинку", type="filepath")
-            raw_caption = gr.Textbox(
-                label="More Detailed Caption (серверный Florence-2)",
-                interactive=True,
-                lines=6,
-                placeholder="Подпись появится тут (серверный Florence-2)"
-            )
-            user_input = gr.Textbox(
-                label="Вопрос по изображению",
-                placeholder="Например: Что происходит на фото?"
-            )
-            with gr.Row():
-                send_btn = gr.Button("Отправить", variant="primary")
-                clear_btn = gr.Button("Очистить чат")
-
-            gr.Markdown("Галерея примеров (клик — подставить в загрузчик, подпись посчитается на сервере)")
-            gallery = gr.Gallery(
-                value=EXAMPLE_IMAGES,
-                label="Примеры",
-                columns=4,
-                rows=1,
+        # Нижняя компактная строка ввода с маленькой кнопкой вложений внутри
+        with gr.Row(elem_id="bottom-bar"):
+            msg = gr.MultimodalTextbox(
                 show_label=False,
-                height="auto",
-                object_fit="contain"
+                placeholder="Напишите сообщение... (иконка слева — добавить изображение)",
+                elem_id="msg",
             )
+            send = gr.Button("➤", variant="primary", elem_id="send")
 
-            with gr.Accordion("Florence-2: 14 задач", open=False):
-                task_dropdown = gr.Dropdown(
-                    choices=[label for (label, _) in FLORENCE_TASKS],
-                    value="More Detailed Caption",
-                    label="Задача Florence-2",
-                )
-                task_text_prompt = gr.Textbox(
-                    label="Text prompt (для некоторых задач)",
-                    placeholder="Например: a black and brown dog",
-                    visible=False
-                )
-                with gr.Row():
-                    x1_in = gr.Slider(0, 999, step=1, value=100, label="x1 (0..999)", visible=False)
-                    y1_in = gr.Slider(0, 999, step=1, value=100, label="y1 (0..999)", visible=False)
-                    x2_in = gr.Slider(0, 999, step=1, value=800, label="x2 (0..999)", visible=False)
-                    y2_in = gr.Slider(0, 999, step=1, value=800, label="y2 (0..999)", visible=False)
-                run_task_btn = gr.Button("Запустить задачу", visible=True)
-                task_gallery = gr.Gallery(label="Результирующие изображения", columns=3, height=320)
-                task_text_out = gr.Textbox(label="Результат (JSON/TXT)", lines=16)
-
-        with gr.Column(scale=6):
-            chatbot = gr.Chatbot(label="Чат с моделью", height=640)
-
-    # Галерея: выбор примера → подставляем URL в загрузчик
-    def on_gallery_select(evt: gr.SelectData):
-        img = EXAMPLE_IMAGES[evt.index]
-        # обнуляем caption и состояние
-        return img, "", "", None
-
-    gallery.select(
-        on_gallery_select,
-        inputs=None,
-        outputs=[image_input, raw_caption, asset_state, img_size_state]
+    # Отправка по Enter и по кнопке
+    msg.submit(
+        respond,
+        inputs=[msg, chatbot, caption_state, asset_state],
+        outputs=[msg, chatbot, caption_state, asset_state]
     )
-
-    # Изменение картинки: автогенерация подписи Florence-2 на сервере
-    image_input.change(
-        on_image_change,
-        inputs=[image_input],
-        outputs=[raw_caption, asset_state, img_size_state]
-    )
-
-    # Изменение выбора задачи → показать/скрыть поля
-    task_dropdown.change(
-        update_task_inputs,
-        inputs=[task_dropdown],
-        outputs=[task_text_prompt, x1_in, y1_in, x2_in, y2_in, run_task_btn]
+    send.click(
+        respond,
+        inputs=[msg, chatbot, caption_state, asset_state],
+        outputs=[msg, chatbot, caption_state, asset_state]
     )
 
-    # Запуск произвольной задачи Florence-2
-    run_task_btn.click(
-        run_florence_task,
-        inputs=[image_input, asset_state, task_dropdown, task_text_prompt, x1_in, y1_in, x2_in, y2_in],
-        outputs=[task_gallery, task_text_out]
-    )
-
-    # Отправка сообщения в чат
-    send_btn.click(
-        chat_stream,
-        inputs=[image_input, user_input, chatbot, raw_caption],
-        outputs=[chatbot, raw_caption]
-    )
-    user_input.submit(
-        chat_stream,
-        inputs=[image_input, user_input, chatbot, raw_caption],
-        outputs=[chatbot, raw_caption]
-    )
-
-    # Очистка чата + подписи
+    # Очистка
     def clear_all():
-        return [], "", ""
-
-    clear_btn.click(
+        return {"text": "", "files": []}, [], "", ""
+    gr.Button("Очистить", variant="secondary").click(
         clear_all,
         inputs=None,
-        outputs=[chatbot, raw_caption, user_input]
+        outputs=[msg, chatbot, caption_state, asset_state]
     )
 
-# Запуск
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=int(os.environ.get("PORT", 7860)),
-        share=False
-    )
+    demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)), share=False)