Update app.py

"""HF Agents Course 최종 과제 - Gemini 또는 Hugging Face 선택형 경량 버전

설계 원칙: 문항당 LLM 호출 1회.
웹 검색(호출 없음) -> 검색 결과 + 첨부 파일을 한 번에 Gemini에 전달 -> 최종 답만 받음
"""
import base64
import json
import mimetypes
import os
import re
import time
from collections import deque

import gradio as gr
import pandas as pd
import requests

# ZeroGPU 하드웨어에서 시작 오류를 막기 위한 더미 함수 (CPU 하드웨어에서는 무시됨)
try:
import spaces

@spaces.GPU
def _gpu_placeholder():
return "ok"
except ImportError:
pass

try:
from ddgs import DDGS
except ImportError:
try:
from duckduckgo_search import DDGS
except ImportError:
DDGS = None

# ---------------------------------------------------------------------------
# 설정 (Space Variables/Secrets로 조정)
# ---------------------------------------------------------------------------
SCORING_API = "https://agents-course-unit4-scoring.hf.space"
GEMINI_API = "https://generativelanguage.googleapis.com/v1beta"
FILES_DIR = "/tmp/task_files"
CACHE_PATH = "/tmp/answers_cache.json"
os.makedirs(FILES_DIR, exist_ok=True)

PROVIDER = (os.getenv("PROVIDER", "") or ("gemini" if os.getenv("GEMINI_API_KEY") else "hf")).lower() # gemini | hf
MIN_INTERVAL = float(os.getenv("MIN_INTERVAL", "7" if PROVIDER == "gemini" else "2")) # LLM 호출 간 최소 간격(초)
HF_ROUTER = "https://router.huggingface.co/v1"
HF_MODELS = [m.strip() for m in (os.getenv("HF_MODELS") or os.getenv("HF_MODEL") or "Qwen/Qwen2.5-72B-Instruct").split(",") if m.strip()]
MAX_RETRY = int(os.getenv("MAX_RETRY", "3")) # 429 재시도 횟수
FETCH_PAGES = int(os.getenv("FETCH_PAGES", "2")) # 본문을 읽을 검색 결과 수
PAGE_CHARS = int(os.getenv("PAGE_CHARS", "5000")) # 페이지당 최대 글자 수
LLM_QUERY = os.getenv("LLM_QUERY", "0") == "1" # 1이면 검색어도 Gemini로 생성(호출 2배)
GEMINI_MODELS = os.getenv("GEMINI_MODELS", "") # 선택: 쉼표로 구분한 모델 이름 목록

PROMPT = """You are answering a GAIA-style benchmark question. The answer is graded by EXACT MATCH.

Rules:
- Use the provided web context and attached file. If the context is insufficient, use your own knowledge and reason carefully.
- Give ONLY the answer value: no explanation, no trailing period, no units unless asked.
- Numbers: digits only, no thousands separators, no currency or percent symbols unless asked.
- Lists: comma-separated, in the order the question asks.
- Strings: no leading articles (a, an, the), no abbreviations unless asked.
- End your reply with one final line exactly in the form:
FINAL ANSWER: <answer>

Question:
{question}

{extra}"""

# ---------------------------------------------------------------------------
# 로그
# ---------------------------------------------------------------------------
_events = deque(maxlen=12)


def log(msg: str):
line = f"[{time.strftime('%H:%M:%S')}] {msg}"
print(line, flush=True)
_events.append(line)


def recent_log() -> str:
return "\n".join(_events)


# ---------------------------------------------------------------------------
# 캐시
# ---------------------------------------------------------------------------
def load_cache() -> dict:
try:
with open(CACHE_PATH, "r", encoding="utf-8") as f:
return json.load(f)
except Exception: # noqa: BLE001
return {}


def save_cache(task_id: str, answer: str):
cache = load_cache()
cache[task_id] = answer
with open(CACHE_PATH, "w", encoding="utf-8") as f:
json.dump(cache, f, ensure_ascii=False)


# ---------------------------------------------------------------------------
# Gemini REST 호출 (라이브러리 없이 requests만 사용)
# ---------------------------------------------------------------------------
class LLMUnavailable(Exception):
pass


def api_key() -> str:
return os.getenv("GEMINI_API_KEY", "")


def list_models() -> list[str]:
r = requests.get(
f"{GEMINI_API}/models",
headers={"x-goog-api-key": api_key()},
params={"pageSize": 200},
timeout=30,
)
r.raise_for_status()
names = []
for m in r.json().get("models", []):
if "generateContent" in m.get("supportedGenerationMethods", []):
names.append(m["name"].replace("models/", ""))
return names


_BAD = ("image", "tts", "audio", "live", "embed", "vision", "robotics", "computer", "imagen", "veo")
_candidates: list[str] = []


def candidate_models() -> list[str]:
"""GEMINI_MODELS가 있으면 그 목록, 없으면 키로 쓸 수 있는 모델에서 자동 선택."""
global _candidates
if _candidates:
return _candidates
if GEMINI_MODELS.strip():
_candidates = [m.strip().replace("models/", "") for m in GEMINI_MODELS.split(",") if m.strip()]
return _candidates
names = [n for n in list_models() if n.startswith("gemini") and not any(b in n for b in _BAD)]
lite = [n for n in names if "flash-lite" in n]
flash = [n for n in names if "flash" in n and "flash-lite" not in n]
_candidates = (lite[:2] + flash[:2]) or names[:3]
log(f"자동 선택된 모델 후보: {_candidates}")
return _candidates


_last_call = 0.0


def throttle():
global _last_call
wait = MIN_INTERVAL - (time.time() - _last_call)
if wait > 0:
time.sleep(wait)
_last_call = time.time()


def call_gemini(parts: list[dict]) -> tuple[str, str]:
"""(응답 텍스트, 사용한 모델)을 반환. 모든 후보가 실패하면 LLMUnavailable."""
if not api_key():
raise LLMUnavailable("GEMINI_API_KEY가 설정되지 않았습니다.")
last_err = ""
for model in candidate_models():
for attempt in range(MAX_RETRY + 1):
throttle()
try:
r = requests.post(
f"{GEMINI_API}/models/{model}:generateContent",
headers={"x-goog-api-key": api_key(), "Content-Type": "application/json"},
json={
"contents": [{"role": "user", "parts": parts}],
"generationConfig": {"temperature": 0, "maxOutputTokens": 2048},
},
timeout=120,
)
except requests.RequestException as e:
last_err = f"{model}: 네트워크 오류 {e}"
time.sleep(5)
continue

