Update app.py

app.py

@@ -1,1702 +1,33 @@
 import os
-import json
-import base64
-import asyncio
-import httpx
-import uvicorn
-import threading
-from datetime import datetime, timezone, timedelta
-from collections import Counter, defaultdict
-from pathlib import Path
-from fastapi import FastAPI, Request, BackgroundTasks
-import aiosqlite, shutil
-from fastapi.responses import FileResponse, HTMLResponse, JSONResponse, Response, StreamingResponse
-from fastapi.middleware.cors import CORSMiddleware
-
-app = FastAPI()
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
-
-
-@app.exception_handler(Exception)
-async def global_exception_handler(request, exc):
-    """모든 미처리 예외를 JSON으로 반환 — 'Internal Server Error' 텍스트 방지"""
-    import traceback
-    traceback.print_exc()
-    return JSONResponse(
-        status_code=500,
-        content={"error": {"message": str(exc)[:200], "type": "server_error"}},
-    )
-
-GROQ_API_KEY = os.environ.get("GROQ_API_KEY", "")
-FAL_KEY      = os.environ.get("FAL_KEY", "")
-ADMIN_EMAIL  = "arxivgpt@gmail.com"
-SA_BACKUP_REPO = "ginigen-ai/siteagent-db"
-
-# ── 영구 스토리지 DB ────────────────────────────────────────
-import asyncio as _asyncio
-_PERSISTENT_DIR = "/data"
-_LOCAL_DIR = "./data"
-
-def _get_db_path():
-    if os.path.exists(_PERSISTENT_DIR):
-        try:
-            tf = os.path.join(_PERSISTENT_DIR, ".write_test")
-            with open(tf, "w") as f: f.write("ok")
-            os.remove(tf)
-            print(f"✅ Persistent storage: {_PERSISTENT_DIR}")
-            return os.path.join(_PERSISTENT_DIR, "siteagent.db")
-        except: pass
-    os.makedirs(_LOCAL_DIR, exist_ok=True)
-    print(f"🟡 Local fallback: {_LOCAL_DIR}")
-    return os.path.join(_LOCAL_DIR, "siteagent.db")
-
-SA_DB_PATH = _get_db_path()
-_db_lock = None
-
-def _get_lock():
-    global _db_lock
-    if _db_lock is None: _db_lock = _asyncio.Lock()
-    return _db_lock
-
-async def _db_write(sql, params=None):
-    """안전한 DB 쓰기 (락 + 재시도)"""
-    lock = _get_lock()
-    for attempt in range(5):
-        try:
-            async with lock:
-                async with aiosqlite.connect(SA_DB_PATH, timeout=30.0) as db:
-                    await db.execute("PRAGMA journal_mode=WAL")
-                    cursor = await db.execute(sql, params or ())
-                    await db.commit()
-                    return cursor
-        except Exception as e:
-            if "database is locked" in str(e) and attempt < 4:
-                await _asyncio.sleep(0.5 * (attempt + 1))
-                continue
-            raise
-
-async def _db_read(sql, params=None):
-    """DB 읽기"""
-    async with aiosqlite.connect(SA_DB_PATH, timeout=10.0) as db:
-        db.row_factory = aiosqlite.Row
-        cursor = await db.execute(sql, params or ())
-        return await cursor.fetchall()
-
-async def _db_read_one(sql, params=None):
-    async with aiosqlite.connect(SA_DB_PATH, timeout=10.0) as db:
-        db.row_factory = aiosqlite.Row
-        cursor = await db.execute(sql, params or ())
-        return await cursor.fetchone()
-
-async def _sa_backup_db():
-    """DB를 HF Hub에 백업 (무결성 검사 후)"""
-    if not HF_TOKEN or not os.path.exists(SA_DB_PATH): return
-    try:
-        import sqlite3
-        conn = sqlite3.connect(SA_DB_PATH)
-        result = conn.execute("PRAGMA integrity_check").fetchone()
-        conn.close()
-        if result[0] != 'ok':
-            print(f"🚨 [SA-backup] DB corrupt — skipped: {result[0][:100]}")
+import sys
+
+def main():
+    try:
+        # Get the code from secrets
+        code = os.environ.get("MAIN_CODE")
+        
+        if not code:
+            # Fallback: create a simple error display
+            import gradio as gr
+            with gr.Blocks() as demo:
+                gr.Markdown("# ⚠️ Error")
+                gr.Markdown("The application code wasn't found in secrets. Please add the MAIN_CODE secret.")
+            demo.launch()
             return
