Update app.py

app.py

@@ -1,12 +1,13 @@
-import os
-import re
-import io
-import sys
-import time
 import base64
 import html
+import io
+import logging
 import mimetypes
+import os
+import re
 import subprocess
+import sys
+import time
 from functools import lru_cache
 from pathlib import Path
 from typing import Any, TypedDict
@@ -17,16 +18,15 @@ import pandas as pd
 import pypdf
 import requests
 from ddgs import DDGS
-
 from groq import Groq
 from langchain_core.messages import HumanMessage, SystemMessage
 from langchain_core.tools import tool
 from langchain_groq import ChatGroq
-from langchain_community.tools import DuckDuckGoSearchRun
 from langgraph.graph import END, StateGraph
 
 
 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")
@@ -36,96 +36,90 @@ GROQ_VISION_MODEL = os.getenv("GROQ_VISION_MODEL", "meta-llama/llama-4-scout-17b
 GROQ_AUDIO_MODEL = os.getenv("GROQ_AUDIO_MODEL", "whisper-large-v3-turbo")
 
 GAIA_DIR = os.getenv("GAIA_DIR", "./data/gaia")
-ALLOW_CODE_EXECUTION = 1
+ALLOW_CODE_EXECUTION = os.getenv("ALLOW_CODE_EXECUTION", "1").lower() not in {"0", "false", "no"}
 
 MAX_CONTEXT_CHARS = 24_000
 MAX_SEARCH_CONTEXT_CHARS = 20_000
 
+IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"}
+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")
+
+
+def error_text(message: str, exc: Exception | None = None) -> str:
+    if exc is None:
+        return f"{ERROR_PREFIX} {message}"
+    return f"{ERROR_PREFIX} {message}: {type(exc).__name__}: {exc}"
+
 
 def get_groq_client() -> Groq:
     key = os.getenv("GROQ_API_KEY")
     if not key:
-        raise ValueError("GROQ_API_KEY secret not set!")
+        raise ValueError("Не задан секрет GROQ_API_KEY.")
     return Groq(api_key=key)
 
 
 def make_chat_model(model: str, max_tokens: int) -> ChatGroq:
     key = os.getenv("GROQ_API_KEY")
     if not key:
-        raise ValueError("GROQ_API_KEY secret not set!")
-    return ChatGroq(
-        model=model,
-        api_key=key,
-        temperature=0,
-        max_tokens=max_tokens,
-    )
+        raise ValueError("Не задан секрет GROQ_API_KEY.")
+    return ChatGroq(model=model, api_key=key, temperature=0, max_tokens=max_tokens)
 
 
 @lru_cache(maxsize=1)
-def _get_task_file_map() -> dict[str, str]:
+def get_task_file_map() -> dict[str, str]:
     result: dict[str, str] = {}
     validation_dir = Path(GAIA_DIR) / "2023" / "validation"
 
     if not validation_dir.exists():
-        print(f"[warn] GAIA validation dir not found: {validation_dir}")
+        logger.warning("Папка с validation-файлами GAIA не найдена: %s", validation_dir)
         return result
 
-    for p in validation_dir.rglob("*"):
-        if not p.is_file():
-            continue
-        if p.suffix.lower() == ".parquet":
-            continue
-        result[p.stem] = str(p)
+    for path in validation_dir.rglob("*"):
+        if path.is_file() and path.suffix.lower() != ".parquet":
+            result[path.stem] = str(path)
 
-    print(f"[file-map] mapped {len(result)} local GAIA files from {validation_dir}")
+    logger.info("Найдено локальных файлов GAIA: %s (%s)", len(result), validation_dir)
     return result
 
 
 def get_task_file(task_id: str) -> str | None:
     if not task_id:
         return None
-    return _get_task_file_map().get(task_id)
+    return get_task_file_map().get(task_id)
 
 
-def _fetch_task_bytes(task_id: str) -> tuple[bytes, str]:
+def fetch_task_bytes(task_id: str) -> tuple[bytes, str]:
     local_path = get_task_file(task_id)
     if not local_path:
-        raise FileNotFoundError(f"No local file mapped for task_id: {task_id}")
+        raise FileNotFoundError(f"для task_id={task_id} не найден локальный файл")
 
     path = Path(local_path)
     if not path.exists():
-        raise FileNotFoundError(f"File not found at path: {local_path}")
+        raise FileNotFoundError(f"файл не найден: {local_path}")
 
-    data = path.read_bytes()
     content_type, _ = mimetypes.guess_type(str(path))
-    if not content_type:
-        content_type = "application/octet-stream"
-    return data, content_type
-
-
-IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"}
-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
+    return path.read_bytes(), content_type or "application/octet-stream"
 
 
-def _is_image(ct: str, data: bytes) -> bool:
-    if ct.startswith("image/"):
-        return True
-    if data.startswith(b"\x89PNG"):
-        return True
-    if data.startswith(b"\xff\xd8\xff"):
-        return True
-    if data.startswith(b"GIF87a") or data.startswith(b"GIF89a"):
-        return True
-    if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
-        return True
-    return False
+def is_image(content_type: str, data: bytes) -> bool:
+    return (
+        content_type.startswith("image/")
+        or data.startswith(b"\x89PNG")
+        or data.startswith(b"\xff\xd8\xff")
+        or data.startswith(b"GIF87a")
+        or data.startswith(b"GIF89a")
+        or (data[:4] == b"RIFF" and data[8:12] == b"WEBP")
+    )
 
 
-def _image_mime(data: bytes, ct: str) -> str:
+def image_mime(data: bytes, content_type: str) -> str:
     if data.startswith(b"\x89PNG"):
         return "image/png"
     if data.startswith(b"\xff\xd8\xff"):
@@ -134,19 +128,12 @@ def _image_mime(data: bytes, ct: str) -> str:
         return "image/webp"
     if data.startswith(b"GIF87a") or data.startswith(b"GIF89a"):
         return "image/gif"
-    if ct.startswith("image/"):
-        return ct
-    return "image/png"
+    return content_type if content_type.startswith("image/") else "image/png"
 
 
-def _is_audio_or_video(ct: str, path: str) -> bool:
-    ext = Path(path).suffix.lower()
-    return ct.startswith("audio/") or ct.startswith("video/") or ext in AUDIO_VIDEO_EXTS
-
-
-def is_youtube_question(question: str) -> bool:
-    q = question.lower()
-    return "youtube.com/watch" in q or "youtu.be/" in q
+def is_audio_or_video(content_type: str, path: str) -> bool:
+    suffix = Path(path).suffix.lower()
+    return content_type.startswith(("audio/", "video/")) or suffix in AUDIO_VIDEO_EXTS
 
 
 def detect_local_file_kind(task_id: str) -> tuple[str, str | None]:
@@ -155,15 +142,14 @@ def detect_local_file_kind(task_id: str) -> tuple[str, str | None]:
         return "none", None
 
     suffix = Path(local_path).suffix.lower()
-
     try:
-        data, ct = _fetch_task_bytes(task_id)
+        data, content_type = fetch_task_bytes(task_id)
     except Exception:
         return "binary", local_path
 
-    if suffix in IMAGE_EXTS or _is_image(ct, data):
+    if suffix in IMAGE_EXTS or is_image(content_type, data):
         return "image", local_path
-    if suffix in AUDIO_VIDEO_EXTS or _is_audio_or_video(ct, local_path):
+    if suffix in AUDIO_VIDEO_EXTS or is_audio_or_video(content_type, local_path):
         return "audio", local_path
     if suffix in SPREADSHEET_EXTS:
         return "spreadsheet", local_path
@@ -176,42 +162,46 @@ def detect_local_file_kind(task_id: str) -> tuple[str, str | None]:
     return "binary", local_path
 
 
-def truncate_text(text: str, limit: int = MAX_CONTEXT_CHARS) -> str:
-    text = str(text)
-    if len(text) <= limit:
-        return text
-    return text[:limit] + f"\n\n[TRUNCATED to {limit} characters]"
+def truncate_text(text: Any, limit: int = MAX_CONTEXT_CHARS) -> str:
+    value = str(text)
+    if len(value) <= limit:
+        return value
+    return value[:limit] + f"\n\n[TRUNCATED to {limit} characters]"
+
 
 @tool
 def analyze_image(task_id: str, question: str = "") -> str:
-    """Analyze a local GAIA imae using the Groq vision model."""
+    """Analyze the GAIA image attached to a task and return visual facts for answer generation."""
     try:
-        data, ct = _fetch_task_bytes(task_id)
-    except Exception as e:
-        return f"ERROR: Could not fetch image for task {task_id}: {type(e).__name__}: {e}"
+        data, content_type = fetch_task_bytes(task_id)
+    except Exception as exc:
+        return error_text(f"не удалось открыть изображение для task_id={task_id}", exc)
 
-    if not _is_image(ct, data):
-        return f"ERROR: File for task {task_id} does not appear to be an image. content_type={ct}"
+    if not is_image(content_type, data):
+        return error_text(f"файл task_id={task_id} не похож на изображение, content_type={content_type}")
 
-    b64 = base64.standard_b64encode(data).decode("utf-8")
-    mime = _image_mime(data, ct)
-    prompt = question or "Describe this 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 = (
-            f"{prompt}\n\n"
-            "This is a chess task. Identify the board coordinates, side to move, relevant pieces, checks, "
-            "mate threats, and the best move. Return the move in standard chess notation if possible."
+        prompt += (
+            "\n\nThis is a chess task. Identify board coordinates, side to move, relevant pieces, "
+            "checks, mate threats, and the best move in standard notation if possible."
         )
 
     try:
         client = get_groq_client()
-        resp = client.chat.completions.create(
+        response = client.chat.completions.create(
             model=GROQ_VISION_MODEL,
             messages=[
                 {
                     "role": "user",
                     "content": [
-                        {"type": "image_url", "image_url": {"url": f"data:{mime};base64,{b64}"}},
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:{image_mime(data, content_type)};base64,"
+                                f"{base64.standard_b64encode(data).decode('utf-8')}"
+                            },
+                        },
                         {"type": "text", "text": prompt},
                     ],
                 }
@@ -219,22 +209,22 @@ def analyze_image(task_id: str, question: str = "") -> str:
             temperature=0,
             max_tokens=768,
         )
-        return resp.choices[0].message.content.strip()
-    except Exception as e:
-        return f"ERROR: Vision model error: {type(e).__name__}: {e}"
+        return response.choices[0].message.content.strip()
+    except Exception as exc:
+        return error_text("ошибка vision-модели", exc)
 
 
 @tool
 def transcribe_audio(task_id: str) -> str:
-    """Transcribe a local GAIA audio/video file using Groq Whisper."""
+    """Transcribe the GAIA audio or video file attached to a task and return the transcript."""
     try:
-        data, ct = _fetch_task_bytes(task_id)
+        data, content_type = fetch_task_bytes(task_id)
         local_path = get_task_file(task_id) or ""
-    except Exception as e:
-        return f"ERROR: Could not fetch audio for task {task_id}: {type(e).__name__}: {e}"
+    except Exception as exc:
+        return error_text(f"не удалось открыть аудио или видео для task_id={task_id}", exc)
 
-    if not _is_audio_or_video(ct, local_path):
-        return f"ERROR: File for task {task_id} does not appear to be audio/video. content_type={ct}"
+    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":
@@ -242,64 +232,81 @@ def transcribe_audio(task_id: str) -> str:
 
     try:
         client = get_groq_client()
-        audio_file = (f"audio.{suffix}", io.BytesIO(data), ct or f"audio/{suffix}")
+        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()
-    except Exception as e:
-        return f"ERROR: Audio transcription error: {type(e).__name__}: {e}"
+    except Exception as exc:
+        return error_text("ошибка транскрибации аудио", exc)
 
 
 @tool
 def read_text_file(task_id: str) -> str:
-    """Read a local GAIA text/PDF/spreadsheet/code file and return compact text context."""
+    """Read the GAIA text, PDF, spreadsheet, or source file attached to a task and return compact context."""
     try:
         local_path = get_task_file(task_id)
         if not local_path:
-            return f"ERROR: No local file attached for task {task_id}."
+            return error_text(f"для task_id={task_id} не найден локальный файл")
 
         path = Path(local_path)
         suffix = path.suffix.lower()
 
         if suffix in SPREADSHEET_EXTS:
             return read_spreadsheet_context(path)
-        if suffix == ".pdf":
+        if suffix in PDF_EXTS:
             return read_pdf_context(path)
         if suffix in CODE_EXTS:
             return read_code_context(path)
 
-        data, ct = _fetch_task_bytes(task_id)
-        if _is_image(ct, data) or _is_audio_or_video(ct, local_path):
-            return f"ERROR: File is binary image/audio/video; use analyze_image or transcribe_audio instead. content_type={ct}"
+        data, content_type = fetch_task_bytes(task_id)
+        if is_image(content_type, data) or is_audio_or_video(content_type, local_path):
+            return error_text(
+                "файл является бинарным изображением, аудио или видео; "
+                "используйте analyze_image или transcribe_audio"
+            )
 
-        return truncate_text(data.decode("utf-8", errors="replace"), MAX_CONTEXT_CHARS)
-    except Exception as e:
-        return f"ERROR: Error reading file for task {task_id}: {type(e).__name__}: {e}"
+        return truncate_text(data.decode("utf-8", errors="replace"))
+    except Exception as exc:
+        return error_text(f"ошибка чтения файла для task_id={task_id}", exc)
 
 
 def read_pdf_context(path: Path) -> str:
-    parts: list[str] = [f"PDF file: {path.name}"]
-    reader = pypdf.PdfReader(str(path))
-    for i, page in enumerate(reader.pages):
+    parts = [f"PDF file: {path.name}"]
+    try:
+        reader = pypdf.PdfReader(str(path))
+    except Exception as exc:
+        return error_text(f"ошибка открытия PDF-файла {path.name}", exc)
+
+    for index, page in enumerate(reader.pages, 1):
         try:
             text = page.extract_text() or ""
-        except Exception as e:
-            text = f"[page extraction error: {type(e).__name__}: {e}]"
-        parts.append(f"\n--- Page {i + 1} ---\n{text}")
+        except Exception as exc:
+            text = f"[ошибка извлечения текста со страницы: {type(exc).__name__}: {exc}]"
+        parts.append(f"\n--- Page {index} ---\n{text}")
         if len("\n".join(parts)) > MAX_CONTEXT_CHARS:
             break
-    return truncate_text("\n".join(parts), MAX_CONTEXT_CHARS)
+
+    return truncate_text("\n".join(parts))
 
 
 def read_spreadsheet_context(path: Path) -> str:
-    parts: list[str] = [f"Spreadsheet file: {path.name}"]
-    xls = pd.ExcelFile(path)
+    parts = [f"Spreadsheet file: {path.name}"]
+    try:
+        workbook = pd.ExcelFile(path)
+    except Exception as exc:
+        return error_text(f"ошибка открытия таблицы {path.name}", exc)
+
+    for sheet_name in workbook.sheet_names:
+        try:
+            df = pd.read_excel(path, sheet_name=sheet_name)
+        except Exception as exc:
+            parts.append(f"\n--- Sheet: {sheet_name} ---")
+            parts.append(f"[ошибка чтения листа: {type(exc).__name__}: {exc}]")
+            continue
 
-    for sheet_name in xls.sheet_names:
-        df = pd.read_excel(path, sheet_name=sheet_name)
         parts.append(f"\n--- Sheet: {sheet_name} ---")
         parts.append(f"Shape: {df.shape}")
         parts.append(f"Columns: {list(df.columns)}")
@@ -312,38 +319,41 @@ def read_spreadsheet_context(path: Path) -> str:
         else:
             parts.append("Head 40 rows:")
             parts.append(df.head(40).to_csv(index=False))
-            parts.append("Numeric summary:")
             try:
+                parts.append("Numeric summary:")
                 parts.append(str(df.describe(include="all")))
-            except Exception:
-                pass
+            except Exception as exc:
+                parts.append(f"[ошибка построения сводки: {type(exc).__name__}: {exc}]")
 
         if len("\n".join(parts)) > MAX_CONTEXT_CHARS:
             break
 
-    return truncate_text("\n".join(parts), MAX_CONTEXT_CHARS)
+    return truncate_text("\n".join(parts))
 
 
 def build_spreadsheet_summary(path: Path) -> str:
     parts: list[str] = []
-    xls = pd.ExcelFile(path)
+    try:
+        workbook = pd.ExcelFile(path)
+    except Exception as exc:
+        return error_text(f"ошибка открытия таблицы для сводки {path.name}", exc)
 
-    for sheet_name in xls.sheet_names:
-        df = pd.read_excel(path, sheet_name=sheet_name)
+    for sheet_name in workbook.sheet_names:
+        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}]")
+            continue
         if df.empty:
             continue
 
         work = df.copy()
