Update app.py

app.py

@@ -1,37 +1,282 @@
 #!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 """
-multimodal gpt-oss 120b — Gradio app: Florence в браузере (WebGPU), LLM через NVIDIA Integrate
-
-- Подпись к изображению генерится на клиенте (Transformers.js + WebGPU / wasm фоллбэк).
-- Сервер НЕ грузит torch/Florence.
-- LLM-стриминг как раньше (openai/gpt-oss-120b).
+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 + галерея изображений результатов (если модель вернёт предикты-изображения).
 """
 
 import os
+import io
+import json
+import time
 import traceback
-from typing import Any, Optional, List
+import zipfile
+import mimetypes
+from typing import Any, Dict, List, Optional, Tuple
+
+import requests
 import gradio as gr
+from PIL import Image
 from openai import OpenAI
 
-# (опционально) локальный .env при локальном запуске
-try:
-    from dotenv import load_dotenv
-    load_dotenv()
-except Exception:
-    pass
-
 # --------------------- Конфигурация ---------------------
 NV_API_KEY = os.environ.get("NV_API_KEY")  # ОБЯЗАТЕЛЬНО прописать в Secrets HF Spaces
 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."
     )
 
-# OpenAI совместимый клиент для LLM
+# 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
+
+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(
+        NVCF_ASSETS_URL,
+        headers={
+            "Authorization": f"Bearer {NV_API_KEY}",
+            "Content-Type": "application/json",
+            "accept": "application/json",
+        },
+        json={"contentType": content_type, "description": description},
+        timeout=30,
+    )
+    auth_resp.raise_for_status()
+    up_url = auth_resp.json().get("uploadUrl")
+    asset_id = str(auth_resp.json().get("assetId"))
+
+    with open(image_path, "rb") as f:
+        put_resp = requests.put(
+            up_url,
+            data=f,
+            headers={
+                "x-amz-meta-nvcf-asset-description": description,
+                "content-type": content_type,
+            },
+            timeout=300,
+        )
+    put_resp.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]]:
+    """
+    Вызывает Florence-2 VLM.
+    Возвращает: (primary_text, images_list, text_files_dict)
+      - primary_text: лучший извлечённый текстовый ответ/описание
+      - images_list: список PIL.Image (если вернуло изображения)
+      - text_files_dict: словарь {filename: text/json_str} из архива
+    """
+    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 walk(o):
+            results = []
+            if isinstance(o, dict):
+                # приоритет по ключам
+                for k in keys_priority:
+                    if k in o and isinstance(o[k], str) and o[k].strip():
+                        results.append(o[k].strip())
+                # иначе рекурсивно
+                for v in o.values():
+                    results.extend(walk(v))
+            elif isinstance(o, list):
+                for it in o:
+                    results.extend(walk(it))
+            elif isinstance(o, str):
+                if o.strip():
+                    results.append(o.strip())
+            return results
+
+        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"):
+        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)}
+        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)
+
+    # В самом худшем случае — отдать как текст
+    try:
+        text = data.decode("utf-8", errors="ignore")
+    except Exception:
+        text = f"[Не удалось декодировать ответ: {len(data)} bytes]"
+    return text, [], {"raw.txt": text}
+
+def florence_more_detailed_caption(image_path: str) -> Tuple[str, str]:
+    """
+    Получает <MORE_DETAILED_CAPTION> для изображения.
+    Возвращает (caption_text, 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
 
 def _extract_text_from_stream_chunk(chunk: Any) -> str:
     """
@@ -59,11 +304,11 @@ 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):
     """
     Основной generator для стриминга ответов LLM.
-    Теперь caption_text приходит напрямую из браузера (WebGPU/wasm).
+    caption_text — подпись, сгенерированная Florence-2 на сервере.
     """
     history = history or []
 
@@ -152,6 +397,88 @@ def chat_stream(image, user_message: str, history: Optional[List[List[str]]], ca
 
     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
+
+        # Сформируем сводный текст
+        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)
+
+        return gallery_items, result_text
+
+    except Exception as e:
+        return [], f"[Ошибка Florence-2: {e}]"
 
 # --------------------- Примеры для галереи ---------------------
 EXAMPLE_IMAGES = [
@@ -167,169 +494,31 @@ css = """
 #title { text-align: center; }
 """
 
-# JS: надёжная загрузка Transformers.js (ESM → UMD → локальный), WebGPU/wasm, Florence-2 large→base
-WEBGPU_CAPTION_JS = r"""
-async (image, use_client) => {
-  const loadWithScript = (url) => new Promise((res, rej) => {
-    const s = document.createElement('script');
-    s.src = url; s.async = true;
-    s.onload = () => res();
-    s.onerror = (e) => rej(e);
-    document.head.appendChild(s);
-  });
-
-  const loadTransformers = async () => {
-    // 1) ESM: несколько CDN
-    const esms = [
-      'https://cdn.jsdelivr.net/npm/@xenova/[email protected]',
-      'https://cdn.jsdelivr.net/npm/@xenova/[email protected]?module',
-      'https://unpkg.com/@xenova/[email protected]?module',
-      'https://esm.run/@xenova/[email protected]',
-    ];
-    for (const url of esms) {
-      try { return await import(url); }
-      catch (e) { console.warn('ESM import failed:', url, e); }
-    }
-    // 2) UMD: глобальная window.transformers
-    const umds = [
-      'https://cdn.jsdelivr.net/npm/@xenova/[email protected]/dist/transformers.min.js',
-      'https://unpkg.com/@xenova/[email protected]/dist/transformers.min.js',
-      // локальный фоллбэк (если положите файл в репозиторий)
-      '/file=assets/transformers-3.2.2.min.js',
-    ];
-    for (const url of umds) {
-      try {
-        await loadWithScript(url);
-        if (window.transformers) return window.transformers;
-      } catch (e) { console.warn('UMD load failed:', url, e); }
-    }
-    throw new Error('Transformers.js: все CDN/UMD источники недоступны');
-  };
-
-  try {
-    if (!use_client) return null;
-
-    // WebGPU наличие
-    const hasWebGPU = 'gpu' in navigator;
-    if (!hasWebGPU) {
-      console.warn('WebGPU недоступен, будет попытка wasm-фоллбэка.');
-    }
-
-    const toHTMLImage = async (imgVal) => {
-      if (!imgVal) throw new Error("Нет изображения");
-      let src = null;
-      if (typeof imgVal === 'string') src = imgVal;
-      else if (imgVal?.image) src = imgVal.image;
-      else if (imgVal?.data) src = imgVal.data;
-      if (!src) throw new Error("Не удалось прочитать изображение");
-      const im = new Image();
-      im.crossOrigin = 'anonymous';
-      im.src = src;
-      await im.decode();
-      return im;
-    };
-
-    const tjs = await loadTransformers();
-    const pipeline = tjs.pipeline ?? tjs?.default?.pipeline;
-    const env = tjs.env ?? tjs?.default?.env;
-    if (!pipeline || !env) throw new Error("Transformers.js загрузился без pipeline/env");
-
-    // Настройка бэкенда и кэша
-    env.allowRemoteModels = true;
-    env.useBrowserCache = true;
-    env.backends ??= {};
-    env.backends.onnx ??= {};
-    // Путь к wasm-артефактам (на всякий)
-    env.backends.onnx.wasm ??= {};
-    env.backends.onnx.wasm.wasmPaths = 'https://cdn.jsdelivr.net/npm/@xenova/[email protected]/dist/wasm/';
-    env.backends.onnx.wasm.numThreads = 1;
-
-    // Пробуем WebGPU, fallback → wasm
-    let backend = 'webgpu';
-    if (!hasWebGPU) backend = 'wasm';
-
-    // Инициализация captioner (один раз)
-    if (!window.__web_captioner || window.__web_captioner_backend !== backend) {
-      const candidates = backend === 'webgpu'
-        ? ['Xenova/Florence-2-large-ft', 'Xenova/Florence-2-base-ft']
-        : ['Xenova/Florence-2-base-ft'];
-
-      let lastErr = null;
-      for (const model of candidates) {
-        try {
-          if (backend === 'webgpu') {
-            env.backends.onnx.backend = 'webgpu';
-            window.__web_captioner = await pipeline(
-              'image-to-text', model,
-              { device: 'webgpu', dtype: 'fp16', quantized: true }
-            );
-          } else {
-            env.backends.onnx.backend = 'wasm';
-            window.__web_captioner = await pipeline(
-              'image-to-text', model,
-              { device: 'wasm', quantized: true }
-            );
-          }
-          window.__web_captioner_backend = backend;
-          break;
-        } catch (e) {
-          lastErr = e;
-          console.warn(`Init failed (${backend}) for ${model}`, e);
-        }
-      }
-      if (!window.__web_captioner) {
-        // Последняя попытка: если WebGPU падал — откат на wasm
-        if (backend === 'webgpu') {
-          try {
-            env.backends.onnx.backend = 'wasm';
-            window.__web_captioner = await pipeline(
-              'image-to-text', 'Xenova/Florence-2-base-ft',
-              { device: 'wasm', quantized: true }
-            );
-            window.__web_captioner_backend = 'wasm';
-          } catch (e2) {
-            throw lastErr || e2;
-          }
-        } else {
-          throw lastErr || new Error('Не удалось инициализировать captioner');
-        }
-      }
-    }
-
-    const imgEl = await toHTMLImage(image);
-    const out = await window.__web_captioner(imgEl, { text: '<MORE_DETAILED_CAPTION>' });
-    const text = Array.isArray(out)
-      ? (out[0]?.generated_text ?? out[0]?.text ?? JSON.stringify(out[0]))
-      : (out?.generated_text ?? out?.text ?? String(out));
-    return text;
-  } catch (e) {
-    return `[WebGPU caption error: ${e?.message || e}]`;
-  }
-}
-"""
-
 with gr.Blocks(css=css, analytics_enabled=False) as demo:
-    gr.Markdown("<h2 id='title'>🖼️ multimodal gpt-oss 120b — визуальный чат (Florence в браузере / WebGPU)</h2>")
+    gr.Markdown("<h2 id='title'>🖼️ multimodal gpt-oss 120b — визуальный чат (Florence-2 через NIM API, без WebGPU)</h2>")
+
+    # Состояние: 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")
-            use_webgpu = gr.Checkbox(value=True, label="Генерировать подпись к изображению в браузере (WebGPU/wasm)")
             raw_caption = gr.Textbox(
-                label="More Detailed Caption (клиентский Florence-2)", 
+                label="More Detailed Caption (серверный Florence-2)",
                 interactive=True,
                 lines=6,
-                placeholder="Подпись появится тут (WebGPU/wasm)"
+                placeholder="Подпись появится тут (серверный Florence-2)"
             )
             user_input = gr.Textbox(
-                label="Вопрос по изображению", 
+                label="Вопрос по изображению",
                 placeholder="Например: Что происходит на фото?"
             )
             with gr.Row():
                 send_btn = gr.Button("Отправить", variant="primary")
                 clear_btn = gr.Button("Очистить чат")
 
-            gr.Markdown("Галерея примеров (клик — подставить в загрузчик, подпись посчитается на клиенте)")
+            gr.Markdown("Галерея примеров (клик — подставить в загрузчик, подпись посчитается на сервере)")
             gallery = gr.Gallery(
                 value=EXAMPLE_IMAGES,
                 label="Примеры",
@@ -340,37 +529,63 @@ with gr.Blocks(css=css, analytics_enabled=False) as demo:
                 object_fit="contain"
             )
 
+            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)
 
-    # Клик по галерее: подставить изображение и очистить подпись (капшенер сработает на change)
+    # Галерея: выбор примера → подставляем URL в загрузчик
     def on_gallery_select(evt: gr.SelectData):
         img = EXAMPLE_IMAGES[evt.index]
-        return img, ""
+        # обнуляем caption и состояние
+        return img, "", "", None
 
     gallery.select(
         on_gallery_select,
         inputs=None,
-        outputs=[image_input, raw_caption]
+        outputs=[image_input, raw_caption, asset_state, img_size_state]
     )
 
-    # Изменение картинки: считаем подпись на клиенте (WebGPU/wasm)
+    # Изменение картинки: автогенерация подписи Florence-2 на сервере
     image_input.change(
-        None,
-        inputs=[image_input, use_webgpu],
-        outputs=[raw_caption],
-        js=WEBGPU_CAPTION_JS
+        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]
     )
 
-    # Переключение флажка: если включили — пересчитать подпись; если выключили — очистить
-    use_webgpu.change(
-        None,
-        inputs=[image_input, use_webgpu],
-        outputs=[raw_caption],
-        js=WEBGPU_CAPTION_JS
+    # Запуск произвольной задачи 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]
     )
 
-    # Отправка сообщения: берём caption прямо из текстбокса (клиентский Florence)
+    # Отправка сообщения в чат
     send_btn.click(
         chat_stream,
         inputs=[image_input, user_input, chatbot, raw_caption],