-    except Exception as e:
-        print(f"🚨 [SA-backup] DB unreadable — skipped: {e}")
-        return
-    def _sync():
-        from huggingface_hub import HfApi
-        api = HfApi(token=HF_TOKEN)
-        try: api.create_repo(repo_id=SA_BACKUP_REPO, repo_type="dataset", private=True, exist_ok=True)
-        except: pass
-        from datetime import datetime
-        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
-        api.upload_file(path_or_fileobj=SA_DB_PATH, path_in_repo=f"backup/siteagent_{ts}.db", repo_id=SA_BACKUP_REPO, repo_type="dataset")
-        api.upload_file(path_or_fileobj=SA_DB_PATH, path_in_repo="latest/siteagent.db", repo_id=SA_BACKUP_REPO, repo_type="dataset")
-        return ts
-    try:
-        import asyncio
-        ts = await asyncio.to_thread(_sync)
-        print(f"✅ [SA-backup] Hub backup: {ts}")
-    except Exception as e:
-        print(f"⚠️ [SA-backup] error: {e}")
-
-
-async def _sa_restore_db():
-    """Hub에서 DB 복원 (시작 시)"""
-    if not HF_TOKEN: return False
-    if os.path.exists(SA_DB_PATH) and os.path.getsize(SA_DB_PATH) > 0:
-        try:
-            import sqlite3
-            conn = sqlite3.connect(SA_DB_PATH)
-            result = conn.execute("PRAGMA integrity_check").fetchone()
-            conn.close()
-            if result[0] == 'ok':
-                print("📍 [SA-restore] Existing DB healthy, skip restore")
-                return False
-            else:
-                print(f"⚠️ [SA-restore] Existing DB corrupt, restoring...")
-                os.remove(SA_DB_PATH)
-        except:
-            os.remove(SA_DB_PATH)
-    def _sync():
-        from huggingface_hub import HfApi, hf_hub_download
-        try:
-            api = HfApi(token=HF_TOKEN)
-            api.create_repo(repo_id=SA_BACKUP_REPO, repo_type="dataset", private=True, exist_ok=True)
-        except: pass
-        return hf_hub_download(repo_id=SA_BACKUP_REPO, filename="latest/siteagent.db", repo_type="dataset", token=HF_TOKEN)
-    try:
-        import asyncio
-        downloaded = await asyncio.to_thread(_sync)
-        import sqlite3
-        conn = sqlite3.connect(downloaded)
-        result = conn.execute("PRAGMA integrity_check").fetchone()
-        conn.close()
-        if result[0] != 'ok':
-            print("🚨 [SA-restore] Hub backup corrupt, starting fresh")
-            return False
-        for suffix in ['-wal', '-shm']:
-            wf = SA_DB_PATH + suffix
-            if os.path.exists(wf): os.remove(wf)
-        shutil.copy(downloaded, SA_DB_PATH)
-        print("✅ [SA-restore] DB restored from Hub")
-        return True
-    except Exception as e:
-        print(f"⚠️ [SA-restore] failed (first run?): {e}")
-        return False
-
-
-async def init_siteagent_db():
-    """SiteAgent 영구 DB 초기화"""
-    await _sa_restore_db()
-    async with aiosqlite.connect(SA_DB_PATH, timeout=30.0) as db:
-        await db.execute("PRAGMA journal_mode=WAL")
-
-        # 사용자
-        await db.execute("""CREATE TABLE IF NOT EXISTS users (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            email TEXT UNIQUE NOT NULL,
-            nickname TEXT,
-            role TEXT DEFAULT 'user',
-            visit_count INTEGER DEFAULT 0,
-            last_seen_at REAL,
-            created_at REAL
-        )""")
-
-        # 페이지 방문 기록
-        await db.execute("""CREATE TABLE IF NOT EXISTS page_visits (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            email TEXT NOT NULL,
-            url_hash TEXT NOT NULL,
-            url TEXT,
-            title TEXT,
-            domain TEXT,
-            visit_count INTEGER DEFAULT 1,
-            total_duration_sec REAL DEFAULT 0,
-            last_visited_at REAL,
-            created_at REAL,
-            UNIQUE(email, url_hash)
-        )""")
-
-        # 사용자 입력 (프롬프트/명령어) 이력
-        await db.execute("""CREATE TABLE IF NOT EXISTS user_inputs (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            email TEXT NOT NULL,
-            url_hash TEXT,
-            url TEXT,
-            input_type TEXT,
-            input_text TEXT,
-            feature TEXT,
-            result_length INTEGER DEFAULT 0,
-            created_at REAL
-        )""")
-
-        # 기능별 사용 통계
-        await db.execute("""CREATE TABLE IF NOT EXISTS feature_usage (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            email TEXT NOT NULL,
-            feature TEXT NOT NULL,
-            use_count INTEGER DEFAULT 1,
-            last_used_at REAL,
-            UNIQUE(email, feature)
-        )""")
-
-        # 인덱스
-        await db.execute("CREATE INDEX IF NOT EXISTS idx_visits_email ON page_visits(email, last_visited_at DESC)")
-        await db.execute("CREATE INDEX IF NOT EXISTS idx_inputs_email ON user_inputs(email, created_at DESC)")
-        await db.execute("CREATE INDEX IF NOT EXISTS idx_usage_email ON feature_usage(email, use_count DESC)")
-        await db.execute("CREATE INDEX IF NOT EXISTS idx_visits_domain ON page_visits(domain, visit_count DESC)")
-
-        # 관리자 자동 등록
-        import time
-        cursor = await db.execute("SELECT email FROM users WHERE email=?", (ADMIN_EMAIL,))
-        if not await cursor.fetchone():
-            await db.execute("INSERT INTO users (email,nickname,role,created_at) VALUES (?,?,?,?)",
-                           (ADMIN_EMAIL, "🔑관리자", "admin", time.time()))
-
-        await db.commit()
-        count = await db.execute("SELECT COUNT(*) FROM users")
-        cnt = (await count.fetchone())[0]
-        print(f"✅ SiteAgent DB initialized: {SA_DB_PATH} ({cnt} users)")
-HF_TOKEN     = os.environ.get("HF_TOKEN", "")
-DATASET_ID   = "ginigen-ai/siteagent"
-LOG_FILE     = "/tmp/sa_events.jsonl"
-
-
-# ── 서로게이트 문자 제거 (YouTube 이모지 등) ────────────────────
-import re as _re
-
-def _sanitize_text(text):
-    """lone surrogate(\\ud800-\\udfff) 제거 — UTF-8 인코딩 에러 방지"""
-    if not isinstance(text, str):
-        return text
-    clean = _re.sub(r'[\ud800-\udfff]', '', text)
-    try:
-        clean.encode('utf-8')
-        return clean
-    except UnicodeEncodeError:
-        return clean.encode('utf-8', 'replace').decode('utf-8')
-
-
-def _sanitize_messages(messages):
-    """메시지 배열 전체에서 서로게이트 제거"""
-    if not messages:
-        return messages
-    clean = []
-    for msg in messages:
-        m = dict(msg)
-        if isinstance(m.get("content"), str):
-            m["content"] = _sanitize_text(m["content"])
-        elif isinstance(m.get("content"), list):
-            m["content"] = [
-                {**item, "text": _sanitize_text(item["text"])} if isinstance(item, dict) and "text" in item else item
-                for item in m["content"]
-            ]
-        clean.append(m)
-    return clean
-
-
-def _strip_response_tables(data):
-    """JSONResponse 데이터 내 모든 content에서 표 제거"""
-    try:
-        if isinstance(data, dict):
-            for ch in data.get("choices", []):
-                msg = ch.get("message", {})
-                if isinstance(msg.get("content"), str):
-                    msg["content"] = _strip_md_table(msg["content"])
-    except Exception:
-        pass
-    return data
-
-
-def _strip_md_table(text):
-    """마크다운 표를 개조식 리스트로 강제 변환"""
-    if not isinstance(text, str) or '|' not in text:
-        return text
-    lines = text.split('\n')
-    out = []
-    tbl = []
-    in_tbl = False
-    for line in lines:
-        if _re.match(r'^\s*\|.+\|\s*$', line):
-            in_tbl = True
-            tbl.append(line)
-        else:
-            if in_tbl:
-                _flush_table(tbl, out)
-                tbl = []
-                in_tbl = False
-            out.append(line)
-    if in_tbl:
-        _flush_table(tbl, out)
-    return '\n'.join(out)
-
-
-def _flush_table(tbl, out):
-    if len(tbl) < 2:
-        out.extend(tbl)
-        return
-    headers = [c.strip() for c in tbl[0].strip('|').split('|')]
-    for i, tr in enumerate(tbl):
-        cells = [c.strip() for c in tr.strip('|').split('|')]
-        if i == 0:
-            out.append('**' + ' · '.join(c for c in cells if c) + '**')
-        elif i == 1 and _re.match(r'^[\s:\-|]+$', tr):
-            continue
-        else:
-            parts = []
-            for j, cell in enumerate(cells):
-                if cell:
-                    if j < len(headers) and headers[j] and headers[j] != cell:
-                        parts.append(f'**{headers[j]}**: {cell}')
-                    else:
-                        parts.append(cell)
-            out.append('• ' + ' / '.join(parts))
-
-
-# ── page-agent JS + 커스텀 UI JS 메모리 로드 ────────────────────
-_PAGE_AGENT_JS: bytes = b""
-
-def _load_js():
-    global _PAGE_AGENT_JS
-    local = Path(__file__).parent / "secure-pageagent.extend.js"
-    if local.exists():
-        _PAGE_AGENT_JS = local.read_bytes()
-        print(f"✅ secure-pageagent.extend.js loaded ({len(_PAGE_AGENT_JS):,} bytes)")
-    else:
-        print("❌ secure-pageagent.extend.js not found")
-
-_load_js()
-
-
-# ── JS를 Base64로 반환 (CSP 완전 우회) ──────────────────────────
-@app.get("/api/agent-script")
-async def agent_script():
-    if not _PAGE_AGENT_JS:
-        return JSONResponse({"error": "agent script not loaded"}, status_code=500)
-    return JSONResponse({
-        "js": base64.b64encode(_PAGE_AGENT_JS).decode(),
-        "size": len(_PAGE_AGENT_JS)
-    })
-
-
-# ── gpt-oss-120b 통합 프록시 (tools→텍스트 변환→파싱→래핑) + 2회 재시도 ──
-GROQ_URL = "https://api.groq.com/openai/v1/chat/completions"
-MAX_RETRIES = 2
-
-# PageAgent 액션을 텍스트 지시로 변환
-ACTION_INSTRUCTIONS = """
-## 응답 형식 (반드시 JSON으로만 응답)
-아래 JSON 형식으로만 응답하라. 설명 텍스트 없이 JSON만 출력:
-
-{
-  "evaluation_previous_goal": "이전 액션 평가 (1줄)",
-  "memory": "현재까지 파악한 정보 요약",
-  "next_goal": "다음에 할 일",
-  "action": { ... 아래 액션 중 하나 선택 ... }
-}
-
-## 사용 가능한 액션:
-
-1. **완료** (최종 답변을 사용자에게 전달):
-   "action": {"done": {"text": "사용자에게 보여줄 최종 답변", "success": true}}
-
-2. **요소 클릭** (인덱스 번호로 클릭):
-   "action": {"click_element_by_index": {"index": 42}}
-
-3. **텍스트 입력** (입력 필드에 텍스트 입력):
-   "action": {"input_text": {"index": 15, "text": "입력할 텍스트"}}
-
-4. **드롭다운 선택**:
-   "action": {"select_dropdown_option": {"index": 8, "text": "선택할 옵션"}}
-
-5. **세로 스크롤** (위/아래):
-   "action": {"scroll": {"down": true, "num_pages": 1}}
-
-6. **가로 스크롤** (좌/우, 넓은 테이블 등):
-   "action": {"scroll_horizontally": {"right": true, "pixels": 300}}
-
-7. **대기**:
-   "action": {"wait": {"seconds": 2}}
-
-8. **JavaScript 실행** (다른 액션으로 불가능할 때만):
-   "action": {"execute_javascript": {"script": "document.querySelector('video').play()"}}
-   - 비디오 재생: document.querySelector('video').play()
-   - 요소 표시: document.querySelector('.hidden-panel').style.display='block'
-   - 값 읽기: document.querySelector('.price').textContent
-
-9. **사용자에게 질문** (정보가 부족하여 추가 확인이 필요할 때):
-   "action": {"ask_user": {"question": "출발 날짜를 알려주세요"}}
-   - 날짜, 인원수, 옵션 등 필수 정보가 누락된 경우 사용
-   - 추측하지 말고 반드시 물어보라
-
-## 핵심 규칙
-- JSON만 출력. 마크다운 코드블록(```) 금지
-- done.text는 반드시 자연스러운 한국어
-- 페이지에서 정보를 찾아야 하면 클릭/스크롤 액션을 사용
-- 이미 답을 알면 바로 done으로 응답
-- 필수 정보가 누락되면 추측하지 말고 ask_user로 물어보라
-
-## 중요: 실패 처리
-- 같은 액션이 실패(⚠️)하면 절대 반복하지 마라. 다른 액션을 시도하라.
-- 스크롤이 실패하면("Already at the bottom/top") 더 이상 스크롤하지 마라. 클릭이나 다른 방법을 시도하라.
-- 3번 이상 같은 종류의 액션이 실패하면 done으로 사용자에게 상황을 설명하라.
-
-## 중요: 액션 선택 우선순위
-- 버튼, 링크, 비디오 재생 등 조작 요청 → click_element_by_index를 먼저 시도하라.
-- 비디오 재생 요청 → 재생 버튼(play, ▶) 인덱스를 찾아 클릭. 없으면 execute_javascript로 document.querySelector('video').play() 실행.
-- 정보가 보이지 않을 때만 스크롤. 스크롤은 최대 3회까지만.
-- 넓은 표에서 오른쪽 데이터가 잘리면 scroll_horizontally를 사용하라.
-- 요청을 5스텝 이내에 완료할 수 없으면 현재까지 결과를 done으로 보고하라.
-"""
-
-@app.post("/api/chat/completions")
-async def chat_proxy(request: Request):
-    try:
-        body = await request.json()
-    except Exception:
-        return JSONResponse({"error": "invalid json"}, status_code=400)
-
-    # ── 기본 데모 모드 (Groq gpt-oss-120b) ──
-    if not GROQ_API_KEY:
-        return JSONResponse({"error": "GROQ_API_KEY not set"}, status_code=500)
-
-    # tools 저장 후 제거 (gpt-oss-120b는 텍스트로 처리)
-    original_tools = body.pop("tools", None)
-    body.pop("tool_choice", None)
-    body.pop("parallel_tool_calls", None)
-
-    # ★ Groq 내장 도구 요청 감지 (X-SA-Mode 헤더 또는 sa_mode 파라미터)
-    sa_mode = body.pop("sa_mode", None)
-    _sa_email_val = body.pop("sa_email", "")
-    _sa_url_val = body.pop("sa_url", "")
-
-    # ★ 서로게이트 문자 제거 (YouTube 이모지 등 — 모든 분기 전에 적용)
-    if "messages" in body:
-        body["messages"] = _sanitize_messages(body["messages"])
-
-    # ★ 사용자 입력 자동 DB 기록 (모든 채팅/검색/계산)
-    try:
-        import time as _time, hashlib as _hl
-        _sa_email = _sa_email_val
-        _sa_url = _sa_url_val
-        if _sa_email:
-            _msgs = body.get("messages", [])
-            _last_user = ""
-            for _m in reversed(_msgs):
-                if _m.get("role") == "user":
-                    _ct = _m.get("content", "")
-                    _last_user = _ct if isinstance(_ct, str) else str(_ct)[:500]
-                    break
-            if _last_user:
-                _uh = _hl.sha256(_sa_url.encode()).hexdigest()[:16] if _sa_url else ""
-                _feat = sa_mode or "chat"
-                _asyncio.create_task(_db_write(
-                    "INSERT INTO user_inputs (email,url_hash,url,input_type,input_text,feature,created_at) VALUES (?,?,?,?,?,?,?)",
-                    (_sa_email, _uh, _sa_url[:500], "chat", _last_user[:1000], _feat, _time.time())
-                ))
-                _asyncio.create_task(_db_write(
-                    "INSERT INTO feature_usage (email,feature,use_count,last_used_at) VALUES (?,?,1,?) ON CONFLICT(email,feature) DO UPDATE SET use_count=use_count+1, last_used_at=?",
-                    (_sa_email, _feat, _time.time(), _time.time())
-                ))
-    except Exception as _le:
-        print(f"[log] chat input logging error: {_le}")
-    if not sa_mode:
-        sa_mode = request.headers.get("X-SA-Mode", "")
-
-    body["model"] = "openai/gpt-oss-120b"
-    body["stream"] = False
-    body["temperature"] = 1
-    body["top_p"] = 1
-    body["stop"] = None
-    for k in ["max_tokens", "thinking", "verbosity"]:
-        body.pop(k, None)
-
-    # ★ 모드별 분기
-    if sa_mode == "search":
-        # ── 웹 검색 모드: browser_search 활성화 ──
-        body["tools"] = [{"type": "browser_search"}]
-        body["tool_choice"] = "required"
-        body["max_completion_tokens"] = 4096
-        body["reasoning_effort"] = "low"
-        original_tools = None  # tool_call 래핑 안 함
-        msgs = body.get("messages", [])
-        if msgs and msgs[0].get("role") == "system":
-            msgs[0]["content"] += "\n\n[중요] 반드시 자연스러운 한국어로 답변하라."
-        elif msgs:
-            msgs.insert(0, {"role": "system", "content": "반드시 자연스러운 한국어로 답변하라."})
-        body["messages"] = msgs
-        print("[proxy] mode: browser_search")
-
-    elif sa_mode == "calc":
-        # ── 계산 모드: code_interpreter 활성화 ──
-        body["tools"] = [{"type": "code_interpreter"}]
-        body["tool_choice"] = "required"
-        body["max_completion_tokens"] = 4096
-        body["reasoning_effort"] = "medium"
-        original_tools = None
-        msgs = body.get("messages", [])
-        if msgs and msgs[0].get("role") == "system":
-            msgs[0]["content"] += "\n\n[중요] 계산 결과를 자연스러운 한국어로 설명하라."
-        elif msgs:
-            msgs.insert(0, {"role": "system", "content": "계산 결과를 자연스러운 한국어로 설명하라."})
-        body["messages"] = msgs
-        print("[proxy] mode: code_interpreter")
-
-    elif original_tools:
-        # ── DOM 액션 모드 (기존): ACTION_INSTRUCTIONS 주입 ──
-        body["max_completion_tokens"] = 8192
-        # ★ 동적 reasoning_effort: 첫 스텝은 medium, 이후 low (속도 최적화)
-        msgs = body.get("messages", [])
-        user_msgs = [m for m in msgs if m.get("role") == "user"]
-        body["reasoning_effort"] = "medium" if len(user_msgs) <= 2 else "low"
-
-        if msgs[0].get("role") == "system":
-            msgs[0]["content"] = msgs[0]["content"] + "\n" + ACTION_INSTRUCTIONS
-        else:
-            msgs.insert(0, {"role": "system", "content": ACTION_INSTRUCTIONS})
-        body["messages"] = msgs
-        print(f"[proxy] mode: dom_action (reasoning: {body['reasoning_effort']})")
-
-    else:
-        # ── 일반 텍스트 모드 ──
-        body["max_completion_tokens"] = 4096
-        body["reasoning_effort"] = "low"
-        msgs = body.get("messages", [])
-        if msgs and msgs[0].get("role") == "system":
-            if "한국어" not in msgs[0]["content"]:
-                msgs[0]["content"] += "\n\n[중요] 최종 답변은 반드시 자연스러운 한국어로 작성하라."
-        body["messages"] = msgs
-        print("[proxy] mode: text")
-
-    headers = {
-        "Authorization": f"Bearer {GROQ_API_KEY}",
-        "Content-Type": "application/json",
-    }
-
-    # ── 2회 재시도 ──
-    data = None
-    status = 500
-    for attempt in range(MAX_RETRIES + 1):
-        try:
-            async with httpx.AsyncClient(timeout=180) as client:
-                resp = await client.post(GROQ_URL, headers=headers, json=body)
-                try:
-                    data = resp.json()
-                except Exception:
-                    print(f"[proxy] Groq returned non-JSON: {resp.text[:200]}")
-                    data = {"error": {"message": "Groq returned invalid response", "type": "proxy_error"}}
-                status = resp.status_code
-
-            if status == 429:
-                wait = 2 * (attempt + 1)
-                print(f"[proxy] 429 → retry {attempt+1}/{MAX_RETRIES} ({wait}s)")
-                if attempt < MAX_RETRIES:
-                    await asyncio.sleep(wait)
-                    continue
-            elif status >= 500:
-                print(f"[proxy] {status} → retry {attempt+1}/{MAX_RETRIES}")
-                if attempt < MAX_RETRIES:
-                    await asyncio.sleep(1)
-                    continue
-            break
-        except Exception as e:
-            print(f"[proxy] exception: {e}")
-            if attempt < MAX_RETRIES:
-                await asyncio.sleep(1)
-                continue
-            return JSONResponse({"error": {"message": str(e)}}, status_code=502)
-
-    if status != 200:
-        return JSONResponse(data or {"error": "unknown"}, status_code=status)
-
-    # ★ search/calc 모드: executed_tools에서 결과 추출하여 깔끔하게 반환
-    if sa_mode in ("search", "calc"):
-        try:
-            content = data["choices"][0]["message"].get("content", "")
-            # executed_tools 로깅
-            executed = data["choices"][0]["message"].get("executed_tools", [])
-            if executed:
-                print(f"[proxy] executed_tools: {len(executed)} tools used")
-            # Groq 인용 태그 제거
-            import re
-            try:
-                msg = data["choices"][0]["message"]
-                if msg.get("content"):
-                    msg["content"] = re.sub(r'【[^】]*】', '', msg["content"]).strip()
-            except: pass
-            return JSONResponse(data)
-        except Exception as e:
-            print(f"[proxy] search/calc extract error: {e}")
-            return JSONResponse(data)
-
-    # ── tools가 있었으면: LLM 텍스트 응답 → AgentOutput tool_call 래핑 ──
-    if original_tools:
-        raw_text = ""
-        try:
-            raw_text = data["choices"][0]["message"]["content"] or ""
-        except Exception:
-            pass
-
-        print(f"[proxy] raw ({len(raw_text)}): {raw_text[:300]}...")
-
-        # JSON 추출 (코드블록 제거 포함)
-        agent_output = _extract_agent_output(raw_text)
-
-        wrapped = {
-            "id": data.get("id", "sa"),
-            "object": "chat.completion",
-            "created": data.get("created", 0),
-            "model": "openai/gpt-oss-120b",
-            "choices": [{
-                "index": 0,
-                "message": {
-                    "role": "assistant",
-                    "tool_calls": [{
-                        "id": "call_sa_" + str(data.get("created", 0)),
-                        "type": "function",
-                        "function": {
-                            "name": "AgentOutput",
-                            "arguments": agent_output
-                        }
-                    }]
-                },
-                "finish_reason": "tool_calls"
-            }],
-            "usage": data.get("usage", {})
-        }
-        return JSONResponse(wrapped)
-
-    _strip_response_tables(data)
-    return JSONResponse(data)
-
-
-def _extract_agent_output(raw: str) -> str:
-    """LLM 텍스트 응답에서 AgentOutput JSON 추출"""
-    text = raw.strip()
-
-    # 마크다운 코드블록 제거
-    if text.startswith("```"):
-        text = text.split("\n", 1)[-1] if "\n" in text else text[3:]
-    if text.endswith("```"):
-        text = text[:-3].strip()
-    if text.startswith("json"):
-        text = text[4:].strip()
-
-    # JSON 파싱 시도
-    parsed = None
-    try:
-        parsed = json.loads(text)
-    except json.JSONDecodeError:
-        # JSON이 텍스트에 묻혀있으면 첫 번째 { ~ 마지막 } 추출
-        start = text.find("{")
-        end = text.rfind("}")
-        if start >= 0 and end > start:
-            try:
-                parsed = json.loads(text[start:end+1])
-            except json.JSONDecodeError:
-                pass
-
-    if parsed and isinstance(parsed, dict) and "action" in parsed:
-        # 유효한 AgentOutput
-        action = parsed["action"]
-
-        # done.text가 있으면 한국어 확인
-        if isinstance(action, dict) and "done" in action:
-            done = action["done"]
-            if isinstance(done, dict) and done.get("text"):
-                print(f"[proxy] → done: {done['text'][:80]}...")
-            elif isinstance(done, dict) and not done.get("text"):
-                # text 비었으면 memory/next_goal에서 보충
-                fill = parsed.get("memory", "") or parsed.get("next_goal", "")
-                if fill:
-                    done["text"] = fill
-                    parsed["action"]["done"] = done
-
-        # click/scroll 등 액션은 그대로 전달
-        for act_name in ["click_element_by_index", "input_text", "scroll",
-                         "select_dropdown_option", "wait", "scroll_horizontally",
-                         "execute_javascript", "ask_user"]:
-            if act_name in action:
-                print(f"[proxy] → action: {act_name} {action[act_name]}")
-
-        return json.dumps(parsed, ensure_ascii=False)
-
-    # JSON 파싱 실패 → 전체를 done.text로
-    final_text = raw.strip()
-    if parsed and isinstance(parsed, dict):
-        # JSON이긴 한데 action이 없는 경우 → 텍스트 추출
-        for key in ["text", "content", "answer", "response", "result"]:
-            if key in parsed and isinstance(parsed[key], str):
-                final_text = parsed[key]
-                break
-
-    print(f"[proxy] → fallback done: {final_text[:80]}...")
-    return json.dumps({
-        "evaluation_previous_goal": "Processed",
-        "memory": "",
-        "next_goal": "",
-        "action": {"done": {"text": final_text or "응답을 생성할 수 없습니다.", "success": bool(final_text)}}
-    }, ensure_ascii=False)
-
-
-# ── 검색/계산 직접 호출 (커스텀 UI용) ────────────────────────────
-@app.post("/api/search")
-async def search_api(request: Request):
-    """browser_search를 사용한 웹 검색"""
-    try:
-        body = await request.json()
-    except Exception:
-        return JSONResponse({"error": "invalid json"}, status_code=400)
-
-    query = body.get("query", "")
-    if not query:
-        return JSONResponse({"error": "query required"}, status_code=400)
-    if not GROQ_API_KEY:
-        return JSONResponse({"error": "GROQ_API_KEY not set"}, status_code=500)
-
-    payload = {
-        "model": "openai/gpt-oss-120b",
-        "messages": [
-            {"role": "system", "content": "반드시 자연스러운 한국어로 답변하라. 핵심만 간결하게. 표(table)는 절대 사용하지 마라. 개조식 서술형으로 작성하라."},
-            {"role": "user", "content": query}
-        ],
-        "tools": [{"type": "browser_search"}],
-        "tool_choice": "required",
-        "max_completion_tokens": 4096,
-        "reasoning_effort": "low",
-        "stream": False
-    }
-
-    headers = {"Authorization": f"Bearer {GROQ_API_KEY}", "Content-Type": "application/json"}
-    try:
-        async with httpx.AsyncClient(timeout=120) as client:
-            resp = await client.post(GROQ_URL, headers=headers, json=payload)
-            data = resp.json()
-        content = data.get("choices", [{}])[0].get("message", {}).get("content", "검색 결과를 가져올 수 없습니다.")
-        # Groq browser_search 인용 태그 제거 (【0†L4-L8】 등)
-        import re
-        content = re.sub(r'【[^】]*】', '', content).strip()
-        content = re.sub(r'\s{2,}', ' ', content)
-        return JSONResponse({"result": content})
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=502)
-
-
-@app.post("/api/calc")
-async def calc_api(request: Request):
-    """code_interpreter를 사용한 계산"""
-    try:
-        body = await request.json()
-    except Exception:
-        return JSONResponse({"error": "invalid json"}, status_code=400)
-
-    query = body.get("query", "")
-    if not query:
-        return JSONResponse({"error": "query required"}, status_code=400)
-    if not GROQ_API_KEY:
-        return JSONResponse({"error": "GROQ_API_KEY not set"}, status_code=500)
-
-    payload = {
-        "model": "openai/gpt-oss-120b",
-        "messages": [
-            {"role": "system", "content": "계산 결과를 자연스러운 한국어로 설명하라."},
-            {"role": "user", "content": query}
-        ],
-        "tools": [{"type": "code_interpreter"}],
-        "tool_choice": "required",
-        "max_completion_tokens": 4096,
-        "reasoning_effort": "medium",
-        "stream": False
-    }
-
-    headers = {"Authorization": f"Bearer {GROQ_API_KEY}", "Content-Type": "application/json"}
-    try:
-        async with httpx.AsyncClient(timeout=120) as client:
-            resp = await client.post(GROQ_URL, headers=headers, json=payload)
-            data = resp.json()
-        content = data.get("choices", [{}])[0].get("message", {}).get("content", "계산 결과를 가져올 수 없습니다.")
-        return JSONResponse({"result": content})
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=502)
-
-
-# ── 트래킹 ──────────────────────────────────────────────────────
-_log_lock = threading.Lock()
-
-def push_event_sync(event: dict):
-    line = json.dumps(event, ensure_ascii=False) + "\n"
-    with _log_lock:
-        with open(LOG_FILE, "a", encoding="utf-8") as f:
-            f.write(line)
-    if not HF_TOKEN:
-        return
-    try:
-        from huggingface_hub import HfApi, hf_hub_download
-        api = HfApi(token=HF_TOKEN)
-        date_str = datetime.now(timezone.utc).strftime("%Y-%m-%d")
-        path_in_repo = f"logs/{date_str}.jsonl"
-        existing = ""
-        try:
-            local = hf_hub_download(repo_id=DATASET_ID, filename=path_in_repo,
-                                    repo_type="dataset", token=HF_TOKEN)
-            with open(local, encoding="utf-8") as f:
-                existing = f.read()
-        except Exception:
-            pass
-        api.upload_file(
-            path_or_fileobj=(existing + line).encode("utf-8"),
-            path_in_repo=path_in_repo, repo_id=DATASET_ID,
-            repo_type="dataset", token=HF_TOKEN,
-            commit_message=f"track {date_str}")
-    except Exception as e:
-        print(f"[push_event] {e}")
-
-
-def calc_stats():
-    events = []
-    if os.path.exists(LOG_FILE):
-        with _log_lock:
-            with open(LOG_FILE, encoding="utf-8") as f:
-                for line in f:
-                    line = line.strip()
-                    if line:
-                        try:
-                            events.append(json.loads(line))
-                        except Exception:
-                            pass
-    if not events:
-        return {"total_sessions":0,"total_commands":0,"total_installs":0,
-                "providers":{},"top_domains":[],"daily_active":[],"events_today":0}
-    sessions=set(); commands=installs=0
-    providers=Counter(); domains=Counter(); daily=defaultdict(set)
-    for e in events:
-        sid=e.get("session_id","")
-        if sid: sessions.add(sid)
-        ev=e.get("event","")
-        if ev=="command": commands+=1
-        if ev=="install": installs+=1
-        if ev=="settings_save":
-            prov=e.get("provider","")
-            if prov: providers[prov]+=1
-        domain=e.get("domain","")
-        if domain: domains[domain]+=1
-        ts=e.get("ts","")
-        if ts and sid: daily[ts[:10]].add(sid)
-    today=datetime.now(timezone.utc).date()
-    daily_active=[{"date":(today-timedelta(days=i)).isoformat(),
-                   "users":len(daily.get((today-timedelta(days=i)).isoformat(),set()))}
-                  for i in range(13,-1,-1)]
-    today_str=today.isoformat()
-    return {"total_sessions":len(sessions),"total_commands":commands,"total_installs":installs,
-            "providers":dict(providers.most_common(10)),
-            "top_domains":[{"domain":d,"count":c} for d,c in domains.most_common(10)],
-            "daily_active":daily_active,
-            "events_today":sum(1 for e in events if e.get("ts","")[:10]==today_str)}
-
-
-@app.on_event("startup")
-async def startup_init_db():
-    await init_siteagent_db()
-    # 주기적 백업 (30분마다)
-    import asyncio
-    async def _periodic_backup():
-        while True:
-            await asyncio.sleep(1800)  # 30분
-            try:
-                await _sa_backup_db()
-            except Exception as e:
-                print(f"⚠️ Periodic backup error: {e}")
-    asyncio.create_task(_periodic_backup())
-    # 첫 백업 (5분 후)
-    async def _first_backup():
-        await asyncio.sleep(300)
-        await _sa_backup_db()
-    asyncio.create_task(_first_backup())
-
-@app.on_event("startup")
-def restore_logs_from_hf():
-    if not HF_TOKEN:
-        return
-    try:
-        from huggingface_hub import HfApi, hf_hub_download
-        api = HfApi(token=HF_TOKEN)
-        files = [
-            f.rfilename for f in api.list_repo_tree(
-                repo_id=DATASET_ID, repo_type="dataset", token=HF_TOKEN
-            )
-            if f.rfilename.startswith("logs/") and f.rfilename.endswith(".jsonl")
-        ]
-        restored = 0
-        with open(LOG_FILE, "a", encoding="utf-8") as out:
-            for fname in sorted(files):
-                try:
-                    local = hf_hub_download(
-                        repo_id=DATASET_ID, filename=fname,
-                        repo_type="dataset", token=HF_TOKEN
-                    )
-                    with open(local, encoding="utf-8") as f:
-                        for line in f:
-                            line = line.strip()
-                            if line:
-                                out.write(line + "\n")
-                                restored += 1
-                except Exception as e:
-                    print(f"[restore] skip {fname}: {e}")
-        print(f"[restore] {restored} events restored from HF dataset")
-    except Exception as e:
-        print(f"[restore] failed: {e}")
-
-
-@app.post("/api/track")
-async def track(request: Request, background_tasks: BackgroundTasks):
-    try:
-        body = await request.json()
-    except Exception:
-        return JSONResponse({"ok": False}, status_code=400)
-    allowed = {"event","session_id","provider","domain","ts","browser","os","lang"}
-    event = {k:v for k,v in body.items() if k in allowed}
-    event["ts"] = event.get("ts") or datetime.now(timezone.utc).isoformat()
-    background_tasks.add_task(push_event_sync, event)
-    return JSONResponse({"ok": True})
-
-
-# ── 사용자 관리 API ────────────────────────────────────────
-@app.post("/api/user/register")
-async def user_register(request: Request):
-    """사용자 자동 등록 (Gmail 기반)"""
-    import time
-    try:
-        body = await request.json()
-        email = body.get("email", "").strip().lower()
-        if not email or "@" not in email:
-            return JSONResponse({"error": "invalid email"}, status_code=400)
-
-        existing = await _db_read_one("SELECT id,role FROM users WHERE email=?", (email,))
-        if existing:
-            await _db_write("UPDATE users SET visit_count=visit_count+1, last_seen_at=? WHERE email=?",
-                          (time.time(), email))
-            return {"status": "exists", "role": dict(existing)["role"]}
-
-        # 신규 등록 — 동물 닉네임 자동 생성
-        import random
-        animals = ["🐱고양이","🐶강아지","🦊여우","🐻곰","🐼팬더","🐨코알라","🦁사자","🐯호랑이","🐰토끼","🦝너구리","🐸개구리","🦉올빼미","🦋나비","🐬돌고래","🦈상어","🐧펭귄","🦜앵무새","🐢거북이"]
-        nick = "익명" + random.choice(animals) + str(random.randint(10,99))
-        role = "admin" if email == ADMIN_EMAIL else "user"
-
-        await _db_write("INSERT OR IGNORE INTO users (email,nickname,role,visit_count,last_seen_at,created_at) VALUES (?,?,?,1,?,?)",
-                       (email, nick, role, time.time(), time.time()))
-        return {"status": "created", "nickname": nick, "role": role}
-    except Exception as e:
-        return JSONResponse({"error": str(e)[:100]}, status_code=500)
-
-
-@app.post("/api/user/log")
-async def user_log_activity(request: Request):
-    """사용자 활동 기록 (방문, 입력, 기능 사용)"""
-    import time, hashlib
-    try:
-        body = await request.json()
-        email = body.get("email", "").strip().lower()
-        if not email: return JSONResponse({"error": "email required"}, status_code=400)
-
-        action = body.get("action", "")
-        url = body.get("url", "")
-        title = body.get("title", "")
-        input_text = _sanitize_text(body.get("input_text", ""))
-        feature = body.get("feature", "")
-
-        url_hash = hashlib.sha256(url.encode()).hexdigest()[:16] if url else ""
-        domain = ""
-        if url:
-            try:
-                from urllib.parse import urlparse
-                domain = urlparse(url).netloc
-            except: pass
-
-        now = time.time()
-
-        if action == "visit" and url:
-            existing = await _db_read_one("SELECT id FROM page_visits WHERE email=? AND url_hash=?", (email, url_hash))
-            if existing:
-                await _db_write("UPDATE page_visits SET visit_count=visit_count+1, title=?, last_visited_at=? WHERE email=? AND url_hash=?",
-                              (title[:200] if title else None, now, email, url_hash))
-            else:
-                await _db_write("INSERT INTO page_visits (email,url_hash,url,title,domain,last_visited_at,created_at) VALUES (?,?,?,?,?,?,?)",
-                              (email, url_hash, url[:500], title[:200] if title else None, domain, now, now))
-
-        elif action == "input" and input_text:
-            await _db_write("INSERT INTO user_inputs (email,url_hash,url,input_type,input_text,feature,result_length,created_at) VALUES (?,?,?,?,?,?,?,?)",
-                          (email, url_hash, url[:500] if url else None, body.get("input_type","chat"), input_text[:1000], feature, body.get("result_length",0), now))
-
-        if feature:
-            existing = await _db_read_one("SELECT id FROM feature_usage WHERE email=? AND feature=?", (email, feature))
-            if existing:
-                await _db_write("UPDATE feature_usage SET use_count=use_count+1, last_used_at=? WHERE email=? AND feature=?",
-                              (now, email, feature))
-            else:
-                await _db_write("INSERT INTO feature_usage (email,feature,use_count,last_used_at) VALUES (?,?,1,?)",
-                              (email, feature, now))
-
-        return {"status": "ok"}
-    except Exception as e:
-        print(f"[user-log] error: {e}")
-        return JSONResponse({"error": str(e)[:100]}, status_code=500)
-
-
-@app.get("/api/user/profile")
-async def user_profile(email: str = ""):
-    """사용자 프로필 + 활동 요약"""
-    email = email.strip().lower()
-    if not email: return JSONResponse({"error": "email required"}, status_code=400)
-    user = await _db_read_one("SELECT * FROM users WHERE email=?", (email,))
-    if not user: return JSONResponse({"error": "user not found"}, status_code=404)
-    user_dict = dict(user)
-
-    # 최근 방문 TOP 10
-    visits = await _db_read("SELECT domain, SUM(visit_count) as cnt FROM page_visits WHERE email=? GROUP BY domain ORDER BY cnt DESC LIMIT 10", (email,))
-    user_dict["top_domains"] = [{"domain": dict(v)["domain"], "count": dict(v)["cnt"]} for v in visits]
-
-    # 기능 사용 통계
-    usage = await _db_read("SELECT feature, use_count FROM feature_usage WHERE email=? ORDER BY use_count DESC", (email,))
-    user_dict["feature_usage"] = [{"feature": dict(u)["feature"], "count": dict(u)["use_count"]} for u in usage]
-
-    # 최근 입력 5건
-    inputs = await _db_read("SELECT input_text, feature, url, created_at FROM user_inputs WHERE email=? ORDER BY created_at DESC LIMIT 10", (email,))
-    user_dict["recent_inputs"] = [dict(i) for i in inputs]
-
-    return user_dict
-
-
-@app.delete("/api/admin/user/{email}")
-async def admin_delete_user(email: str, request: Request):
-    """관리자: 사용자 및 관련 데이터 삭제"""
-    admin_email = request.headers.get("X-Admin-Email", "")
-    if admin_email != ADMIN_EMAIL:
-        return JSONResponse({"error": "unauthorized"}, status_code=403)
-    await _db_write("DELETE FROM user_inputs WHERE email=?", (email,))
-    await _db_write("DELETE FROM page_visits WHERE email=?", (email,))
-    await _db_write("DELETE FROM feature_usage WHERE email=?", (email,))
-    await _db_write("DELETE FROM users WHERE email=?", (email,))
-    return {"status": "deleted", "email": email}
-
-
-@app.delete("/api/admin/record/{table}/{record_id}")
-async def admin_delete_record(table: str, record_id: int, request: Request):
-    """관리자: 개별 레코드 삭제"""
-    admin_email = request.headers.get("X-Admin-Email", "")
-    if admin_email != ADMIN_EMAIL:
-        return JSONResponse({"error": "unauthorized"}, status_code=403)
-    allowed = {"users","page_visits","user_inputs","feature_usage"}
-    if table not in allowed:
-        return JSONResponse({"error": f"table not allowed: {table}"}, status_code=400)
-    await _db_write(f"DELETE FROM {table} WHERE id=?", (record_id,))
-    return {"status": "deleted", "table": table, "id": record_id}
-
-
-@app.get("/api/admin/dashboard")
-async def admin_dashboard(request: Request):
-    """관리자: 전체 통계 대시보드"""
-    admin_email = request.query_params.get("admin", "")
-    if admin_email != ADMIN_EMAIL:
-        return JSONResponse({"error": "unauthorized"}, status_code=403)
-    users = await _db_read("SELECT COUNT(*) as cnt FROM users")
-    visits = await _db_read("SELECT COUNT(*) as cnt FROM page_visits")
-    inputs = await _db_read("SELECT COUNT(*) as cnt FROM user_inputs")
-
-    top_domains = await _db_read("SELECT domain, SUM(visit_count) as cnt FROM page_visits GROUP BY domain ORDER BY cnt DESC LIMIT 20")
-    top_features = await _db_read("SELECT feature, SUM(use_count) as cnt FROM feature_usage GROUP BY feature ORDER BY cnt DESC")
-    recent_users = await _db_read("SELECT email, nickname, role, visit_count, last_seen_at FROM users ORDER BY last_seen_at DESC LIMIT 20")
-
-    return {
-        "total_users": dict(users[0])["cnt"],
-        "total_visits": dict(visits[0])["cnt"],
-        "total_inputs": dict(inputs[0])["cnt"],
-        "top_domains": [dict(d) for d in top_domains],
-        "top_features": [dict(f) for f in top_features],
-        "recent_users": [dict(u) for u in recent_users],
-    }
-
-
-@app.get("/admin")
-async def admin_page(request: Request):
-    """관리자 대시보드 HTML UI"""
-    admin = request.query_params.get("key", "")
-    if admin != ADMIN_EMAIL:
-        return HTMLResponse("<h1>🔒 접근 거부</h1><p>?key=관리자이메일 필요</p>", status_code=403)
-    html_path = Path(__file__).parent / "admin_dashboard.html"
-    if html_path.exists():
-        return HTMLResponse(html_path.read_text(encoding="utf-8"))
-    return HTMLResponse("<h1>❌ admin_dashboard.html not found</h1>", status_code=500)
-
-
-@app.get("/api/admin/all-visits")
-async def admin_all_visits(request: Request):
-    """관리자: 전체 방문 기록"""
-    admin_email = request.query_params.get("admin", "")
-    if admin_email != ADMIN_EMAIL:
-        return JSONResponse({"error": "unauthorized"}, status_code=403)
-    rows = await _db_read(
-        "SELECT id,email,url_hash,url,title,domain,visit_count,last_visited_at FROM page_visits ORDER BY last_visited_at DESC LIMIT 100"
-    )
-    return {"visits": [dict(r) for r in rows]}
-
-
-@app.get("/api/admin/inputs")
-async def admin_inputs(request: Request):
-    """관리자: 최근 입력 로그"""
-    admin_email = request.query_params.get("admin", "")
-    if admin_email != ADMIN_EMAIL:
-        return JSONResponse({"error": "unauthorized"}, status_code=403)
-    rows = await _db_read("SELECT id,email,feature,input_text,url,created_at FROM user_inputs ORDER BY created_at DESC LIMIT 100")
-    return {"inputs": [dict(r) for r in rows]}
-
-
-@app.get("/api/stats")
-async def stats():
-    return JSONResponse(calc_stats())
-
-
-
-
-# ── MARL 테스트 (디버그용) ────────────────────────────────────
-@app.get("/api/marl-test")
-async def marl_test():
-    _init_marl()
-    result = {"marl_available": MARL_AVAILABLE, "groq_key_set": bool(GROQ_API_KEY)}
-    if MARL_AVAILABLE:
-        try:
-            config = MarlConfig(mode="insight", return_final_only=True, language="ko", budget_scale=0.5)
-            ml = Marl(call_fn=_groq_call_fn, config=config)
-            import asyncio
-            r = await asyncio.to_thread(ml.run, "1+1=? 한 줄로 답하라.", "한국어로 답변")
-            result["test_answer"] = r.answer[:200] if r.answer else "EMPTY"
-            result["test_elapsed"] = round(r.elapsed, 2)
-            result["test_ok"] = bool(r.answer and not r.answer.startswith("[ERROR"))
-        except Exception as e:
-            result["test_error"] = str(e)
-            result["test_ok"] = False
-    else:
-        result["test_ok"] = False
-        result["test_error"] = "MARL not available"
-    return JSONResponse(result)
-
-
-# ── 정적 파일 ────────────────────────────────────────────────────
-@app.get("/secure-pageagent.extend.js")
-async def serve_js():
-    if _PAGE_AGENT_JS:
-        return Response(_PAGE_AGENT_JS, media_type="application/javascript")
-    return JSONResponse({"error": "js not found"}, status_code=404)
-
-@app.get("/style.css")
-async def serve_css():
-    return Response("", media_type="text/css")
-
-@app.get("/")
-@app.get("/index.html")
-async def serve_index():
-    path = "index.html"
-    if not os.path.isfile(path):
-        return JSONResponse({"error": "index.html not found"}, status_code=404)
-    return FileResponse(path, media_type="text/html")
-
-
-
-
-
-# ── MARL 통합 (메타인지 + 창발성) ─────────────────────────────
-# ── 이미지 생성 (fal.ai xai/grok-imagine) ────────────────────
-@app.post("/api/imagine")
-async def imagine_endpoint(request: Request):
-    """fal.ai Grok Imagine으로 이미지 생성 + Ginigen.AI 워터마크"""
-    if not FAL_KEY:
-        return JSONResponse({"error": "FAL_KEY not set"}, status_code=500)
-
-    try:
-        body = await request.json()
-    except Exception:
-        return JSONResponse({"error": "invalid json"}, status_code=400)
-
-    prompt = _sanitize_text(body.get("prompt", ""))
-    _marl_email = body.get("sa_email", "")
-    _marl_url = body.get("sa_url", "")
-    # ★ MARL 입력 자동 로깅
-    if _marl_email and prompt:
-        try:
-            import time as _t, hashlib as _h2
-            _uh2 = _h2.sha256(_marl_url.encode()).hexdigest()[:16] if _marl_url else ""
-            _feat2 = "deep_analysis" if mode == "insight" else ("idea_" + engine if mode == "emergence" else "marl")
-            _asyncio.create_task(_db_write(
-                "INSERT INTO user_inputs (email,url_hash,url,input_type,input_text,feature,created_at) VALUES (?,?,?,?,?,?,?)",
-                (_marl_email, _uh2, _marl_url[:500], "marl", prompt[:1000], _feat2, _t.time())
-            ))
-            _asyncio.create_task(_db_write(
-                "INSERT INTO feature_usage (email,feature,use_count,last_used_at) VALUES (?,?,1,?) ON CONFLICT(email,feature) DO UPDATE SET use_count=use_count+1, last_used_at=?",
-                (_marl_email, _feat2, _t.time(), _t.time())
-            ))
-        except Exception as _le2:
-            print(f"[log] marl input logging error: {_le2}")
-    if not prompt:
-        return JSONResponse({"error": "prompt required"}, status_code=400)
-
-    aspect = body.get("aspect_ratio", "1:1")
-    num = min(int(body.get("num_images", 1)), 4)
-
-    import httpx as hx
-    import asyncio
-
-    async def _generate_one(idx):
-        """단일 이미지 생성 (fal.ai queue)"""
-        try:
-            async with hx.AsyncClient(timeout=120.0) as client:
-                # 1) Submit
-                sub_resp = await client.post(
-                    "https://queue.fal.run/xai/grok-imagine-image",
-                    headers={"Authorization": f"Key {FAL_KEY}", "Content-Type": "application/json"},
-                    json={"prompt": prompt, "num_images": 1, "aspect_ratio": aspect, "output_format": "jpeg"}
-                )
-                if sub_resp.status_code != 200:
-                    return {"error": f"submit failed: {sub_resp.status_code}"}
-
-                data = sub_resp.json()
-
-                # fal.ai가 즉시 결과를 줄 수도 있고, request_id를 줄 수도 있음
-                if "images" in data:
-                    img_url = data["images"][0]["url"]
-                elif "request_id" in data:
-                    req_id = data["request_id"]
-                    # 2) Poll for result
-                    for _ in range(60):  # 최대 60초
-                        await asyncio.sleep(1)
-                        status_resp = await client.get(
-                            f"https://queue.fal.run/xai/grok-imagine-image/requests/{req_id}/status",
-                            headers={"Authorization": f"Key {FAL_KEY}"}
-                        )
-                        st = status_resp.json()
-                        if st.get("status") == "COMPLETED":
-                            result_resp = await client.get(
-                                f"https://queue.fal.run/xai/grok-imagine-image/requests/{req_id}",
-                                headers={"Authorization": f"Key {FAL_KEY}"}
-                            )
-                            rdata = result_resp.json()
-                            img_url = rdata.get("images", [{}])[0].get("url", "")
-                            break
-                        elif st.get("status") in ("FAILED", "CANCELLED"):
-                            return {"error": "generation failed"}
-                    else:
-                        return {"error": "timeout"}
-                else:
-                    return {"error": "unexpected response"}
-
-                if not img_url:
-                    return {"error": "no image url"}
-
-                # 3) 이미지 다운로드 + 워터마크
-                img_resp = await client.get(img_url)
-                if img_resp.status_code != 200:
-                    return {"url": img_url}  # 워터마크 없이 원본 URL 반환
-
-                # PIL 워터마크
-                try:
-                    from io import BytesIO
-                    from PIL import Image, ImageDraw, ImageFont
-                    import base64
-
-                    img = Image.open(BytesIO(img_resp.content)).convert("RGBA")
-                    overlay = Image.new("RGBA", img.size, (0, 0, 0, 0))
-                    draw = ImageDraw.Draw(overlay)
-
-                    # 워터마크 텍스트
-                    wm_text = "Ginigen.AI"
-                    font_size = max(14, img.width // 30)
-                    try:
-                        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", font_size)
-                    except:
-                        font = ImageFont.load_default()
-
-                    bbox = draw.textbbox((0, 0), wm_text, font=font)
-                    tw, th = bbox[2] - bbox[0], bbox[3] - bbox[1]
-                    pad = 8
-                    x = img.width - tw - pad * 2 - 10
-                    y = img.height - th - pad * 2 - 10
-
-                    # 반투명 배경 박스
-                    draw.rectangle([x - pad, y - pad, x + tw + pad, y + th + pad], fill=(0, 0, 0, 120))
-                    draw.text((x, y), wm_text, font=font, fill=(255, 255, 255, 200))
-
-                    result_img = Image.alpha_composite(img, overlay).convert("RGB")
-
-                    buf = BytesIO()
-                    result_img.save(buf, format="JPEG", quality=92)
-                    b64 = base64.b64encode(buf.getvalue()).decode()
-                    return {"data_uri": f"data:image/jpeg;base64,{b64}", "width": img.width, "height": img.height}
-                except Exception as e:
-                    print(f"[imagine] watermark failed: {e}, returning raw url")
-                    return {"url": img_url}
-
-        except Exception as e:
-            print(f"[imagine] error: {e}")
-            return {"error": str(e)}
-
-    # 병렬 생성
-    tasks = [_generate_one(i) for i in range(num)]
-    results = await asyncio.gather(*tasks)
-
-    return JSONResponse({
-        "images": results,
-        "prompt": prompt,
-        "revised_prompt": "",
-    })
-
-
-# ── 이미지 편집 (fal.ai xai/grok-imagine edit) ───────────────
-@app.post("/api/imagine-edit")
-async def imagine_edit_endpoint(request: Request):
-    """fal.ai Grok Imagine Edit — 이미지+프롬프트로 편집 + 워터마크"""
-    if not FAL_KEY:
-        return JSONResponse({"error": "FAL_KEY not set"}, status_code=500)
-
-    import json as _json
-    try:
-        raw = await request.body()
-        raw_str = raw.decode('utf-8', errors='replace')
-        print(f"[imagine-edit] body size: {len(raw)} bytes, first 50: {raw_str[:50]}")
-        body = _json.loads(raw_str)
-    except Exception as e:
-        print(f"[imagine-edit] JSON parse error: {e}")
-        return JSONResponse({"error": f"JSON parse error: {str(e)[:100]}"}, status_code=400)
-
-    prompt = _sanitize_text(body.get("prompt", ""))
-    image_url = body.get("image_url", "")
-    
-    # 클라이언트에서 1024px로 압축된 data URI → fal.ai에 직접 전달
-    print(f"[imagine-edit] image_url type: {'data_uri' if image_url.startswith('data:') else 'url'}, size: {len(image_url)} chars")
-    if not prompt:
-        return JSONResponse({"error": "prompt required"}, status_code=400)
-    if not image_url:
-        return JSONResponse({"error": "image_url required"}, status_code=400)
-
-    import httpx as hx
-    import asyncio
-
-    try:
-        async with hx.AsyncClient(timeout=120.0) as client:
-            # ★ Step 0: data URI → fal.ai storage 업로드 → hosted URL
-            actual_image_url = image_url
-            if image_url.startswith("data:"):
-                import base64 as b64mod
-                try:
-                    header, b64data = image_url.split(",", 1)
-                    img_bytes = b64mod.b64decode(b64data)
-                    ct = "image/jpeg"
-                    if "png" in header: ct = "image/png"
-                    
-                    print(f"[imagine-edit] Uploading {len(img_bytes)} bytes to fal.ai storage...")
-                    up_resp = await client.put(
-                        "https://rest.alpha.fal.ai/storage/upload",
-                        headers={
-                            "Authorization": f"Key {FAL_KEY}",
-                            "Content-Type": ct,
-                            "X-Fal-File-Name": "edit_input.jpg",
-                        },
-                        content=img_bytes,
-                        timeout=30.0
-                    )
-                    print(f"[imagine-edit] Upload status: {up_resp.status_code}, body: {up_resp.text[:200]}")
-                    
-                    if up_resp.status_code == 200:
-                        up_data = up_resp.json()
-                        actual_image_url = up_data.get("url", up_data.get("file_url", ""))
-                        print(f"[imagine-edit] Uploaded URL: {actual_image_url[:100]}")
-                    else:
-                        # PUT 실패 → POST 시도
-                        up_resp2 = await client.post(
-                            "https://rest.alpha.fal.ai/storage/upload",
-                            headers={
-                                "Authorization": f"Key {FAL_KEY}",
-                                "Content-Type": ct,
-                            },
-                            content=img_bytes,
-                            timeout=30.0
-                        )
-                        print(f"[imagine-edit] Upload POST status: {up_resp2.status_code}, body: {up_resp2.text[:200]}")
-                        if up_resp2.status_code == 200:
-                            up_data2 = up_resp2.json()
-                            actual_image_url = up_data2.get("url", up_data2.get("file_url", ""))
-                        else:
-                            # 최후 수단: data URI 그대로
-                            actual_image_url = image_url
-                            print("[imagine-edit] Upload failed, using data URI directly")
-                except Exception as e:
-                    print(f"[imagine-edit] Upload error: {e}, using data URI")
-                    actual_image_url = image_url
-
-            # 1) Submit edit request
-            submit_payload = {"prompt": prompt, "num_images": 1, "output_format": "jpeg", "image_urls": [actual_image_url]}
-            print(f"[imagine-edit] Submit: image_url type={'hosted' if actual_image_url.startswith('http') else 'data_uri'}, len={len(actual_image_url)}")
-            
-            sub_resp = await client.post(
-                "https://queue.fal.run/xai/grok-imagine-image/edit",
-                headers={"Authorization": f"Key {FAL_KEY}", "Content-Type": "application/json"},
-                json=submit_payload
-            )
-            
-            print(f"[imagine-edit] Submit status: {sub_resp.status_code}")
-            sub_text = sub_resp.text
-            print(f"[imagine-edit] Submit response: {sub_text[:300]}")
-            
-            if sub_resp.status_code != 200:
-                return JSONResponse({"error": f"submit failed: {sub_resp.status_code} - {sub_text[:100]}"}, status_code=502)
-
-            try:
-                data = sub_resp.json()
-            except Exception as je:
-                print(f"[imagine-edit] JSON parse error on submit response: {je}")
-                return JSONResponse({"error": f"fal.ai response parse error: {sub_text[:100]}"}, status_code=502)
-            img_url = ""
-
-            if "images" in data:
-                img_url = data["images"][0]["url"]
-            elif "request_id" in data:
-                # fal.ai가 준 URL 직접 사용 (edit 경로 차이 자동 대응)
-                status_url = data.get("status_url", "")
-                response_url = data.get("response_url", "")
-                if not status_url:
-                    req_id = data["request_id"]
-                    status_url = f"https://queue.fal.run/xai/grok-imagine-image/edit/requests/{req_id}/status"
-                    response_url = f"https://queue.fal.run/xai/grok-imagine-image/edit/requests/{req_id}"
-                
-                print(f"[imagine-edit] Polling: {status_url}")
-                for poll_i in range(60):
-                    await asyncio.sleep(1)
-                    try:
-                        status_resp = await client.get(status_url, headers={"Authorization": f"Key {FAL_KEY}"})
-                        st_text = status_resp.text
-                        st = status_resp.json()
-                        cur_status = st.get("status", "")
-                        if poll_i % 5 == 0:
-                            print(f"[imagine-edit] Poll {poll_i}: {cur_status}")
-                        
-                        if cur_status == "COMPLETED":
-                            result_resp = await client.get(response_url, headers={"Authorization": f"Key {FAL_KEY}"})
-                            rdata = result_resp.json()
-                            img_url = rdata.get("images", [{}])[0].get("url", "")
-                            print(f"[imagine-edit] Completed! img_url: {img_url[:80] if img_url else 'NONE'}")
-                            break
-                        elif cur_status in ("FAILED", "CANCELLED"):
-                            err_msg = st.get("error", "edit failed")
-                            print(f"[imagine-edit] Failed: {err_msg}")
-                            return JSONResponse({"error": f"edit failed: {err_msg}"}, status_code=502)
-                    except Exception as pe:
-                        print(f"[imagine-edit] Poll error: {pe}")
-                        continue
-                else:
-                    return JSONResponse({"error": "timeout (60s)"}, status_code=504)
-            else:
-                print(f"[imagine-edit] Unexpected response: {str(data)[:200]}")
-                return JSONResponse({"error": "unexpected response"}, status_code=502)
-
-            if not img_url:
-                return JSONResponse({"error": "no image url"}, status_code=502)
-
-            # 2) 이미지 다운로드 + 워터마크
-            img_resp = await client.get(img_url)
-            if img_resp.status_code != 200:
-                return JSONResponse({"images": [{"url": img_url}], "prompt": prompt})
-
-            try:
-                from io import BytesIO
-                from PIL import Image, ImageDraw, ImageFont
-                import base64
-
-                img = Image.open(BytesIO(img_resp.content)).convert("RGBA")
-                overlay = Image.new("RGBA", img.size, (0, 0, 0, 0))
-                draw = ImageDraw.Draw(overlay)
-                wm_text = "Ginigen.AI"
-                font_size = max(14, img.width // 30)
-                try:
-                    font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", font_size)
-                except:
-                    font = ImageFont.load_default()
-                bbox = draw.textbbox((0, 0), wm_text, font=font)
-                tw, th = bbox[2] - bbox[0], bbox[3] - bbox[1]
-                pad = 8
-                x = img.width - tw - pad * 2 - 10
-                y = img.height - th - pad * 2 - 10
-                draw.rectangle([x - pad, y - pad, x + tw + pad, y + th + pad], fill=(0, 0, 0, 120))
-                draw.text((x, y), wm_text, font=font, fill=(255, 255, 255, 200))
-                result_img = Image.alpha_composite(img, overlay).convert("RGB")
-                buf = BytesIO()
-                result_img.save(buf, format="JPEG", quality=92)
-                b64 = base64.b64encode(buf.getvalue()).decode()
-                return JSONResponse({"images": [{"data_uri": f"data:image/jpeg;base64,{b64}", "width": img.width, "height": img.height}], "prompt": prompt})
-            except Exception as e:
-                print(f"[imagine-edit] watermark failed: {e}")
-                return JSONResponse({"images": [{"url": img_url}], "prompt": prompt})
-
-    except Exception as e:
-        print(f"[imagine-edit] error: {e}")
-        return JSONResponse({"error": str(e)}, status_code=500)
-
-
-# core.py lazy import — 실패해도 서버 시작 차단 안 함
-MARL_AVAILABLE = False
-Marl = None
-MarlConfig = None
-
-def _init_marl():
-    global MARL_AVAILABLE, Marl, MarlConfig
-    if Marl is not None:
-        return MARL_AVAILABLE
-    try:
-        import sys
-        _dir = os.path.dirname(os.path.abspath(__file__))
-        if _dir not in sys.path:
-            sys.path.insert(0, _dir)
-        from core import Marl as _M, MarlConfig as _MC
-        Marl = _M
-        MarlConfig = _MC
-        MARL_AVAILABLE = True
-        print("✅ MARL core loaded (lazy)")
-    except Exception as e:
-        MARL_AVAILABLE = False
-        print(f"⚠️ MARL core not available: {e}")
-        import traceback; traceback.print_exc()
-    return MARL_AVAILABLE
-
-
-def _groq_call_fn(prompt: str, system: str, max_tokens: int, temperature: float) -> str:
-    """Groq API를 사용하는 MARL call_fn (sync, httpx)"""
-    import httpx as hx
-    prompt = _sanitize_text(prompt)
-    system = _sanitize_text(system)
-    if not GROQ_API_KEY:
-        print("[marl-call] ERROR: no API key")
-        return "[ERROR] GROQ_API_KEY not set"
-    try:
-        print(f"[marl-call] system={system[:60]}... prompt={prompt[:60]}... max_tok={max_tokens} temp={temperature}")
-        resp = hx.post(
-            GROQ_URL,
-            headers={"Authorization": f"Bearer {GROQ_API_KEY}", "Content-Type": "application/json"},
-            json={
-                "model": "openai/gpt-oss-120b",
-                "messages": [
-                    {"role": "system", "content": system[:4000]},
-                    {"role": "user", "content": prompt[:12000]}
-                ],
-                "max_completion_tokens": min(max_tokens, 4096),
-                "temperature": temperature,
-                "stream": False
-            },
-            timeout=120.0
-        )
-        if resp.status_code != 200:
-            print(f"[marl-call] HTTP {resp.status_code}: {resp.text[:200]}")
-            return f"[ERROR] HTTP {resp.status_code}"
-        data = resp.json()
-        content = data.get("choices", [{}])[0].get("message", {}).get("content", "")
-        print(f"[marl-call] OK: {len(content)} chars")
-        return content if content else "[ERROR] Empty response"
-    except Exception as e:
-        print(f"[marl-call] EXCEPTION: {e}")
-        return f"[ERROR] {e}"
-
-
-@app.post("/api/marl")
-async def marl_endpoint(request: Request):
-    """MARL 5단계 파이프라인 — 메타인지(insight) 또는 창발성(emergence)"""
-    _init_marl()
-    if not MARL_AVAILABLE:
-        return JSONResponse({"error": "MARL core not available. Check server logs."}, status_code=500)
-    if not GROQ_API_KEY:
-        return JSONResponse({"error": "GROQ_API_KEY not set"}, status_code=500)
-
-    try:
-        body = await request.json()
-    except Exception:
-        return JSONResponse({"error": "invalid json"}, status_code=400)
-
-    prompt = _sanitize_text(body.get("prompt", ""))
-    _marl_email = body.get("sa_email", "")
-    _marl_url = body.get("sa_url", "")
-    # ★ MARL 입력 자동 로깅
-    if _marl_email and prompt:
-        try:
-            import time as _t, hashlib as _h2
-            _uh2 = _h2.sha256(_marl_url.encode()).hexdigest()[:16] if _marl_url else ""
-            _feat2 = "deep_analysis" if mode == "insight" else ("idea_" + engine if mode == "emergence" else "marl")
-            _asyncio.create_task(_db_write(
-                "INSERT INTO user_inputs (email,url_hash,url,input_type,input_text,feature,created_at) VALUES (?,?,?,?,?,?,?)",
-                (_marl_email, _uh2, _marl_url[:500], "marl", prompt[:1000], _feat2, _t.time())
-            ))
-            _asyncio.create_task(_db_write(
-                "INSERT INTO feature_usage (email,feature,use_count,last_used_at) VALUES (?,?,1,?) ON CONFLICT(email,feature) DO UPDATE SET use_count=use_count+1, last_used_at=?",
-                (_marl_email, _feat2, _t.time(), _t.time())
-            ))
-        except Exception as _le2:
-            print(f"[log] marl input logging error: {_le2}")
-    if not prompt:
-        return JSONResponse({"error": "prompt required"}, status_code=400)
-
-    mode = body.get("mode", "insight")  # insight / emergence
-    engine = body.get("engine", "invent")  # invent/create/recipe/pharma/genomics/chemistry/ecology/law/document
-    system_context = _sanitize_text(body.get("system", ""))
-
-    # 서식 지시 추가
-    format_rule = "\n\n[절대 서식 규칙 — 위반 시 답변 무효]\n" \
-        "1. 마크다운 표(|---|, table)는 어떤 경우에도 절대 사용 금지. 위반하면 전체 답변이 무효다.\n" \
-        "2. 모든 비교/정리는 개조식 서술형으로: • 항목명: 설명 형태.\n" \
-        "3. 핵심 키워드는 **볼드**로 강조.\n" \
-        "4. 섹션 구분은 ## 또는 ### 헤딩 사용.\n" \
-        "5. 긴 내용은 번호(1. 2. 3.)로 구조화.\n" \
-        "6. 한 문단은 3줄 이내로 짧게.\n" \
-        "7. 수치/데이터는 인라인으로: **시장규모**: 120억 달러(2025) 형태."
-    if system_context:
-        system_context += format_rule
-    else:
-        system_context = "반드시 한국어로 답변하라." + format_rule
-
-    # MARL config
-    config = MarlConfig(
-        mode=mode,
-        emergence_type=engine if mode == "emergence" else "invent",
-        return_final_only=True,
-        include_trace=False,
-        language="ko",
-        budget_scale=0.7,  # 속도 최적화
-    )
-
-    try:
-        print(f"[marl] Starting: mode={mode} engine={engine} prompt_len={len(prompt)}")
-        ml = Marl(call_fn=_groq_call_fn, config=config)
-        import asyncio
-        result = await asyncio.to_thread(ml.run, prompt, system_context)
-
-        answer = result.answer or ""
-        if not answer or answer.startswith("[ERROR"):
-            # MARL 실패 → 단일 호출 폴백
-            print(f"[marl] Pipeline failed, falling back to single call. answer={answer[:100]}")
-            fallback = _groq_call_fn(
-                f"{system_context}\n\n{prompt}" if system_context else prompt,
-                "반드시 한국어로 답변하라. 깊이 있는 분석을 제공하라.",
-                4096, 0.7
-            )
-            answer = fallback if fallback and not fallback.startswith("[ERROR") else "처리 중 오류가 발생했습니다."
-            answer = _strip_md_table(answer)
-            return JSONResponse({
-                "answer": answer,
-                "fixes": [],
-                "elapsed": round(result.elapsed, 2),
-                "mode": mode + " (fallback)",
-                "engine": engine if mode == "emergence" else None,
-                "metadata": {"fallback": True}
-            })
-
-        # Groq 인용 태그 제거
-        import re
-        answer = re.sub(r'【[^】]*】', '', answer).strip()
-        answer = _strip_md_table(answer)
-        print(f"[marl] Success: {len(answer)} chars, {round(result.elapsed,1)}s, {len(result.fixes)} fixes")
-        return JSONResponse({
-            "answer": answer,
-            "fixes": result.fixes,
-            "elapsed": round(result.elapsed, 2),
-            "mode": mode,
-            "engine": engine if mode == "emergence" else None,
-            "metadata": result.metadata
-        })
-    except Exception as e:
-        print(f"[marl] EXCEPTION: {e}")
-        import traceback; traceback.print_exc()
-        # 최종 폴백: 단일 Groq 호출
-        try:
-            fallback = _groq_call_fn(prompt[:8000], "반드시 한국어로 답변하라.", 4096, 0.7)
-            if fallback and not fallback.startswith("[ERROR"):
-                return JSONResponse({"answer": _strip_md_table(fallback), "fixes": [], "elapsed": 0, "mode": "fallback", "metadata": {"error": str(e)}})
-        except:
-            pass
-        return JSONResponse({"error": str(e)}, status_code=500)
-
+        
+        # Execute the code directly
+        exec(compile(code, '<string>', 'exec'), globals())
+        
+    except Exception as e:
+        import gradio as gr
+        import traceback
+        error_msg = traceback.format_exc()
+        
+        with gr.Blocks() as demo:
+            gr.Markdown("# ⚠️ Error Loading Application")
+            gr.Markdown(f"**Error:** {str(e)}")
+            gr.Code(error_msg, language="python", label="Traceback")
+        demo.launch()
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    main()