-        work.columns = [str(col).strip() for col in work.columns]
-        numeric_cols = [
-            col
-            for col in work.columns
-            if pd.api.types.is_numeric_dtype(work[col])
-        ]
+        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])]
         categorical_cols = [
-            col
-            for col in work.columns
-            if col not in numeric_cols and work[col].nunique(dropna=True) <= 40
+            column
+            for column in work.columns
+            if column not in numeric_cols and work[column].nunique(dropna=True) <= 40
         ]
 
         parts.append(f"Sheet: {sheet_name}")
@@ -356,31 +366,32 @@ def build_spreadsheet_summary(path: Path) -> str:
             if not numeric_cols:
                 break
             grouped = work.groupby(category_col, dropna=False)[numeric_cols].sum(numeric_only=True)
-            if grouped.empty:
-                continue
-            parts.append(f"Totals grouped by {category_col}:")
-            parts.append(grouped.head(40).to_csv())
+            if not grouped.empty:
+                parts.append(f"Totals grouped by {category_col}:")
+                parts.append(grouped.head(40).to_csv())
 
         if len("\n".join(parts)) > MAX_CONTEXT_CHARS:
             break
 
-    return truncate_text("\n".join(parts), MAX_CONTEXT_CHARS)
+    return truncate_text("\n".join(parts))
 
 
 def read_code_context(path: Path) -> str:
-    source = path.read_text(encoding="utf-8", errors="replace")
-    parts = [f"Code file: {path.name}", "--- Source code ---", source]
-    return truncate_text("\n".join(parts), MAX_CONTEXT_CHARS)
+    try:
+        source = path.read_text(encoding="utf-8", errors="replace")
+    except Exception as exc:
+        return error_text(f"ошибка чтения кода {path.name}", exc)
+    return truncate_text(f"Code file: {path.name}\n--- Source code ---\n{source}")
 
 
 def run_python_file(path: Path, timeout_seconds: int = 45) -> str:
     if not ALLOW_CODE_EXECUTION:
-        return "execution skipped"
+        return "Выполнение Python-файла отключено через ALLOW_CODE_EXECUTION."
     if path.suffix.lower() != ".py":
-        return "not a Python file"
+        return "Файл не является Python-файлом."
 
     try:
-        proc = subprocess.run(
+        process = subprocess.run(
             [sys.executable, str(path)],
             cwd=str(path.parent),
             capture_output=True,
@@ -388,29 +399,17 @@ def run_python_file(path: Path, timeout_seconds: int = 45) -> str:
             timeout=timeout_seconds,
             env={**os.environ, "PYTHONIOENCODING": "utf-8"},
         )
-        stdout = proc.stdout.strip()
-        stderr = proc.stderr.strip()
+        stdout = process.stdout.strip()
+        stderr = process.stderr.strip()
         return (
-            f"Return code: {proc.returncode}\n"
+            f"Return code: {process.returncode}\n"
             f"STDOUT:\n{stdout[-6000:]}\n\n"
             f"STDERR:\n{stderr[-3000:]}"
         )
     except subprocess.TimeoutExpired:
-        return f"ERROR: Code execution timed out after {timeout_seconds} seconds."
-    except Exception as e:
-        return f"ERROR: Code execution failed: {type(e).__name__}: {e}"
-
-web_search_tool = DuckDuckGoSearchRun(name="web_search")
-
-def safe_tool_run(tool_obj: Any, query: str, limit: int = 6000) -> str:
-    try:
-        if hasattr(tool_obj, "run"):
-            out = tool_obj.run(query)
-        else:
-            out = tool_obj.invoke(query)
-        return truncate_text(str(out), limit)
-    except Exception as e:
-        return f"[tool error: {type(e).__name__}: {e}]"
+        return error_text(f"выполнение кода превысило лимит {timeout_seconds} секунд")
+    except Exception as exc:
+        return error_text("ошибка выполнения кода", exc)
 
 
 def html_to_text(markup: str, limit: int = 8000) -> str:
@@ -427,68 +426,58 @@ def html_to_text(markup: str, limit: int = 8000) -> str:
 
 def fetch_url_text(url: str, limit: int = 8000) -> str:
     try:
-        resp = requests.get(
+        response = requests.get(
             url,
             timeout=12,
-            headers={
-                "User-Agent": (
-                    "Mozilla/5.0 (compatible; GAIA-course-agent/1.0; "
-                    "+https://huggingface.co/spaces)"
-                )
-            },
+            headers={"User-Agent": "Mozilla/5.0 (compatible; GAIA-space-agent/1.0)"},
         )
-        resp.raise_for_status()
-        content_type = resp.headers.get("content-type", "")
+        response.raise_for_status()
+        content_type = response.headers.get("content-type", "")
         if "pdf" in content_type or url.lower().endswith(".pdf"):
             return f"[PDF source: {url}]"
-        return html_to_text(resp.text, limit=limit)
-    except Exception as e:
-        return f"[fetch error: {type(e).__name__}: {e}]"
+        return html_to_text(response.text, limit=limit)
+    except Exception as exc:
+        return f"[ошибка загрузки URL: {type(exc).__name__}: {exc}]"
 
 
 def likely_relevant_url(url: str) -> bool:
     parsed = urlparse(url)
     if parsed.scheme not in {"http", "https"}:
         return False
-    if any(skip in parsed.netloc for skip in ["youtube.com", "youtu.be", "facebook.com", "x.com"]):
-        return False
-    return True
+    blocked_hosts = ("youtube.com", "youtu.be", "facebook.com", "x.com")
+    return not any(host in parsed.netloc for host in blocked_hosts)
 
 
 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 e:
-        print(f"[ddgs warning] {type(e).__name__}: {e}")
+    except Exception as exc:
+        logger.warning("DuckDuckGo-поиск не сработал: %s: %s", type(exc).__name__, exc)
         return []
 
     normalized: list[dict[str, str]] = []
     for item in results or []:
-        href = str(item.get("href") or item.get("url") or "").strip()
+        url = str(item.get("href") or item.get("url") or "").strip()
         title = str(item.get("title") or "").strip()
         body = str(item.get("body") or item.get("snippet") or "").strip()
-        if not href and not body:
-            continue
-        normalized.append({"title": title, "url": href, "body": body})
+        if url or body:
+            normalized.append({"title": title, "url": url, "body": body})
     return normalized
 
 
 def build_research_queries(question: str, base_query: str) -> list[str]:
     queries: list[str] = []
+
     quoted_phrases = re.findall(r'["“]([^"”]{3,120})["”]', question)
     if quoted_phrases:
         queries.append(" ".join(f'"{phrase}"' for phrase in quoted_phrases[:4]))
 
-    urls = re.findall(r"https?://[^\s)>\]]+", question)
-    for url in urls[:3]:
+    for url in re.findall(r"https?://[^\s)>\]]+", question)[:3]:
         parsed = urlparse(url.rstrip(".,;"))
         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]))
 
