Update app.py

app.py

@@ -1,36 +1,29 @@
+"""
+HWP AI 어시스턴트 - Gradio 웹 앱
+AI가 HWP 파일을 읽고, 보고, 말하며, 생각하고 기억합니다.
+- Tab 1: LLM 채팅 (스트리밍, 파일 첨부 지원)
+- Tab 2: HWP 변환기
+"""
+import gradio as gr
+import tempfile
 import os
+import subprocess
+import shutil
+import sys
+import re
 import json
-import copy
-import time
+import uuid
+import sqlite3
+import base64
 import requests
-import random
-import logging
-import numpy as np
-import spaces
-from typing import Any, Dict, List, Optional, Union
-
-import torch
-from PIL import Image
-import gradio as gr
-
-from diffusers import (
-    DiffusionPipeline,
-    AutoencoderKL,
-    ZImagePipeline
-)
-
-from huggingface_hub import (
-    hf_hub_download,
-    HfFileSystem,
-    ModelCard,
-    snapshot_download)
+import zlib
+import zipfile
+from pathlib import Path
+from datetime import datetime
+from typing import Generator, List, Dict, Optional
+from xml.etree import ElementTree as ET
 
-from diffusers.utils import load_image
-from typing import Iterable
-
-# ============================================
-# Comic Style CSS
-# ============================================
+# ============== Comic Style CSS ==============
 COMIC_CSS = """
 @import url('https://fonts.googleapis.com/css2?family=Bangers&family=Comic+Neue:wght@400;700&display=swap');
 
@@ -200,6 +193,38 @@ textarea:focus, input[type="text"]:focus {
     color: #1F2937 !important;
 }
 
+.feature-box {
+    background: linear-gradient(135deg, #E0F2FE 0%, #BAE6FD 100%) !important;
+    border: 3px solid #1F2937 !important;
+    border-radius: 12px !important;
+    padding: 20px !important;
+    margin: 15px 0 !important;
+    box-shadow: 5px 5px 0 #1F2937 !important;
+}
+
+.feature-title {
+    font-family: 'Bangers', cursive !important;
+    font-size: 1.5rem !important;
+    color: #1F2937 !important;
+    margin-bottom: 10px !important;
+    text-shadow: 1px 1px 0 #FFF !important;
+}
+
+.feature-item {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 8px 0;
+    font-family: 'Comic Neue', cursive !important;
+    font-weight: 700 !important;
+    font-size: 1rem !important;
+    color: #1F2937 !important;
+}
+
+.feature-icon {
+    font-size: 1.5rem;
+}
+
 label, .gr-input-label, .gr-block-label {
     color: #1F2937 !important;
     font-family: 'Comic Neue', cursive !important;
@@ -255,518 +280,847 @@ label, .gr-input-label, .gr-block-label {
     color: #1F2937;
 }
 
-/* Slider Styling */
-input[type="range"] {
-    accent-color: #3B82F6;
+/* Chatbot Styling */
+.gr-chatbot {
+    border: 3px solid #1F2937 !important;
+    border-radius: 12px !important;
+    box-shadow: 5px 5px 0 #1F2937 !important;
 }
 
-/* Image/Gallery Container */
-.gr-image, .gr-gallery {
+/* Tab Styling */
+.gr-tab-nav {
+    background: linear-gradient(135deg, #F59E0B 0%, #FACC15 100%) !important;
     border: 3px solid #1F2937 !important;
-    border-radius: 8px !important;
+    border-radius: 8px 8px 0 0 !important;
+}
+
+.gr-tab-nav button {
+    font-family: 'Bangers', cursive !important;
+    font-size: 1.2rem !important;
+    letter-spacing: 1px !important;
+    color: #1F2937 !important;
+}
+
+.gr-tab-nav button.selected {
+    background: #FFF !important;
+    border-bottom: 3px solid #FFF !important;
+}
+
+/* File Upload Box */
+.upload-box {
+    border: 3px dashed #3B82F6 !important;
+    border-radius: 12px !important;
+    background: linear-gradient(135deg, #EFF6FF 0%, #DBEAFE 100%) !important;
     box-shadow: 4px 4px 0 #1F2937 !important;
 }
 
-/* Original CSS additions */
-#gen_btn{height: 100%}
-#gen_column{align-self: stretch}
-#title{text-align: center}
-#title h1{font-size: 3em; display:inline-flex; align-items:center}
-#title img{width: 100px; margin-right: 0.5em}
-#gallery .grid-wrap{height: 10vh}
-#lora_list{background: var(--block-background-fill);padding: 0 1em .3em; font-size: 90%}
-.card_internal{display: flex;height: 100px;margin-top: .5em}
-.card_internal img{margin-right: 1em}
-.styler{--form-gap-width: 0px !important}
-#progress{height:30px}
-#progress .generating{display:none}
-.progress-container {width: 100%;height: 30px;background-color: #f0f0f0;border-radius: 15px;overflow: hidden;margin-bottom: 20px}
-.progress-bar {height: 100%;background-color: #4f46e5;width: calc(var(--current) / var(--total) * 100%);transition: width 0.5s ease-in-out}
+.download-box {
+    border: 3px solid #10B981 !important;
+    border-radius: 12px !important;
+    background: linear-gradient(135deg, #ECFDF5 0%, #D1FAE5 100%) !important;
+    box-shadow: 4px 4px 0 #1F2937 !important;
+}
 """
 
