Update app.py

app.py

@@ -7,6 +7,7 @@ import os
 import re
 import subprocess
 import sys
+import tempfile
 import time
 from functools import lru_cache
 from pathlib import Path
@@ -29,32 +30,67 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 ERROR_PREFIX = "ОШИБКА:"
 
 GROQ_TEXT_MODEL = os.getenv("GROQ_TEXT_MODEL", "llama-3.1-8b-instant")
-GROQ_FINAL_MODEL = os.getenv("GROQ_FINAL_MODEL", "llama-3.1-8b-instant")
-GROQ_STRONG_MODEL = os.getenv("GROQ_STRONG_MODEL", GROQ_TEXT_MODEL)
-GROQ_RESEARCH_MODEL = os.getenv("GROQ_RESEARCH_MODEL", GROQ_TEXT_MODEL)
-GROQ_VISION_MODEL = os.getenv("GROQ_VISION_MODEL", "meta-llama/llama-4-scout-17b-16e-instruct")
+GROQ_VISION_MODEL = os.getenv(
+    "GROQ_VISION_MODEL", "meta-llama/llama-4-scout-17b-16e-instruct"
+)
 GROQ_AUDIO_MODEL = os.getenv("GROQ_AUDIO_MODEL", "whisper-large-v3-turbo")
 
 GAIA_DIR = os.getenv("GAIA_DIR", "./data/gaia")
-ALLOW_CODE_EXECUTION = os.getenv("ALLOW_CODE_EXECUTION", "1").lower() not in {"0", "false", "no"}
-ENABLE_RESEARCH_RETRY = os.getenv("ENABLE_RESEARCH_RETRY", "0").lower() in {"1", "true", "yes"}
+ALLOW_CODE_EXECUTION = os.getenv("ALLOW_CODE_EXECUTION", "1").lower() not in {
+    "0",
+    "false",
+    "no",
+}
+ENABLE_RESEARCH_RETRY = os.getenv("ENABLE_RESEARCH_RETRY", "0").lower() in {
+    "1",
+    "true",
+    "yes",
+}
 
 MAX_CONTEXT_CHARS = int(os.getenv("MAX_CONTEXT_CHARS", "9000"))
 MAX_SEARCH_CONTEXT_CHARS = int(os.getenv("MAX_SEARCH_CONTEXT_CHARS", "7000"))
 SEARCH_RESULTS_PER_QUERY = int(os.getenv("SEARCH_RESULTS_PER_QUERY", "4"))
 SEARCH_FETCH_LIMIT = int(os.getenv("SEARCH_FETCH_LIMIT", "2200"))
+YOUTUBE_MAX_BYTES = int(os.getenv("YOUTUBE_MAX_BYTES", str(24 * 1024 * 1024)))
+YOUTUBE_FRAME_COUNT = int(os.getenv("YOUTUBE_FRAME_COUNT", "8"))
 
 IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"}
-AUDIO_VIDEO_EXTS = {".mp3", ".wav", ".m4a", ".flac", ".ogg", ".webm", ".mp4", ".mov", ".mkv"}
+AUDIO_VIDEO_EXTS = {
+    ".mp3",
+    ".wav",
+    ".m4a",
+    ".flac",
+    ".ogg",
+    ".webm",
+    ".mp4",
+    ".mov",
+    ".mkv",
+}
 SPREADSHEET_EXTS = {".xlsx", ".xls"}
 PDF_EXTS = {".pdf"}
 CODE_EXTS = {".py", ".js", ".ts", ".java", ".cpp", ".c", ".rb", ".go", ".rs"}
-TEXT_EXTS = {".txt", ".md", ".csv", ".json", ".xml", ".html", ".htm", ".yaml", ".yml"} | CODE_EXTS
-
-logging.basicConfig(level=os.getenv("LOG_LEVEL", "INFO").upper(), format="%(message)s")
-logger = logging.getLogger("gaia-space-agent")
-for noisy_logger in ("httpx", "httpcore", "ddgs", "duckduckgo_search", "primp"):
-    logging.getLogger(noisy_logger).setLevel(logging.WARNING)
+TEXT_EXTS = {
+    ".txt",
+    ".md",
+    ".csv",
+    ".json",
+    ".xml",
+    ".html",
+    ".htm",
+    ".yaml",
+    ".yml",
+} | CODE_EXTS
+
+for noisy_logger in (
+    "openai",
+    "groq",
+    "httpx",
+    "httpcore",
+    "ddgs",
+    "duckduckgo_search",
+    "primp",
+):
+    logging.getLogger(noisy_logger).setLevel(logging.ERROR)
 
 
 def error_text(message: str, exc: Exception | None = None) -> str:
@@ -83,14 +119,15 @@ def get_task_file_map() -> dict[str, str]:
     validation_dir = Path(GAIA_DIR) / "2023" / "validation"
 
     if not validation_dir.exists():
-        logger.warning("Папка с validation-файлами GAIA не найдена: %s", validation_dir)
+        print(
+            f"Папка с validation-файлами GAIA не найдена: {validation_dir}", flush=True
+        )
         return result
 
     for path in validation_dir.rglob("*"):
         if path.is_file() and path.suffix.lower() != ".parquet":
             result[path.stem] = str(path)
 
-    logger.info("Найдено локальных файлов GAIA: %s (%s)", len(result), validation_dir)
     return result
 
 
@@ -183,9 +220,14 @@ def analyze_image(task_id: str, question: str = "") -> str:
         return error_text(f"не удалось открыть изображение для task_id={task_id}", exc)
 
     if not is_image(content_type, data):