if r.status_code == 200:
cand = (r.json().get("candidates") or [{}])[0]
text = "".join(
p.get("text", "")
for p in cand.get("content", {}).get("parts", [])
if not p.get("thought")
)
if text.strip():
return text, model
last_err = f"{model}: 빈 응답({cand.get('finishReason')})"
break

body = r.text
last_err = f"{model}: HTTP {r.status_code} {body[:180].replace(chr(10), ' ')}"
if r.status_code == 429:
# 일일 한도 소진 또는 한도 0이면 재시도해도 소용없으므로 다음 모델로
if "PerDay" in body or "limit: 0" in body:
log(f"{model}: 일일 한도 소진 또는 한도 0 -> 다음 모델")
break
if attempt == MAX_RETRY:
break
m = re.search(r'"retryDelay":\s*"(\d+(?:\.\d+)?)s"', body)
wait = min(float(m.group(1)) + 1, 60) if m else 15 * (attempt + 1)
log(f"{model}: 429, {int(wait)}초 후 재시도 ({attempt + 1}/{MAX_RETRY})")
time.sleep(wait)
continue
if r.status_code >= 500:
time.sleep(5)
continue
break # 400, 403, 404 등은 이 모델 포기
raise LLMUnavailable(last_err or "사용 가능한 모델이 없습니다.")


# ---------------------------------------------------------------------------
# Hugging Face Inference Providers (OpenAI 호환 라우터)
# ---------------------------------------------------------------------------
def hf_token() -> str:
return os.getenv("HF_TOKEN", "")


def call_hf(parts: list[dict]) -> tuple[str, str]:
"""(응답 텍스트, 사용한 모델)을 반환. 텍스트 전용이므로 이미지/오디오 파트는 전달하지 못합니다."""
if not hf_token():
raise LLMUnavailable("HF_TOKEN이 설정되지 않았습니다.")
text = "\n".join(p["text"] for p in parts if "text" in p)
if any("inline_data" in p for p in parts):
text = ("NOTE: An image/audio attachment exists but you cannot view it; "
"answer from the other information.\n\n" + text)
last_err = ""
for model in HF_MODELS:
for attempt in range(MAX_RETRY + 1):
throttle()
try:
r = requests.post(
f"{HF_ROUTER}/chat/completions",
headers={"Authorization": f"Bearer {hf_token()}", "Content-Type": "application/json"},
json={"model": model, "messages": [{"role": "user", "content": text}],
"max_tokens": 1024, "temperature": 0},
timeout=120,
)
except requests.RequestException as e:
last_err = f"{model}: 네트워크 오류 {e}"
time.sleep(5)
continue
if r.status_code == 200:
content = (r.json().get("choices") or [{}])[0].get("message", {}).get("content") or ""
content = re.sub(r"(?s)<think>.*?</think>", "", content).strip()
if content:
return content, model
last_err = f"{model}: 빈 응답"
break
body = r.text
last_err = f"{model}: HTTP {r.status_code} {body[:180].replace(chr(10), ' ')}"
if r.status_code == 402:
raise LLMUnavailable("HF 무료 크레딧 소진(402). " + body[:150])

app.py

@@ -1,32 +1,19 @@
-import glob
+"""HF Agents Course 최종 과제 - Gemini 또는 Hugging Face 선택형 경량 버전
+
+설계 원칙: 문항당 LLM 호출 1회.
+  웹 검색(호출 없음) -> 검색 결과 + 첨부 파일을 한 번에 Gemini에 전달 -> 최종 답만 받음
+"""
+import base64
 import json
+import mimetypes
 import os
 import re
-import threading
 import time
 from collections import deque
-from concurrent.futures import ThreadPoolExecutor, wait, FIRST_COMPLETED
-
-# litellm의 재시도 기능에 필요한 tenacity가 없으면 시작 시 자동 설치
-try:
-    import tenacity  # noqa: F401
-except ImportError:
-    import subprocess
-    import sys
-
-    subprocess.run([sys.executable, "-m", "pip", "install", "tenacity"], check=False)
 
 import gradio as gr
 import pandas as pd
 import requests
-from smolagents import (
-    CodeAgent,
-    DuckDuckGoSearchTool,
-    InferenceClientModel,
-    LiteLLMModel,
-    VisitWebpageTool,
-    tool,
-)
 
 # ZeroGPU 하드웨어에서 시작 오류를 막기 위한 더미 함수 (CPU 하드웨어에서는 무시됨)
 try:
@@ -38,61 +25,68 @@ try:
 except ImportError:
     pass
 
+try:
+    from ddgs import DDGS
+except ImportError:
+    try:
+        from duckduckgo_search import DDGS
+    except ImportError:
+        DDGS = None
+
 # ---------------------------------------------------------------------------
-# 설정 (Space의 Variables에서 조정 가능)
+# 설정 (Space Variables/Secrets로 조정)
 # ---------------------------------------------------------------------------
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+SCORING_API = "https://agents-course-unit4-scoring.hf.space"
+GEMINI_API = "https://generativelanguage.googleapis.com/v1beta"
 FILES_DIR = "/tmp/task_files"
 CACHE_PATH = "/tmp/answers_cache.json"
 os.makedirs(FILES_DIR, exist_ok=True)
 