@@ -499,13 +488,10 @@ def build_research_queries(question: str, base_query: str) -> list[str]:
             queries.append(f"{' '.join(capitalized_terms[:3])} {year_text}")
         queries.append(f"{base_query} {year_text}")
 
-    q_lower = question.lower()
-    if "wikipedia" in q_lower and capitalized_terms:
-        queries.append(f"site:en.wikipedia.org {' '.join(capitalized_terms[:4])}")
-    if "wikipedia" in q_lower:
+    if "wikipedia" in question.lower():
         queries.append(f"site:en.wikipedia.org {base_query}")
 
-    queries += [base_query, question]
+    queries.extend([base_query, question])
 
     deduped: list[str] = []
     for query in queries:
@@ -515,24 +501,26 @@ 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]) -> list[str]:
+def build_additional_research_queries(question: str, previous_queries: list[str], llm: ChatGroq) -> list[str]:
     messages = [
-        SystemMessage(content=(
-            "Create 3 concise web search queries for answering the task. "
-            "Prefer exact entity names, dates, source names, and required answer type. "
-            "Return one query per line, no numbering."
-        )),
+        SystemMessage(
+            content=(
+                "Create 3 concise web search queries for answering the task. "
+                "Prefer exact entity names, dates, source names, and required answer type. "
+                "Return one query per line, no numbering."
+            )
+        ),
         HumanMessage(content=question),
     ]
+
     try:
-        llm = make_chat_model(GROQ_FINAL_MODEL, max_tokens=160)
         raw = llm.invoke(messages).content
-    except Exception as e:
-        print(f"[query expansion warning] {type(e).__name__}: {e}")
+    except Exception as exc:
+        logger.warning("Не удалось расширить поисковые запросы: %s: %s", type(exc).__name__, exc)
         return []
 
+    previous = {query.lower() for query in previous_queries}
     queries: list[str] = []
-    previous = {q.lower() for q in previous_queries}
     for line in raw.splitlines():
         query = clean_answer(re.sub(r"^\s*[-*\d.)]+\s*", "", line))
         query = re.sub(r"\s+", " ", query).strip()
@@ -541,151 +529,141 @@ def build_additional_research_queries(question: str, previous_queries: list[str]
     return queries[:3]
 
 
-def fetch_youtube_timedtext(video_id: str) -> str:
-    urls = [
-        f"https://video.google.com/timedtext?lang=en&v={video_id}",
-        f"https://www.youtube.com/api/timedtext?lang=en&v={video_id}",
-    ]
-    for url in urls:
-        try:
-            resp = requests.get(url, timeout=12, headers={"User-Agent": "GAIA-course-agent/1.0"})
-            resp.raise_for_status()
-            if not resp.text.strip():
-                continue
-            chunks = re.findall(r"<text[^>]*>(.*?)</text>", resp.text, flags=re.S)
-            if 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 e:
-            print(f"[youtube timedtext warning] {type(e).__name__}: {e}")
-    return ""
-
-
-def build_youtube_context(question: str, video_id: str | None) -> str:
-    queries: list[str] = []
-    quoted_phrases = re.findall(r'["“]([^"”]{3,120})["”]', question)
-    if video_id:
-        queries += [
-            f'"{video_id}" transcript',
-            f'"{video_id}" subtitles',
-            f'"{video_id}"',
-        ]
-        for phrase in quoted_phrases[:3]:
-            queries.append(f'"{video_id}" "{phrase}"')
-    if quoted_phrases:
-        queries.append(" ".join(f'"{phrase}"' for phrase in quoted_phrases[:3]))
-
-    queries.append(question)
-
-    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)}")
+def build_research_context(question: str, base_query: str) -> str:
+    parts = [f"Question: {question}", f"Primary query: {base_query}"]
     seen_urls: set[str] = set()
 
-    for query in queries[:8]:
+    for query in build_research_queries(question, base_query):
         parts.append(f"\n=== Search query: {query} ===")
         results = ddg_search(query, max_results=6)
-        if not results:
-            parts.append(safe_tool_run(web_search_tool, query, limit=2000))
-            continue
+        fetched_count = 0
 
-        for i, result in enumerate(results, 1):
+        for index, result in enumerate(results, 1):
             url = result["url"]
-            parts.append(f"[{i}] {result['title']}\nURL: {url}\nSnippet: {result['body']}")
-            if not url or url in seen_urls:
-                continue
-            parsed = urlparse(url)
-            if parsed.scheme not in {"http", "https"}:
-                continue
-            if "youtube.com" in parsed.netloc or "youtu.be" in parsed.netloc:
+            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 >= 2:
                 continue
+
             seen_urls.add(url)
-            fetched = fetch_url_text(url, limit=4000)
-            if fetched and not fetched.startswith("[fetch error"):
+            fetched = fetch_url_text(url, limit=5000)
+            if fetched and not fetched.startswith("[ошибка загрузки"):
+                fetched_count += 1
                 parts.append(f"Fetched text from {url}:\n{fetched}")
+
             if len("\n".join(parts)) > MAX_SEARCH_CONTEXT_CHARS:
                 return truncate_text("\n".join(parts), MAX_SEARCH_CONTEXT_CHARS)
 
     return truncate_text("\n".join(parts), MAX_SEARCH_CONTEXT_CHARS)
 
 
-def build_research_context(question: str, base_query: str) -> str:
-    parts = [f"Question: {question}", f"Primary query: {base_query}"]
-    seen_urls: set[str] = set()
-    queries = build_research_queries(question, base_query)
+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
 
-    for query in queries:
+    parts = [context, "\n=== Additional focused searches ==="]
+    seen_urls = set(re.findall(r"URL: (https?://\S+)", context))
+
+    for query in extra_queries:
         parts.append(f"\n=== Search query: {query} ===")
         results = ddg_search(query, max_results=6)
-        if not results:
-            parts.append(safe_tool_run(web_search_tool, query, limit=2000))
-            continue
-
         fetched_count = 0
-        for i, result in enumerate(results, 1):
-            url = result["url"]
-            title = result["title"]
-            body = result["body"]
-            parts.append(f"[{i}] {title}\nURL: {url}\nSnippet: {body}")
 
-            if not url or url in seen_urls:
-                continue
-            if not likely_relevant_url(url):
-                continue
-            if fetched_count >= 2:
+        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 >= 2:
                 continue
 
             seen_urls.add(url)
             fetched = fetch_url_text(url, limit=5000)
-            if fetched and not fetched.startswith("[fetch error"):
+            if fetched and not fetched.startswith("[ошибка загрузки"):
                 fetched_count += 1
                 parts.append(f"Fetched text from {url}:\n{fetched}")