-        return error_text(f"файл task_id={task_id} не похож на изображение, content_type={content_type}")
+        return error_text(
+            f"файл task_id={task_id} не похож на изображение, content_type={content_type}"
+        )
 
-    prompt = question or "Describe the image. Extract all visible text, numbers, symbols, and key details."
+    prompt = (
+        question
+        or "Describe the image. Extract all visible text, numbers, symbols, and key details."
+    )
     if "chess" in prompt.lower():
         prompt += (
             "\n\nThis is a chess task. Identify board coordinates, side to move, relevant pieces, "
@@ -219,6 +261,30 @@ def analyze_image(task_id: str, question: str = "") -> str:
         return error_text("ошибка vision-модели", exc)
 
 
+def transcribe_media_bytes(data: bytes, filename: str, content_type: str) -> str:
+    client = get_groq_client()
+    audio_file = (
+        filename,
+        io.BytesIO(data),
+        content_type or "application/octet-stream",
+    )
+    transcription = client.audio.transcriptions.create(
+        file=audio_file,
+        model=GROQ_AUDIO_MODEL,
+        response_format="text",
+    )
+    return str(transcription).strip()
+
+
+def transcribe_media_file(path: Path) -> str:
+    content_type, _ = mimetypes.guess_type(str(path))
+    return transcribe_media_bytes(
+        path.read_bytes(),
+        path.name,
+        content_type or "application/octet-stream",
+    )
+
+
 @tool
 def transcribe_audio(task_id: str) -> str:
     """Transcribe the GAIA audio or video file attached to a task and return the transcript."""
@@ -226,24 +292,18 @@ def transcribe_audio(task_id: str) -> str:
         data, content_type = fetch_task_bytes(task_id)
         local_path = get_task_file(task_id) or ""
     except Exception as exc:
-        return error_text(f"не удалось открыть аудио или видео для task_id={task_id}", exc)
+        return error_text(
+            f"не удалось открыть аудио или видео для task_id={task_id}", exc
+        )
 
     if not is_audio_or_video(content_type, local_path):
-        return error_text(f"файл task_id={task_id} не похож на аудио или видео, content_type={content_type}")
-
-    suffix = Path(local_path).suffix.lower().lstrip(".") or "mp3"
-    if suffix == "mpeg":
-        suffix = "mp3"
+        return error_text(
+            f"файл task_id={task_id} не похож на аудио или видео, content_type={content_type}"
+        )
 
     try:
-        client = get_groq_client()
-        audio_file = (f"audio.{suffix}", io.BytesIO(data), content_type or f"audio/{suffix}")
-        transcription = client.audio.transcriptions.create(
-            file=audio_file,
-            model=GROQ_AUDIO_MODEL,
-            response_format="text",
-        )
-        return str(transcription).strip()
+        filename = Path(local_path).name or "audio.mp3"
+        return transcribe_media_bytes(data, filename, content_type)
     except Exception as exc:
         return error_text("ошибка транскрибации аудио", exc)
 
@@ -289,7 +349,9 @@ def read_pdf_context(path: Path) -> str:
         try:
             text = page.extract_text() or ""
         except Exception as exc:
-            text = f"[ошибка извлечения текста со страницы: {type(exc).__name__}: {exc}]"
+            text = (
+                f"[ошибка извлечения текста со страницы: {type(exc).__name__}: {exc}]"
+            )
         parts.append(f"\n--- Page {index} ---\n{text}")
         if len("\n".join(parts)) > MAX_CONTEXT_CHARS:
             break
@@ -347,14 +409,20 @@ def build_spreadsheet_summary(path: Path) -> str:
         try:
             df = pd.read_excel(path, sheet_name=sheet_name)
         except Exception as exc:
-            parts.append(f"Sheet: {sheet_name}\n[ошибка чтения листа: {type(exc).__name__}: {exc}]")
+            parts.append(
+                f"Sheet: {sheet_name}\n[ошибка чтения листа: {type(exc).__name__}: {exc}]"
+            )
             continue
         if df.empty:
             continue
 
         work = df.copy()
         work.columns = [str(column).strip() for column in work.columns]
-        numeric_cols = [column for column in work.columns if pd.api.types.is_numeric_dtype(work[column])]
+        numeric_cols = [
+            column
+            for column in work.columns
+            if pd.api.types.is_numeric_dtype(work[column])
+        ]
         categorical_cols = [
             column
             for column in work.columns
@@ -363,14 +431,18 @@ def build_spreadsheet_summary(path: Path) -> str:
 
         parts.append(f"Sheet: {sheet_name}")
         if numeric_cols:
-            totals = work[numeric_cols].sum(numeric_only=True).sort_values(ascending=False)
+            totals = (
+                work[numeric_cols].sum(numeric_only=True).sort_values(ascending=False)
+            )
             parts.append("Numeric column totals:")
             parts.append(totals.to_string())
 
         for category_col in categorical_cols[:6]:
             if not numeric_cols:
                 break
-            grouped = work.groupby(category_col, dropna=False)[numeric_cols].sum(numeric_only=True)
+            grouped = work.groupby(category_col, dropna=False)[numeric_cols].sum(
+                numeric_only=True
+            )
             if not grouped.empty:
                 parts.append(f"Totals grouped by {category_col}:")
                 parts.append(grouped.head(40).to_csv())
@@ -456,8 +528,7 @@ def likely_relevant_url(url: str) -> bool:
 def ddg_search(query: str, max_results: int = 5) -> list[dict[str, str]]:
     try:
         results = DDGS().text(query, max_results=max_results)
-    except Exception as exc:
-        logger.warning("DuckDuckGo-поиск не сработал: %s: %s", type(exc).__name__, exc)
+    except Exception:
         return []
 
     normalized: list[dict[str, str]] = []
@@ -481,7 +552,9 @@ def solve_reversed_english_task(question: str) -> str | None:
         return None
 
     reversed_text = question[::-1]
-    match = re.search(r'opposite of the word ["“”\']?([A-Za-z]+)["“”\']?', reversed_text, flags=re.I)
+    match = re.search(
+        r'opposite of the word ["“”\']?([A-Za-z]+)["“”\']?', reversed_text, flags=re.I
+    )
     if not match:
         return None
 
@@ -502,10 +575,14 @@ def solve_reversed_english_task(question: str) -> str | None:
 
 def solve_commutativity_table(question: str) -> str | None:
     lower = question.lower()
-    if "|---" not in question or ("commutative" not in lower and "commutativity" not in lower):
+    if "|---" not in question or (
+        "commutative" not in lower and "commutativity" not in lower
+    ):
         return None
 
-    lines = [line.strip() for line in question.splitlines() if line.strip().startswith("|")]
+    lines = [
+        line.strip() for line in question.splitlines() if line.strip().startswith("|")
+    ]
     if len(lines) < 3:
         return None
 
@@ -525,7 +602,11 @@ def solve_commutativity_table(question: str) -> str | None:
                 continue
             left_right = table.get(left, {}).get(right)
             right_left = table.get(right, {}).get(left)
-            if left_right is not None and right_left is not None and left_right != right_left:
+            if (
+                left_right is not None
+                and right_left is not None
+                and left_right != right_left
+            ):
                 counterexample_elements.update({left, right})
 
     if counterexample_elements:
@@ -535,7 +616,11 @@ def solve_commutativity_table(question: str) -> str | None:
 
 def solve_botany_grocery_list(question: str) -> str | None:
     lower = question.lower()
-    if "grocery list" not in lower or "vegetables" not in lower or "botanical fruits" not in lower:
+    if (
+        "grocery list" not in lower
+        or "vegetables" not in lower
+        or "botanical fruits" not in lower
+    ):
         return None
 
     match = re.search(
@@ -545,7 +630,9 @@ def solve_botany_grocery_list(question: str) -> str | None:
     if not match:
         return None
 
-    items = [re.sub(r"\s+", " ", item).strip(" .") for item in match.group(1).split(",")]
+    items = [
+        re.sub(r"\s+", " ", item).strip(" .") for item in match.group(1).split(",")
+    ]
     vegetable_names = {
         "broccoli",
         "cabbage",
@@ -579,7 +666,11 @@ def is_direct_question(question: str) -> bool:
     return (
         is_reversed_english_task(question)
         or ("|---" in question and ("commutative" in lower or "commutativity" in lower))
-        or ("grocery list" in lower and "botanical fruits" in lower and "vegetables" in lower)
+        or (
+            "grocery list" in lower
+            and "botanical fruits" in lower
+            and "vegetables" in lower
+        )
     )
 
 
@@ -595,7 +686,9 @@ def build_research_queries(question: str, base_query: str) -> list[str]:
         if parsed.netloc:
             queries.append(f"site:{parsed.netloc} {base_query}")
 
-    capitalized_terms = re.findall(r"\b[A-Z][\w.'-]*(?:\s+[A-Z][\w.'-]*){1,4}\b", question)
+    capitalized_terms = re.findall(
+        r"\b[A-Z][\w.'-]*(?:\s+[A-Z][\w.'-]*){1,4}\b", question
+    )
     if capitalized_terms:
         queries.append(" ".join(f'"{term}"' for term in capitalized_terms[:4]))
 
@@ -619,7 +712,9 @@ def build_research_queries(question: str, base_query: str) -> list[str]:
     return deduped[:5]
 
 
-def build_additional_research_queries(question: str, previous_queries: list[str], llm: ChatGroq) -> list[str]:
+def build_additional_research_queries(
+    question: str, previous_queries: list[str], llm: ChatGroq
+) -> list[str]:
     messages = [
         SystemMessage(
             content=(
@@ -633,8 +728,7 @@ def build_additional_research_queries(question: str, previous_queries: list[str]
 
     try:
         raw = llm.invoke(messages).content
-    except Exception as exc:
-        logger.warning("Не удалось расширить поисковые запросы: %s: %s", type(exc).__name__, exc)
+    except Exception:
         return []
 
     previous = {query.lower() for query in previous_queries}
@@ -659,9 +753,17 @@ def build_research_context(question: str, base_query: str) -> str:
 
         for index, result in enumerate(results, 1):
             url = result["url"]
-            parts.append(f"[{index}] {result['title']}\nURL: {url}\nSnippet: {result['body']}")
+            parts.append(
+                f"[{index}] {result['title']}\nURL: {url}\nSnippet: {result['body']}"
+            )
 
-            if not url or url in seen_urls or not likely_relevant_url(url) or fetched_count >= 1 or total_fetched >= 4:
+            if (
+                not url
+                or url in seen_urls
+                or not likely_relevant_url(url)
+                or fetched_count >= 1
+                or total_fetched >= 4
+            ):
                 continue
 
             seen_urls.add(url)
@@ -677,7 +779,9 @@ def build_research_context(question: str, base_query: str) -> str:
     return truncate_text("\n".join(parts), MAX_SEARCH_CONTEXT_CHARS)
 
 
-def extend_research_context(question: str, context: str, used_query: str, llm: ChatGroq) -> str:
+def extend_research_context(
+    question: str, context: str, used_query: str, llm: ChatGroq
+) -> str:
     extra_queries = build_additional_research_queries(question, [used_query], llm)
     if not extra_queries:
         return context
@@ -692,8 +796,15 @@ def extend_research_context(question: str, context: str, used_query: str, llm: C
 
         for index, result in enumerate(results, 1):
             url = result["url"]
-            parts.append(f"[{index}] {result['title']}\nURL: {url}\nSnippet: {result['body']}")
-            if not url or url in seen_urls or not likely_relevant_url(url) or fetched_count >= 1:
+            parts.append(
+                f"[{index}] {result['title']}\nURL: {url}\nSnippet: {result['body']}"
+            )
+            if (
+                not url
+                or url in seen_urls
+                or not likely_relevant_url(url)
+                or fetched_count >= 1
+            ):
                 continue
 
             seen_urls.add(url)
@@ -726,36 +837,196 @@ def fetch_youtube_timedtext(video_id: str) -> str:
 
     for url in urls:
         try:
-            response = requests.get(url, timeout=12, headers={"User-Agent": "GAIA-space-agent/1.0"})
+            response = requests.get(
+                url, timeout=12, headers={"User-Agent": "GAIA-space-agent/1.0"}
+            )
             response.raise_for_status()
             chunks = re.findall(r"<text[^>]*>(.*?)</text>", response.text, flags=re.S)
             if not chunks:
                 continue
-            text = " ".join(html.unescape(re.sub(r"<[^>]+>", " ", chunk)) for chunk in chunks)
+            text = " ".join(
+                html.unescape(re.sub(r"<[^>]+>", " ", chunk)) for chunk in chunks
+            )
             text = re.sub(r"\s+", " ", text).strip()
             if text:
                 return text
-        except Exception as exc:
-            logger.warning("Не удалось получить YouTube timedtext: %s: %s", type(exc).__name__, exc)
+        except Exception:
+            pass
 
     return ""
 
 
+def download_youtube_media(
+    video_id: str, target_dir: Path, kind: str
+) -> tuple[Path | None, str]:
+    url = f"https://www.youtube.com/watch?v={video_id}"
+    fmt = "worstaudio/worst" if kind == "audio" else "worst[ext=mp4]/worst"
+    output_template = str(target_dir / f"{kind}.%(ext)s")
+
+    try:
+        from yt_dlp import YoutubeDL
+    except ImportError:
+        return None, f"{kind}: yt-dlp не установлен"
+
+    try:
+        with YoutubeDL(
+            {
+                "format": fmt,
+                "outtmpl": output_template,
+                "noplaylist": True,
+                "quiet": True,
+                "no_warnings": True,
+                "max_filesize": YOUTUBE_MAX_BYTES,
+                "socket_timeout": 20,
+                "retries": 1,
+            }
+        ) as downloader:
+            downloader.download([url])
+    except Exception as exc:
+        return None, f"{kind}: yt-dlp не смог скачать видео ({type(exc).__name__})"
+
+    files = sorted(
+        target_dir.glob(f"{kind}.*"),
+        key=lambda path: path.stat().st_size if path.exists() else 0,
+        reverse=True,
+    )
+    return (files[0], "") if files else (None, f"{kind}: файл не был скачан")
+
+
+def extract_video_frames(
+    video_path: Path, frame_dir: Path, frame_count: int = YOUTUBE_FRAME_COUNT
+) -> list[Path]:
+    frame_dir.mkdir(parents=True, exist_ok=True)
+    try:
+        subprocess.run(
+            [
+                "ffmpeg",
+                "-y",
+                "-i",
+                str(video_path),
+                "-vf",
+                "fps=1/10,scale=640:-1",
+                "-frames:v",
+                str(frame_count),
+                str(frame_dir / "frame_%03d.jpg"),
+            ],
+            capture_output=True,
+            text=True,
+            timeout=45,
+            check=False,
+        )
+    except Exception:
+        return []
+
+    return sorted(frame_dir.glob("frame_*.jpg"))[:frame_count]
+
+
+def analyze_video_frames(frame_paths: list[Path], question: str) -> str:
+    if not frame_paths:
+        return ""
+
+    content: list[dict[str, Any]] = [
+        {
+            "type": "text",
+            "text": (
+                "These are sampled frames from a YouTube video. "
+                "Extract only visual evidence useful for answering the question. "
+                "Mention counts, visible species/objects, text, actions, and timestamps implied by frame order.\n\n"
+                f"Question: {question}"
+            ),
+        }
+    ]
+
+    for index, frame_path in enumerate(frame_paths, 1):
+        data = frame_path.read_bytes()
+        content.append({"type": "text", "text": f"Frame {index}:"})
+        content.append(
+            {
+                "type": "image_url",
+                "image_url": {
+                    "url": f"data:{image_mime(data, 'image/jpeg')};base64,"
+                    f"{base64.standard_b64encode(data).decode('utf-8')}"
+                },
+            }
+        )
+
+    try:
+        response = get_groq_client().chat.completions.create(
+            model=GROQ_VISION_MODEL,
+            messages=[{"role": "user", "content": content}],
+            temperature=0,
+            max_tokens=768,
+        )
+        return response.choices[0].message.content.strip()
+    except Exception as exc:
+        return error_text("ошибка vision-декодирования видео", exc)
+
+
+@tool
+def decode_youtube_video(question: str) -> str:
+    """Decode a YouTube video with audio and vision models, returning transcript and visual observations."""
+    video_id = extract_youtube_id(question)
+    if not video_id:
+        return error_text("в вопросе не найден YouTube video id")
+
+    parts = [f"Question: {question}", f"YouTube video id: {video_id}"]
+    timedtext = fetch_youtube_timedtext(video_id)
+    if timedtext:
+        parts.append(f"Timedtext transcript:\n{truncate_text(timedtext, 5000)}")
+
+    notes: list[str] = []
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_path = Path(temp_dir)
+
+        audio_path, audio_note = download_youtube_media(video_id, temp_path, "audio")
+        if audio_path:
+            try:
+                transcript = transcribe_media_file(audio_path)
+                if transcript and not is_bad_answer(transcript):
+                    parts.append(
+                        f"Audio model transcript:\n{truncate_text(transcript, 6000)}"
+                    )
+            except Exception as exc:
+                notes.append(f"audio: {type(exc).__name__}")
+        elif audio_note:
+            notes.append(audio_note)
+
+        video_path, video_note = download_youtube_media(video_id, temp_path, "video")
+        if video_path:
+            frames = extract_video_frames(video_path, temp_path / "frames")
+            frame_summary = analyze_video_frames(frames, question)
+            if frame_summary and not is_bad_answer(frame_summary):
+                parts.append(
+                    f"Vision model frame analysis:\n{truncate_text(frame_summary, 3000)}"
+                )
+        elif video_note:
+            notes.append(video_note)
+
+    if len(parts) == 2:
+        return error_text(
+            "; ".join(notes) if notes else "не удалось декодировать YouTube-видео"
+        )
+
+    if notes:
+        parts.append("Decode notes: " + "; ".join(notes[:2]))
+    return truncate_text("\n\n".join(parts), MAX_CONTEXT_CHARS)
+
+
 def build_youtube_context(question: str, video_id: str | None) -> str:
     queries = [question]
     quoted_phrases = re.findall(r'["“]([^"”]{3,120})["”]', question)
 
     if video_id:
-        queries = [f'"{video_id}" transcript', f'"{video_id}" subtitles', f'"{video_id}"'] + queries
+        queries = [
+            f'"{video_id}" transcript',
+            f'"{video_id}" subtitles',
+            f'"{video_id}"',
+        ] + queries
         queries.extend(f'"{video_id}" "{phrase}"' for phrase in quoted_phrases[:3])
     if quoted_phrases:
         queries.append(" ".join(f'"{phrase}"' for phrase in quoted_phrases[:3]))
 
     parts = [f"Question: {question}", f"YouTube video id: {video_id or 'unknown'}"]
-    if video_id:
-        transcript = fetch_youtube_timedtext(video_id)
-        if transcript:
-            parts.append(f"\n=== YouTube timedtext transcript ===\n{truncate_text(transcript, 8000)}")
 
     seen_urls: set[str] = set()
     total_fetched = 0
@@ -765,9 +1036,16 @@ def build_youtube_context(question: str, video_id: str | None) -> str:
 
         for index, result in enumerate(results, 1):
             url = result["url"]
-            parts.append(f"[{index}] {result['title']}\nURL: {url}\nSnippet: {result['body']}")
+            parts.append(
+                f"[{index}] {result['title']}\nURL: {url}\nSnippet: {result['body']}"
+            )
             parsed = urlparse(url)
-            if not url or url in seen_urls or parsed.scheme not in {"http", "https"} or total_fetched >= 3:
+            if (
+                not url
+                or url in seen_urls
+                or parsed.scheme not in {"http", "https"}
+                or total_fetched >= 3
+            ):
                 continue
             if "youtube.com" in parsed.netloc or "youtu.be" in parsed.netloc:
                 continue
@@ -858,20 +1136,20 @@ class AgentState(TypedDict, total=False):
 
 class BasicAgent:
     def __init__(self) -> None:
-        self.answer_llm = make_chat_model(GROQ_TEXT_MODEL, max_tokens=192)
-        self.final_llm = make_chat_model(GROQ_FINAL_MODEL, max_tokens=48)
-        self.strong_llm = make_chat_model(GROQ_STRONG_MODEL, max_tokens=384)
-        self.research_llm = make_chat_model(GROQ_RESEARCH_MODEL, max_tokens=384)
+        self.text_llm = make_chat_model(GROQ_TEXT_MODEL, max_tokens=384)
         self.graph = self.build_graph()
 
-        logger.info("LangGraph-агент инициализирован.")
-        logger.info("Текстовая модель: %s", GROQ_TEXT_MODEL)
-        logger.info("Финальная модель: %s", GROQ_FINAL_MODEL)
-        logger.info("Исследовательская модель: %s", GROQ_RESEARCH_MODEL)
-        logger.info("Vision-модель: %s", GROQ_VISION_MODEL)
-        logger.info("Audio-модель: %s", GROQ_AUDIO_MODEL)
-        logger.info("Выполнение кода: %s", "включено" if ALLOW_CODE_EXECUTION else "отключено")
-        logger.info("Повторный расширенный web-поиск: %s", "включен" if ENABLE_RESEARCH_RETRY else "отключен")
+        print("LangGraph-агент инициализирован.", flush=True)
+        print(
+            f"Модели: text={GROQ_TEXT_MODEL}; vision={GROQ_VISION_MODEL}; audio={GROQ_AUDIO_MODEL}",
+            flush=True,
+        )
+        print(
+            "Выполнение кода: "
+            f"{'включено' if ALLOW_CODE_EXECUTION else 'отключено'}; "
+            f"повторный web-поиск: {'включен' if ENABLE_RESEARCH_RETRY else 'отключен'}",
+            flush=True,
+        )
 
     def build_graph(self):
         graph = StateGraph(AgentState)
@@ -939,7 +1217,10 @@ class BasicAgent:
         else:
             route = "solve_research"
 
-        logger.info("Маршрут задачи: file_kind=%s, route=%s, path=%s", file_kind, route, local_path)
+        print(
+            f"Маршрут задачи: file_kind={file_kind}, route={route}, path={local_path}",
+            flush=True,
+        )
         return {"file_kind": file_kind, "local_path": local_path, "route": route}
 
     def select_route(self, state: AgentState) -> str:
@@ -959,7 +1240,7 @@ class BasicAgent:
         question = state.get("question", "")
         task_id = state.get("task_id", "")
         context = analyze_image.invoke({"task_id": task_id, "question": question})
-        raw_answer = self.answer_from_context(question, context, "Image analysis", self.strong_llm)
+        raw_answer = self.answer_from_context(question, context, "Image analysis")
         return {"context": context, "raw_answer": raw_answer}
 
     def solve_audio(self, state: AgentState) -> dict[str, Any]:
@@ -967,14 +1248,18 @@ class BasicAgent:
         task_id = state.get("task_id", "")
         transcript = transcribe_audio.invoke({"task_id": task_id})
         context = f"Audio/video transcript:\n{transcript}"
-        raw_answer = self.answer_from_context(question, context, "Audio transcript", self.answer_llm)
+        raw_answer = self.answer_from_context(question, context, "Audio transcript")
         return {"context": context, "raw_answer": raw_answer}
 
     def solve_spreadsheet(self, state: AgentState) -> dict[str, Any]:
         question = state.get("question", "")
         local_path = state.get("local_path")
         if not local_path:
-            return {"raw_answer": error_text("для spreadsheet-маршрута не найден путь к файлу")}
+            return {
+                "raw_answer": error_text(
+                    "для spreadsheet-маршрута не найден путь к файлу"
+                )
+            }
 
         path = Path(local_path)
         context = read_spreadsheet_context(path)
@@ -986,7 +1271,6 @@ class BasicAgent:
             question,
             context,
             "Spreadsheet data and computed summary",
-            self.strong_llm,
         )
         return {"context": context, "raw_answer": raw_answer}
 
@@ -994,20 +1278,33 @@ class BasicAgent:
         question = state.get("question", "")
         local_path = state.get("local_path")
         if not local_path:
-            return {"raw_answer": error_text("для code-маршрута не найден путь к файлу")}
+            return {
+                "raw_answer": error_text("для code-маршрута не найден путь к файлу")
+            }
 
         path = Path(local_path)
         code_context = read_code_context(path)
-        execution_context = run_python_file(path) if path.suffix.lower() == ".py" else "Выполнение пропущено: файл не Python."
+        execution_context = (
+            run_python_file(path)
+            if path.suffix.lower() == ".py"
+            else "Выполнение пропущено: файл не Python."
+        )
         context = f"{code_context}\n\n--- Execution result ---\n{execution_context}"
 
-        if "final numeric output" in question.lower() and "STDOUT:" in execution_context:
-            stdout_block = execution_context.split("STDOUT:", 1)[1].split("STDERR:", 1)[0].strip()
+        if (
+            "final numeric output" in question.lower()
+            and "STDOUT:" in execution_context
+        ):
+            stdout_block = (
+                execution_context.split("STDOUT:", 1)[1].split("STDERR:", 1)[0].strip()
+            )
             candidate = last_nonempty_line(stdout_block)
             if candidate and re.search(r"[-+]?\d", candidate):
                 return {"context": context, "raw_answer": candidate}
 
-        raw_answer = self.answer_from_context(question, context, "Code and execution result", self.strong_llm)
+        raw_answer = self.answer_from_context(
+            question, context, "Code and execution result"
+        )
         return {"context": context, "raw_answer": raw_answer}
 
     def solve_direct(self, state: AgentState) -> dict[str, Any]:
@@ -1018,44 +1315,50 @@ class BasicAgent:
 
         direct_answer = solve_directly(question)
         if direct_answer is not None:
-            return {"context": "Задача решена детерминированным Python-разбором.", "raw_answer": direct_answer}
+            return {
+                "context": "Задача решена детерминированным Python-разбором.",
+                "raw_answer": direct_answer,
+            }
 
         context = ""
         if local_path and file_kind in {"pdf", "text", "binary"}:
             context = read_text_file.invoke({"task_id": task_id})
 
-        raw_answer = self.answer_from_context(question, context, f"Direct context; file_kind={file_kind}", self.answer_llm)
+        raw_answer = self.answer_from_context(
+            question, context, f"Direct context; file_kind={file_kind}"
+        )
         return {"context": context, "raw_answer": raw_answer}
 
     def solve_research(self, state: AgentState) -> dict[str, Any]:
         question = state.get("question", "")
         query = self.make_search_query(question)
-        logger.info("Поисковый запрос: %s", query)
-
         context = build_research_context(question, query)
-        logger.info("Размер поискового контекста: %s", len(context))
 
-        raw_answer = self.answer_from_context(question, context, "Web research results", self.research_llm)
+        raw_answer = self.answer_from_context(question, context, "Web research results")
         if is_bad_answer(raw_answer) and ENABLE_RESEARCH_RETRY:
-            context = extend_research_context(question, context, query, self.final_llm)
-            logger.info("Размер расширенного поискового контекста: %s", len(context))
-            raw_answer = self.answer_from_context(question, context, "Extended web research results", self.strong_llm)
+            context = extend_research_context(question, context, query, self.text_llm)
+            raw_answer = self.answer_from_context(
+                question, context, "Extended web research results"
+            )
 
         return {"context": context, "raw_answer": raw_answer}
 
     def solve_youtube(self, state: AgentState) -> dict[str, Any]:
         question = state.get("question", "")
         video_id = extract_youtube_id(question)
-        context = build_youtube_context(question, video_id)
-        raw_answer = self.answer_from_context(question, context, "YouTube/web transcript search results", self.research_llm)
+        decoded_context = decode_youtube_video.invoke({"question": question})
+        web_context = build_youtube_context(question, video_id)
+        context = f"{decoded_context}\n\n--- Web context ---\n{web_context}"
+        raw_answer = self.answer_from_context(
+            question, context, "Decoded YouTube video and web context"
+        )
 
         if is_bad_answer(raw_answer) and ENABLE_RESEARCH_RETRY:
-            context = extend_research_context(question, context, question, self.final_llm)
+            context = extend_research_context(
+                question, context, question, self.text_llm
+            )
             raw_answer = self.answer_from_context(
-                question,
-                context,
-                "Extended YouTube/web transcript search results",
-                self.strong_llm,
+                question, context, "Extended YouTube/video context"
             )
 
         return {"context": context, "raw_answer": raw_answer}
@@ -1070,10 +1373,18 @@ class BasicAgent:
         if is_bad_answer(raw_answer):
             return {"verified_answer": "", "error": raw_answer or "пустой ответ"}
 
-        if route not in {"solve_research", "solve_youtube"} or file_kind in {"code", "spreadsheet", "audio"}:
+        if route not in {"solve_research", "solve_youtube"} or file_kind in {
+            "code",
+            "spreadsheet",
+            "audio",
+        }:
             return {"verified_answer": raw_answer}
 
-        if "\n" not in raw_answer and len(raw_answer.split()) <= 12 and len(raw_answer) <= 120:
+        if (
+            "\n" not in raw_answer
+            and len(raw_answer.split()) <= 12
+            and len(raw_answer) <= 120
+        ):
             return {"verified_answer": raw_answer}
 
         messages = [
@@ -1095,9 +1406,8 @@ class BasicAgent:
         ]
 
         try:
-            verified = self.final_llm.invoke(messages).content.strip()
-        except Exception as exc:
-            logger.warning("Проверка ответа не сработала: %s: %s", type(exc).__name__, exc)
+            verified = self.text_llm.invoke(messages).content.strip()
+        except Exception:
             verified = raw_answer
 
         if is_bad_answer(verified):
@@ -1106,20 +1416,34 @@ class BasicAgent:
 
     def final_cleaner(self, state: AgentState) -> dict[str, Any]:
         question = state.get("question", "")
-        answer = clean_answer(state.get("verified_answer") or state.get("raw_answer") or "")
+        answer = clean_answer(
+            state.get("verified_answer") or state.get("raw_answer") or ""
+        )
 
         if is_bad_answer(answer):
-            return {"final_answer": "", "error": state.get("error") or answer or "плохой ответ"}
+            return {
+                "final_answer": "",
+                "error": state.get("error") or answer or "плохой ответ",
+            }
 
         if "\n" in answer or len(answer.split()) > 12 or len(answer) > 120:
             answer = self.extract_final_answer(question, answer)
 
         answer = clean_answer(answer)
         if is_bad_answer(answer):
-            return {"final_answer": "", "error": state.get("error") or answer or "плохой ответ"}
+            return {
+                "final_answer": "",
+                "error": state.get("error") or answer or "плохой ответ",
+            }
         return {"final_answer": answer}
 
-    def answer_from_context(self, question: str, context: str, context_label: str, llm: ChatGroq) -> str:
+    def answer_from_context(
+        self,
+        question: str,
+        context: str,
+        context_label: str,
+        llm: ChatGroq | None = None,
+    ) -> str:
         system = (
             "You answer GAIA benchmark questions.\n"
             "Return ONLY the final answer: a number, name, word, date, or short phrase.\n"
@@ -1139,38 +1463,20 @@ class BasicAgent:
             user = f"Question:\n{question}\n\nFinal answer only:"
 
         try:
-            return llm.invoke([SystemMessage(content=system), HumanMessage(content=user)]).content.strip()
+            llm = llm or self.text_llm
+            return llm.invoke(
+                [SystemMessage(content=system), HumanMessage(content=user)]
+            ).content.strip()
         except Exception as exc:
-            message = str(exc)
-            model_rejected_tools = (
-                "tool_use_failed" in message
-                or "Tool choice is none" in message
-                or "model called a tool" in message
-            )
-            if model_rejected_tools:
-                try:
-                    logger.warning("LLM дала tool-use ошибку, повторяю через модель %s", GROQ_TEXT_MODEL)
-                    return self.answer_llm.invoke([SystemMessage(content=system), HumanMessage(content=user)]).content.strip()
-                except Exception as fallback_exc:
-                    return error_text("ошибка fallback-вызова LLM", fallback_exc)
-            if llm is not self.answer_llm:
-                try:
-                    logger.warning("LLM-вызов не сработал, повторяю через легкую модель %s", GROQ_TEXT_MODEL)
-                    fallback_user = (
-                        f"Question:\n{question}\n\n"
-                        f"{context_label}:\n{truncate_text(context, 4000)}\n\n"
-                        "Final answer only:"
-                    )
-                    return self.answer_llm.invoke(
-                        [SystemMessage(content=system), HumanMessage(content=fallback_user)]
-                    ).content.strip()
-                except Exception as fallback_exc:
-                    return error_text("ошибка fallback-вызова LLM", fallback_exc)
             return error_text("ошибка вызова LLM", exc)
 
     def extract_final_answer(self, question: str, raw_answer: str) -> str:
         raw_answer = clean_answer(raw_answer)
-        if "\n" not in raw_answer and len(raw_answer.split()) <= 12 and len(raw_answer) <= 120:
+        if (
+            "\n" not in raw_answer
+            and len(raw_answer.split()) <= 12
+            and len(raw_answer) <= 120
+        ):
             return raw_answer
 
         messages = [
@@ -1190,9 +1496,8 @@ class BasicAgent:
         ]
 
         try:
-            return clean_answer(self.final_llm.invoke(messages).content.strip())
-        except Exception as exc:
-            logger.warning("Финальное извлечение ответа не сработало: %s: %s", type(exc).__name__, exc)
+            return clean_answer(self.text_llm.invoke(messages).content.strip())
+        except Exception:
             return clean_answer(last_nonempty_line(raw_answer))
 
     def make_search_query(self, question: str) -> str:
@@ -1211,9 +1516,9 @@ class BasicAgent:
         return query[:220]
 
     def __call__(self, question: str, task_id: str = "") -> str:
-        logger.info("\n%s", "-" * 60)
-        logger.info("ID задачи: %s", task_id)
-        logger.info("Вопрос: %s", question[:160])
+        print(f"\n{'-' * 60}", flush=True)
+        print(f"ID задачи: {task_id}", flush=True)
+        print(f"Вопрос: {question[:160]}", flush=True)
 
         try:
             result = self.graph.invoke(
@@ -1223,10 +1528,12 @@ class BasicAgent:
             answer = clean_answer(result.get("final_answer", ""))
             if not answer:
                 answer = error_text(result.get("error", "финальный ответ не получен"))
-            logger.info("Итоговый ответ: %s", answer)
+            print(f"Итоговый ответ: {answer}", flush=True)
             return answer
         except Exception as exc:
-            logger.error("Агент завершился с ошибкой: %s: %s", type(exc).__name__, exc)
+            print(
+                f"Агент завершился с ошибкой: {type(exc).__name__}: {exc}", flush=True
+            )
             return error_text("агент завершился с ошибкой", exc)
 
 
@@ -1237,7 +1544,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         return "Сначала войдите в Hugging Face.", None
 
     username = profile.username
-    logger.info("Пользователь HF: %s", username)
+    print(f"Пользователь HF: {username}", flush=True)
 
     try:
         agent = BasicAgent()
@@ -1246,13 +1553,15 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
     questions_url = f"{DEFAULT_API_URL}/questions"
     submit_url = f"{DEFAULT_API_URL}/submit"
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else ""
+    agent_code = (
+        f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else ""
+    )
 
     try:
         response = requests.get(questions_url, timeout=20)
         response.raise_for_status()
         questions_data = response.json()
-        logger.info("Получено вопросов: %s", len(questions_data))
+        print(f"Получено вопросов: {len(questions_data)}", flush=True)
     except Exception as exc:
         return error_text("не удалось получить список вопросов", exc), None
 
@@ -1267,20 +1576,29 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
         try:
             answer = agent(question_text, task_id=task_id)
-            results_log.append({"ID задачи": task_id, "Вопрос": question_text[:120], "Ответ": answer})
+            results_log.append(
+                {"ID задачи": task_id, "Вопрос": question_text[:120], "Ответ": answer}
+            )
 
             if answer and not is_bad_answer(answer):
                 answers_payload.append({"task_id": task_id, "submitted_answer": answer})
             else:
-                logger.info("Ответ не отправлен для task_id=%s: %s", task_id, answer)
+                print(f"Ответ не отправлен для task_id={task_id}: {answer}", flush=True)
         except Exception as exc:
             answer = error_text("ошибка обработки вопроса", exc)
-            results_log.append({"ID задачи": task_id, "Вопрос": question_text[:120], "Ответ": answer})
-            logger.error("Ошибка вопроса task_id=%s: %s: %s", task_id, type(exc).__name__, exc)
+            results_log.append(
+                {"ID задачи": task_id, "Вопрос": question_text[:120], "Ответ": answer}
+            )
+            print(
+                f"Ошибка вопроса task_id={task_id}: {type(exc).__name__}: {exc}",
+                flush=True,
+            )
             time.sleep(1)
 
     if not answers_payload:
-        return "Агент не подготовил ни одного ответа для отправки.", pd.DataFrame(results_log)
+        return "Агент не подготовил ни одного ответа для отправки.", pd.DataFrame(
+            results_log
+        )
 
     payload = {
         "username": username.strip(),
@@ -1316,7 +1634,9 @@ with gr.Blocks(title="GAIA LangGraph Agent") as demo:
     if oauth_available:
         gr.LoginButton()
     else:
-        gr.Markdown("OAuth Hugging Face недоступен вне Space. Для сабмита нужен вход в HF.")
+        gr.Markdown(
+            "OAuth Hugging Face недоступен вне Space. Для сабмита нужен вход в HF."
+        )
 
     run_button = gr.Button("Запустить оценку и отправить ответы")
     status_output = gr.Textbox(label="Статус", lines=6, interactive=False)
@@ -1325,10 +1645,10 @@ with gr.Blocks(title="GAIA LangGraph Agent") as demo:
     run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
 if space_host_startup:
-    logger.info("SPACE_HOST найден: %s", space_host_startup)
+    print(f"SPACE_HOST найден: {space_host_startup}", flush=True)
 if space_id_startup:
-    logger.info("SPACE_ID найден: %s", space_id_startup)
+    print(f"SPACE_ID найден: {space_id_startup}", flush=True)
 
 if __name__ == "__main__":
-    logger.info("Запускаю Gradio-интерфейс LangGraph-агента.")
+    print("Запускаю Gradio-интерфейс LangGraph-агента.", flush=True)
     demo.launch(debug=os.getenv("GRADIO_DEBUG", "0") == "1", share=False)