-WORKERS = int(os.getenv("WORKERS", "1"))                      # 동시 실행 문항 수
-QUESTION_TIMEOUT = int(os.getenv("QUESTION_TIMEOUT", "300"))  # 문항당 제한 시간(초)
-MAX_STEPS = int(os.getenv("MAX_STEPS", "8"))                  # 에이전트 최대 단계
-MODEL_TIMEOUT = int(os.getenv("MODEL_TIMEOUT", "90"))         # LLM 1회 호출 제한(초)
-HEARTBEAT = 3                                                 # 화면 갱신 주기(초)
+PROVIDER = (os.getenv("PROVIDER", "") or ("gemini" if os.getenv("GEMINI_API_KEY") else "hf")).lower()  # gemini | hf
+MIN_INTERVAL = float(os.getenv("MIN_INTERVAL", "7" if PROVIDER == "gemini" else "2"))  # LLM 호출 간 최소 간격(초)
+HF_ROUTER = "https://router.huggingface.co/v1"
+HF_MODELS = [m.strip() for m in (os.getenv("HF_MODELS") or os.getenv("HF_MODEL") or "Qwen/Qwen2.5-72B-Instruct").split(",") if m.strip()]
+MAX_RETRY = int(os.getenv("MAX_RETRY", "3"))             # 429 재시도 횟수
+FETCH_PAGES = int(os.getenv("FETCH_PAGES", "2"))         # 본문을 읽을 검색 결과 수
+PAGE_CHARS = int(os.getenv("PAGE_CHARS", "5000"))        # 페이지당 최대 글자 수
+LLM_QUERY = os.getenv("LLM_QUERY", "0") == "1"           # 1이면 검색어도 Gemini로 생성(호출 2배)
+GEMINI_MODELS = os.getenv("GEMINI_MODELS", "")           # 선택: 쉼표로 구분한 모델 이름 목록
+
+PROMPT = """You are answering a GAIA-style benchmark question. The answer is graded by EXACT MATCH.
 
-ANSWER_RULES = """You are a careful research and reasoning agent solving GAIA-style questions.
 Rules:
-1. Use the tools (web search, webpage visit, file reading, python code) whenever the
-   question needs facts you are not 100% sure about. Do not guess.
-2. The final answer is graded by EXACT MATCH. Return ONLY the answer value, with no
-   explanation, no units unless asked, no trailing period, no "FINAL ANSWER:" prefix.
-3. If the answer is a number: no thousands separators, no currency/percent symbols
-   unless the question asks for them.
-4. If the answer is a list: comma-separated, in the order the question requests.
-5. If the answer is a string: no articles (a, an, the) and no abbreviations unless
-   the question asks for them.
-6. If a file path is given, read it with the read_local_file tool or with python code.
-7. Be efficient: stop researching as soon as you have a reliable answer.
-8. Finish by calling final_answer(...) with the answer only."""
+- Use the provided web context and attached file. If the context is insufficient, use your own knowledge and reason carefully.
+- Give ONLY the answer value: no explanation, no trailing period, no units unless asked.
+- Numbers: digits only, no thousands separators, no currency or percent symbols unless asked.
+- Lists: comma-separated, in the order the question asks.
+- Strings: no leading articles (a, an, the), no abbreviations unless asked.
+- End your reply with one final line exactly in the form:
+FINAL ANSWER: <answer>
+
+Question:
+{question}
+
+{extra}"""
 
 # ---------------------------------------------------------------------------
-# 이벤트 로그 (화면 상태창에 최근 기록을 보여주기 위함)
+# 로그
 # ---------------------------------------------------------------------------
-_events = deque(maxlen=10)
-_active: dict = {}  # task_id -> 시작 시각
-_state_lock = threading.Lock()
+_events = deque(maxlen=12)
 
 
 def log(msg: str):
     line = f"[{time.strftime('%H:%M:%S')}] {msg}"
     print(line, flush=True)
-    with _state_lock:
-        _events.append(line)
+    _events.append(line)
 
 
 def recent_log() -> str:
-    with _state_lock:
-        return "\n".join(_events)
+    return "\n".join(_events)
 
 
 # ---------------------------------------------------------------------------
 # 캐시
 # ---------------------------------------------------------------------------
-_cache_lock = threading.Lock()
-
-
 def load_cache() -> dict:
     try:
         with open(CACHE_PATH, "r", encoding="utf-8") as f:
@@ -101,224 +95,367 @@ def load_cache() -> dict:
         return {}
 
 
-def save_cache_entry(task_id: str, answer: str):
-    with _cache_lock:
-        cache = load_cache()
-        cache[task_id] = answer
-        with open(CACHE_PATH, "w", encoding="utf-8") as f:
-            json.dump(cache, f, ensure_ascii=False)
+def save_cache(task_id: str, answer: str):
+    cache = load_cache()
+    cache[task_id] = answer
+    with open(CACHE_PATH, "w", encoding="utf-8") as f:
+        json.dump(cache, f, ensure_ascii=False)
 
 
 # ---------------------------------------------------------------------------
-# 도구
+# Gemini REST 호출 (라이브러리 없이 requests만 사용)
 # ---------------------------------------------------------------------------
-@tool
-def read_local_file(path: str) -> str:
-    """Reads a local file (txt, csv, json, py, md, xlsx) and returns its content as text.
+class LLMUnavailable(Exception):
+    pass
 
-    Args:
-        path: Absolute or relative path of the file to read.
-    """
-    try:
-        if not os.path.exists(path):
-            basename = os.path.basename(path)
-            matches = glob.glob(os.path.join(FILES_DIR, f"*{basename}"))
-            if matches:
-                path = matches[0]
-        lower = path.lower()
-        if lower.endswith((".xlsx", ".xls")):
-            sheets = pd.read_excel(path, sheet_name=None)
-            return "\n\n".join(
-                f"## Sheet: {n}\n{df.to_string(max_rows=200)}" for n, df in sheets.items()
-            )
-        if lower.endswith(".csv"):
-            return pd.read_csv(path).to_string(max_rows=200)
-        with open(path, "r", encoding="utf-8", errors="ignore") as f:
-            return f.read()[:20000]
-    except Exception as e:  # noqa: BLE001
-        return f"Could not read file: {e}"
 
+def api_key() -> str:
+    return os.getenv("GEMINI_API_KEY", "")
 