+
             if len("\n".join(parts)) > MAX_SEARCH_CONTEXT_CHARS:
                 return truncate_text("\n".join(parts), MAX_SEARCH_CONTEXT_CHARS)
 
     return truncate_text("\n".join(parts), MAX_SEARCH_CONTEXT_CHARS)
 
 
-def extend_research_context(question: str, context: str, used_query: str) -> str:
-    extra_queries = build_additional_research_queries(question, [used_query])
-    if not extra_queries:
-        return context
+def extract_youtube_id(question: str) -> str | None:
+    match = re.search(r"(?:v=|youtu\.be/)([A-Za-z0-9_-]{11})", question)
+    return match.group(1) if match else None
 
-    parts = [context, "\n=== Additional focused searches ==="]
-    seen_urls = set(re.findall(r"URL: (https?://\S+)", context))
-    for query in extra_queries:
+
+def is_youtube_question(question: str) -> bool:
+    lower = question.lower()
+    return "youtube.com/watch" in lower or "youtu.be/" in lower
+
+
+def fetch_youtube_timedtext(video_id: str) -> str:
+    urls = [
+        f"https://video.google.com/timedtext?lang=en&v={video_id}",
+        f"https://www.youtube.com/api/timedtext?lang=en&v={video_id}",
+    ]
+
+    for url in urls:
+        try:
+            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 = re.sub(r"\s+", " ", text).strip()
+            if text:
+                return text
+        except Exception as exc:
+            logger.warning("Не удалось получить YouTube timedtext: %s: %s", type(exc).__name__, exc)
+
+    return ""
+
+
+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.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()
+    for query in queries[:8]:
         parts.append(f"\n=== Search query: {query} ===")
         results = ddg_search(query, max_results=6)
-        if not results:
-            parts.append(safe_tool_run(web_search_tool, query, limit=2000))
-            continue
 
-        fetched_count = 0
-        for i, result in enumerate(results, 1):
+        for index, result in enumerate(results, 1):
             url = result["url"]
-            parts.append(f"[{i}] {result['title']}\nURL: {url}\nSnippet: {result['body']}")
-            if not url or url in seen_urls or not likely_relevant_url(url):
+            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"}:
                 continue
-            if fetched_count >= 2:
+            if "youtube.com" in parsed.netloc or "youtu.be" in parsed.netloc:
                 continue
+
             seen_urls.add(url)
-            fetched = fetch_url_text(url, limit=5000)
-            if fetched and not fetched.startswith("[fetch error"):
-                fetched_count += 1
+            fetched = fetch_url_text(url, limit=4000)
+            if fetched and not fetched.startswith("[ошибка загрузки"):
                 parts.append(f"Fetched text from {url}:\n{fetched}")
+
             if len("\n".join(parts)) > MAX_SEARCH_CONTEXT_CHARS:
                 return truncate_text("\n".join(parts), MAX_SEARCH_CONTEXT_CHARS)
 
     return truncate_text("\n".join(parts), MAX_SEARCH_CONTEXT_CHARS)
 
 
-def clean_answer(answer: str) -> str:
-    answer = str(answer or "").strip()
-
+def clean_answer(answer: Any) -> str:
+    value = str(answer or "").strip()
     prefixes = [
         "FINAL ANSWER:",
         "Final Answer:",
@@ -694,22 +672,30 @@ def clean_answer(answer: str) -> str:
         "the answer is:",
         "Answer:",
         "answer:",
+        "ФИНАЛЬНЫЙ ОТВЕТ:",
+        "Финальный ответ:",
+        "Ответ:",
+        "ответ:",
     ]
-    for p in prefixes:
-        if answer.lower().startswith(p.lower()):
-            answer = answer[len(p):].strip()
 
-    answer = answer.strip().strip("`*").strip()
-    answer = answer.strip('"').strip("'").strip()
+    for prefix in prefixes:
+        if value.lower().startswith(prefix.lower()):
+            value = value[len(prefix) :].strip()
 
-    return answer
+    return value.strip().strip("`*").strip().strip('"').strip("'").strip()
 
 
-def is_bad_answer(answer: str) -> bool:
-    a = clean_answer(answer).lower()
-    if not a:
+def is_bad_answer(answer: Any) -> bool:
+    value = clean_answer(answer).lower()
+    if not value:
         return True
+
     bad_markers = [
+        "ошибка:",
+        "не хватает данных",
+        "недостаточно данных",
+        "не удалось",
+        "не найден",
         "error:",
         "i don't know",
         "i do not know",
@@ -720,121 +706,14 @@ def is_bad_answer(answer: str) -> bool:
         "no answer",
         "no answer found",
         "no information found",
-        "i could not find",
-        "i couldn't find",
         "could not find",
         "couldn't find",
         "not found",
-        "not in the search results",
-        "not in the provided",
-        "this answer is not",
-        "unknown",
         "insufficient information",
-        "cannot determine",
-    ]
-    return any(m in a for m in bad_markers)
-
-
-def reversed_english_question(question: str) -> bool:
-    rev = question[::-1].lower()
-    markers = ["if you understand", "the answer", "opposite", "write", "word"]
-    return sum(1 for m in markers if m in rev) >= 2
-
-
-def solve_directly_with_python(question: str) -> str | None:
-    q = question.strip()
-
-    if reversed_english_question(q):
-        rev = q[::-1]
-        m = re.search(r'opposite of the word ["“”\']?([A-Za-z]+)["“”\']?', rev, flags=re.I)
-        if m:
-            word = m.group(1).lower()
-            opposites = {
-                "left": "right",
-                "right": "left",
-                "up": "down",
-                "down": "up",
-                "yes": "no",
-                "no": "yes",
-                "true": "false",
-                "false": "true",
-                "hot": "cold",
-                "cold": "hot",
-            }
-            if word in opposites:
-                return opposites[word]
-
-    return None
-
-
-def solve_commutativity_table(question: str) -> str | None:
-    q = question.lower()
-
-    if "|---" not in question:
-        return None
-
-    if "commutative" not in q and "commutativity" not in q:
-        return None
-
-    lines = [
-        line.strip()
-        for line in question.splitlines()
-        if line.strip().startswith("|")
+        "insufficient evidence",
+        "unknown",
     ]
-
-    if len(lines) < 3:
-        return None
-
-    header = [x.strip() for x in lines[0].strip("|").split("|")]
-    cols = header[1:]
-
-    table = {}
-
-    for line in lines[2:]:
-        cells = [x.strip() for x in line.strip("|").split("|")]
-        if len(cells) != len(cols) + 1:
-            continue
-
-        row = cells[0]
-        values = cells[1:]
-        table[row] = dict(zip(cols, values))
-
-    for a in cols:
-        for b in cols:
-            if a == b:
-                continue
-
-            ab = table.get(a, {}).get(b)
-            ba = table.get(b, {}).get(a)
-
-            if ab is not None and ba is not None and ab != ba:
-                return ", ".join(sorted([a, b]))
-
-    return "commutative"
-
-
-def direct_question(question: str) -> bool:
-    q = question.lower()
-    rev = q[::-1]
-
-    if reversed_english_question(question):
-        return True
-    if "|---" in question or question.count("|") >= 8:
-        return True
-    if any(marker in q for marker in [
-        "grocery list",
-        "shopping list",
-        "given this table",
-        "opposite of",
-        "reverse",
-        "what is the final numeric output",
-    ]):
-        return True
-    if any(marker in rev for marker in ["opposite", "the answer", "write"]):
-        return True
-    if "http://" in q or "https://" in q or "youtube.com" in q or "youtu.be" in q:
-        return False
-    return False
+    return any(marker in value for marker in bad_markers)
 
 
 def last_nonempty_line(text: str) -> str:
@@ -842,12 +721,7 @@ def last_nonempty_line(text: str) -> str:
     return lines[-1] if lines else ""
 
 
-def extract_youtube_id(question: str) -> str | None:
-    m = re.search(r"(?:v=|youtu\.be/)([A-Za-z0-9_-]{11})", question)
-    return m.group(1) if m else None
-
-
-class AgentState(TypedDict):
+class AgentState(TypedDict, total=False):
     question: str
     task_id: str
     route: str
@@ -861,44 +735,39 @@ class AgentState(TypedDict):
 
 
 class BasicAgent:
-    def __init__(self):
+    def __init__(self) -> None:
         self.answer_llm = make_chat_model(GROQ_TEXT_MODEL, max_tokens=256)
-        self.final_llm = make_chat_model(GROQ_FINAL_MODEL, max_tokens=48)
+        self.final_llm = make_chat_model(GROQ_FINAL_MODEL, max_tokens=64)
         self.strong_llm = make_chat_model(GROQ_STRONG_MODEL, max_tokens=512)
         self.research_llm = make_chat_model(GROQ_RESEARCH_MODEL, max_tokens=512)
-
         self.graph = self.build_graph()
 
-        print(f"   Text model    : {GROQ_TEXT_MODEL}")
-        print(f"   Final model   : {GROQ_FINAL_MODEL}")
-        print(f"   Research model: {GROQ_RESEARCH_MODEL}")
-        print(f"   Vision model  : {GROQ_VISION_MODEL}")
-        print(f"   Audio model   : {GROQ_AUDIO_MODEL}")
-        print(f"   Code execution: {ALLOW_CODE_EXECUTION}")
+        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 "отключено")
 
     def build_graph(self):
-        g = StateGraph(AgentState)
-
-        g.add_node("classify_task", self.classify_task)
-        g.add_node("route_by_type", self.route_by_type_node)
-
-        g.add_node("solve_image", self.solve_image)
-        g.add_node("solve_audio", self.solve_audio)
-        g.add_node("solve_spreadsheet", self.solve_spreadsheet)
-        g.add_node("solve_code", self.solve_code)
-        g.add_node("solve_direct", self.solve_direct)
-        g.add_node("solve_research", self.solve_research)
-        g.add_node("solve_youtube", self.solve_youtube)
-
-        g.add_node("verify_answer", self.verify_answer)
-        g.add_node("final_cleaner", self.final_cleaner)
-
-        g.set_entry_point("classify_task")
-        g.add_edge("classify_task", "route_by_type")
-
-        g.add_conditional_edges(
-            "route_by_type",
-            self.route_by_type,
+        graph = StateGraph(AgentState)
+
+        graph.add_node("classify_task", self.classify_task)
+        graph.add_node("solve_image", self.solve_image)
+        graph.add_node("solve_audio", self.solve_audio)
+        graph.add_node("solve_spreadsheet", self.solve_spreadsheet)
+        graph.add_node("solve_code", self.solve_code)
+        graph.add_node("solve_direct", self.solve_direct)
+        graph.add_node("solve_research", self.solve_research)
+        graph.add_node("solve_youtube", self.solve_youtube)
+        graph.add_node("verify_answer", self.verify_answer)
+        graph.add_node("final_cleaner", self.final_cleaner)
+
+        graph.set_entry_point("classify_task")
+        graph.add_conditional_edges(
+            "classify_task",
+            self.select_route,
             {
                 "solve_image": "solve_image",
                 "solve_audio": "solve_audio",
@@ -910,7 +779,7 @@ class BasicAgent:
             },
         )
 
-        for node in [
+        for node in (
             "solve_image",
             "solve_audio",
             "solve_spreadsheet",
@@ -918,18 +787,16 @@ class BasicAgent:
             "solve_direct",
             "solve_research",
             "solve_youtube",
-        ]:
-            g.add_edge(node, "verify_answer")
+        ):
+            graph.add_edge(node, "verify_answer")
 
-        g.add_edge("verify_answer", "final_cleaner")
-        g.add_edge("final_cleaner", END)
-
-        return g.compile()
+        graph.add_edge("verify_answer", "final_cleaner")
+        graph.add_edge("final_cleaner", END)
+        return graph.compile()
 
     def classify_task(self, state: AgentState) -> dict[str, Any]:
         question = state.get("question", "")
         task_id = state.get("task_id", "")
-
         file_kind, local_path = detect_local_file_kind(task_id)
 
         if file_kind == "image":
@@ -942,21 +809,15 @@ class BasicAgent:
             route = "solve_code"
         elif file_kind in {"pdf", "text", "binary"}:
             route = "solve_direct"
-        elif direct_question(question):
-            route = "solve_direct"
         elif is_youtube_question(question):
             route = "solve_youtube"
         else:
             route = "solve_research"
 
-        print(f"[classify] file_kind={file_kind}, route={route}, path={local_path}")
+        logger.info("Маршрут задачи: file_kind=%s, route=%s, path=%s", file_kind, route, local_path)
         return {"file_kind": file_kind, "local_path": local_path, "route": route}
 
-    def route_by_type_node(self, state: AgentState) -> dict[str, Any]:
-        print(f"[route_by_type] {state.get('route')}")
-        return {}
-
-    def route_by_type(self, state: AgentState) -> str:
+    def select_route(self, state: AgentState) -> str:
         route = state.get("route", "solve_research")
         allowed = {
             "solve_image",
@@ -972,58 +833,47 @@ class BasicAgent:
     def solve_image(self, state: AgentState) -> dict[str, Any]:
         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=question,
-            context=context,
-            context_label="Image analysis",
-            llm=self.strong_llm,
-        )
+        raw_answer = self.answer_from_context(question, context, "Image analysis", self.strong_llm)
         return {"context": context, "raw_answer": raw_answer}
 
     def solve_audio(self, state: AgentState) -> dict[str, Any]:
         question = state.get("question", "")
         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=question,
-            context=context,
-            context_label="Audio transcript",
-            llm=self.answer_llm,
-        )
+        raw_answer = self.answer_from_context(question, context, "Audio transcript", self.answer_llm)
         return {"context": context, "raw_answer": raw_answer}
 
-    def solve_spreadsheet(self, state: AgentState) -> dict:
-        path = state["local_path"]
-        question = state["question"]
+    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-маршрута не найден путь к файлу")}
 
-        context = read_spreadsheet_context(Path(path))
-        summary = build_spreadsheet_summary(Path(path))
+        path = Path(local_path)
+        context = read_spreadsheet_context(path)
+        summary = build_spreadsheet_summary(path)
         if summary:
             context = f"{context}\n\n--- Computed spreadsheet summary ---\n{summary}"
 
         raw_answer = self.answer_from_context(
-            question=question,
-            context=context,
-            context_label="Spreadsheet data and computed summary",
-            llm=self.strong_llm,
+            question,
+            context,
+            "Spreadsheet data and computed summary",
+            self.strong_llm,
         )
-
         return {"context": context, "raw_answer": raw_answer}
 
     def solve_code(self, state: AgentState) -> dict[str, Any]:
         question = state.get("question", "")
         local_path = state.get("local_path")
-
         if not local_path:
-            return {"raw_answer": "ERROR: code route selected but no local file path found"}
+            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 "[execution skipped: not 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:
@@ -1032,12 +882,7 @@ class BasicAgent:
             if candidate and re.search(r"[-+]?\d", candidate):
                 return {"context": context, "raw_answer": candidate}
 
-        raw_answer = self.answer_from_context(
-            question=question,
-            context=context,
-            context_label="Code and execution result",
-            llm=self.strong_llm,
-        )
+        raw_answer = self.answer_from_context(question, context, "Code and execution result", self.strong_llm)
         return {"context": context, "raw_answer": raw_answer}
 
     def solve_direct(self, state: AgentState) -> dict[str, Any]:
@@ -1046,83 +891,45 @@ class BasicAgent:
         file_kind = state.get("file_kind", "none")
         local_path = state.get("local_path")
 
-        shortcut = solve_directly_with_python(question)
-        if shortcut is not None:
-            return {"context": "Solved by deterministic Python shortcut.", "raw_answer": shortcut}
-
-        direct = solve_commutativity_table(question)
-        if direct is not None:
-            return {"raw_answer": direct}
-
         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=question,
-            context=context,
-            context_label=f"Direct context; file_kind={file_kind}",
-            llm=self.answer_llm,
-        )
+        raw_answer = self.answer_from_context(question, context, f"Direct context; file_kind={file_kind}", self.answer_llm)
         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)
-        print(f"[research query] {query}")
+        logger.info("Поисковый запрос: %s", query)
 
         context = build_research_context(question, query)
+        logger.info("Размер поискового контекста: %s", len(context))
 
-        print(f"[research context len] {len(context)}")
-        print(f"[research context preview] {repr(context[:500])}")
-
-        raw_answer = self.answer_from_context(
-            question=question,
-            context=context,
-            context_label="Web research results",
-            llm=self.research_llm,
-        )
-
+        raw_answer = self.answer_from_context(question, context, "Web research results", self.research_llm)
         if is_bad_answer(raw_answer):
-            context = extend_research_context(question, context, query)
-            print(f"[research extended context len] {len(context)}")
-            raw_answer = self.answer_from_context(
-                question=question,
-                context=context,
-                context_label="Extended web research results",
-                llm=self.strong_llm,
-            )
+            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)
 
-        print(f"[research raw_answer] {repr(raw_answer[:500])}")
         return {"context": context, "raw_answer": raw_answer}
-    
-    def solve_youtube(self, state: AgentState) -> dict:
-        question = state["question"]
-        video_id = extract_youtube_id(question)
 
+    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=question,
-            context=context,
-            context_label="YouTube/web transcript search results",
-            llm=self.research_llm,
-        )
+        raw_answer = self.answer_from_context(question, context, "YouTube/web transcript search results", self.research_llm)
 
         if is_bad_answer(raw_answer):
-            context = extend_research_context(question, context, question)
+            context = extend_research_context(question, context, question, self.final_llm)
             raw_answer = self.answer_from_context(
-                question=question,
-                context=context,
-                context_label="Extended YouTube/web transcript search results",
-                llm=self.strong_llm,
+                question,
+                context,
+                "Extended YouTube/web transcript search results",
+                self.strong_llm,
             )
 
-        return {
-            "context": context,
-            "raw_answer": raw_answer,
-        }
+        return {"context": context, "raw_answer": raw_answer}
 
     def verify_answer(self, state: AgentState) -> dict[str, Any]:
         question = state.get("question", "")
@@ -1132,10 +939,7 @@ class BasicAgent:
         file_kind = state.get("file_kind", "none")
 
         if is_bad_answer(raw_answer):
-            return {"verified_answer": "", "error": raw_answer or "empty answer"}
-
-        if context.startswith("Solved by deterministic"):
-            return {"verified_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"}:
             return {"verified_answer": raw_answer}
@@ -1144,27 +948,31 @@ class BasicAgent:
             return {"verified_answer": raw_answer}
 
         messages = [
-            SystemMessage(content=(
-                "You verify a draft answer for a GAIA benchmark task. "
-                "Use only the provided context. Return only the corrected final answer. "
-                "If the context does not support an answer, return ERROR: insufficient evidence."
-            )),
-            HumanMessage(content=(
-                f"Question:\n{question}\n\n"
-                f"Context, if any:\n{truncate_text(context, 5000)}\n\n"
-                f"Draft answer:\n{truncate_text(raw_answer, 3000)}\n\n"
-                "Correct final answer only:"
-            )),
+            SystemMessage(
+                content=(
+                    "You verify a draft answer for a GAIA benchmark task. "
+                    "Use only the provided context. Return only the corrected final answer. "
+                    "If the context does not support an answer, return ERROR: insufficient evidence."
+                )
+            ),
+            HumanMessage(
+                content=(
+                    f"Question:\n{question}\n\n"
+                    f"Context:\n{truncate_text(context, 5000)}\n\n"
+                    f"Draft answer:\n{truncate_text(raw_answer, 3000)}\n\n"
+                    "Correct final answer only:"
+                )
+            ),
         ]
+
         try:
             verified = self.final_llm.invoke(messages).content.strip()
-        except Exception as e:
+        except Exception as exc:
+            logger.warning("Проверка ответа не сработала: %s: %s", type(exc).__name__, exc)
             verified = raw_answer
-            print(f"[verify warning] {type(e).__name__}: {e}")
 
         if is_bad_answer(verified):
             return {"verified_answer": "", "error": clean_answer(verified)}
-
         return {"verified_answer": clean_answer(verified)}
 
     def final_cleaner(self, state: AgentState) -> dict[str, Any]:
@@ -1172,17 +980,16 @@ class BasicAgent:
         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 "bad answer"}
+            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 "bad answer"}
+            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:
         system = (
             "You answer GAIA benchmark questions.\n"
@@ -1203,15 +1010,20 @@ class BasicAgent:
 
         try:
             return llm.invoke([SystemMessage(content=system), HumanMessage(content=user)]).content.strip()
-        except Exception as e:
-            message = str(e)
-            if "tool_use_failed" in message or "Tool choice is none" in message or "model called a tool" in message:
+        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:
-                    print(f"[llm fallback] {type(e).__name__}: retrying with {GROQ_TEXT_MODEL}")
+                    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_error:
-                    return f"ERROR: LLM answer error: {type(fallback_error).__name__}: {fallback_error}"
-            return f"ERROR: LLM answer error: {type(e).__name__}: {e}"
+                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)
@@ -1219,42 +1031,47 @@ class BasicAgent:
             return raw_answer
 
         messages = [
-            SystemMessage(content=(
-                "Extract the final answer from the draft. "
-                "Return ONLY the answer itself. No explanation. No prefix. No quotes."
-            )),
-            HumanMessage(content=(
-                f"Question:\n{question}\n\n"
-                f"Draft answer:\n{truncate_text(raw_answer, 3000)}\n\n"
-                "Final answer only:"
-            )),
+            SystemMessage(
+                content=(
+                    "Extract the final answer from the draft. "
+                    "Return ONLY the answer itself. No explanation. No prefix. No quotes."
+                )
+            ),
+            HumanMessage(
+                content=(
+                    f"Question:\n{question}\n\n"
+                    f"Draft answer:\n{truncate_text(raw_answer, 3000)}\n\n"
+                    "Final answer only:"
+                )
+            ),
         ]
+
         try:
             return clean_answer(self.final_llm.invoke(messages).content.strip())
-        except Exception as e:
-            print(f"[final extractor warning] {type(e).__name__}: {e}")
+        except Exception as exc:
+            logger.warning("Финальное извлечение ответа не сработало: %s: %s", type(exc).__name__, exc)
             return clean_answer(last_nonempty_line(raw_answer))
 
     def make_search_query(self, question: str) -> str:
-        q = re.sub(r"\s+", " ", question).strip()
-        if len(q) <= 220:
-            return q
+        question = re.sub(r"\s+", " ", question).strip()
+        if len(question) <= 220:
+            return question
 
         messages = [
             SystemMessage(content="Rewrite the task as a concise web search query. Output only the query."),
-            HumanMessage(content=q[:1000]),
+            HumanMessage(content=question[:1000]),
         ]
         try:
-            query = self.final_llm.invoke(messages).content.strip()
-            query = clean_answer(query)
-            return query[:220] if query else q[:220]
-        except Exception:
-            return q[:220]
+            query = clean_answer(self.final_llm.invoke(messages).content.strip())
+            return query[:220] if query else question[:220]
+        except Exception as exc:
+            logger.warning("Не удалось сжать вопрос в поисковый запрос: %s: %s", type(exc).__name__, exc)
+            return question[:220]
 
     def __call__(self, question: str, task_id: str = "") -> str:
-        print(f"\n{'─' * 60}")
-        print(f"[task_id] {task_id}")
-        print(f"[question] {question[:160]}...")
+        logger.info("\n%s", "-" * 60)
+        logger.info("ID задачи: %s", task_id)
+        logger.info("Вопрос: %s", question[:160])
 
         try:
             result = self.graph.invoke(
@@ -1262,44 +1079,40 @@ class BasicAgent:
                 config={"recursion_limit": 12},
             )
             answer = clean_answer(result.get("final_answer", ""))
-
             if not answer:
-                error = result.get("error", "no final answer")
-                answer = f"ERROR: {error}"
-
-            print(f"[final] {answer}")
+                answer = error_text(result.get("error", "финальный ответ не получен"))
+            logger.info("Итоговый ответ: %s", answer)
             return answer
-        except Exception as e:
-            print(f"[agent error] {type(e).__name__}: {e}")
-            return f"ERROR: {type(e).__name__}: {e}"
+        except Exception as exc:
+            logger.error("Агент завершился с ошибкой: %s: %s", type(exc).__name__, exc)
+            return error_text("агент завершился с ошибкой", exc)
 
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     space_id = os.getenv("SPACE_ID")
 
     if not profile:
-        return "Please log in to Hugging Face first.", None
+        return "Сначала войдите в Hugging Face.", None
 
     username = profile.username
-    print(f"Logged in: {username}")
-
-    questions_url = f"{DEFAULT_API_URL}/questions"
-    submit_url = f"{DEFAULT_API_URL}/submit"
+    logger.info("Пользователь HF: %s", username)
 
     try:
         agent = BasicAgent()
-    except Exception as e:
-        return f"Agent init error: {type(e).__name__}: {e}", None
+    except Exception as exc:
+        return error_text("не удалось инициализировать агента", exc), 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 ""
 
     try:
-        resp = requests.get(questions_url, timeout=20)
-        resp.raise_for_status()
-        questions_data = resp.json()
-        print(f"Fetched {len(questions_data)} questions.")
-    except Exception as e:
-        return f"Error fetching questions: {type(e).__name__}: {e}", None
+        response = requests.get(questions_url, timeout=20)
+        response.raise_for_status()
+        questions_data = response.json()
+        logger.info("Получено вопросов: %s", len(questions_data))
+    except Exception as exc:
+        return error_text("не удалось получить список вопросов", exc), None
 
     results_log: list[dict[str, str]] = []
     answers_payload: list[dict[str, str]] = []
@@ -1312,38 +1125,41 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
         try:
             answer = agent(question_text, task_id=task_id)
-            results_log.append({"Task ID": task_id, "Question": question_text[:120], "Answer": answer})
+            results_log.append({"ID задачи": task_id, "Вопрос": question_text[:120], "Ответ": answer})
 
-            if answer and not answer.startswith("ERROR:"):
+            if answer and not is_bad_answer(answer):
                 answers_payload.append({"task_id": task_id, "submitted_answer": answer})
             else:
-                print(f"[skip submit] {task_id}: {answer}")
-
-        except Exception as e:
-            err = f"ERROR: {type(e).__name__}: {e}"
-            results_log.append({"Task ID": task_id, "Question": question_text[:120], "Answer": err})
-            print(f"[question error] {task_id}: {err}")
+                logger.info("Ответ не отправлен для task_id=%s: %s", task_id, answer)
+        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)
             time.sleep(1)
 
     if not answers_payload:
-        return "Agent produced no submittable answers.", pd.DataFrame(results_log)
+        return "Агент не подготовил ни одного ответа для отправки.", pd.DataFrame(results_log)
 
-    payload = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
+    payload = {
+        "username": username.strip(),
+        "agent_code": agent_code,
+        "answers": answers_payload,
+    }
 
     try:
-        resp = requests.post(submit_url, json=payload, timeout=60)
-        resp.raise_for_status()
-        r = resp.json()
+        response = requests.post(submit_url, json=payload, timeout=60)
+        response.raise_for_status()
+        result = response.json()
         status = (
-            f"✅ Submission successful!\n"
-            f"User : {r.get('username')}\n"
-            f"Score: {r.get('score', 'N/A')}% "
-            f"({r.get('correct_count', '?')}/{r.get('total_attempted', '?')} correct)\n"
-            f"Msg  : {r.get('message', '')}\n"
-            f"Submitted answers: {len(answers_payload)}/{len(questions_data)}"
+            "Сабмит выполнен.\n"
+            f"Пользователь: {result.get('username')}\n"
+            f"Счет: {result.get('score', 'N/A')}% "
+            f"({result.get('correct_count', '?')}/{result.get('total_attempted', '?')})\n"
+            f"Сообщение: {result.get('message', '')}\n"
+            f"Отправлено ответов: {len(answers_payload)}/{len(questions_data)}"
         )
-    except Exception as e:
-        status = f"Submission error: {type(e).__name__}: {e}"
+    except Exception as exc:
+        status = error_text("ошибка отправки сабмита", exc)
 
     return status, pd.DataFrame(results_log)
 
@@ -1352,35 +1168,25 @@ space_host_startup = os.getenv("SPACE_HOST")
 space_id_startup = os.getenv("SPACE_ID")
 oauth_available = bool(space_host_startup or space_id_startup or os.getenv("HF_TOKEN"))
 
-
-with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner — Routed LangGraph")
-    gr.Markdown(
-        """
-        **Architecture:** `classify_task → route_by_type → solve_* → verify_answer → final_cleaner`.
-
-        Local files are routed deterministically by Python. Web are called only inside `solve_research`, without automatic LLM tool-calling.
-        """
-    )
+with gr.Blocks(title="GAIA LangGraph Agent") as demo:
+    gr.Markdown("# GAIA LangGraph Agent")
 
     if oauth_available:
         gr.LoginButton()
     else:
-        gr.Markdown("Hugging Face OAuth is disabled locally. Run inside a Space or set `HF_TOKEN`.")
-    run_button = gr.Button("Run Evaluation & Submit All Answers")
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=6, interactive=False)
-    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
-
-    run_button.click(
-        fn=run_and_submit_all,
-        outputs=[status_output, results_table],
-    )
+        gr.Markdown("OAuth Hugging Face недоступен вне Space. Для сабмита нужен вход в HF.")
+
+    run_button = gr.Button("Запустить оценку и отправить ответы")
+    status_output = gr.Textbox(label="Статус", lines=6, interactive=False)
+    results_table = gr.DataFrame(label="Ответы агента", wrap=True)
+
+    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
 if space_host_startup:
-    print(f"✅ SPACE_HOST found: {space_host_startup}")
+    logger.info("SPACE_HOST найден: %s", space_host_startup)
 if space_id_startup:
-    print(f"✅ SPACE_ID found: {space_id_startup}")
+    logger.info("SPACE_ID найден: %s", space_id_startup)
 
 if __name__ == "__main__":
-    print("Launching Gradio Interface for Routed LangGraph Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    logger.info("Запускаю Gradio-интерфейс LangGraph-агента.")
+    demo.launch(debug=os.getenv("GRADIO_DEBUG", "0") == "1", share=False)