-loras = [
-    # 로컬 jimin LoRA (app.py와 같은 디렉토리에 jimin.safetensors 필요)
-    {
-        "image": "https://i.namu.wiki/i/VxF2jh087d4V6f9LWw1jQoLcQ_ymdhyD7XtRnq2KVYmN6DZsL4vCTrd1v-ubr8zfejyCCKvUWaBVf9JM9GqR271X6nh4e6mUbW11LaFr9QtepztFJeDZJ1VISkW5KBbebCpqv-w2Uv7RmMPwB5kacg.webp",
+# ============== 환경 설정 ==============
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PYHWP_PATH = os.path.join(SCRIPT_DIR, 'pyhwp')
+DB_PATH = os.path.join(SCRIPT_DIR, 'chat_history.db')
+
+if os.path.exists(PYHWP_PATH):
+    sys.path.insert(0, PYHWP_PATH)
+
+# ============== 모듈 임포트 ==============
+try:
+    import olefile
+    OLEFILE_AVAILABLE = True
+    print("✅ olefile loaded")
+except ImportError:
+    OLEFILE_AVAILABLE = False
+
+try:
+    from markdownify import markdownify as md
+    MARKDOWNIFY_AVAILABLE = True
+    print("✅ markdownify loaded")
+except ImportError:
+    MARKDOWNIFY_AVAILABLE = False
+
+try:
+    import html2text
+    HTML2TEXT_AVAILABLE = True
+    print("✅ html2text loaded")
+except ImportError:
+    HTML2TEXT_AVAILABLE = False
+
+try:
+    from bs4 import BeautifulSoup
+    BS4_AVAILABLE = True
+except ImportError:
+    BS4_AVAILABLE = False
+
+try:
+    import PyPDF2
+    PYPDF2_AVAILABLE = True
+    print("✅ PyPDF2 loaded")
+except ImportError:
+    PYPDF2_AVAILABLE = False
+
+try:
+    import pdfplumber
+    PDFPLUMBER_AVAILABLE = True
+    print("✅ pdfplumber loaded")
+except ImportError:
+    PDFPLUMBER_AVAILABLE = False
+
+# ============== API 키 설정 ==============
+GROQ_API_KEY = os.environ.get("GROQ_API_KEY", "")
+FIREWORKS_API_KEY = os.environ.get("FIREWORKS_API_KEY", "")
+
+# ============== SQLite 데이터베이스 ==============
+def init_database():
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS sessions (
+            session_id TEXT PRIMARY KEY,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            title TEXT
+        )
+    ''')
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS messages (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT,
+            role TEXT,
+            content TEXT,
+            file_info TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+def create_session() -> str:
+    session_id = str(uuid.uuid4())
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("INSERT INTO sessions (session_id, title) VALUES (?, ?)",
+                   (session_id, f"대화 {datetime.now().strftime('%Y-%m-%d %H:%M')}"))
+    conn.commit()
+    conn.close()
+    return session_id
+
+def save_message(session_id: str, role: str, content: str, file_info: str = None):
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("INSERT INTO messages (session_id, role, content, file_info) VALUES (?, ?, ?, ?)",
+                   (session_id, role, content, file_info))
+    cursor.execute("UPDATE sessions SET updated_at = CURRENT_TIMESTAMP WHERE session_id = ?", (session_id,))
+    conn.commit()
+    conn.close()
+
+def get_session_messages(session_id: str, limit: int = 20) -> List[Dict]:
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("SELECT role, content, file_info, created_at FROM messages WHERE session_id = ? ORDER BY created_at DESC LIMIT ?",
+                   (session_id, limit))
+    rows = cursor.fetchall()
+    conn.close()
+    return [{"role": r[0], "content": r[1], "file_info": r[2], "created_at": r[3]} for r in reversed(rows)]
+
+def get_all_sessions() -> List[Dict]:
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("SELECT session_id, title, created_at, updated_at FROM sessions ORDER BY updated_at DESC LIMIT 50")
+    rows = cursor.fetchall()
+    conn.close()
+    return [{"session_id": r[0], "title": r[1], "created_at": r[2], "updated_at": r[3]} for r in rows]
+
+def update_session_title(session_id: str, title: str):
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("UPDATE sessions SET title = ? WHERE session_id = ?", (title, session_id))
+    conn.commit()
+    conn.close()
+
+init_database()
+
+# ============== 파일 유틸리티 ==============
+def extract_text_from_pdf(file_path: str) -> str:
+    text_parts = []
+    if PDFPLUMBER_AVAILABLE:
+        try:
+            with pdfplumber.open(file_path) as pdf:
+                for page in pdf.pages:
+                    text = page.extract_text()
+                    if text:
+                        text_parts.append(text)
+            if text_parts:
+                return "\n\n".join(text_parts)
+        except Exception as e:
+            print(f"pdfplumber error: {e}")
+    
+    if PYPDF2_AVAILABLE:
+        try:
+            with open(file_path, 'rb') as f:
+                reader = PyPDF2.PdfReader(f)
+                for page in reader.pages:
+                    text = page.extract_text()
+                    if text:
+                        text_parts.append(text)
+            if text_parts:
+                return "\n\n".join(text_parts)
+        except Exception as e:
+            print(f"PyPDF2 error: {e}")
+    return None
+
+def extract_text_from_txt(file_path: str) -> str:
+    for encoding in ['utf-8', 'euc-kr', 'cp949', 'utf-16', 'latin-1']:
+        try:
+            with open(file_path, 'r', encoding=encoding) as f:
+                return f.read()
+        except:
+            continue
+    return None
+
+def image_to_base64(file_path: str) -> str:
+    with open(file_path, 'rb') as f:
+        return base64.b64encode(f.read()).decode('utf-8')
+
+def get_image_mime_type(file_path: str) -> str:
+    ext = Path(file_path).suffix.lower()
+    return {'.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png',
+            '.gif': 'image/gif', '.webp': 'image/webp', '.bmp': 'image/bmp'}.get(ext, 'image/jpeg')
+
+def is_image_file(fp: str) -> bool:
+    return Path(fp).suffix.lower() in ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp']
+
+def is_hwp_file(fp: str) -> bool:
+    return Path(fp).suffix.lower() == '.hwp'
+
+def is_hwpx_file(fp: str) -> bool:
+    return Path(fp).suffix.lower() == '.hwpx'
+
+def is_pdf_file(fp: str) -> bool:
+    return Path(fp).suffix.lower() == '.pdf'
+
+def is_text_file(fp: str) -> bool:
+    return Path(fp).suffix.lower() in ['.txt', '.md', '.json', '.csv', '.xml', '.html', '.css', '.js', '.py']
+
+# ============== HWPX 텍스트 추출 ==============
+def extract_text_from_hwpx(file_path: str) -> tuple:
+    try:
+        text_parts = []
+        with zipfile.ZipFile(file_path, 'r') as zf:
+            file_list = zf.namelist()
+            section_files = sorted([f for f in file_list if f.startswith('Contents/section') and f.endswith('.xml')])
+            if not section_files:
+                section_files = sorted([f for f in file_list if 'section' in f.lower() and f.endswith('.xml')])
+            
+            for section_file in section_files:
+                try:
+                    with zf.open(section_file) as sf:
+                        content = sf.read()
+                        content_str = content.decode('utf-8')
+                        content_str = re.sub(r'\sxmlns[^"]*"[^"]*"', '', content_str)
+                        content_str = re.sub(r'<[a-zA-Z]+:', '<', content_str)
+                        content_str = re.sub(r'</[a-zA-Z]+:', '</', content_str)
+                        
+                        try:
+                            root = ET.fromstring(content_str)
+                            texts = []
+                            for elem in root.iter():
+                                if elem.tag.endswith('t') or elem.tag == 't':
+                                    if elem.text:
+                                        texts.append(elem.text)
+                                elif elem.text and elem.text.strip():
+                                    if any(x in elem.tag.lower() for x in ['text', 'run', 'para', 'char']):
+                                        texts.append(elem.text.strip())
+                            if texts:
+                                text_parts.append(' '.join(texts))
+                        except ET.ParseError:
+                            text_matches = re.findall(r'>([^<]+)<', content.decode('utf-8', errors='ignore'))
+                            clean_texts = [t.strip() for t in text_matches if t.strip() and len(t.strip()) > 1]
+                            if clean_texts:
+                                text_parts.append(' '.join(clean_texts))
+                except:
+                    continue
+        
+        if text_parts:
+            result = '\n\n'.join(text_parts)
+            result = re.sub(r'\s+', ' ', result)
+            result = re.sub(r'\n{3,}', '\n\n', result)
+            return result.strip(), None
+        return None, "HWPX에서 텍스트를 찾을 수 없습니다"
+    except zipfile.BadZipFile:
+        return None, "유효하지 않은 HWPX 파일"
+    except Exception as e:
+        return None, f"HWPX 처리 오류: {str(e)}"
+
+# ============== HWP 텍스트 추출 ==============
+def extract_text_with_hwp5txt(file_path: str) -> tuple:
+    try:
+        result = subprocess.run(['hwp5txt', file_path], capture_output=True, timeout=60)
+        if result.returncode == 0 and result.stdout:
+            for enc in ['utf-8', 'cp949', 'euc-kr']:
+                try:
+                    text = result.stdout.decode(enc)
+                    if text.strip() and len(text.strip()) > 10:
+                        return text.strip(), None
+                except:
+                    continue
+    except FileNotFoundError:
+        pass
+    except Exception as e:
+        print(f"hwp5txt error: {e}")
+    
+    try:
+        code = f'''
+import sys
+sys.path.insert(0, "{PYHWP_PATH}")
+from hwp5.filestructure import Hwp5File
+from hwp5.hwp5txt import extract_text
+hwp = Hwp5File("{file_path}")
+for idx in hwp.bodytext.sections():
+    section = hwp.bodytext.section(idx)
+    for para in extract_text(section):
+        if para.strip():
+            print(para.strip())
+hwp.close()
+'''
+        result = subprocess.run([sys.executable, '-c', code], capture_output=True, timeout=60)
+        if result.returncode == 0 and result.stdout:
+            for enc in ['utf-8', 'cp949', 'euc-kr']:
+                try:
+                    text = result.stdout.decode(enc)
+                    if text.strip() and len(text.strip()) > 10:
+                        return text.strip(), None
+                except:
+                    continue
+    except Exception as e:
+        print(f"hwp5txt subprocess error: {e}")
+    
+    return None, "hwp5txt 실패"
+
+def extract_text_with_olefile(file_path: str) -> tuple:
+    if not OLEFILE_AVAILABLE:
+        return None, "olefile 모듈 없음"
+    
+    try:
+        ole = olefile.OleFileIO(file_path)
+        if not ole.exists('FileHeader'):
+            ole.close()
+            return None, "HWP 파일 헤더 없음"
         
-        "title": "koyoon Style",
-        "repo": "./",  # 로컬 경로
-        "weights": "koyoon.safetensors",
-        "trigger_word": "koyoon"    
-    },
-    
-    {
-        "image": "https://i.namu.wiki/i/umL8EZtn0hs-nMRYeFxIrkGrMe-R1u5c9fJE8ufrLjvXz52VcSIbG7TT9QJoL2rR7vsFww1lLrE4bwfn5uOBzfq9a90HGdNdlTLmr_KoqOchTovbVC3RDzhDbp7FI-Wq-esCu7_BYIptqethL4onBg.webp",
+        header_data = ole.openstream('FileHeader').read()
+        is_compressed = (header_data[36] & 1) == 1 if len(header_data) > 36 else True
         
-        "title": "jimin Style",
-        "repo": "./",  # 로컬 경로
-        "weights": "jimin.safetensors",
-        "trigger_word": "jimin"    
-    },
-    {
-        "image": "https://huggingface.co/strangerzonehf/Flux-Ultimate-LoRA-Collection/resolve/main/images/1111111111.png",
-        "title": "AWPortrait Z",
-        "repo": "Shakker-Labs/AWPortrait-Z", #1
-        "weights": "AWPortrait-Z.safetensors",
-        "trigger_word": "Portrait"    
-    },
-
-    {
-        "image": "https://cdn-uploads.huggingface.co/production/uploads/653cd3049107029eb004f968/DLCGlF9uUnFo5zxR5uyx6.png",
-        "title": "50s Western",
-        "repo": "neph1/50s_western_lora_zit", 
-        "weights": "50s_western_z_100.safetensors",
-        "trigger_word": "50s_western"    
-    },
-
-    {
-        "image": "https://huggingface.co/neph1/80s_scifi_lora_zit/resolve/main/images/ComfyUI_10288_.png",
-        "title": "80s Scifi",
-        "repo": "neph1/80s_scifi_lora_zit", 
-        "weights": "80s_scifi_z_80.safetensors",
-        "trigger_word": "80s_scifi"    
-    },
-
- # --------------------------------------------------------------------------------------------------------------------------------------   
-    {
-        "image": "https://huggingface.co/Ttio2/Z-Image-Turbo-pencil-sketch/resolve/main/images/z-image_00097_.png",
-        "title": "Turbo Pencil",
-        "repo": "Ttio2/Z-Image-Turbo-pencil-sketch", #0
-        "weights": "Zimage_pencil_sketch.safetensors",
-        "trigger_word": "pencil sketch"    
-    },
-    {
-        "image": "https://huggingface.co/neph1/50s_scifi_lora_zit/resolve/main/images/ComfyUI_08067_.png",
-        "title": "50s Scifi",
-        "repo": "neph1/50s_scifi_lora_zit",
-        "weights": "50s_scifi_z_80.safetensors",
-        "trigger_word": "50s_scifi"    
-    },
-    {
-        "image": "https://huggingface.co/strangerzonehf/Flux-Ultimate-LoRA-Collection/resolve/main/images/cookie-mons.png",
-        "title": "Yarn Art Style",
-        "repo": "linoyts/yarn-art-style", #28
-        "weights": "yarn-art-style_000001250.safetensors",
-        "trigger_word": "yarn art style"    
-    },
-    {
-        "image": "https://huggingface.co/Quorlen/Z-Image-Turbo-Behind-Reeded-Glass-Lora/resolve/main/images/ComfyUI_00391_.png",
-        "title": "Behind Reeded Glass",
-        "repo": "Quorlen/Z-Image-Turbo-Behind-Reeded-Glass-Lora", #26
-        "weights": "Z_Image_Turbo_Behind_Reeded_Glass_Lora_TAV2_000002750.safetensors",
-        "trigger_word": "Act1vate!, Behind reeded glass"    
-    },
-    {
-        "image": "https://huggingface.co/ostris/z_image_turbo_childrens_drawings/resolve/main/images/1764433619736__000003000_9.jpg",
-        "title": "Childrens Drawings",
-        "repo": "ostris/z_image_turbo_childrens_drawings", #2
-        "weights": "z_image_turbo_childrens_drawings.safetensors",
-        "trigger_word": "Children Drawings"    
-    },
-    {
-        "image": "https://huggingface.co/strangerzonehf/Flux-Ultimate-LoRA-Collection/resolve/main/images/xcxc.png",
-        "title": "Tarot Z",
-        "repo": "multimodalart/tarot-z-image-lora", #22
-        "weights": "tarot-z-image_000001250.safetensors",
-        "trigger_word": "trtcrd"    
-    },
-    {
-        "image": "https://huggingface.co/renderartist/Technically-Color-Z-Image-Turbo/resolve/main/images/ComfyUI_00917_.png",
-        "title": "Technically Color Z",
-        "repo": "renderartist/Technically-Color-Z-Image-Turbo", #3
-        "weights": "Technically_Color_Z_Image_Turbo_v1_renderartist_2000.safetensors",
-        "trigger_word": "t3chnic4lly"    
-    },
-    {
-        "image": "https://huggingface.co/SkyAsl/Tattoo-artist-Z/resolve/main/images/a%20dragon%20with%20flames.png",
-        "title": "Tattoo-artist-Z",
-        "repo": "SkyAsl/Tattoo-artist-Z", #31
-        "weights": "adapter_model.safetensors",
-        "trigger_word": "a tattoo design"    
-    },
-    {
-        "image": "https://huggingface.co/strangerzonehf/Flux-Ultimate-LoRA-Collection/resolve/main/images/z-image_00147_.png",
-        "title": "Turbo Ghibli",
-        "repo": "Ttio2/Z-Image-Turbo-Ghibli-Style", #19
-        "weights": "ghibli_zimage_finetune.safetensors",
-        "trigger_word": "Ghibli Style"    
-    },
-    {
-        "image": "https://huggingface.co/tarn59/pixel_art_style_lora_z_image_turbo/resolve/main/images/ComfyUI_00273_.png",
-        "title": "Pixel Art",
-        "repo": "tarn59/pixel_art_style_lora_z_image_turbo", #4
-        "weights": "pixel_art_style_z_image_turbo.safetensors",
-        "trigger_word": "Pixel art style."    
-    },
-    {
-        "image": "https://huggingface.co/renderartist/Saturday-Morning-Z-Image-Turbo/resolve/main/images/Saturday_Morning_Z_15.png",
-        "title": "Saturday Morning",
-        "repo": "renderartist/Saturday-Morning-Z-Image-Turbo", #5
-        "weights": "Saturday_Morning_Z_Image_Turbo_v1_renderartist_1250.safetensors",
-        "trigger_word": "saturd4ym0rning"    
-    },
-    {
-        "image": "https://huggingface.co/AIImageStudio/ReversalFilmGravure_z_Image_turbo/resolve/main/images/2025-12-01_173047-z_image_z_image_turbo_bf16-435125750859057-euler_10_hires.png",
-        "title": "ReversalFilmGravure",
-        "repo": "AIImageStudio/ReversalFilmGravure_z_Image_turbo", #6
-        "weights": "z_image_turbo_ReversalFilmGravure_v1.0.safetensors",
-        "trigger_word": "Reversal Film Gravure, analog film photography"    
-    },
-    {
-        "image": "https://huggingface.co/renderartist/Coloring-Book-Z-Image-Turbo-LoRA/resolve/main/images/CBZ_00274_.png",
-        "title": "Coloring Book Z",
-        "repo": "renderartist/Coloring-Book-Z-Image-Turbo-LoRA", #7
-        "weights": "Coloring_Book_Z_Image_Turbo_v1_renderartist_2000.safetensors",
-        "trigger_word": "c0l0ringb00k"    
-    },
-    {
-        "image": "https://huggingface.co/damnthatai/1950s_American_Dream/resolve/main/images/ZImage_20251129163459_135x_00001_.jpg",
-        "title": "1950s American Dream",
-        "repo": "damnthatai/1950s_American_Dream", #8
-        "weights": "5os4m3r1c4n4_z.safetensors",
-        "trigger_word": "5os4m3r1c4n4, 1950s, painting, a painting of"    
-    },
-    {
-        "image": "https://huggingface.co/wcde/Z-Image-Turbo-DeJPEG-Lora/resolve/main/images/01.png",
-        "title": "DeJPEG",
-        "repo": "wcde/Z-Image-Turbo-DeJPEG-Lora", #9
-        "weights": "dejpeg_v3.safetensors",
-        "trigger_word": ""    
-    },
-    {
-        "image": "https://huggingface.co/suayptalha/Z-Image-Turbo-Realism-LoRA/resolve/main/images/n4aSpqa-YFXYo4dtcIg4W.png",
-        "title": "DeJPEG",
-        "repo": "suayptalha/Z-Image-Turbo-Realism-LoRA", #10
-        "weights": "pytorch_lora_weights.safetensors",
-        "trigger_word": "Realism"    
-    },
-    {
-        "image": "https://huggingface.co/renderartist/Classic-Painting-Z-Image-Turbo-LoRA/resolve/main/images/Classic_Painting_Z_00247_.png",
-        "title": "Classic Painting Z",
-        "repo": "renderartist/Classic-Painting-Z-Image-Turbo-LoRA", #11
-        "weights": "Classic_Painting_Z_Image_Turbo_v1_renderartist_1750.safetensors",
-        "trigger_word": "class1cpa1nt"    
-    },
-    {
-        "image": "https://huggingface.co/DK9/3D_MMORPG_style_z-image-turbo_lora/resolve/main/images/10_with_lora.png",
-        "title": "3D MMORPG",
-        "repo": "DK9/3D_MMORPG_style_z-image-turbo_lora", #12
-        "weights": "lostark_v1.safetensors",
-        "trigger_word": ""    
-    },
-    {
-        "image": "https://huggingface.co/Danrisi/Olympus_UltraReal_ZImage/resolve/main/images/Z-Image_01011_.png",
-        "title": "Olympus UltraReal",
-        "repo": "Danrisi/Olympus_UltraReal_ZImage", #13
-        "weights": "Olympus.safetensors",
-        "trigger_word": "digital photography, early 2000s compact camera aesthetic, amateur candid shot, digital photography, early 2000s compact camera aesthetic, amateur candid shot, direct flash lighting, hard flash shadow, specular highlights, overexposed highlights"    
-    },
-    {
-        "image": "https://huggingface.co/AiAF/D-ART_Z-Image-Turbo_LoRA/resolve/main/images/example_l3otpwzaz.png",
-        "title": "D ART Z Image",
-        "repo": "AiAF/D-ART_Z-Image-Turbo_LoRA", #14
-        "weights": "D-ART_Z-Image-Turbo.safetensors",
-        "trigger_word": "D-ART"    
-    },
-    {
-        "image": "https://huggingface.co/AlekseyCalvin/Marionette_Modernism_Z-image-Turbo_LoRA/resolve/main/bluebirdmandoll.webp",
-        "title": "Marionette Modernism",
-        "repo": "AlekseyCalvin/Marionette_Modernism_Z-image-Turbo_LoRA", #15
-        "weights": "ZImageDadadoll_000003600.safetensors",
-        "trigger_word": "DADADOLL style"    
-    },
-    {
-        "image": "https://huggingface.co/AlekseyCalvin/HistoricColor_Z-image-Turbo-LoRA/resolve/main/HSTZgen2.webp",
-        "title": "Historic Color Z",
-        "repo": "AlekseyCalvin/HistoricColor_Z-image-Turbo-LoRA", #16
-        "weights": "ZImage1HST_000004000.safetensors",
-        "trigger_word": "HST style"    
-    },
-    {
-        "image": "https://huggingface.co/tarn59/80s_air_brush_style_z_image_turbo/resolve/main/images/ComfyUI_00707_.png",
-        "title": "80s Air Brush",
-        "repo": "tarn59/80s_air_brush_style_z_image_turbo", #17
-        "weights": "80s_air_brush_style_v2_z_image_turbo.safetensors",
-        "trigger_word": "80s Air Brush style."    
-    },
-    {
-        "image": "https://huggingface.co/CedarC/Z-Image_360/resolve/main/images/1765505225357__000006750_6.jpg",
-        "title": "360panorama",
-        "repo": "CedarC/Z-Image_360", #18
-        "weights": "Z-Image_360.safetensors",
-        "trigger_word": "360panorama"    
-    },
-    {
-        "image": "https://huggingface.co/HAV0X1014/Z-Image-Turbo-KF-Bat-Eared-Fox-LoRA/resolve/main/images/ComfyUI_00132_.png",
-        "title": "KF-Bat-Eared",
-        "repo": "HAV0X1014/Z-Image-Turbo-KF-Bat-Eared-Fox-LoRA", #21
-        "weights": "z-image-turbo-bat_eared_fox.safetensors",
-        "trigger_word": "bat_eared_fox_kemono_friends"    
-    },
-    {
-        "image": "https://cdn-uploads.huggingface.co/production/uploads/653cd3049107029eb004f968/IHttgddXu6ZBMo7eyy8p6.png",
-        "title": "80s Horror",
-        "repo": "neph1/80s_horror_movies_lora_zit", #23
-        "weights": "80s_horror_z_80.safetensors",
-        "trigger_word": "80s_horror"    
-    },
-    {
-        "image": "https://huggingface.co/Quorlen/z_image_turbo_Sunbleached_Protograph_Style_Lora/resolve/main/images/ComfyUI_00024_.png",
-        "title": "Sunbleached Protograph",
-        "repo": "Quorlen/z_image_turbo_Sunbleached_Protograph_Style_Lora", #24
-        "weights": "zimageturbo_Sunbleach_Photograph_Style_Lora_TAV2_000002750.safetensors",
-        "trigger_word": "Act1vate!"    
-    },
-    {
-        "image": "https://huggingface.co/bunnycore/Z-Art-2.1/resolve/main/images/ComfyUI_00069_.png",
-        "title": "Z-Art-2.1",
-        "repo": "bunnycore/Z-Art-2.1", #25
-        "weights": "Z-Image-Art2.1.safetensors",
-        "trigger_word": "anime art"    
-    },
-    {
-        "image": "https://huggingface.co/cactusfriend/longfurby-z/resolve/main/images/1764658860954__000003000_1.jpg",
-        "title": "Longfurby",
-        "repo": "cactusfriend/longfurby-z", #27
-        "weights": "longfurbyZ.safetensors",
-        "trigger_word": ""    
-    },
-    {
-        "image": "https://huggingface.co/SkyAsl/Pixel-artist-Z/resolve/main/pixel-art-result.png",
-        "title": "Pixel Art",
-        "repo": "SkyAsl/Pixel-artist-Z", #29
-        "weights": "adapter_model.safetensors",
-        "trigger_word": "a pixel art character"    
-    },
-]
-
-dtype = torch.bfloat16
-device = "cuda" if torch.cuda.is_available() else "cpu"
-base_model = "Tongyi-MAI/Z-Image-Turbo"
-
-print(f"Loading {base_model} pipeline...")
-
-# Initialize Pipeline
-pipe = ZImagePipeline.from_pretrained(
-    base_model,
-    torch_dtype=dtype,
-    low_cpu_mem_usage=False,
-).to(device)
-
-# ======== AoTI compilation + FA3 ========
-# As per reference for optimization
-try:
-    print("Applying AoTI compilation and FA3...")
-    pipe.transformer.layers._repeated_blocks = ["ZImageTransformerBlock"]
-    spaces.aoti_blocks_load(pipe.transformer.layers, "zerogpu-aoti/Z-Image", variant="fa3")
-    print("Optimization applied successfully.")
-except Exception as e:
-    print(f"Optimization warning: {e}. Continuing with standard pipeline.")
-
-MAX_SEED = np.iinfo(np.int32).max
-
-class calculateDuration:
-    def __init__(self, activity_name=""):
-        self.activity_name = activity_name
-
-    def __enter__(self):
-        self.start_time = time.time()
-        return self
-    
-    def __exit__(self, exc_type, exc_value, traceback):
-        self.end_time = time.time()
-        self.elapsed_time = self.end_time - self.start_time
-        if self.activity_name:
-            print(f"Elapsed time for {self.activity_name}: {self.elapsed_time:.6f} seconds")
+        all_texts = []
+        for entry in ole.listdir():
+            entry_path = '/'.join(entry)
+            if entry_path.startswith('BodyText/Section'):
+                try:
+                    stream_data = ole.openstream(entry).read()
+                    if is_compressed:
+                        try:
+                            stream_data = zlib.decompress(stream_data, -15)
+                        except:
+                            try:
+                                stream_data = zlib.decompress(stream_data)
+                            except:
+                                pass
+                    
+                    section_text = extract_hwp_section_text(stream_data)
+                    if section_text:
+                        all_texts.append(section_text)
+                except:
+                    continue
+        
+        ole.close()
+        if all_texts:
+            return '\n\n'.join(all_texts).strip(), None
+        return None, "텍스트를 찾을 수 없습니다"
+    except Exception as e:
+        return None, f"olefile 오류: {str(e)}"
+
+def extract_hwp_section_text(data: bytes) -> str:
+    texts = []
+    pos = 0
+    while pos < len(data) - 4:
+        try:
+            header = int.from_bytes(data[pos:pos+4], 'little')
+            tag_id = header & 0x3FF
+            size = (header >> 20) & 0xFFF
+            pos += 4
+            if size == 0xFFF:
+                if pos + 4 > len(data):
+                    break
+                size = int.from_bytes(data[pos:pos+4], 'little')
+                pos += 4
+            if pos + size > len(data):
+                break
+            record_data = data[pos:pos+size]
+            pos += size
+            if tag_id == 67 and size > 0:
+                text = decode_para_text(record_data)
+                if text:
+                    texts.append(text)
+        except:
+            pos += 1
+            continue
+    return '\n'.join(texts) if texts else None
+
+def decode_para_text(data: bytes) -> str:
+    result = []
+    i = 0
+    while i < len(data) - 1:
+        code = int.from_bytes(data[i:i+2], 'little')
+        if code == 0:
+            pass
+        elif code == 1:
+            i += 14
+        elif code == 2:
+            i += 14
+        elif code == 3:
+            i += 14
+        elif code == 4:
+            pass
+        elif code == 9:
+            result.append('\t')
+        elif code == 10:
+            result.append('\n')
+        elif code == 13:
+            result.append('\n')
+        elif code == 24:
+            result.append('-')
+        elif code == 30 or code == 31:
+            result.append(' ')
+        elif code < 32:
+            pass
         else:
-            print(f"Elapsed time: {self.elapsed_time:.6f} seconds")
-
-def update_selection(evt: gr.SelectData, width, height):
-    selected_lora = loras[evt.index]
-    new_placeholder = f"Type a prompt for {selected_lora['title']}"
-    lora_repo = selected_lora["repo"]
-    # 로컬 LoRA 처리
-    if lora_repo == "./":
-        updated_text = f"### Selected: Local LoRA - {selected_lora['title']} ✅"
+            try:
+                char = chr(code)
+                if char.isprintable() or char in '\n\t ':
+                    result.append(char)
+            except:
+                pass
+        i += 2
+    text = ''.join(result).strip()
+    text = re.sub(r'[ \t]+', ' ', text)
+    text = re.sub(r'\n{3,}', '\n\n', text)
+    return text if len(text) > 2 else None
+
+def extract_text_from_hwp(file_path: str) -> tuple:
+    print(f"\n📖 [HWP 읽기] {os.path.basename(file_path)}")
+    text, error = extract_text_with_hwp5txt(file_path)
+    if text and len(text.strip()) > 20:
+        print(f"  ✅ 성공: {len(text)} 글자")
+        return text, None
+    text, error = extract_text_with_olefile(file_path)
+    if text and len(text.strip()) > 20:
+        print(f"  ✅ 성공: {len(text)} 글자")
+        return text, None
+    print(f"  ❌ 실패: {error}")
+    return None, "모든 추출 방법 실패"
+
+def extract_text_from_hwp_or_hwpx(file_path: str) -> tuple:
+    if is_hwpx_file(file_path):
+        print(f"\n📖 [HWPX 읽기] {os.path.basename(file_path)}")
+        return extract_text_from_hwpx(file_path)
     else:
-        updated_text = f"### Selected: [{lora_repo}](https://huggingface.co/{lora_repo}) ✅"
-    
-    # Default aspect ratio
-    aspect = "1:1 (Instagram Square)"
-    width = 1024
-    height = 1024
-    
-    if "aspect" in selected_lora:
-        if selected_lora["aspect"] == "portrait":
-            aspect = "9:16 (Instagram Reels/TikTok/Shorts)"
-            width = 768
-            height = 1344
-        elif selected_lora["aspect"] == "landscape":
-            aspect = "16:9 (YouTube/Twitter/X)"
-            width = 1344
-            height = 768
-    
-    return (
-        gr.update(placeholder=new_placeholder),
-        updated_text,
-        evt.index,
-        aspect,
-        width,
-        height,
-    )
-
-@spaces.GPU
-def run_lora(prompt, image_input, image_strength, cfg_scale, steps, selected_index, randomize_seed, seed, width, height, lora_scale, progress=gr.Progress(track_tqdm=True)):
-    # Clean up previous LoRAs in both cases
-    with calculateDuration("Unloading LoRA"):
-        pipe.unload_lora_weights()
-    
-    # Check if a LoRA is selected
-    if selected_index is not None and selected_index < len(loras):
-        selected_lora = loras[selected_index]
-        lora_path = selected_lora["repo"]
-        trigger_word = selected_lora["trigger_word"]
-        
-        # Prepare Prompt with Trigger Word
-        if(trigger_word):
-            if "trigger_position" in selected_lora:
-                if selected_lora["trigger_position"] == "prepend":
-                    prompt_mash = f"{trigger_word} {prompt}"
-                else:
-                    prompt_mash = f"{prompt} {trigger_word}"
+        return extract_text_from_hwp(file_path)
+
+# ============== HWP 변환 함수들 ==============
+def check_hwp_version(file_path):
+    try:
+        with open(file_path, 'rb') as f:
+            header = f.read(32)
+            if b'HWP Document File' in header:
+                return "HWP v5", True
+            elif header[:4] == b'\xd0\xcf\x11\xe0':
+                return "HWP v5 (OLE)", True
+            elif header[:4] == b'PK\x03\x04':
+                return "HWPX", True
             else:
-                prompt_mash = f"{trigger_word} {prompt}"
-        else:
-            prompt_mash = prompt
+                return "Unknown", False
+    except Exception as e:
+        return f"Error: {e}", False
 
-        # Load LoRA
-        with calculateDuration(f"Loading LoRA weights for {selected_lora['title']}"):
-            weight_name = selected_lora.get("weights", None)
+def convert_to_html_subprocess(input_path, output_dir):
+    output_path = os.path.join(output_dir, "output.html")
+    try:
+        for cmd in [['hwp5html', '--output', output_path, input_path]]:
             try:
-                pipe.load_lora_weights(
-                    lora_path, 
-                    weight_name=weight_name, 
-                    adapter_name="default",
-                    low_cpu_mem_usage=True
-                )
-                # Set adapter scale
-                pipe.set_adapters(["default"], adapter_weights=[lora_scale])
-            except Exception as e:
-                print(f"Error loading LoRA: {e}")
-                gr.Warning("Failed to load LoRA weights. Generating with base model.")
-    else:
-        # Base Model Case
-        print("No LoRA selected. Running with Base Model.")
-        prompt_mash = prompt
+                result = subprocess.run(cmd, capture_output=True, timeout=120)
+                if result.returncode == 0:
+                    if os.path.exists(output_path):
+                        return output_path, None
+                    for item in os.listdir(output_dir):
+                        item_path = os.path.join(output_dir, item)
+                        if item.lower().endswith(('.html', '.htm')):
+                            return item_path, None
+                        if os.path.isdir(item_path):
+                            return item_path, None
+            except:
+                continue
+    except Exception as e:
+        print(f"HTML 변환 오류: {e}")
+    return None, "HTML 변환 실패"
+
+def html_to_markdown(html_content):
+    if MARKDOWNIFY_AVAILABLE:
+        try:
+            return md(html_content, heading_style="ATX", bullets="-"), None
+        except:
+            pass
+    if HTML2TEXT_AVAILABLE:
+        try:
+            h = html2text.HTML2Text()
+            h.body_width = 0
+            return h.handle(html_content), None
+        except:
+            pass
+    if BS4_AVAILABLE:
+        try:
+            soup = BeautifulSoup(html_content, 'html.parser')
+            return soup.get_text(separator='\n'), None
+        except:
+            pass
+    return None, "Markdown 변환 실패"
+
+def convert_hwp_to_markdown(input_path: str) -> tuple:
+    text, error = extract_text_from_hwp_or_hwpx(input_path)
+    if text:
+        return text, None
+    return None, error
+
+# ============== LLM API ==============
+def call_groq_api_stream(messages: List[Dict], api_key: str) -> Generator[str, None, None]:
+    if not api_key:
+        yield "❌ Groq API 키가 설정되지 않았습니다."
+        return
+    try:
+        response = requests.post(
+            "https://api.groq.com/openai/v1/chat/completions",
+            headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
+            json={
+                "model": "meta-llama/llama-4-scout-17b-16e-instruct",
+                "messages": messages,
+                "temperature": 0.7,
+                "max_tokens": 8192,
+                "stream": True
+            },
+            stream=True
+        )
+        if response.status_code != 200:
+            yield f"❌ Groq API 오류: {response.status_code}"
+            return
+        for line in response.iter_lines():
+            if line:
+                line = line.decode('utf-8')
+                if line.startswith('data: ') and line[6:] != '[DONE]':
+                    try:
+                        data = json.loads(line[6:])
+                        content = data.get('choices', [{}])[0].get('delta', {}).get('content', '')
+                        if content:
+                            yield content
+                    except:
+                        continue
+    except Exception as e:
+        yield f"❌ API 오류: {str(e)}"
+
+def call_fireworks_api_stream(messages: List[Dict], image_base64: str, mime_type: str, api_key: str) -> Generator[str, None, None]:
+    if not api_key:
+        yield "❌ Fireworks API 키가 설정되지 않았습니다."
+        return
+    try:
+        formatted_messages = [{"role": m["role"], "content": m["content"]} for m in messages[:-1]]
+        formatted_messages.append({
+            "role": messages[-1]["role"],
+            "content": [
+                {"type": "image_url", "image_url": {"url": f"data:{mime_type};base64,{image_base64}"}},
+                {"type": "text", "text": messages[-1]["content"]}
+            ]
+        })
+        response = requests.post(
+            "https://api.fireworks.ai/inference/v1/chat/completions",
+            headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
+            json={
+                "model": "accounts/fireworks/models/qwen3-vl-235b-a22b-thinking",
+                "max_tokens": 4096,
+                "temperature": 0.6,
+                "messages": formatted_messages,
+                "stream": True
+            },
+            stream=True
+        )
+        if response.status_code != 200:
+            yield f"❌ Fireworks API 오류: {response.status_code}"
+            return
+        for line in response.iter_lines():
+            if line:
+                line = line.decode('utf-8')
+                if line.startswith('data: ') and line[6:] != '[DONE]':
+                    try:
+                        data = json.loads(line[6:])
+                        content = data.get('choices', [{}])[0].get('delta', {}).get('content', '')
+                        if content:
+                            yield content
+                    except:
+                        continue
+    except Exception as e:
+        yield f"❌ API 오류: {str(e)}"
+
+# ============== 채팅 처리 ==============
+def process_file(file_path: str) -> tuple:
+    if not file_path:
+        return None, None, None
+    filename = os.path.basename(file_path)
+    
+    if is_image_file(file_path):
+        return "image", image_to_base64(file_path), get_image_mime_type(file_path)
+    
+    if is_hwp_file(file_path) or is_hwpx_file(file_path):
+        text, error = extract_text_from_hwp_or_hwpx(file_path)
+        if text and len(text.strip()) > 20:
+            return "text", f"[📄 한글 문서: {filename}]\n\n{text}", None
+        return "error", f"한글 문서 추출 실패: {error}", None
+    
+    if is_pdf_file(file_path):
+        text = extract_text_from_pdf(file_path)
+        if text:
+            return "text", f"[📑 PDF 문서: {filename}]\n\n{text}", None
+        return "error", "PDF 추출 실패", None
+    
+    if is_text_file(file_path):
+        text = extract_text_from_txt(file_path)
+        if text:
+            return "text", f"[📝 텍스트 파일: {filename}]\n\n{text}", None
+        return "error", "텍스트 읽기 실패", None
+    
+    return "unsupported", f"지원하지 않는 형식: {filename}", None
+
+def chat_response(message: str, history: List[Dict], file: Optional[str],
+                  session_id: str, groq_key: str, fireworks_key: str) -> Generator[tuple, None, None]:
+    if history is None:
+        history = []
+    if not message.strip() and not file:
+        yield history, session_id
+        return
+    if not session_id:
+        session_id = create_session()
+    
+    file_type, file_content, file_mime = None, None, None
+    file_info = None
+    
+    if file:
+        file_type, file_content, file_mime = process_file(file)
+        file_info = json.dumps({"type": file_type, "filename": os.path.basename(file)})
         
-    with calculateDuration("Randomizing seed"):
-        if randomize_seed:
-            seed = random.randint(0, MAX_SEED)
+        if file_type == "error":
+            history = history + [
+                {"role": "user", "content": message or "파일 업로드"},
+                {"role": "assistant", "content": f"❌ {file_content}"}
+            ]
+            yield history, session_id
+            return
+        elif file_type == "unsupported":
+            history = history + [
+                {"role": "user", "content": message or "파일 업로드"},
+                {"role": "assistant", "content": f"⚠️ {file_content}"}
+            ]
+            yield history, session_id
+            return
+    
+    user_msg = message
+    if file:
+        filename = os.path.basename(file)
+        user_msg = f"📎 {filename}\n\n{message}" if message else f"📎 {filename}"
+    
+    history = history + [{"role": "user", "content": user_msg}, {"role": "assistant", "content": ""}]
+    yield history, session_id
+    
+    db_messages = get_session_messages(session_id, limit=10)
+    api_messages = [{
+        "role": "system",
+        "content": "당신은 도움이 되는 AI 어시스턴트입니다. 한국어로 자연스럽게 대화하며, 파일이 첨부되면 내용을 상세히 분석하여 답변합니다. 문서의 핵심 내용을 파악하고, 사용자의 질문에 정확하게 답변하세요."
+    }]
+    
+    for m in db_messages:
+        api_messages.append({"role": m["role"], "content": m["content"]})
+    
+    current_content = message or ""
+    if file_type == "text" and file_content:
+        current_content = f"{file_content}\n\n사용자 질문: {message}" if message else f"{file_content}\n\n위 문서 내용을 요약해주세요."
+    
+    api_messages.append({"role": "user", "content": current_content})
     
-    generator = torch.Generator(device=device).manual_seed(seed)
+    full_response = ""
+    if file_type == "image":
+        for chunk in call_fireworks_api_stream(api_messages, file_content, file_mime, fireworks_key):
+            full_response += chunk
+            history[-1] = {"role": "assistant", "content": full_response}
+            yield history, session_id
+    else:
+        for chunk in call_groq_api_stream(api_messages, groq_key):
+            full_response += chunk
+            history[-1] = {"role": "assistant", "content": full_response}
+            yield history, session_id
+    
+    save_message(session_id, "user", current_content, file_info)
+    save_message(session_id, "assistant", full_response)
+    
+    if len(db_messages) == 0 and message:
+        update_session_title(session_id, message[:50])
+
+def new_chat():
+    return [], create_session(), None
+
+def load_session(session_id: str) -> tuple:
+    if not session_id:
+        return [], ""
+    messages = get_session_messages(session_id, limit=50)
+    return [{"role": m["role"], "content": m["content"]} for m in messages], session_id
 
-    # Note: Z-Image-Turbo is strictly T2I in this reference implementation. 
-    # Img2Img via image_input is disabled/ignored for this pipeline update.
+# ============== HWP 변환기 ==============
+def convert_to_odt_subprocess(input_path, output_dir):
+    output_path = os.path.join(output_dir, "output.odt")
+    try:
+        result = subprocess.run(['hwp5odt', '--output', output_path, input_path], capture_output=True, timeout=120)
+        if result.returncode == 0 and os.path.exists(output_path):
+            return output_path, None
+    except:
+        pass
+    return None, "ODT 변환 실패"
+
+def convert_to_xml_subprocess(input_path, output_dir):
+    output_path = os.path.join(output_dir, "output.xml")
+    try:
+        result = subprocess.run(['hwp5xml', input_path], capture_output=True, timeout=120)
+        if result.returncode == 0 and result.stdout:
+            with open(output_path, 'wb') as f:
+                f.write(result.stdout)
+            return output_path, None
+    except:
+        pass
+    return None, "XML 변환 실패"
+
+def convert_hwp(file, output_format, progress=gr.Progress()):
+    if not file:
+        return None, "❌ 파일을 업로드해주세요.", ""
+    
+    input_file = file.name if hasattr(file, 'name') else str(file)
+    ext_lower = Path(input_file).suffix.lower()
+    
+    if ext_lower not in ['.hwp', '.hwpx']:
+        return None, "❌ HWP 또는 HWPX 파일만 지원됩니다.", ""
+    
+    progress(0.1, desc="📖 파일 읽는 중...")
+    version, is_valid = check_hwp_version(input_file)
+    if not is_valid:
+        return None, f"❌ 지원하지 않는 파일: {version}", ""
     
-    with calculateDuration("Generating image"):
-        # For Turbo models, guidance_scale is typically 0.0
-        forced_guidance = 0.0 # Turbo mode
+    tmp_dir = tempfile.mkdtemp()
+    
+    try:
+        input_filename = os.path.basename(input_file)
+        input_path = os.path.join(tmp_dir, input_filename)
+        shutil.copy(input_file, input_path)
+        
+        progress(0.3, desc=f"🔄 {output_format}로 변환 중...")
         
-        final_image = pipe(
-            prompt=prompt_mash,
-            height=int(height),
-            width=int(width),
-            num_inference_steps=int(steps),
-            guidance_scale=forced_guidance,
-            generator=generator,
-        ).images[0]
+        output_path, error, ext = None, None, ""
         
-    yield final_image, seed, gr.update(visible=False)
-
-def get_huggingface_safetensors(link):
-  split_link = link.split("/")
-  if(len(split_link) == 2):
-            model_card = ModelCard.load(link)
-            base_model = model_card.data.get("base_model")
-            print(base_model)
-      
-            # Relaxed check to allow Z-Image or Flux or others, assuming user knows what they are doing
-            # or specifically check for Z-Image-Turbo
-            if base_model not in ["Tongyi-MAI/Z-Image-Turbo", "black-forest-labs/FLUX.1-dev"]:
-                # Just a warning instead of error to allow experimentation
-                print("Warning: Base model might not match.")
+        if output_format == "HTML":
+            if ext_lower == '.hwpx':
+                return None, "❌ HWPX는 HTML 변환을 지원하지 않습니다.", ""
+            output_path, error = convert_to_html_subprocess(input_path, tmp_dir)
+            ext = ".html"
+            if output_path and os.path.isdir(output_path):
+                zip_path = shutil.make_archive(os.path.join(tmp_dir, "html"), 'zip', output_path)
+                output_path, ext = zip_path, ".zip"
                 
-            image_path = model_card.data.get("widget", [{}])[0].get("output", {}).get("url", None)
-            trigger_word = model_card.data.get("instance_prompt", "")
-            image_url = f"https://huggingface.co/{link}/resolve/main/{image_path}" if image_path else None
-            fs = HfFileSystem()
+        elif output_format == "ODT (OpenDocument)":
+            if ext_lower == '.hwpx':
+                return None, "❌ HWPX는 ODT 변환을 지원하지 않습니다.", ""
+            output_path, error = convert_to_odt_subprocess(input_path, tmp_dir)
+            ext = ".odt"
+            
+        elif output_format == "TXT (텍스트)":
+            text, error = extract_text_from_hwp_or_hwpx(input_path)
+            if text:
+                output_path = os.path.join(tmp_dir, "output.txt")
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    f.write(text)
+            ext = ".txt"
+            
+        elif output_format == "Markdown":
+            text, error = convert_hwp_to_markdown(input_path)
+            if text:
+                output_path = os.path.join(tmp_dir, "output.md")
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    f.write(text)
+            ext = ".md"
+            
+        elif output_format == "XML":
+            if ext_lower == '.hwpx':
+                try:
+                    with zipfile.ZipFile(input_path, 'r') as zf:
+                        xml_contents = []
+                        for name in zf.namelist():
+                            if name.endswith('.xml'):
+                                with zf.open(name) as f:
+                                    xml_contents.append(f"<!-- {name} -->\n{f.read().decode('utf-8', errors='ignore')}")
+                        output_path = os.path.join(tmp_dir, "output.xml")
+                        with open(output_path, 'w', encoding='utf-8') as f:
+                            f.write('\n\n'.join(xml_contents))
+                except Exception as e:
+                    error = f"HWPX XML 추출 실패: {e}"
+            else:
+                output_path, error = convert_to_xml_subprocess(input_path, tmp_dir)
+            ext = ".xml"
+        
+        if not output_path:
+            return None, f"❌ {error or '변환 실패'}", ""
+        
+        if not os.path.exists(output_path):
+            return None, "❌ 변환된 파일을 찾을 수 없습니다.", ""
+        
+        progress(0.8, desc="✅ 완료 중...")
+        
+        base_name = Path(input_filename).stem
+        final_output = os.path.join(tmp_dir, f"{base_name}{ext}")
+        if output_path != final_output:
+            shutil.copy2(output_path, final_output)
+        
+        file_size = os.path.getsize(final_output)
+        size_str = f"{file_size/1024:.1f} KB" if file_size > 1024 else f"{file_size} bytes"
+        
+        preview = ""
+        if ext in ['.txt', '.md', '.xml']:
             try:
-                list_of_files = fs.ls(link, detail=False)
-                for file in list_of_files:
-                    if(file.endswith(".safetensors")):
-                        safetensors_name = file.split("/")[-1]
-                    if (not image_url and file.lower().endswith((".jpg", ".jpeg", ".png", ".webp"))):
-                      image_elements = file.split("/")
-                      image_url = f"https://huggingface.co/{link}/resolve/main/{image_elements[-1]}"
-            except Exception as e:
-              print(e)
-              gr.Warning(f"You didn't include a link neither a valid Hugging Face repository with a *.safetensors LoRA")
-              raise Exception(f"You didn't include a link neither a valid Hugging Face repository with a *.safetensors LoRA")
-            return split_link[1], link, safetensors_name, trigger_word, image_url
-
-def check_custom_model(link):
-    if(link.startswith("https://")):
-        if(link.startswith("https://huggingface.co") or link.startswith("https://www.huggingface.co")):
-            link_split = link.split("huggingface.co/")
-            return get_huggingface_safetensors(link_split[1])
-    else: 
-        return get_huggingface_safetensors(link)
-
-def add_custom_lora(custom_lora):
-    global loras
-    if(custom_lora):
-        try:
-            title, repo, path, trigger_word, image = check_custom_model(custom_lora)
-            print(f"Loaded custom LoRA: {repo}")
-            card = f'''
-            <div class="custom_lora_card">
-              <span>Loaded custom LoRA:</span>
-              <div class="card_internal">
-                <img src="{image}" />
-                <div>
-                    <h3>{title}</h3>
-                    <small>{"Using: <code><b>"+trigger_word+"</code></b> as the trigger word" if trigger_word else "No trigger word found. If there's a trigger word, include it in your prompt"}<br></small>
-                </div>
-              </div>
-            </div>
-            '''
-            existing_item_index = next((index for (index, item) in enumerate(loras) if item['repo'] == repo), None)
-            if(not existing_item_index):
-                new_item = {
-                    "image": image,
-                    "title": title,
-                    "repo": repo,
-                    "weights": path,
-                    "trigger_word": trigger_word
-                }
-                print(new_item)
-                existing_item_index = len(loras)
-                loras.append(new_item)
+                with open(final_output, 'r', encoding='utf-8', errors='ignore') as f:
+                    preview = f.read(5000)
+                    if len(preview) >= 5000:
+                        preview += "\n\n... (생략)"
+            except:
+                pass
+        elif ext == '.zip':
+            preview = "📦 HTML이 ZIP으로 압축되었습니다."
         
-            return gr.update(visible=True, value=card), gr.update(visible=True), gr.Gallery(selected_index=None), f"Custom: {path}", existing_item_index, trigger_word
-        except Exception as e:
-            gr.Warning(f"Invalid LoRA: either you entered an invalid link, or a non-supported LoRA")
-            return gr.update(visible=True, value=f"Invalid LoRA: either you entered an invalid link, a non-supported LoRA"), gr.update(visible=False), gr.update(), "", None, ""
-    else:
-        return gr.update(visible=False), gr.update(visible=False), gr.update(), "", None, ""
-
-def remove_custom_lora():
-    return gr.update(visible=False), gr.update(visible=False), gr.update(), "", None, ""
-
-run_lora.zerogpu = True
+        progress(1.0, desc="🎉 완료!")
+        return final_output, f"✅ 변환 완료: {base_name}{ext} ({size_str})", preview
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return None, f"❌ 오류: {str(e)}", ""
 
-with gr.Blocks(title="Z-IMAGE GEN/LORA", delete_cache=(60, 60)) as demo:
-    gr.LoginButton(value="Option: HuggingFace 'Login' for extra GPU quota +", size="sm")        
+# ============== Gradio UI ==============
+with gr.Blocks(title="HWP AI 어시스턴트", css=COMIC_CSS, delete_cache=(60, 60)) as demo:
+    
     # HOME Button
     gr.HTML("""
     <div class="home-button-container">
@@ -780,128 +1134,162 @@ with gr.Blocks(title="Z-IMAGE GEN/LORA", delete_cache=(60, 60)) as demo:
     # Header
     gr.HTML("""
     <div class="header-container">
-        <div class="header-title">🎨 Z-IMAGE GEN/LORA 🎨</div>
-        <div class="header-subtitle">Generate amazing images with Z-Image Turbo and various LoRA styles!</div>
+        <div class="header-title">📄 HWP AI 어시스턴트 🤖</div>
+        <div class="header-subtitle">AI가 HWP 파일을 읽고, 보고, 말하며, 생각하고 기억합니다!</div>
         <div style="margin-top:12px">
-            <span class="stats-badge">⚡ Turbo Speed</span>
-            <span class="stats-badge">🎭 30+ LoRAs</span>
-            <span class="stats-badge">🖼️ High Quality</span>
-            <span class="stats-badge">🔧 Custom LoRA</span>
+            <span class="stats-badge">📖 읽기 READ</span>
+            <span class="stats-badge">👁️ 보기 SEE</span>
+            <span class="stats-badge">💬 말하기 SPEAK</span>
+            <span class="stats-badge">🧠 생각 THINK</span>
+            <span class="stats-badge">💾 기억 MEMORY</span>
         </div>
     </div>
     """)
     
-    selected_index = gr.State(None)
-    with gr.Row():
-        with gr.Column(scale=3):
-            prompt = gr.Textbox(label="Enter Prompt", lines=1, placeholder="✦︎ Choose the LoRA and type the prompt (LoRA = None → Base Model = Active)")
-        with gr.Column(scale=1, elem_id="gen_column"):
-            generate_button = gr.Button("🚀 Generate", variant="primary", elem_id="gen_btn")
-    with gr.Row():
-        with gr.Column():
-            selected_info = gr.Markdown("### No LoRA Selected (Base Model)")
-            gallery = gr.Gallery(
-                [(item["image"], item["title"]) for item in loras],
-                label="Z-Image LoRAs",
-                allow_preview=False,
-                columns=3,
-                elem_id="gallery",
-            )
-            with gr.Group():
-                custom_lora = gr.Textbox(label="Enter Custom LoRA", placeholder="Paste the LoRA path and press Enter (e.g., Shakker-Labs/AWPortrait-Z).")
-                gr.Markdown("[Check the list of Z-Image LoRA's](https://huggingface.co/models?other=base_model:adapter:Tongyi-MAI/Z-Image-Turbo)", elem_id="lora_list")
-            custom_lora_info = gr.HTML(visible=False)
-            custom_lora_button = gr.Button("Remove custom LoRA", visible=False)
-        with gr.Column():
-            progress_bar = gr.Markdown(elem_id="progress",visible=False)
-            result = gr.Image(label="Generated Image", format="png", height=630)
-
-    # SNS Aspect Ratio Presets
-    ASPECT_RATIOS = {
-        "1:1 (Instagram Square)": (1024, 1024),
-        "9:16 (Instagram Reels/TikTok/Shorts)": (768, 1344),
-        "16:9 (YouTube/Twitter/X)": (1344, 768),
-        "4:5 (Instagram Portrait)": (896, 1120),
-        "5:4 (Instagram Landscape)": (1120, 896),
-        "3:4 (Portrait Photo)": (896, 1152),
-        "4:3 (Landscape Photo)": (1152, 896),
-        "2:3 (Pinterest)": (832, 1248),
-        "3:2 (Classic Photo)": (1248, 832),
-        "21:9 (Cinematic Ultra-wide)": (1344, 576),
-        "9:21 (Tall Banner)": (576, 1344),
-    }
-    
-    def update_size(aspect_ratio):
-        width, height = ASPECT_RATIOS.get(aspect_ratio, (1024, 1024))
-        return width, height
-    
-    with gr.Row():
-        with gr.Accordion("⚙️ Advanced Settings", open=True):
-            with gr.Row():
-                input_image = gr.Image(label="Input image (Ignored for Z-Image-Turbo)", type="filepath", visible=False)
-                image_strength = gr.Slider(label="Denoise Strength", info="Ignored for Z-Image-Turbo", minimum=0.1, maximum=1.0, step=0.01, value=0.75, visible=False)
-            
-            gr.HTML('<div class="info-box">📐 <b>Image Size</b> - Select aspect ratio for different platforms</div>')
+    session_state = gr.State("")
+    
+    with gr.Tabs():
+        # Tab 1: AI 채팅
+        with gr.Tab("💬 AI 채팅"):
+            # Feature Box
+            gr.HTML("""
+            <div class="feature-box">
+                <div class="feature-title">🎯 AI 문서 분석 기능</div>
+                <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 10px;">
+                    <div class="feature-item"><span class="feature-icon">📖</span> <b>읽기</b> - HWP/HWPX/PDF 자동 텍스트 추출</div>
+                    <div class="feature-item"><span class="feature-icon">👁️</span> <b>보기</b> - 이미지 분석 및 이해</div>
+                    <div class="feature-item"><span class="feature-icon">💬</span> <b>말하기</b> - 자연스러운 한국어 대화</div>
+                    <div class="feature-item"><span class="feature-icon">🧠</span> <b>생각</b> - 문서 내용 분석 및 요약</div>
+                    <div class="feature-item"><span class="feature-icon">💾</span> <b>기억</b> - 대화 기록 자동 저장</div>
+                </div>
+            </div>
+            """)
             
             with gr.Row():
-                aspect_ratio = gr.Dropdown(
-                    choices=list(ASPECT_RATIOS.keys()),
-                    value="1:1 (Instagram Square)",
-                    label="📱 Aspect Ratio (SNS Presets)",
-                    info="Choose the best ratio for your target platform"
-                )
+                with gr.Column(scale=1):
+                    gr.HTML('<div class="info-box">⚙️ <b>설정</b></div>')
+                    
+                    with gr.Accordion("🔑 API 키 설정", open=True):
+                        groq_key = gr.Textbox(label="Groq API Key", type="password", value=GROQ_API_KEY, placeholder="gsk_...")
+                        fireworks_key = gr.Textbox(label="Fireworks API Key", type="password", value=FIREWORKS_API_KEY, placeholder="fw_...")
+                    
+                    gr.HTML("""
+                    <div class="info-box">
+                        📁 <b>지원 파일 형식</b><br><br>
+                        🖼️ <b>이미지</b>: JPG, PNG, GIF, WebP<br>
+                        📑 <b>문서</b>: PDF, TXT, MD<br>
+                        📄 <b>한글</b>: HWP, HWPX ✨
+                    </div>
+                    """)
+                    
+                    new_btn = gr.Button("🆕 새 대화 시작", variant="primary")
+                    
+                    with gr.Accordion("📜 대화 기록 (Memory)", open=False):
+                        session_list = gr.Dataframe(headers=["ID", "제목", "시간"], interactive=False)
+                        refresh_btn = gr.Button("🔄 새로고침", size="sm")
+                
+                with gr.Column(scale=3):
+                    chatbot = gr.Chatbot(label="💬 AI 대화", height=500)
+                    
+                    with gr.Row():
+                        file_upload = gr.File(
+                            label="📎 파일 첨부 (HWP/HWPX/PDF/이미지)",
+                            file_types=[".jpg", ".jpeg", ".png", ".gif", ".webp", ".pdf", ".txt", ".md", ".hwp", ".hwpx"],
+                            scale=1,
+                            elem_classes=["upload-box"]
+                        )
+                        msg_input = gr.Textbox(
+                            placeholder="💭 메시지를 입력하세요... (파일을 업로드하면 AI가 내용을 읽고 분석합니다)",
+                            lines=2,
+                            show_label=False,
+                            scale=4
+                        )
+                    
+                    with gr.Row():
+                        submit_btn = gr.Button("🚀 전송", variant="primary", scale=3)
+                        clear_btn = gr.Button("🗑️ 지우기", scale=1)
+        
+        # Tab 2: HWP 변환기
+        with gr.Tab("📄 HWP 변환기"):
+            gr.HTML("""
+            <div class="feature-box">
+                <div class="feature-title">🔄 HWP/HWPX 파일 변환기</div>
+                <p style="font-family: 'Comic Neue', cursive; font-weight: 700; color: #1F2937;">
+                    한글 문서를 다양한 형식으로 변환합니다. AI가 문서를 읽고 텍스트를 추출합니다.
+                </p>
+            </div>
+            """)
             
             with gr.Row():
-                width = gr.Slider(label="Width", minimum=256, maximum=1536, step=64, value=1536)
-                height = gr.Slider(label="Height", minimum=256, maximum=1536, step=64, value=1536)
+                with gr.Column():
+                    gr.HTML('<div class="info-box">📤 <b>파일 업로드</b></div>')
+                    hwp_input = gr.File(
+                        label="HWP/HWPX 파일 선택",
+                        file_types=[".hwp", ".hwpx"],
+                        elem_classes=["upload-box"]
+                    )
+                    format_select = gr.Radio(
+                        ["HTML", "ODT (OpenDocument)", "TXT (텍스트)", "Markdown", "XML"],
+                        value="TXT (텍스트)",
+                        label="📋 변환 형식"
+                    )
+                    convert_btn = gr.Button("🔄 변환하기", variant="primary", size="lg")
+                    
+                with gr.Column():
+                    gr.HTML('<div class="info-box">📥 <b>변환 결과</b></div>')
+                    status_out = gr.Textbox(label="상태", interactive=False)
+                    file_out = gr.File(label="다운로드", elem_classes=["download-box"])
             
-            with gr.Column():
-                with gr.Row():
-                    cfg_scale = gr.Slider(label="CFG Scale", info="Forced to 0.0 for Turbo", minimum=0, maximum=20, step=0.5, value=0.0, interactive=False)
-                    steps = gr.Slider(label="Steps", minimum=1, maximum=50, step=1, value=25)
-                
-                with gr.Row():
-                    randomize_seed = gr.Checkbox(True, label="Randomize seed")
-                    seed = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=0, randomize=True)
-                    lora_scale = gr.Slider(label="LoRA Scale", minimum=0, maximum=3, step=0.01, value=0.95)
-    
-    # Connect aspect ratio dropdown to width/height sliders
-    aspect_ratio.change(
-        fn=update_size,
-        inputs=[aspect_ratio],
-        outputs=[width, height]
-    )
-
+            with gr.Accordion("📋 미리보기", open=False):
+                preview_out = gr.Textbox(lines=15, interactive=False)
+            
+            gr.HTML("""
+            <div class="info-box">
+                ℹ️ <b>안내</b>: HWPX 파일은 TXT, Markdown, XML 변환만 지원됩니다.
+            </div>
+            """)
+    
     # Footer
     gr.HTML("""
     <div class="footer-comic">
-        <p style="font-family:'Bangers',cursive;font-size:1.5rem;letter-spacing:2px">🎨 Z-IMAGE GEN/LORA 🎨</p>
-        <p>Powered by Z-Image Turbo + LoRA Adapters</p>
-        <p>⚡ Fast Generation • 🎭 Multiple Styles • 🖼️ High Quality</p>
+        <p style="font-family:'Bangers',cursive;font-size:1.8rem;letter-spacing:2px">📄 HWP AI 어시스턴트 🤖</p>
+        <p>AI가 HWP 파일을 읽고, 보고, 말하며, 생각하고 기억합니다!</p>
+        <p>📖 READ • 👁️ SEE • 💬 SPEAK • 🧠 THINK • 💾 MEMORY</p>
         <p style="margin-top:10px"><a href="https://www.humangen.ai" target="_blank" style="color:#FACC15;text-decoration:none;font-weight:bold;">🏠 www.humangen.ai</a></p>
     </div>
     """)
+    
+    # ============== 이벤트 핸들러 ==============
+    def on_submit(msg, hist, f, sid, gk, fk):
+        if hist is None:
+            hist = []
+        for r in chat_response(msg, hist, f, sid, gk, fk):
+            yield r[0], r[1], "", None
+    
+    submit_btn.click(on_submit, [msg_input, chatbot, file_upload, session_state, groq_key, fireworks_key],
+                     [chatbot, session_state, msg_input, file_upload])
+    msg_input.submit(on_submit, [msg_input, chatbot, file_upload, session_state, groq_key, fireworks_key],
+                     [chatbot, session_state, msg_input, file_upload])
+    
+    new_btn.click(lambda: ([], create_session(), None, ""), outputs=[chatbot, session_state, file_upload, msg_input])
+    clear_btn.click(lambda: ([], None, ""), outputs=[chatbot, file_upload, msg_input])
+    
+    def refresh():
+        sessions = get_all_sessions()
+        return [[s["session_id"][:8], s["title"] or "제목없음", s["updated_at"][:16] if s["updated_at"] else ""] for s in sessions]
+    
+    refresh_btn.click(refresh, outputs=[session_list])
+    
+    def select_session(evt: gr.SelectData, data):
+        if evt.index[0] < len(data):
+            for s in get_all_sessions():
+                if s["session_id"].startswith(data[evt.index[0]][0]):
+                    return load_session(s["session_id"])
+        return [], ""
+    
+    session_list.select(select_session, [session_list], [chatbot, session_state])
+    convert_btn.click(convert_hwp, [hwp_input, format_select], [file_out, status_out, preview_out])
+    demo.load(refresh, outputs=[session_list])
 
-    gallery.select(
-        update_selection,
-        inputs=[width, height],
-        outputs=[prompt, selected_info, selected_index, aspect_ratio, width, height]
-    )
-    custom_lora.input(
-        add_custom_lora,
-        inputs=[custom_lora],
-        outputs=[custom_lora_info, custom_lora_button, gallery, selected_info, selected_index, prompt]
-    )
-    custom_lora_button.click(
-        remove_custom_lora,
-        outputs=[custom_lora_info, custom_lora_button, gallery, selected_info, selected_index, custom_lora]
-    )
-    gr.on(
-        triggers=[generate_button.click, prompt.submit],
-        fn=run_lora,
-        inputs=[prompt, input_image, image_strength, cfg_scale, steps, selected_index, randomize_seed, seed, width, height, lora_scale],
-        outputs=[result, seed, progress_bar]
-    )
-
-demo.queue()
-demo.launch(css=COMIC_CSS, ssr_mode=False, show_error=True)
+if __name__ == "__main__":
+    demo.launch(ssr_mode=False)