-# ---------------------------------------------------------------------------
-# 모델 / 에이전트
-# ---------------------------------------------------------------------------
-def gemini_model_id() -> str:
-    return os.getenv("GEMINI_MODEL", "gemini-3.8-flash").replace("gemini/", "")
-
-
-def build_model():
-    gemini_key = os.getenv("GEMINI_API_KEY")
-    if gemini_key:
-        return LiteLLMModel(
-            model_id=f"gemini/{gemini_model_id()}",
-            api_key=gemini_key,
-            timeout=MODEL_TIMEOUT,   # LLM 호출이 무한정 멈추지 않도록 제한
-            num_retries=2,
-        )
-    openai_key = os.getenv("OPENAI_API_KEY")
-    if openai_key:
-        return LiteLLMModel(
-            model_id=f"openai/{os.getenv('OPENAI_MODEL', 'gpt-4o-mini')}",
-            api_key=openai_key,
-            timeout=MODEL_TIMEOUT,
-            num_retries=2,
-        )
-    return InferenceClientModel(
-        model_id=os.getenv("HF_MODEL", "Qwen/Qwen2.5-Coder-32B-Instruct"),
-        token=os.getenv("HF_TOKEN"),
+
+def list_models() -> list[str]:
+    r = requests.get(
+        f"{GEMINI_API}/models",
+        headers={"x-goog-api-key": api_key()},
+        params={"pageSize": 200},
+        timeout=30,
     )
+    r.raise_for_status()
+    names = []
+    for m in r.json().get("models", []):
+        if "generateContent" in m.get("supportedGenerationMethods", []):
+            names.append(m["name"].replace("models/", ""))
+    return names
+
+
+_BAD = ("image", "tts", "audio", "live", "embed", "vision", "robotics", "computer", "imagen", "veo")
+_candidates: list[str] = []
+
+
+def candidate_models() -> list[str]:
+    """GEMINI_MODELS가 있으면 그 목록, 없으면 키로 쓸 수 있는 모델에서 자동 선택."""
+    global _candidates
+    if _candidates:
+        return _candidates
+    if GEMINI_MODELS.strip():
+        _candidates = [m.strip().replace("models/", "") for m in GEMINI_MODELS.split(",") if m.strip()]
+        return _candidates
+    names = [n for n in list_models() if n.startswith("gemini") and not any(b in n for b in _BAD)]
+    lite = [n for n in names if "flash-lite" in n]
+    flash = [n for n in names if "flash" in n and "flash-lite" not in n]
+    _candidates = (lite[:2] + flash[:2]) or names[:3]
+    log(f"자동 선택된 모델 후보: {_candidates}")
+    return _candidates
+
+
+_last_call = 0.0
+
+
+def throttle():
+    global _last_call
+    wait = MIN_INTERVAL - (time.time() - _last_call)
+    if wait > 0:
+        time.sleep(wait)
+    _last_call = time.time()
+
+
+def call_gemini(parts: list[dict]) -> tuple[str, str]:
+    """(응답 텍스트, 사용한 모델)을 반환. 모든 후보가 실패하면 LLMUnavailable."""
+    if not api_key():
+        raise LLMUnavailable("GEMINI_API_KEY가 설정되지 않았습니다.")
+    last_err = ""
+    for model in candidate_models():
+        for attempt in range(MAX_RETRY + 1):
+            throttle()
+            try:
+                r = requests.post(
+                    f"{GEMINI_API}/models/{model}:generateContent",
+                    headers={"x-goog-api-key": api_key(), "Content-Type": "application/json"},
+                    json={
+                        "contents": [{"role": "user", "parts": parts}],
+                        "generationConfig": {"temperature": 0, "maxOutputTokens": 2048},
+                    },
+                    timeout=120,
+                )
+            except requests.RequestException as e:
+                last_err = f"{model}: 네트워크 오류 {e}"
+                time.sleep(5)
+                continue
 
+            if r.status_code == 200:
+                cand = (r.json().get("candidates") or [{}])[0]
+                text = "".join(
+                    p.get("text", "")
+                    for p in cand.get("content", {}).get("parts", [])
+                    if not p.get("thought")
+                )
+                if text.strip():
+                    return text, model
+                last_err = f"{model}: 빈 응답({cand.get('finishReason')})"
+                break
+
+            body = r.text
+            last_err = f"{model}: HTTP {r.status_code} {body[:180].replace(chr(10), ' ')}"
+            if r.status_code == 429:
+                # 일일 한도 소진 또는 한도 0이면 재시도해도 소용없으므로 다음 모델로
+                if "PerDay" in body or "limit: 0" in body:
+                    log(f"{model}: 일일 한도 소진 또는 한도 0 -> 다음 모델")
+                    break
+                if attempt == MAX_RETRY:
+                    break
+                m = re.search(r'"retryDelay":\s*"(\d+(?:\.\d+)?)s"', body)
+                wait = min(float(m.group(1)) + 1, 60) if m else 15 * (attempt + 1)
+                log(f"{model}: 429, {int(wait)}초 후 재시도 ({attempt + 1}/{MAX_RETRY})")
+                time.sleep(wait)
+                continue
+            if r.status_code >= 500:
+                time.sleep(5)
+                continue
+            break  # 400, 403, 404 등은 이 모델 포기
+    raise LLMUnavailable(last_err or "사용 가능한 모델이 없습니다.")
 
-def build_agent() -> CodeAgent:
-    return CodeAgent(
-        tools=[DuckDuckGoSearchTool(), VisitWebpageTool(), read_local_file],
-        model=build_model(),
-        additional_authorized_imports=[
-            "pandas", "numpy", "re", "json", "math", "datetime",
-            "collections", "itertools", "statistics", "requests", "bs4",
-        ],
-        max_steps=MAX_STEPS,
-        verbosity_level=1,
-    )
+
+# ---------------------------------------------------------------------------
+# Hugging Face Inference Providers (OpenAI 호환 라우터)
+# ---------------------------------------------------------------------------
+def hf_token() -> str:
+    return os.getenv("HF_TOKEN", "")
+
+
+def call_hf(parts: list[dict]) -> tuple[str, str]:
+    """(응답 텍스트, 사용한 모델)을 반환. 텍스트 전용이므로 이미지/오디오 파트는 전달하지 못합니다."""
+    if not hf_token():
+        raise LLMUnavailable("HF_TOKEN이 설정되지 않았습니다.")
+    text = "\n".join(p["text"] for p in parts if "text" in p)
+    if any("inline_data" in p for p in parts):
+        text = ("NOTE: An image/audio attachment exists but you cannot view it; "
+                "answer from the other information.\n\n" + text)
+    last_err = ""
+    for model in HF_MODELS:
+        for attempt in range(MAX_RETRY + 1):
+            throttle()
+            try:
+                r = requests.post(
+                    f"{HF_ROUTER}/chat/completions",
+                    headers={"Authorization": f"Bearer {hf_token()}", "Content-Type": "application/json"},
+                    json={"model": model, "messages": [{"role": "user", "content": text}],
+                          "max_tokens": 1024, "temperature": 0},
+                    timeout=120,
+                )
+            except requests.RequestException as e:
+                last_err = f"{model}: 네트워크 오류 {e}"
+                time.sleep(5)
+                continue
+            if r.status_code == 200:
+                content = (r.json().get("choices") or [{}])[0].get("message", {}).get("content") or ""
+                content = re.sub(r"(?s)<think>.*?</think>", "", content).strip()
+                if content:
+                    return content, model
+                last_err = f"{model}: 빈 응답"
+                break
+            body = r.text
+            last_err = f"{model}: HTTP {r.status_code} {body[:180].replace(chr(10), ' ')}"
+            if r.status_code == 402:
+                raise LLMUnavailable("HF 무료 크레딧 소진(402). " + body[:150])
+            if r.status_code in (401, 403):
+                raise LLMUnavailable(f"HF_TOKEN 인증/권한 오류({r.status_code}). 토큰의 Inference Providers 권한을 확인하세요.")
+            if r.status_code == 429:
+                if attempt == MAX_RETRY:
+                    break
+                wait = 15 * (attempt + 1)
+                log(f"{model}: 429, {wait}초 후 재시도 ({attempt + 1}/{MAX_RETRY})")
+                time.sleep(wait)
+                continue
+            if r.status_code >= 500:
+                time.sleep(5)
+                continue
+            break  # 400, 404 등은 이 모델 포기
+    raise LLMUnavailable(last_err or "사용 가능한 모델이 없습니다.")
 
 
-def clean_answer(answer) -> str:
-    text = str(answer).strip()
-    text = re.sub(r"^\s*final answer\s*:\s*", "", text, flags=re.IGNORECASE)
-    return text.strip().rstrip(".").strip()
+def call_llm(parts: list[dict]) -> tuple[str, str]:
+    return call_hf(parts) if PROVIDER == "hf" else call_gemini(parts)
 
 
 # ---------------------------------------------------------------------------
-# 채점 서버 통신
+# 웹 검색 + 페이지 읽기 (Gemini 호출 없음)
 # ---------------------------------------------------------------------------
-def fetch_questions(api_url: str) -> list[dict]:
-    resp = requests.get(f"{api_url}/questions", timeout=30)
-    resp.raise_for_status()
-    data = resp.json()
-    if not data:
-        raise ValueError("질문 목록이 비어 있습니다.")
-    return data
+def html_to_text(html: str) -> str:
+    html = re.sub(r"(?is)<(script|style|noscript|svg|header|footer|nav)[^>]*>.*?</\1>", " ", html)
+    text = re.sub(r"(?s)<[^>]+>", " ", html)
+    text = re.sub(r"&nbsp;|&#160;", " ", text)
+    return re.sub(r"\s+", " ", text).strip()
 
 
-def download_task_file(api_url: str, task_id: str, file_name: str):
+def web_context(query: str) -> str:
+    if DDGS is None:
+        return ""
+    try:
+        results = list(DDGS().text(query, max_results=6))
+    except Exception as e:  # noqa: BLE001
+        log(f"검색 실패: {type(e).__name__}")
+        return ""
+    chunks = []
+    for i, res in enumerate(results, start=1):
+        chunks.append(f"[{i}] {res.get('title', '')}\n{res.get('href', '')}\n{res.get('body', '')}")
+    for res in results[:FETCH_PAGES]:
+        url = res.get("href")
+        if not url or url.lower().endswith((".pdf", ".zip", ".mp4")):
+            continue
+        try:
+            page = requests.get(url, timeout=15, headers={"User-Agent": "Mozilla/5.0"})
+            if page.ok and "text/html" in page.headers.get("content-type", ""):
+                chunks.append(f"--- PAGE: {url} ---\n{html_to_text(page.text)[:PAGE_CHARS]}")
+        except requests.RequestException:
+            continue
+    return "\n\n".join(chunks)
+
+
+# ---------------------------------------------------------------------------
+# 첨부 파일
+# ---------------------------------------------------------------------------
+def download_file(task_id: str, file_name: str):
     if not file_name:
         return None
     try:
-        resp = requests.get(f"{api_url}/files/{task_id}", timeout=60)
-        resp.raise_for_status()
+        r = requests.get(f"{SCORING_API}/files/{task_id}", timeout=60)
+        r.raise_for_status()
         path = os.path.join(FILES_DIR, f"{task_id}_{file_name}")
         with open(path, "wb") as f:
-            f.write(resp.content)
+            f.write(r.content)
         return path
     except Exception as e:  # noqa: BLE001
-        log(f"파일 다운로드 실패 {task_id[:8]}: {e}")
+        log(f"파일 다운로드 실패: {e}")
         return None
 
 
+def file_to_parts(path: str) -> tuple[str, list[dict]]:
+    """(프롬프트에 붙일 텍스트, Gemini에 직접 넣을 inline_data 파트들)"""
+    lower = path.lower()
+    try:
+        if lower.endswith((".png", ".jpg", ".jpeg", ".webp", ".mp3", ".wav", ".m4a")):
+            if os.path.getsize(path) > 15 * 1024 * 1024:
+                return "(첨부 파일이 너무 커서 생략됨)", []
+            mime = mimetypes.guess_type(path)[0] or "application/octet-stream"
+            if lower.endswith(".mp3"):
+                mime = "audio/mp3"
+            with open(path, "rb") as f:
+                data = base64.b64encode(f.read()).decode()
+            return "(첨부 파일은 함께 전달됨)", [{"inline_data": {"mime_type": mime, "data": data}}]
+        if lower.endswith((".xlsx", ".xls")):
+            sheets = pd.read_excel(path, sheet_name=None)
+            return "\n\n".join(f"## Sheet {n}\n{df.to_string(max_rows=300)}" for n, df in sheets.items())[:30000], []
+        if lower.endswith(".csv"):
+            return pd.read_csv(path).to_string(max_rows=300)[:30000], []
+        with open(path, "r", encoding="utf-8", errors="ignore") as f:
+            return f.read()[:30000], []
+    except Exception as e:  # noqa: BLE001
+        return f"(파일 읽기 실패: {e})", []
+
+
 # ---------------------------------------------------------------------------
-# 문항 풀이 (캐시 + 시간 제한)
+# 한 문항 풀이
 # ---------------------------------------------------------------------------
-def solve_one(item: dict, api_url: str) -> str:
-    prompt = ANSWER_RULES + "\n\nQuestion:\n" + item["question"]
-    file_path = download_task_file(api_url, item["task_id"], item.get("file_name", ""))
-    if file_path:
-        prompt += f"\n\nAn attached file is available at: {file_path}"
-    return clean_answer(build_agent().run(prompt))
-
-
-def solve_with_timeout(item: dict, api_url: str):
-    """(답변, 성공 여부, 비고)를 반환합니다."""
-    task_id = item["task_id"]
-    short = task_id[:8]
-    cached = load_cache().get(task_id)
-    if cached:
-        log(f"캐시 사용 {short} -> {cached}")
-        return cached, True, "cache"
-
-    box: dict = {}
-
-    def target():
-        try:
-            box["answer"] = solve_one(item, api_url)
-        except Exception as e:  # noqa: BLE001
-            box["error"] = f"{type(e).__name__}: {e}"[:300]
-
-    log(f"시작 {short}")
-    with _state_lock:
-        _active[task_id] = time.time()
-    t = threading.Thread(target=target, daemon=True)
-    t.start()
-    t.join(QUESTION_TIMEOUT)
-    with _state_lock:
-        _active.pop(task_id, None)
-
-    if t.is_alive():
-        log(f"시간 초과 {short} ({QUESTION_TIMEOUT}초)")
-        return "unknown", False, f"timeout {QUESTION_TIMEOUT}s"
-    if "error" in box:
-        log(f"오류 {short}: {box['error']}")
-        return "unknown", False, box["error"]
-
-    save_cache_entry(task_id, box["answer"])
-    log(f"완료 {short} -> {box['answer']}")
-    return box["answer"], True, ""
-
-
-def iter_solve(questions: list[dict], api_url: str):
-    """끝난 문항은 (item, answer, ok, note)로, 대기 중에는 주기적으로 None을 내보냅니다."""
-    valid = [q for q in questions if q.get("task_id") and q.get("question") is not None]
-    pool = ThreadPoolExecutor(max_workers=WORKERS)
+def parse_final(text: str) -> str:
+    m = re.findall(r"FINAL ANSWER:\s*(.+)", text, flags=re.IGNORECASE)
+    ans = m[-1] if m else (text.strip().splitlines() or [""])[-1]
+    return ans.strip().strip("`").strip().rstrip(".").strip()
+
+
+def make_search_query(question: str) -> str:
+    if not LLM_QUERY:
+        return question[:300]
     try:
-        pending = {pool.submit(solve_with_timeout, q, api_url): q for q in valid}
-        while pending:
-            done, _ = wait(list(pending), timeout=HEARTBEAT, return_when=FIRST_COMPLETED)
-            if not done:
-                yield None
-                continue
-            for fut in done:
-                item = pending.pop(fut)
-                answer, ok, note = fut.result()
-                yield item, answer, ok, note
-    finally:
-        pool.shutdown(wait=False)
+        text, _ = call_llm([{"text": "Write ONE concise web search query (max 12 words) that would help answer "
+                                         "this question. Reply with the query only.\n\n" + question}])
+        return text.strip().splitlines()[0][:200]
+    except LLMUnavailable:
+        return question[:300]
+
+
+def solve(item: dict) -> tuple[str, str]:
+    """(답변, 사용한 모델)"""
+    question = item["question"]
+    extra_parts: list[dict] = []
+    extra_text = ""
+
+    path = download_file(item["task_id"], item.get("file_name", ""))
+    if path:
+        file_text, extra_parts = file_to_parts(path)
+        extra_text += f"ATTACHED FILE ({os.path.basename(path)}):\n{file_text}\n\n"
+
+    ctx = web_context(make_search_query(question))
+    if ctx:
+        extra_text += f"WEB CONTEXT (may be incomplete or irrelevant):\n{ctx}\n"
+
+    prompt = PROMPT.format(question=question, extra=extra_text[:60000])
+    text, model = call_llm([{"text": prompt}] + extra_parts)
+    return parse_final(text), model
+
+
+# ---------------------------------------------------------------------------
+# 채점 서버
+# ---------------------------------------------------------------------------
+def fetch_questions() -> list[dict]:
+    r = requests.get(f"{SCORING_API}/questions", timeout=30)
+    r.raise_for_status()
+    data = r.json()
+    if not data:
+        raise ValueError("질문 목록이 비어 있습니다.")
+    return data
 
 
 def make_df(rows: dict, order: list[str]) -> pd.DataFrame:
-    data = [rows[tid] for tid in order if tid in rows]
-    return pd.DataFrame(data, columns=["Task ID", "Question", "Submitted Answer", "OK", "Note"])
-
-
-def status_text(label: str, done: int, total: int, start: float) -> str:
-    with _state_lock:
-        running = len(_active)
-        oldest = int(time.time() - min(_active.values())) if _active else 0
-    return (
-        f"{label}: {done}/{total} 완료 | 실행 중 {running}개 "
-        f"(가장 오래된 문항 {oldest}���) | 총 경과 {int(time.time() - start)}초\n"
-        f"--- 최근 기록 ---\n{recent_log()}"
+    return pd.DataFrame(
+        [rows[t] for t in order if t in rows],
+        columns=["Task ID", "Question", "Submitted Answer", "OK", "Note"],
     )
 
 
-def run_batch(questions: list[dict], api_url: str, label: str):
-    """진행 상황을 화면에 내보내고, 마지막에 (rows, order)를 반환합니다."""
+def run_batch(questions: list[dict], label: str):
+    """문항을 순서대로 풀며 진행 상황을 내보냅니다. 마지막에 (rows, order, aborted)를 반환."""
     order = [q["task_id"] for q in questions if q.get("task_id")]
     rows: dict = {}
+    cache = load_cache()
     start = time.time()
-    log(f"{label} 시작: 질문 {len(order)}개, WORKERS={WORKERS}, 모델={gemini_model_id()}")
-    yield status_text(label, 0, len(order), start), None
-
-    for event in iter_solve(questions, api_url):
-        if event is not None:
-            item, answer, ok, note = event
-            rows[item["task_id"]] = {
-                "Task ID": item["task_id"],
-                "Question": item["question"],
-                "Submitted Answer": answer,
-                "OK": "O" if ok else "X",
-                "Note": note,
-            }
-        yield status_text(label, len(rows), len(order), start), make_df(rows, order)
-    return rows, order
+    fails = 0
+    aborted = False
+    log(f"{label} 시작: {len(order)}문항 (문항당 LLM 호출 {2 if LLM_QUERY else 1}회)")
+
+    for i, item in enumerate(questions, start=1):
+        tid = item.get("task_id")
+        if not tid or item.get("question") is None:
+            continue
+        head = f"{label}: {i - 1}/{len(order)} 완료, {i}번째 문항 처리 중 (경과 {int(time.time() - start)}초)"
+        yield f"{head}\n--- 최근 기록 ---\n{recent_log()}", make_df(rows, order)
+
+        if tid in cache:
+            answer, ok, note = cache[tid], True, "cache"
+            log(f"캐시 사용 {tid[:8]}")
+        else:
+            try:
+                answer, model = solve(item)
+                save_cache(tid, answer)
+                ok, note = True, model
+                fails = 0
+                log(f"완료 {tid[:8]} -> {answer}")
+            except LLMUnavailable as e:
+                answer, ok, note = "unknown", False, str(e)[:250]
+                fails += 1
+                log(f"LLM 실패 {tid[:8]}: {note}")
+            except Exception as e:  # noqa: BLE001
+                answer, ok, note = "unknown", False, f"{type(e).__name__}: {e}"[:250]
+                log(f"오류 {tid[:8]}: {note}")
+
+        rows[tid] = {"Task ID": tid, "Question": item["question"],
+                     "Submitted Answer": answer, "OK": "O" if ok else "X", "Note": note}
+        if fails >= 2:
+            aborted = True
+            log("LLM이 연속 2회 실패하여 중단합니다. (한도/크레딧 문제 가능성)")
+            break
+
+    yield f"{label} 종료 (경과 {int(time.time() - start)}초)\n--- 최근 기록 ---\n{recent_log()}", make_df(rows, order)
+    return rows, order, aborted
 
 
 # ---------------------------------------------------------------------------
@@ -332,144 +469,117 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     if not space_id:
         yield "SPACE_ID를 찾을 수 없습니다. Space 안에서 실행해야 합니다.", None
         return
-
-    username = profile.username
-    api_url = DEFAULT_API_URL
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-
-    yield "질문을 가져오는 중... (최대 30초)", None
+    yield "질문을 가져오는 중...", None
     try:
-        questions = fetch_questions(api_url)
+        questions = fetch_questions()
     except Exception as e:  # noqa: BLE001
         yield f"질문 가져오기 오류: {e}", None
         return
 
-    rows, order = yield from run_batch(questions, api_url, "본 실행")
+    rows, order, aborted = yield from run_batch(questions, "본 실행")
+    if aborted:
+        yield ("LLM 한도/크레딧 문제로 중단했으므로 제출하지 않았습니다.\n"
+               "푼 답은 저장되어 있어, 한도가 회복된 뒤 다시 누르면 이어서 진행합니다. "
+               "(Space가 재시작되면 저장된 답은 사라집니다.)\n\n" + recent_log()), make_df(rows, order)
+        return
 
-    answers_payload = [
-        {"task_id": tid, "submitted_answer": rows[tid]["Submitted Answer"]}
-        for tid in order if tid in rows
-    ]
+    payload = [{"task_id": t, "submitted_answer": rows[t]["Submitted Answer"]} for t in order if t in rows]
     failed = sum(1 for r in rows.values() if r["OK"] == "X")
-    yield f"풀이 완료 (실패/시간초과 {failed}개). 제출 중...", make_df(rows, order)
-
+    yield f"풀이 완료 (실패 {failed}개). 제출 중...", make_df(rows, order)
     submission = {
-        "username": username.strip(),
-        "agent_code": agent_code,
-        "answers": answers_payload,
+        "username": profile.username.strip(),
+        "agent_code": f"https://huggingface.co/spaces/{space_id}/tree/main",
+        "answers": payload,
     }
     try:
-        resp = requests.post(f"{api_url}/submit", json=submission, timeout=120)
-        resp.raise_for_status()
-        r = resp.json()
-        status = (
-            "제출 성공!\n"
-            f"사용자: {r.get('username')}\n"
-            f"점수: {r.get('score', 'N/A')}% "
-            f"({r.get('correct_count', '?')}/{r.get('total_attempted', '?')} 정답)\n"
-            f"메시지: {r.get('message', '')}"
-        )
+        r = requests.post(f"{SCORING_API}/submit", json=submission, timeout=120)
+        r.raise_for_status()
+        res = r.json()
+        status = (f"제출 성공!\n사용자: {res.get('username')}\n"
+                  f"점수: {res.get('score', 'N/A')}% ({res.get('correct_count', '?')}/{res.get('total_attempted', '?')} 정답)\n"
+                  f"메시지: {res.get('message', '')}")
     except requests.exceptions.HTTPError as e:
-        detail = e.response.text[:500] if e.response is not None else str(e)
-        status = f"제출 실패: {detail}"
+        status = f"제출 실패: {e.response.text[:500] if e.response is not None else e}"
     except Exception as e:  # noqa: BLE001
         status = f"제출 중 오류: {e}"
     yield status, make_df(rows, order)
 
 
 def run_test_only(n_questions: int):
-    api_url = DEFAULT_API_URL
-    yield "질문을 가져오는 중... (최대 30초)", None
+    yield "질문을 가져오는 중...", None
     try:
-        questions = fetch_questions(api_url)[: int(n_questions)]
+        questions = fetch_questions()[: int(n_questions)]
     except Exception as e:  # noqa: BLE001
         yield f"준비 중 오류: {e}", None
         return
-    rows, order = yield from run_batch(questions, api_url, "테스트")
-    yield f"테스트 완료 (제출 안 함)\n--- 최근 기록 ---\n{recent_log()}", make_df(rows, order)
-
+    yield from run_batch(questions, "테스트")
 
-def _call_with_timeout(fn, seconds: int):
-    box: dict = {}
 
-    def target():
+def diagnose():
+    lines = [f"PROVIDER={PROVIDER}, MIN_INTERVAL={MIN_INTERVAL}초, LLM_QUERY={LLM_QUERY}"]
+    yield "\n".join(lines + ["", "모델 확인 중..."])
+    if PROVIDER == "hf":
+        lines.append(f"HF_TOKEN: {'있음' if hf_token() else '없음'}, 사용할 모델: {HF_MODELS}")
         try:
-            box["r"] = fn()
+            r = requests.get(f"{HF_ROUTER}/models", headers={"Authorization": f"Bearer {hf_token()}"}, timeout=30)
+            r.raise_for_status()
+            ids = [m.get("id") for m in r.json().get("data", [])]
+            check = ", ".join(f"{m}={'목록에 있음' if m in ids else '목록에 없음'}" for m in HF_MODELS)
+            lines.append(f"1) 라우터 제공 모델 {len(ids)}개 / {check}")
         except Exception as e:  # noqa: BLE001
-            box["e"] = f"{type(e).__name__}: {e}"[:300]
-
-    th = threading.Thread(target=target, daemon=True)
-    th.start()
-    th.join(seconds)
-    if th.is_alive():
-        return False, f"{seconds}초 안에 응답 없음"
-    if "e" in box:
-        return False, box["e"]
-    return True, str(box.get("r"))[:150]
-
-
-def diagnose():
-    """채점 서버 / Gemini / 웹 검색 연결을 각각 점검합니다."""
-    lines = [
-        f"설정: 모델={gemini_model_id()}, GEMINI_API_KEY={'있음' if os.getenv('GEMINI_API_KEY') else '없음'}, "
-        f"WORKERS={WORKERS}, MAX_STEPS={MAX_STEPS}, QUESTION_TIMEOUT={QUESTION_TIMEOUT}"
-    ]
-    yield "\n".join(lines + ["", "1/3 채점 서버 확인 중..."])
-
-    ok, msg = _call_with_timeout(lambda: len(fetch_questions(DEFAULT_API_URL)), 35)
-    lines.append(f"1) 채점 서버 질문 목록: {'정상' if ok else '실패'} - {msg}")
-    yield "\n".join(lines + ["", "2/3 Gemini 호출 확인 중..."])
-
-    key = os.getenv("GEMINI_API_KEY")
-    if key:
-        def ping():
-            import litellm
-            r = litellm.completion(
-                model=f"gemini/{gemini_model_id()}",
-                api_key=key,
-                messages=[{"role": "user", "content": "Reply with the single word OK."}],
-                timeout=45,
-            )
-            return r.choices[0].message.content
-
-        ok, msg = _call_with_timeout(ping, 60)
-        lines.append(f"2) Gemini 호출: {'정상' if ok else '실패'} - {msg}")
+            lines.append(f"1) 모델 목록 조회 실패(진행은 계속): {type(e).__name__}: {str(e)[:150]}")
     else:
-        lines.append("2) Gemini 호출: GEMINI_API_KEY가 설정되지 않아 건너뜀")
-    yield "\n".join(lines + ["", "3/3 웹 검색 확인 중..."])
-
-    ok, msg = _call_with_timeout(lambda: DuckDuckGoSearchTool()("Hugging Face"), 40)
-    lines.append(f"3) 웹 검색(DuckDuckGo): {'정상' if ok else '실패'} - {msg}")
+        lines.append(f"GEMINI_API_KEY: {'있음' if api_key() else '없음'}")
+        try:
+            names = [n for n in list_models() if n.startswith("gemini")][:25]
+            lines.append("1) 이 키로 사용 가능한 모델(일부): " + ", ".join(names))
+            lines.append(f"   사용할 후보 순서: {candidate_models()}")
+        except Exception as e:  # noqa: BLE001
+            lines.append(f"1) 모델 목록 조회 실패: {type(e).__name__}: {str(e)[:200]}")
+            yield "\n".join(lines)
+            return
+    yield "\n".join(lines + ["", "LLM 호출 테스트 중..."])
+    try:
+        text, model = call_llm([{"text": "Reply with the single word OK."}])
+        lines.append(f"2) LLM 호출: 정상 (모델 {model}, 응답 '{text.strip()[:30]}')")
+    except LLMUnavailable as e:
+        lines.append(f"2) LLM 호출: 실패 - {str(e)[:300]}")
+    yield "\n".join(lines + ["", "웹 검색 테스트 중..."])
+    try:
+        ctx = web_context("Hugging Face")
+        lines.append(f"3) 웹 검색: {'정상' if ctx else '결과 없음'} ({len(ctx)}자)")
+    except Exception as e:  # noqa: BLE001
+        lines.append(f"3) 웹 검색: 실패 - {e}")
     yield "\n".join(lines)
 
 
 def clear_cache():
+    global _candidates
+    _candidates = []
     try:
         os.remove(CACHE_PATH)
-        return "캐시를 삭제했습니다."
+        return "캐시와 모델 선택 정보를 초기화했습니다."
     except FileNotFoundError:
-        return "삭제할 캐시가 없습니다."
+        return "삭제할 캐시가 없습니다. (모델 선택 정보는 초기화됨)"
 
 
 # ---------------------------------------------------------------------------
 # UI
 # ---------------------------------------------------------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner (Gemini 3.8 Flash)")
+    gr.Markdown("# Basic Agent Evaluation Runner (Gemini / Hugging Face 선택형 경량 버전)")
     gr.Markdown(
-        """**Instructions:**
-1. 먼저 '연결 진단'으로 채점 서버, Gemini, 웹 검색이 정상인지 확인합니다.
-2. 로그인 후 '테스트 실행'으로 소수 문항을 확인합니다. (제출 안 함)
+        """**사용 순서**
+1. '연결 진단'으로 모델과 호출 가능 여부를 확인합니다.
+2. 로그인 후 '테스트 실행'(1~2문항)으로 확인합니다. (제출 안 함)
 3. 문제없으면 'Run Evaluation & Submit All Answers'를 누릅니다."""
     )
     gr.LoginButton()
-
     with gr.Row():
         diag_button = gr.Button("연결 진단")
         test_n = gr.Number(value=2, label="테스트할 문항 수 (제출 안 함)", precision=0)
         test_button = gr.Button("테스트 실행 (제출 안 함)")
         cache_button = gr.Button("캐시 초기화")
-
     run_button = gr.Button("Run Evaluation & Submit All Answers")
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=14, interactive=False)
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)