Delete app.py

app.py

@@ -1,1393 +0,0 @@
-import os
-import re
-import random
-import time
-import html
-import base64
-import string
-import json
-import asyncio
-import requests
-import anthropic
-import openai
-import io
-import logging
-
-from http import HTTPStatus
-from typing import Dict, List, Optional, Tuple
-from functools import partial
-
-import gradio as gr
-import modelscope_studio.components.base as ms
-import modelscope_studio.components.legacy as legacy
-import modelscope_studio.components.antd as antd
-
-# === [1] 로거 설정 ===
-log_stream = io.StringIO()
-# Use StreamHandler to output to console *and* capture in StringIO
-console_handler = logging.StreamHandler()
-stringio_handler = logging.StreamHandler(log_stream)
-
-# Configure root logger
-logger = logging.getLogger()
-logger.setLevel(logging.DEBUG) # Set level for root logger
-logger.handlers.clear() # Clear existing handlers if any
-logger.addHandler(console_handler) # Add console output
-logger.addHandler(stringio_handler) # Add StringIO capture
-
-# Configure specific loggers if needed (optional)
-logging.getLogger("httpx").setLevel(logging.WARNING)
-logging.getLogger("httpcore").setLevel(logging.WARNING)
-logging.getLogger("openai").setLevel(logging.WARNING)
-logging.getLogger("anthropic").setLevel(logging.WARNING)
-logging.getLogger("requests").setLevel(logging.WARNING)
-logging.getLogger("urllib3").setLevel(logging.WARNING)
-
-
-def get_logs():
-    """StringIO에 쌓인 로그를 문자열로 반환"""
-    return log_stream.getvalue()
-
-
-# ------------------------
-# 1) DEMO_LIST 및 SystemPrompt
-# ------------------------
-# (DEMO_LIST and SystemPrompt remain the same)
-DEMO_LIST = [
-    {"description": "블록이 위에서 떨어지는 클래식 테트리스 게임을 개발해주세요. 화살표 키로 조작하며, 가로줄이 채워지면 해당 줄이 제거되고 점수가 올라가는 메커니즘이 필요합니다. 난이도는 시간이 지날수록 블록이 빨라지도록 구현하고, 게임오버 조건과 점수 표시 기능을 포함해주세요."},
-    {"description": "두 명이 번갈아가며 플레이할 수 있는 체스 게임을 만들어주세요. 기본적인 체스 규칙(킹, 퀸, 룩, 비숍, 나이트, 폰의 이동 규칙)을 구현하고, 체크와 체크메이트 감지 기능이 필요합니다. 드래그 앤 드롭으로 말을 움직일 수 있게 하며, 이동 기록도 표시해주세요."},
-    {"description": "짝을 맞추는 메모리 카드 게임을 개발해주세요. 카드를 뒤집으면 그림이 나타나고, 같은 그림의 카드 두 장을 찾으면 점수를 얻는 방식입니다. 카드 뒤집기 애니메이션과 함께 시도 횟수를 기록하는 점수 시스템, 그리고 쉬움/보통/어려움 난이도 선택 기능(카드 수 변경)도 구현해주세요."},
-    {"description": "플레이어가 우주선을 조종하여 적 우주선을 파괴하는 슈팅 게임을 만들어주세요. 키보드 방향키로 움직이고 스페이스바로 발사하며, 다양한 적 웨이브가 공격해오는 구조입니다. 충돌 감지 시스템과 함께 파워업 아이템(방패, 다중 발사, 속도 증가 등)을 구현하고, 난이도가 점진적으로 증가하는 시스템을 추가해주세요."},
-    {"description": "3x3 또는 4x4 크기의 슬라이드 퍼즐 게임을 만들어주세요. 숫자나 이미지 조각을 섞은 후, 빈 칸을 이용해 조각들을 올바른 위치로 밀어 맞추는 게임입니다. 섞기 기능과 이동 횟수 카운터, 완성 시 축하 메시지를 표시하고, 난이도 설정(크기 변경)도 구현해주세요."},
-    {"description": "고전적인 뱀 게임을 구현해주세요. 플레이어는 방향키로 뱀을 조종하여 필드에 랜덤하게 생성되는 먹이를 먹으며, 먹이를 먹을 때마다 뱀의 길이가 늘어납니다. 자신의 몸에 부딪히거나 벽에 부딪히면 게임이 종료되며, 점수는 먹은 먹이의 수에 비례합니다. 시간이 지날수록 뱀의 이동 속도가 빨라지는 난이도 조절 기능도 추가해주세요."},
-    {"description": "화면 상단에 여러 줄의 벽돌이 배치된 브레이크아웃 게임을 만들어주세요. 플레이어는 화면 하단의 패들을 좌우로 움직여 공을 튕겨내어 벽돌을 깨야 합니다. 벽돌을 모두 깨면 스테이지 클리어, 공이 바닥에 떨어지면 생명이 감소합니다. 공의 속도는 시간이 지날수록 증가하며, 특수 벽돌(추가 생명, 패들 확장 등)도 구현해주세요."},
-    {"description": "길을 따라 이동하는 적들을 방어하는 타워 디펜스 게임을 개발해주세요. 플레이어는 맵의 특정 위치에 다양한 타워(기본 공격, 범위 공격, 감속 효과 등)를 설치하여 적을 물리쳐야 합니다. 웨이브 시스템으로 난이도가 점진적으로 증가하며, 적을 처치하면 자원을 얻어 타워를 업그레이드하거나 새 타워를 건설할 수 있는 경제 시스템을 구현해주세요."},
-    {"description": "캐릭터가 끝없이 달리며 장애물을 뛰어넘는 엔드리스 러너 게임을 만들어주세요. 스페이스바나 마우스 클릭으로 점프하여 다가오는 장애물(바위, 구덩이, 적 등)을 피해야 합니다. 거리에 따라 점수가 증가하며, 코인 등의 수집품을 모으는 요소와 파워업(일시적 무적, 자석 효과 등)도 추가해주세요. 시간이 지날수록 게임 속도가 빨라지는 난이도 시스템도 구현해주세요."},
-    {"description": "2D 플랫포머 게임을 개발해주세요. 플레이어는 방향키로 캐릭터를 조종하여 발판 위를 이동하고, 스페이스바로 점프하며 코인이나 보석 같은 아이템을 수집합니다. 적 캐릭터(간단한 AI로 움직임)와 함정(가시, 떨어지는 발판 등)을 피해 목표 지점까지 도달하는 레벨 기반 구조로 만들어주세요. 체력 시스템과 체크포인트 기능도 구현해주세요."},
-    {"description": "매번 새로운 미로를 자동 생성하는 미로 게임을 만들어주세요. 플레이어는 시작점에서 출발하여 방향키로 캐릭터를 조종해 출구를 찾아야 합니다. 미로 생성 알고리즘(예: 깊이 우선 탐색, 프림 알고리즘 등)을 활용하여 다양한 크기와 복잡도의 미로를 만들고, 타이머로 시간을 측정하며, 선택적으로 최단 경로를 보여주는 힌트 기능도 구현해주세요."},
-    {"description": "간단한 턴제 RPG 게임을 개발해주세요. 플레이어는 탑다운 뷰에서 타일 기반으로 이동하며, 몬스터와 마주치면 턴제 전투가 시작됩니다. 기본 공격, 특수 스킬, 아이템 사용 등의 전투 옵션과 함께 레벨업 시스템(경험치, 능력치 상승)을 구현해주세요. 또한 전투에서 승리하면 골드와 아이템을 획득할 수 있으며, 상점에서 장비를 구매하는 기능도 추가해주세요."},
-    {"description": "같은 색상/모양의 아이템 3개 이상을 일렬로 맞추는 매치-3 퍼즐 게임을 만들어주세요. 아이템을 스와이프하여 위치를 바꾸고, 매치되면 아이템이 사라지며 점수를 얻는 방식입니다. 특수 매치(4개 이상, T자 모양 등)는 특수 아이템을 생성하며, 연속 매치(콤보)는 추가 점수나 보너스 효과를 제공합니다. 목표 점수 또는 제한 시간/이동 횟수 모드를 구현해주세요."},
-    {"description": "플래피 버드 스타일의 게임을 개발해주세요. 플레이어는 스페이스바나 마우스 클릭으로 새를 점프시켜 위아래로 움직이는 파이프 사이를 통과해야 합니다. 파이프에 부딪히거나 화면 상단/하단에 닿으면 게임 오버이며, 통과한 파이프 쌍마다 점수가 1점씩 증가합니다. 파이프 간격은 랜덤하게 생성되며, 최고 점수를 로컬 스토리지에 저장하는 기능도 구현해주세요."},
-    {"description": "두 개의 유사한 이미지에서 차이점을 찾는 게임을 만들어주세요. 5-10개의 차이점이 있는 이미지 쌍을 준비하고, 플레이어가 차이점을 클릭하면 표시되도록 합니다. 제한 시간 내에 모든 차이점을 찾아야 하며, 오답 클릭 시 시간 패널티가 부과됩니다. 힌트 시스템(차이점 하나를 자동으로 표시)과 난이도 선택(쉬움: 차이점이 명확, 어려움: 미묘한 차이)도 구현해주세요."},
-    {"description": "화면 상단에서 단어가 떨어지는 타이핑 게임을 개발해주세요. 플레이어는 키보드로 해당 단어를 정확히 입력하여 단어가 바닥에 닿기 전에 제거해야 합니다. 정확히 입력한 단어는 사라지고 점수를 얻으며, 난이도에 따라 단어의 길이와 떨어지는 속도가 조절됩니다. 특수 단어(빨간색 등)는 보너스 점수나 시간 추가 등의 효과를 제공하며, 일정 시간/점수마다 난이도가 상승하는 시스템도 구현해주세요."},
-    {"description": "물리 엔진 기반의 미니 골프 게임을 만들어주세요. 플레이어는 마우스 드래그로 공을 치는 방향과 세기를 조절하여 홀에 공을 넣어야 합니다. 다양한 장애물(모래 함정, 물웅덩이, 경사로 등)이 있는 여러 개의 코스를 구현하고, 각 홀마다 타수를 기록하여 최종 점수를 계산합니다. 바람 방향/세기 같은 환경 요소와 함께 궤적 미리보기 기능도 추가해주세요."},
-    {"description": "플레이어가 낚시를 즐기는 시뮬레이션 게임을 개발해주세요. 마우스 클릭으로 낚싯줄을 던지고, 물고기가 물면 타이밍 맞추기 미니게임으로 물고기를 낚아야 합니다. 다양한 종류의 물고기(희귀도별 점수 차등)를 구현하고, 낚은 물고기에 따라 골드를 획득하여 더 좋은 낚싯대, 미끼 등을 구매할 수 있는 업그레이드 시스템을 추가해주세요. 시간대나 날씨에 따라 출현하는 물고기가 달라지는 기���도 구현해주세요."},
-    {"description": "1인용 또는 AI 대전 빙고 게임을 만들어주세요. 5x5 그리드에 1-25 숫자를 무작위로 배치하고, 번갈아가며 숫자를 선택하여 해당 칸을 마킹합니다. 가로, 세로, 대각선으로 5개의 연속된 마킹이 완성되면 빙고가 되며, 먼저 3빙고를 달성하는 쪽이 승리합니다. 컴퓨터 AI는 랜덤하게 또는 전략적으로(빙고에 가까운 라인 우선) 숫자를 선택하도록 구현하고, 타이머와 승/패 기록 시스템도 추가해주세요."},
-    {"description": "화면 하단에서 상단으로 노트가 올라오면 정확한 타이밍에 키를 눌러 점수를 얻는 리듬 게임을 개발해주세요. 4개의 레인(D, F, J, K 키)에 노트가 등장하며, 타이밍 정확도에 따라 Perfect, Good, Miss 등급이 표시됩니다. 배경 음악에 맞춰 노트가 생성되며, 연속 성공 시 콤보 시스템으로 추가 점수를 제공합니다. 난이도 선택(노트 속도와 밀도 조절)과 함께 최종 결과 화면(정확도, 콤보, 등급)도 구현해주세요."},
-    {"description": "탑다운 뷰의 2D 레이싱 게임을 만들어주세요. 플레이어는 방향키로 자동차를 조종하여 트랙을 따라 주행하며, 트랙 이탈 시 감속되는 메커니즘을 구현합니다. 여러 AI 경쟁자들과 경쟁하며 3바퀴를 가장 빨리 완주하는 게임 모드와 함께, 시간 제한 내에 체크포인트를 통과하는 타임 어택 모드도 구현해주세요. 다양한 차량 선택지(속도와 핸들링 특성 차등)와 부스트 아이템, 장애물 등도 추가해주세요."},
-    {"description": "다양한 카테고리의 퀴즈를 풀어나가는 게임을 개발해주세요. 주어진 질문에 4개의 보기 중 정답을 선택하는 방식으로, 정답 시 점수를 획득하고 오답 시 생명이 감소합니다. 30초 제한 시간 내에 답을 선택해야 하며, 난이도에 따라 질문의 복잡도와 제한 시간이 조절됩니다. 50:50 힌트(오답 2개 제거), 시간 추가 등의 도움 아이템과 함께 최종 결과 요약(정답률, 카테고리별 성적)도 구현해주세요."},
-    {"description": "움직이는 표적을 맞추는 사격 갤러리 게임을 만들어주세요. 마우스 클릭으로 발사하며, 다양한 속도와 패턴으로 움직이는 표적(오리, 병, 풍선 등)을 맞추면 점수를 획득합니다. 제한된 시간과 총알 수 안에 최대한 많은 점수를 얻는 것이 목표이며, 특수 표적(황금 표적 등)은 보너스 점수나 추가 시간/총알을 제공합니다. 연속 명중 시 점수 배율이 증가하는 콤보 시스템과 함께 다양한 난이도 레벨(표적 속도/수 증가)도 구현해주세요."},
-    {"description": "가상 주사위를 굴려 보드판을 돌아다니는 보드 게임을 개발해주세요. 플레이어는 차례대로 1-6 주사위를 굴려 말을 이동시키며, 도착한 칸에 따라 다양한 이벤트(앞으로/뒤로 이동, 한 턴 쉬기, 미니게임 등)가 발생합니다. 특수 아이템(추가 주사위, 이벤트 회피 등)을 수집하고 사용할 수 있으며, 먼저 결승점에 도달하거나 가장 많은 포인트를 모은 플레이어가 승리합니다. 1-4명의 로컬 멀티플레이어를 지원하며, AI 플레이어도 구현해주세요."},
-    {"description": "탑다운 뷰의 좀비 서바이벌 게임을 만들어주세요. WASD로 이동하고 마우스로 조준/발사하며, 끊임없이 몰려오는 좀비 웨이브를 최대한 오래 생존하는 것이 목표입니다. 다양한 무기(권총, 샷건, 기관총 등)와 제한된 탄약, 그리고 체력 회복 아이템과 폭탄 같은 특수 아이템을 맵에서 획득할 수 있습니다. 시간이 지날수록 좀비의 수와 속도가 증가하며, 특수 좀비(탱커, 러너 등)도 등장하는 난이도 시스템을 구현해주세요."},
-    {"description": "축구 페널티킥 게임을 개발해주세요. 공격 시에는 방향과 파워를 조절하여 슛을 날리고, 수비 시에는 골키퍼를 좌/중앙/우 중 한 방향으로 다이빙시켜 공을 막아야 합니다. 5번의 키커-골키퍼 대결 후 더 많은 골을 넣은 쪽이 승리하며, 동점일 경우 서든데스로 승부를 가립니다. 슛의 정확도와 파워에 따라 결과가 달라지며, 골키퍼 AI는 패턴 학습을 통해 플레이어의 경향성을 파악하도록 구현해주세요. 1인 플레이와 2인 로컬 대전 모드를 모두 지원해주세요."},
-    {"description": "클래식한 지뢰찾기 게임을 구현해주세요. NxN 크기의 그리드에 M개의 지뢰가 무작위로 배치되며, 플레이어는 좌클릭으로 칸을 열고 우클릭으로 지뢰 위치에 깃발을 표시합니다. 열린 칸에는 주변 8칸의 지뢰 수가 표시되며, 주변에 지뢰가 없는 칸을 열면 연쇄적으로 주변 칸들이 열립니다. 지뢰가 있는 칸을 열면 게임 오버, 지뢰가 아닌 모든 칸을 열면 승리입니다. 난이도 설정(쉬움: 9x9/10개, 중간: 16x16/40개, 어려움: 30x16/99개)과 함께 첫 클릭은 항상 안전하도록 구현해주세요."},
-    {"description": "두 플레이어가 번갈아가며 7x6 그리드에 색깔 디스크를 떨어뜨려 가로, 세로, 대각선으로 4개의 연속된 디스크를 만드는 Connect Four 게임을 개발해주세요. 플레이어는 열을 클릭하여 디스크를 해당 열의 가장 아래 빈 칸에 배치합니다. 4개의 연속된 디스크를 먼저 만드는 플레이어가 승리하며, 모든 칸이 차면 무승부입니다. 1인 플레이(AI 대전)과 2인 로컬 대전 모드를 구현하고, AI는 최소한 1단계 앞을 내다보는 논리로 작동하도록 해주세요."},
-    {"description": "글자 타일을 배치하여 단어를 만드는 스크래블 스타일의 단어 게임을 만들어주세요. 각 플레이어는 7개의 글자 타일을 받고, 이를 보드에 배치하여 가로나 세로로 단어를 형성합니다. 새 단어는 기존 단어와 반드시 연결되어야 하며, 각 타일에는 점수가 있어 단어의 총점이 계산됩니다. 특수 칸(2배 글자 점수, 3배 단어 점수 등)을 활용한 전략적 배치가 가능하며, 사전 검증 기능으로 유효한 단어만 허용합니다. 1-4인 로컬 멀티플레이어와 AI 대전을 지원해주세요."},
-    {"description": "2D 환경에서 진행되는 탱크 전투 게임을 개발해주세요. 플레이어는 WASD로 탱크를 조종하고, 마우스로 포탑을 조준하여 클릭으로 발사합니다. 파괴 가능한 지형(벽돌, 나무 등)과 파괴 불가능한 장애물(강철, 물 등)이 있는 맵에서 적 탱크들과 전투를 벌입니다. 다양한 무기(기본 포탄, 확산탄, 레이저 등)와 아이템(속도 증가, 방어력 강화, 추가 생명 등)을 구현하고, 스테이지별로 증가하는 적 AI 난이도와 보스 전투도 추가해주세요."},
-    {"description": "3개 이상의 같은 보석을 맞추어 제거하는 퍼즐 게임을 만들어주세요. 인접한 두 보석을 스왑하여 매치를 만들며, 매치된 보석이 사라지면 위의 보석들이 떨어지고 새 보석이 채워집니다. 4개 이상 매치 시 특수 보석(가로/세로 폭발, 주변 9칸 폭발 등)이 생성되며, 연쇄 매치가 발생하면 콤보 점수가 추가됩니다. 제한 시간 또는 제한 이동 횟수 내에 목표 점수를 달성하는 레벨 기반 진행 구조와 함께, 특수 미션(특정 색상 N개 제거, 장애물 파괴 등)도 구현해주세요."},
-    {"description": "단일 타워가 끊임없이 몰려오는 적들을 격퇴하는 타워 디펜스 게임을 개발해주세요. 화면 중앙의 타워는 자동으로 가장 가까운 적을 향해 발사하며, 플레이어는 웨이브 사이에 획득한 자원으로 타워를 업그레이드(공격력, 공격 속도, 범위 등)할 수 있습니다. 시간이 지날수록 더 강력하고 다양한 적(빠른 적, 방어력 높은 적, 분열하는 적 등)이 등장하며, 타워의 체력이 0이 되면 게임 오버입니다. 특수 능력(범위 공격, 일시 정지, 즉시 회복 등)과 함께 생존한 웨이브 수에 따른 랭킹 시스템도 구현해주세요."},
-    {"description": "캐릭터가 끝없이 달리며 좀비와 장애물을 피하는 사이드 스크롤링 러너 게임을 만들어주세요. 스페이스바로 점프, S키로 슬라이딩하여 다양한 장애물(웅덩이, 장벽, 좀비 무리 등)을 피해야 합니다. 코인과 파워업(일시적 무적, 자석 효과, 속도 감소 등)을 수집하며, 특정 구간마다 미니 보스 좀비와의 간단한 전투도 포함됩니다. 거리에 따라 점수가 증가하고, 코인으로 캐릭터 업그레이드(더블 점프, 체력 증가 등)를 구매할 수 있는 시스템도 구현해주세요."},
-    {"description": "탑다운 뷰의 간단한 액션 RPG 게임을 개발해주세요. WASD로 이동하고, 마우스 클릭으로 기본 공격, 1-4 키로 특수 스킬을 사용합니다. 플레이어는 몬스터를 처치하며 경험치와 아이템을 획득하고, 레벨업 시 능력치(공격력, 체력, 속도 등)를 향상시킵니다. 다양한 무기와 방어구를 착용할 수 있으며, 스킬 트리 시스템으로 캐릭터를 특화시킬 수 있습니다. 여러 지역과 보스 몬스터, 간단한 퀘스트 시스템도 구현해주세요."},
-]
-
-SystemPrompt = """
-# GameCraft 시스템 프롬프트
-
-## 1. 기본 정보 및 역할
-당신의 이름은 'GameCraft'입니다. 당신은 게임플레이 메커니즘, 인터랙티브 디자인, 성능 최적화에 뛰어난 웹 게임 개발 전문가입니다. HTML, JavaScript, CSS를 활용하여 간결하고 효율적인 웹 기반 게임을 제작하는 것이 당신의 임무입니다.
-
-## 2. 핵심 기술 스택
-- **프론트엔드**: HTML5, CSS3, JavaScript(ES6+)
-- **렌더링 방식**: 브라우저에서 직접 렌더링 가능한 코드 생성
-- **코드 스타일**: 바닐라 JavaScript 우선, 외부 라이브러리 최소화
-
-## 3. 게임 유형별 특화 지침
-### 3.1 아케이드/액션 게임
-- 간결한 충돌 감지 시스템 구현
-- 키보드/터치 입력 최적화
-- 기본적인 점수 시스템
-
-### 3.2 퍼즐 게임
-- 명확한 게임 규칙 및 승리 조건
-- 기본 난이도 구현
-- 핵심 게임 메커니즘에 집중
-
-### 3.3 카드/보드 게임
-- 간소화된 턴 기반 시스템
-- 기본 게임 규칙 자동화
-- 핵심 게임 로직 중심
-
-### 3.4 시뮬레이션 게임
-- 효율적인 상태 관리
-- 가장 중요한 상호작용 구현
-- 핵심 요소만 포함
-
-## 4. 이모지 활용 지침 🎮
-- 게임 UI 요소에 이모지 활용 (예: 생명력 ❤️, 코인 💰, 시간 ⏱️)
-- 이모지 사용은 핵심 요소에만 집중
-
-## 5. 기술적 구현 가이드라인
-### 5.1 코드 구조
-- **간결성 중시**: 코드는 최대한 간결하게 작성하고, 주석은 최소화
-- **모듈화**: 코드 기능별로 분리하되 불필요한 추상화 지양
-- **최적화**: 게임 루프와 렌더링 최적화에 집중
-- **코드 크기 제한**: 전체 코드는 200줄을 넘지 않도록 함 (API 호출 시에는 600줄 제한 고려)
-
-### 5.2 성능 최적화
-- DOM 조작 최소화
-- 불필요한 변수와 함수 제거
-- 메모리 관리에 주의
-
-### 5.3 반응형 디자인
-- 기본적인 반응형 지원
-- 핵심 기능에 집중한 심플한 UI
-
-## 6. 외부 라이브러리
-- 라이브러리 사용은 최소화하고, 필요한 경우에만 사용
-- 라이브러리 사용 시 CDN으로 가져올 것
-
-## 7. 접근성 및 포용성
-- 핵심 접근성 기능에만 집중
-
-## 8. 제약사항 및 유의사항
-- 외부 API 호출 금지 (Vercel 배포 제외)
-- 코드 크기 최소화에 우선순위 (API 호출 시 600줄 이내, 최종 목표 200줄)
-- 주석 최소화 - 필수적인 설명만 포함
-- 불필요한 기능 구현 지양
-
-## 9. 출력 형식
-- HTML 코드 블록으로만 코드 반환
-- 추가 설명 없이 즉시 실행 가능한 코드만 제공
-- 모든 코드는 단일 HTML 파일에 인라인으로 포함
-
-## 10. 코드 품질 기준
-- 효율성과 간결함이 최우선
-- 핵심 게임플레이 메커니즘에만 집중
-- 복잡한 기능보다 작동하는 기본 기능 우선
-- 불필요한 주석이나 장황한 코드 지양
-- 단일 파일에 모든 코드 포함
-- 코드 길이 제한: 완성된 게임 코드는 600줄 이내로 작성 (API 호출 시), 최종 목표 200줄
-
-## 11. 중요: 코드 생성 제한
-- 게임 코드는 반드시 600줄 이내로 제한 (API 호출 시), 최종 목표 200줄
-- 불필요한 설명이나 주석 제외
-- 핵심 기능만 구현하고 부가 기능은 생략
-- 코드 크기가 커질 경우 기능을 간소화하거나 생략할 것
-"""
-
-# ------------------------
-# 2) 공통 상수, 함수, 클래스
-# ------------------------
-# (Role, History, Messages, IMAGE_CACHE, get_image_base64, history_to_messages, messages_to_history remain the same)
-class Role:
-    SYSTEM = "system"
-    USER = "user"
-    ASSISTANT = "assistant"
-
-History = List[Tuple[str, str]]
-Messages = List[Dict[str, str]]
-
-IMAGE_CACHE = {}
-
-def get_image_base64(image_path):
-    """
-    이미지 파일을 base64로 읽어서 캐싱
-    """
-    if image_path in IMAGE_CACHE:
-        return IMAGE_CACHE[image_path]
-    try:
-        with open(image_path, "rb") as image_file:
-            encoded_string = base64.b64encode(image_file.read()).decode()
-            IMAGE_CACHE[image_path] = encoded_string
-            return encoded_string
-    except:
-        # Provide a default placeholder if needed, or handle error
-        logger.error(f"Failed to read image: {image_path}")
-        return IMAGE_CACHE.get('default.png', '') # Assuming you might have a default
-
-def history_to_messages(history: History, system: str) -> Messages:
-    messages = [{'role': Role.SYSTEM, 'content': system}]
-    if history: # Check if history is not None and not empty
-        for h in history:
-            # Ensure h is a tuple/list of length 2
-            if isinstance(h, (list, tuple)) and len(h) == 2:
-                messages.append({'role': Role.USER, 'content': h[0]})
-                messages.append({'role': Role.ASSISTANT, 'content': h[1]})
-            else:
-                logger.warning(f"Skipping invalid history item: {h}")
-    return messages
-
-def messages_to_history(messages: Messages) -> History:
-    history = []
-    # Ensure messages list has the expected structure
-    if not messages or messages[0]['role'] != Role.SYSTEM:
-        logger.error("Invalid messages format for conversion to history.")
-        return history # Return empty history
-
-    # Iterate through pairs of user/assistant messages
-    for i in range(1, len(messages), 2):
-        if i + 1 < len(messages) and messages[i]['role'] == Role.USER and messages[i+1]['role'] == Role.ASSISTANT:
-            history.append([messages[i]['content'], messages[i+1]['content']])
-        else:
-            # Log if the structure is not as expected, but continue if possible
-            logger.warning(f"Skipping unexpected message sequence at index {i} during history conversion.")
-            # break # Option: stop conversion if structure is broken
-    return history
-
-
-# ------------------------
-# 3) API 연동 설정
-# ------------------------
-# (API clients and functions remain the same)
-YOUR_ANTHROPIC_TOKEN = os.getenv('ANTHROPIC_API_KEY', '').strip()
-YOUR_OPENAI_TOKEN    = os.getenv('OPENAI_API_KEY',     '').strip()
-
-# Add basic error handling for missing keys
-if not YOUR_ANTHROPIC_TOKEN:
-    logger.warning("ANTHROPIC_API_KEY is not set. Claude API calls will fail.")
-    # Optionally disable Claude features or raise an error
-if not YOUR_OPENAI_TOKEN:
-    logger.warning("OPENAI_API_KEY is not set. OpenAI API calls will fail.")
-    # Optionally disable OpenAI features or raise an error
-
-# Initialize clients, handle potential errors during initialization
-try:
-    claude_client = anthropic.Anthropic(api_key=YOUR_ANTHROPIC_TOKEN) if YOUR_ANTHROPIC_TOKEN else None
-except Exception as e:
-    logger.error(f"Failed to initialize Anthropic client: {e}")
-    claude_client = None
-
-try:
-    openai_client = openai.OpenAI(api_key=YOUR_OPENAI_TOKEN) if YOUR_OPENAI_TOKEN else None
-except Exception as e:
-    logger.error(f"Failed to initialize OpenAI client: {e}")
-    openai_client = None
-
-
-async def try_claude_api(system_message, claude_messages, timeout=30): # Increased timeout
-    """
-    Claude API 호출 (스트리밍) - 코드 길이 제한 강화 및 에러 핸들링
-    """
-    if not claude_client:
-        logger.error("Claude client not initialized. Cannot call API.")
-        raise ConnectionError("Claude client not available.")
-
-    try:
-        # Ensure system message has the length constraint
-        system_message_with_limit = system_message + "\n\n추가 중요 지침: 생성하는 코드는 절대로 600줄을 넘지 마세요. 코드 간결성이 최우선입니다. 주석을 최소화하고, 핵심 기능만 구현하세요."
-
-        start_time = time.time()
-        logger.debug(f"Calling Claude API. System prompt length: {len(system_message_with_limit)}, Messages count: {len(claude_messages)}")
-
-        # Filter out empty messages just before API call
-        valid_claude_messages = [msg for msg in claude_messages if msg.get("content", "").strip()]
-        if not valid_claude_messages:
-             logger.warning("No valid messages to send to Claude API after filtering.")
-             raise ValueError("No content provided for Claude API call.")
-
-        async with claude_client.messages.stream(
-            model="claude-3-5-sonnet-20240620", # Use the latest Sonnet model
-            max_tokens=4000, # Adjusted max_tokens based on model limits and typical game code size
-            system=system_message_with_limit,
-            messages=valid_claude_messages,
-            temperature=0.3,
-        ) as stream:
-            collected_content = ""
-            async for chunk in stream:
-                current_time = time.time()
-                if current_time - start_time > timeout:
-                    logger.warning("Claude API call timed out.")
-                    raise TimeoutError(f"Claude API timeout after {timeout} seconds")
-
-                if chunk.type == "content_block_delta" and hasattr(chunk, 'delta') and hasattr(chunk.delta, 'text'):
-                    collected_content += chunk.delta.text
-                    yield collected_content
-                    # No sleep needed here, await stream handles it
-                elif chunk.type == "message_stop":
-                    logger.debug("Claude stream finished.")
-                    break # Explicitly break on stop event
-                # Add handling for other chunk types if necessary (e.g., errors)
-                elif chunk.type == "error":
-                     logger.error(f"Claude API stream error: {chunk.error}")
-                     raise anthropic.APIError(f"Claude stream error: {chunk.error}")
-
-
-            # Ensure final content is yielded if stream ends without a final delta
-            # yield collected_content # This might yield duplicate final content, handled by loop structure
-
-    except anthropic.APIConnectionError as e:
-        logger.error(f"Claude API connection error: {e}")
-        raise ConnectionError(f"Failed to connect to Anthropic API: {e}")
-    except anthropic.RateLimitError as e:
-        logger.error(f"Claude API rate limit exceeded: {e}")
-        raise ConnectionAbortedError(f"Anthropic API rate limit hit: {e}")
-    except anthropic.APIStatusError as e:
-        logger.error(f"Claude API status error: {e.status_code} - {e.response}")
-        raise ConnectionRefusedError(f"Anthropic API error ({e.status_code}): {e.message}")
-    except TimeoutError as e:
-        # Already logged above
-         raise e
-    except Exception as e:
-        logger.error(f"Unexpected error during Claude API call: {e}", exc_info=True)
-        raise RuntimeError(f"An unexpected error occurred with Claude API: {e}")
-
-async def try_openai_api(openai_messages, timeout=30): # Added timeout
-    """
-    OpenAI API 호출 (스트리밍) - 코드 길이 제한 강화 및 에러 핸들링
-    """
-    if not openai_client:
-        logger.error("OpenAI client not initialized. Cannot call API.")
-        raise ConnectionError("OpenAI client not available.")
-
-    try:
-        # Ensure system message has the length constraint if present
-        if openai_messages and openai_messages[0]["role"] == "system":
-            openai_messages[0]["content"] += "\n\n추가 중요 지침: 생성하는 코드는 절대로 600줄을 넘지 마세요. 코드 간결성이 최우선입니다. 주석은 최소화하고, 핵심 기능만 구현하세요."
-            system_prompt_length = len(openai_messages[0]["content"])
-        else:
-            # Add system message if missing? Or handle differently? Assuming it should exist.
-            logger.warning("OpenAI messages do not start with a system role.")
-            system_prompt_length = 0
-
-
-        logger.debug(f"Calling OpenAI API (gpt-4o-mini). System prompt length: {system_prompt_length}, Messages count: {len(openai_messages)}")
-
-        # Filter out empty messages just before API call
-        valid_openai_messages = [msg for msg in openai_messages if msg.get("content", "").strip()]
-        if not valid_openai_messages:
-             logger.warning("No valid messages to send to OpenAI API after filtering.")
-             raise ValueError("No content provided for OpenAI API call.")
-
-
-        stream = await asyncio.to_thread( # Use asyncio.to_thread for blocking sync call
-            openai_client.chat.completions.create,
-            model="gpt-4o-mini", # Use a faster/cheaper model if appropriate
-            messages=valid_openai_messages,
-            stream=True,
-            max_tokens=4000, # Adjusted
-            temperature=0.2,
-            timeout=timeout # Pass timeout to the API call itself
-        )
-
-        collected_content = ""
-        # Iterate over the stream (sync iterator needs to be handled carefully in async)
-        # This part might need adjustment depending on how the sync stream behaves in `asyncio.to_thread`
-        # A simple loop might block. Consider processing the stream differently if needed.
-        # For simplicity, assuming the sync iterator works okay here, but watch for blocking.
-        for chunk in stream:
-            if chunk.choices and chunk.choices[0].delta and chunk.choices[0].delta.content is not None:
-                collected_content += chunk.choices[0].delta.content
-                yield collected_content
-                # await asyncio.sleep(0) # Allow other tasks to run
-            # Handle finish reason if needed
-            if chunk.choices and chunk.choices[0].finish_reason:
-                 logger.debug(f"OpenAI stream finished. Reason: {chunk.choices[0].finish_reason}")
-                 break
-
-        # yield collected_content # Yield final content if needed (handled by loop)
-
-    except openai.APIConnectionError as e:
-        logger.error(f"OpenAI API connection error: {e}")
-        raise ConnectionError(f"Failed to connect to OpenAI API: {e}")
-    except openai.RateLimitError as e:
-        logger.error(f"OpenAI API rate limit exceeded: {e}")
-        raise ConnectionAbortedError(f"OpenAI API rate limit hit: {e}")
-    except openai.APIStatusError as e:
-        logger.error(f"OpenAI API status error: {e.status_code} - {e.response}")
-        raise ConnectionRefusedError(f"OpenAI API error ({e.status_code}): {e.message}")
-    except openai.APITimeoutError as e:
-         logger.warning(f"OpenAI API call timed out: {e}")
-         raise TimeoutError(f"OpenAI API timeout: {e}")
-    except Exception as e:
-        logger.error(f"Unexpected error during OpenAI API call: {e}", exc_info=True)
-        raise RuntimeError(f"An unexpected error occurred with OpenAI API: {e}")
-
-
-# ------------------------
-# 4) 템플릿(하나로 통합)
-# ------------------------
-# (load_json_data, create_template_html, load_all_templates remain the same)
-def load_json_data():
-    data_list = []
-    for item in DEMO_LIST:
-        data_list.append({
-            "name": f"[게임] {item['description'][:20]}...",
-            "prompt": item['description']
-        })
-    return data_list
-
-def create_template_html(title, items):
-    """
-    이미지 없이 템플릿 HTML 생성
-    """
-    html_content = r"""
-<style>
-.prompt-grid {
-    display: grid;
-    grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
-    gap: 16px;
-    padding: 12px;
-}
-.prompt-card {
-    background: white;
-    border: 1px solid #eee;
-    border-radius: 12px;
-    padding: 12px;
-    cursor: pointer;
-    box-shadow: 0 4px 8px rgba(0,0,0,0.05);
-    transition: all 0.3s ease;
-    height: 150px; /* Fixed height */
-    display: flex; /* Use flexbox for layout */
-    flex-direction: column; /* Stack elements vertically */
-}
-.prompt-card:hover {
-    transform: translateY(-4px);
-    box-shadow: 0 6px 12px rgba(0,0,0,0.1);
-}
-.card-name {
-    font-weight: bold;
-    margin-bottom: 8px;
-    font-size: 13px;
-    color: #444;
-    flex-shrink: 0; /* Prevent name from shrinking */
-}
-.card-prompt-wrapper {
-    flex-grow: 1; /* Allow prompt wrapper to take remaining space */
-    overflow: hidden; /* Hide overflow */
-    background-color: #f8f9fa;
-    padding: 8px;
-    border-radius: 6px;
-    height: 100%; /* Ensure it tries to fill parent */
-}
-.card-prompt {
-    font-size: 11px;
-    line-height: 1.4;
-    color: #666;
-    display: -webkit-box;
-    -webkit-line-clamp: 5; /* Adjust line clamp based on fixed height */
-    -webkit-box-orient: vertical;
-    overflow: hidden;
-    /* height: 84px; Removed fixed height here */
-    max-height: 100%; /* Allow it to fill the wrapper */
-}
-</style>
-<div class="prompt-grid">
-"""
-    # Use html.escape for security
-    for item in items:
-        escaped_prompt = html.escape(item.get('prompt', ''))
-        escaped_name = html.escape(item.get('name', ''))
-        card_html = f"""
-<div class="prompt-card" onclick="copyToInput(this)" data-prompt="{escaped_prompt}">
-    <div class="card-name">{escaped_name}</div>
-    <div class="card-prompt-wrapper">
-        <div class="card-prompt">{escaped_prompt}</div>
-    </div>
-</div>
-"""
-        html_content += card_html
-    html_content += r"""
-</div>
-<script>
-function copyToInput(card) {
-    const prompt = card.dataset.prompt;
-    // More robust selector targeting the specific textarea within the input panel
-    const textarea = document.querySelector('.input-panel .ant-input-textarea-large textarea');
-    if (textarea) {
-        textarea.value = prompt;
-        // Ensure the input event triggers potential state updates in Gradio/React
-        textarea.dispatchEvent(new Event('input', { bubbles: true }));
-        textarea.dispatchEvent(new Event('change', { bubbles: true })); // Add change event too
-
-        // Close the drawer - find the close button more reliably
-        const drawer = card.closest('.ant-drawer'); // Find the parent drawer
-        if (drawer) {
-             // Find the close button *within* that specific drawer's header
-            const closeButton = drawer.querySelector('.ant-drawer-header .ant-drawer-close');
-             if (closeButton) {
-                 closeButton.click();
-             } else {
-                 console.warn('Could not find the close button for the template drawer.');
-                 // Fallback for the original selector if needed, though less reliable
-                 const fallbackCloseBtn = document.querySelector('.session-drawer .close-btn');
-                 if(fallbackCloseBtn) fallbackCloseBtn.click();
-             }
-        } else {
-             console.warn('Could not find the parent drawer for the template card.');
-        }
-    } else {
-        console.error('Could not find the target textarea.');
-        alert('입력 영역을 찾을 수 없습니다.'); // User feedback
-    }
-}
-</script>
-"""
-    # Use gr.HTML to render the content safely
-    return gr.HTML(value=html_content)
-
-
-def load_all_templates():
-    return create_template_html("🎮 모든 게임 템플릿", load_json_data())
-
-
-# ------------------------
-# 5) 배포/부스트/기타 유틸
-# ------------------------
-
-def remove_code_block(text: Optional[str]) -> str:
-    """Extracts code from Markdown code blocks (html, js, css, or generic)."""
-    if not text:
-        return ""
-    
-    # Pattern for ```html ... ```
-    pattern_html = r'```html\s*([\s\S]+?)\s*```'
-    match_html = re.search(pattern_html, text, re.DOTALL | re.IGNORECASE)
-    if match_html:
-        logger.debug("Extracted code using ```html block.")
-        return match_html.group(1).strip()
-
-    # Pattern for ```javascript ... ``` or ```js ... ```
-    pattern_js = r'```(?:javascript|js)\s*([\s\S]+?)\s*```'
-    match_js = re.search(pattern_js, text, re.DOTALL | re.IGNORECASE)
-    if match_js:
-        logger.debug("Extracted code using ```javascript/js block.")
-        # If it's just JS, wrap it in basic HTML for execution
-        js_code = match_js.group(1).strip()
-        return f"""<!DOCTYPE html>
-<html>
-<head><meta charset="UTF-8"><title>JS Code</title></head>
-<body><script>{js_code}</script></body>
-</html>"""
-
-    # Pattern for ```css ... ```
-    pattern_css = r'```css\s*([\s\S]+?)\s*```'
-    match_css = re.search(pattern_css, text, re.DOTALL | re.IGNORECASE)
-    if match_css:
-        logger.debug("Extracted code using ```css block.")
-        # If it's just CSS, wrap it in basic HTML
-        css_code = match_css.group(1).strip()
-        return f"""<!DOCTYPE html>
-<html>
-<head><meta charset="UTF-8"><title>CSS Code</title><style>{css_code}</style></head>
-<body><p>CSS Only Preview</p></body>
-</html>"""
-
-    # Generic pattern for ``` ... ``` (if specific language blocks fail)
-    pattern_generic = r'```(?:\w+)?\s*([\s\S]+?)\s*```'
-    match_generic = re.search(pattern_generic, text, re.DOTALL)
-    if match_generic:
-        logger.debug("Extracted code using generic ``` block.")
-        # Assume it's HTML if it looks like it, otherwise wrap JS/CSS or return as is?
-        # Let's assume HTML for now if it contains tags
-        potential_code = match_generic.group(1).strip()
-        if '<' in potential_code and '>' in potential_code:
-             return potential_code
-        else:
-             # Could be JS, CSS, or something else. Defaulting to HTML wrap for safety.
-             return f"""<!DOCTYPE html>
-<html>
-<head><meta charset="UTF-8"><title>Code Preview</title></head>
-<body><pre><code>{html.escape(potential_code)}</code></pre></body>
-</html>"""
-
-
-    # If no code blocks found, check if the text itself looks like HTML
-    text_stripped = text.strip()
-    if text_stripped.startswith('<!DOCTYPE') or text_stripped.startswith('<html') or (text_stripped.startswith('<') and text_stripped.endswith('>')):
-        logger.debug("Assuming the entire input is HTML code (no code blocks found).")
-        return text_stripped
-
-    logger.debug("No code blocks found, and input doesn't look like HTML. Returning original text.")
-    # Return empty string if no code is likely present, or the original text?
-    # Returning empty might be safer if the expectation is code extraction.
-    return "" # Or return text if raw text might be intended
-
-
-def optimize_code(code: str) -> str:
-    # (Optimization logic remains the same, ensure it handles empty input)
-    if not code or len(code.strip()) == 0:
-        return ""
-
-    logger.debug(f"Optimizing code (initial length: {len(code)})")
-    lines = code.split('\n')
-    # No need to check length here, optimize regardless
-
-    # Remove comments more carefully
-    def remove_comments(line):
-        line = re.sub(r'//.*$', '', line) # Remove // comments
-        line = re.sub(r'/\*.*?\*/', '', line) # Remove /* */ comments on same line
-        return line
-
-    # Remove multi-line /* */ comments
-    code = re.sub(r'/\*[\s\S]*?\*/', '', code, flags=re.MULTILINE)
-    # Remove <!-- --> comments
-    code = re.sub(r'<!--[\s\S]*?-->', '', code, flags=re.MULTILINE)
-
-    cleaned_lines = []
-    empty_line_count = 0
-    for line in code.split('\n'):
-        line = remove_comments(line).strip() # Remove single-line comments and strip whitespace
-        if line == '':
-            empty_line_count += 1
-            if empty_line_count <= 1: # Allow at most one consecutive empty line
-                cleaned_lines.append('')
-        else:
-            empty_line_count = 0
-            # Remove console.log statements
-            line = re.sub(r'console\.log\(.*?\);?', '', line)
-            # Reduce multiple spaces to single space (be careful not to break strings)
-            # This is risky, might be better to skip unless absolutely necessary
-            # line = re.sub(r' {2,}', ' ', line)
-            if line: # Add line only if it's not empty after cleaning
-                cleaned_lines.append(line)
-
-    cleaned_code = '\n'.join(cleaned_lines).strip()
-    logger.debug(f"Optimized code length: {len(cleaned_code)}")
-    return cleaned_code
-
-def send_to_sandbox(code):
-    """Encodes HTML code for display in an iframe sandbox."""
-    logger.debug(f"Preparing code for sandbox (length: {len(code)})")
-    # No need to call remove_code_block here, assume input is already cleaned code
-    # clean_code = remove_code_block(code) # Remove this line
-    clean_code = optimize_code(code) # Optimize the already extracted code
-
-    if not clean_code.strip():
-        logger.warning("Cannot send empty code to sandbox.")
-        # Return an empty iframe or an error message?
-        return "<p style='color: red;'>No code to display in sandbox.</p>"
-
-    # Basic HTML structure check and wrapping
-    if not re.search(r'<!DOCTYPE html>', clean_code, re.IGNORECASE) and not re.search(r'<html.*?>', clean_code, re.IGNORECASE):
-        logger.debug("Wrapping code in basic HTML structure for sandbox.")
-        # Check if body tags exist, if not, wrap the whole thing
-        if not re.search(r'<body.*?>', clean_code, re.IGNORECASE):
-            # --- 수정된 부분: f-string 내 주석 제거 ---
-            clean_code = f"""<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Game Preview</title>
-    <style>body {{ margin: 0; overflow: hidden; }}</style>
-</head>
-<body>
-{clean_code}
-</body>
-</html>"""
-            # --- 수정 끝 ---
-        else:
-             # If body exists, just ensure doctype and html/head are present
-             # --- 수정된 부분: f-string 내 주석 제거 (else 블록도 확인) ---
-             clean_code = f"""<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Game Preview</title>
-     <style>body {{ margin: 0; overflow: hidden; }}</style>
-</head>
-{clean_code}
-</html>"""
-             # --- 수정 끝 ---
-
-
-    try:
-        # Encode the final HTML
-        encoded_html = base64.b64encode(clean_code.encode('utf-8')).decode('utf-8')
-        data_uri = f"data:text/html;charset=utf-8;base64,{encoded_html}"
-        # Define sandbox attributes for security
-        sandbox_attributes = "allow-scripts allow-same-origin allow-forms" # Allow necessary permissions
-        iframe_html = f'<iframe src="{data_uri}" width="100%" height="920px" style="border:none;" sandbox="{sandbox_attributes}"></iframe>'
-        logger.debug("Sandbox iframe HTML generated.")
-        return iframe_html
-    except Exception as e:
-        logger.error(f"Error encoding HTML for sandbox: {e}", exc_info=True)
-        return f"<p style='color: red;'>Error creating sandbox preview: {html.escape(str(e))}</p>"
-        
-
-
-
-def boost_prompt(prompt: str) -> str:
-    # (Boost prompt logic remains the same, ensure API clients are checked)
-    if not prompt:
-        return ""
-
-    boost_system_prompt = """당신은 웹 게임 개발 프롬프트 전문가입니다.
-주어진 프롬프트를 분석하여 더 명확하고 간결한 요구사항으로 변환하되,
-원래 의도와 목적은 그대로 유지하면서 다음 관점들을 고려하여 증강하십시오:
-
-1. 게임플레이 핵심 메커니즘 명확히 정의 (1-2 문장)
-2. 필수적인 상호작용 요소만 포함 (예: 키보드 조작, 클릭)
-3. 핵심 UI 요소 간략히 기술 (예: 점수 표시, 게임 영역)
-4. 코드 간결성 유지를 위한 우선순위 설정 (가장 중요한 기능 1-2가지 명시)
-5. 기본적인 게임 규칙과 승리/패배 조건 명시 (간단하게)
-
-다음 중요 지침을 반드시 준수하세요:
-- 불필요한 세부 사항이나 부가 기능은 제외 (예: 사운드, 애니메이션, 레벨 디자인 복잡화)
-- 생성될 코드가 600줄을 넘지 않도록 기능을 제한
-- 명확하고 간결한 언어로 요구사항 작성 (총 5-7 문장 이내)
-- 최소한의 필수 게임 요소만 포함
-- 최종 결과는 증강된 프롬프트 텍스트만 반환 (추가 설명 없이)
-"""
-    logger.debug(f"Boosting prompt: {prompt[:100]}...")
-    boosted_prompt = prompt # Default to original if APIs fail
-
-    try:
-        if claude_client:
-            logger.debug("Attempting boost with Claude.")
-            response = claude_client.messages.create(
-                model="claude-3-haiku-20240307", # Use Haiku for faster/cheaper boosting
-                max_tokens=500, # Reduced max_tokens for concise output
-                temperature=0.2, # Lower temperature for more focused output
-                messages=[{
-                    "role": "user",
-                    "content": f"다음 게임 프롬프트를 분석하고 위의 지침에 따라 간결하게 증강하세요:\n\n{prompt}"
-                }],
-                system=boost_system_prompt
-            )
-            if response.content and len(response.content) > 0 and hasattr(response.content[0], 'text'):
-                boosted_prompt = response.content[0].text.strip()
-                logger.debug(f"Claude boosted prompt: {boosted_prompt[:100]}...")
-                return boosted_prompt
-            else:
-                 logger.warning("Claude boost response format unexpected.")
-                 raise anthropic.APIError("Invalid response format from Claude.") # Trigger fallback
-
-        elif openai_client:
-            logger.debug("Claude failed or unavailable, attempting boost with OpenAI.")
-            completion = openai_client.chat.completions.create(
-                model="gpt-3.5-turbo", # Use a cheaper/faster model for boosting
-                messages=[
-                    {"role": "system", "content": boost_system_prompt},
-                    {"role": "user", "content": f"다음 게임 프롬프트를 분석하고 위의 지침에 따라 간결하게 증강하세요:\n\n{prompt}"}
-                ],
-                max_tokens=500, # Reduced
-                temperature=0.2 # Lowered
-            )
-            if completion.choices and len(completion.choices) > 0 and completion.choices[0].message:
-                boosted_prompt = completion.choices[0].message.content.strip()
-                logger.debug(f"OpenAI boosted prompt: {boosted_prompt[:100]}...")
-                return boosted_prompt
-            else:
-                 logger.warning("OpenAI boost response format unexpected.")
-                 # Fall through to return original prompt
-
-        else:
-            logger.warning("Neither Claude nor OpenAI client available for boosting.")
-            # Fall through to return original prompt
-
-    except Exception as e:
-        logger.error(f"Error during prompt boosting: {e}", exc_info=True)
-        # Fall through to return original prompt
-
-    logger.debug("Boosting failed or skipped, returning original prompt.")
-    return boosted_prompt # Return original if all attempts fail
-
-
-def handle_boost(prompt: str):
-    """Handles the boost button click event."""
-    logger.info("Boost button clicked.")
-    if not prompt or not prompt.strip():
-        logger.warning("Boost requested for empty prompt.")
-        # Return original empty prompt and don't change tab state
-        return "", gr.update() # Use gr.update() for no change
-
-    try:
-        boosted = boost_prompt(prompt)
-        # Return the boosted prompt to the input textarea
-        # Keep the active tab as is (don't switch to empty)
-        return boosted, gr.update() # Use gr.update() for no change to the tab state
-    except Exception as e:
-        logger.error(f"Error in handle_boost: {e}", exc_info=True)
-        # Return the original prompt in case of error, maybe show a notification?
-        # For now, just return original prompt
-        return prompt, gr.update()
-
-
-def history_render(history: History):
-    """Prepares history for display in the chatbot component."""
-    logger.debug(f"Rendering history. Number of turns: {len(history)}")
-    # The history format should already be correct for the legacy.Chatbot
-    # Just need to trigger the drawer opening
-    return gr.update(open=True), history
-
-
-def execute_code(query: str):
-    """Handles the 'Code' (Execute) button click."""
-    logger.info("Execute code button clicked.")
-    if not query or not query.strip():
-        logger.warning("Execute code requested for empty input.")
-        return None, gr.update(active_key="empty") # Stay on empty tab
-
-    try:
-        # Extract code first
-        clean_code = remove_code_block(query)
-        logger.debug(f"Code extracted for execution (length: {len(clean_code)})")
-
-        if not clean_code or not clean_code.strip():
-             logger.warning("No valid code found in input to execute.")
-             # Maybe return an error message in the sandbox?
-             error_html = "<p style='color:orange;'>입력에서 실행할 코드를 찾을 수 없습니다. 코드 블록(```html ... ```) 안에 코드를 넣어보세요.</p>"
-             return error_html, gr.update(active_key="render") # Show error in render tab
-
-        # Send the extracted code to the sandbox
-        sandbox_html = send_to_sandbox(clean_code)
-        logger.debug("Switching tab to 'render' for code execution.")
-        return sandbox_html, gr.update(active_key="render")
-
-    except Exception as e:
-        logger.error(f"Error during execute_code: {e}", exc_info=True)
-        error_html = f"<p style='color: red;'>코드 실행 중 오류 발생: {html.escape(str(e))}</p>"
-        # Show error message in the render tab
-        return error_html, gr.update(active_key="render")
-
-
-# ------------------------
-# 6) 데모 클래스
-# ------------------------
-
-class Demo:
-    def __init__(self):
-        pass # No state needed here for now
-
-    async def generation_code(self, query: Optional[str], _setting: Dict[str, str], _history: Optional[History]):
-        """Generates game code based on user query and history."""
-        logger.info(f"Generation request received. Query: '{query[:50]}...', History length: {len(_history) if _history else 0}")
-
-        # Handle empty query - use random demo
-        if not query or not query.strip():
-            logger.info("Empty query received, using random demo description.")
-            query = random.choice(DEMO_LIST)['description']
-            # Update the input field visually? Might be complex. For now, just use it internally.
-
-        # Initialize history if None
-        if _history is None:
-            _history = []
-            logger.debug("History was None, initialized to empty list.")
-
-        # Prepare the prompt with constraints
-        # Reduced line count constraint slightly for flexibility
-        constrained_query = f"""
-다음 게임을 제작해주세요.
-중요 요구사항:
-1. 코드는 HTML, CSS, JavaScript 만을 사용하여 단일 HTML 파일로 작성해주세요.
-2. 모든 코드는 `<script>` 와 `<style>` 태그를 포함하여 HTML 파일 내부에 인라인으로 작성해야 합니다. 외부 파일 참조는 금지합니다.
-3. 코드는 가능한 한 간결하게 작성하고, 불필요한 주석, 설명, 공백 라인은 최소화해주세요.
-4. 생성되는 총 코드 라인 수는 **600줄**을 넘지 않도록 엄격히 제한합니다. (HTML, CSS, JS 포함)
-5. 게임의 핵심 기능만 구현하고, 복잡한 애니메이션, 사운드, 여러 레벨 등 부가 기능은 생략해주세요.
-6. 라이브러리나 프레임워크 사용 없이 바닐라 JavaScript (ES6+)를 사용해주세요.
-7. 즉시 실행 가능한 완전한 HTML 코드만 생성하고, 코드 앞뒤에 설명이나 ```html 같은 마크다운 표시는 절대 포함하지 마세요.
-
-게임 요청:
-{query}
-"""
-        logger.debug(f"Prepared constrained query for LLM.")
-
-        # Prepare messages for APIs
-        try:
-            messages = history_to_messages(_history, _setting.get('system', SystemPrompt)) # Use default if missing
-            system_message = messages[0]['content']
-
-            # Claude messages (User/Assistant roles only)
-            claude_messages = []
-            for msg in messages[1:]: # Skip system message
-                # Ensure content exists before adding
-                if msg.get("content", "").strip():
-                    claude_messages.append({"role": msg["role"], "content": msg["content"]})
-            # Add the current user query
-            claude_messages.append({'role': Role.USER, 'content': constrained_query})
-
-            # OpenAI messages (System + User/Assistant)
-            openai_messages = [{"role": "system", "content": system_message}]
-            for msg in messages[1:]: # Skip system message
-                 if msg.get("content", "").strip():
-                    openai_messages.append({"role": msg["role"], "content": msg["content"]})
-            openai_messages.append({"role": "user", "content": constrained_query})
-
-            logger.debug(f"Prepared messages. Claude: {len(claude_messages)}, OpenAI: {len(openai_messages)}")
-
-        except Exception as e:
-            logger.error(f"Error preparing messages: {e}", exc_info=True)
-            yield [
-                f"Error preparing messages: {html.escape(str(e))}",
-                _history,
-                None,
-                gr.update(active_key="empty"),
-                gr.update(open=False) # Keep code drawer closed on error
-            ]
-            return # Stop generation
-
-        # Initial UI update: Show loading state
-        yield [
-            "⏳ 게임 코드 생성 시작...", # Initial message in code view
-            _history,
-            None, # No sandbox content yet
-            gr.update(active_key="loading"), # Switch to loading tab
-            gr.update(open=True) # Open code drawer to show progress
-        ]
-        await asyncio.sleep(0.1) # Allow UI to update
-
-        collected_content = None
-        error_message = None
-        api_used = None
-
-        # Try Claude first
-        if claude_client:
-            try:
-                logger.info("Attempting code generation with Claude...")
-                api_used = "Claude"
-                # Use async for loop correctly
-                async for content_chunk in try_claude_api(system_message, claude_messages):
-                    collected_content = content_chunk # Update collected content with each chunk
-                    yield [
-                        f"```html\n{collected_content}\n```", # Show streaming progress in code block
-                        _history,
-                        None,
-                        gr.update(active_key="loading"),
-                        gr.update(open=True)
-                    ]
-                    # No sleep needed, handled by async iterator
-                logger.info("Claude generation successful.")
-
-            except Exception as e:
-                logger.warning(f"Claude API failed: {e}", exc_info=False) # Log less verbosely for expected fallbacks
-                error_message = f"Claude API Error: {e}"
-                collected_content = None # Reset content on error
-
-        # Fallback to OpenAI if Claude failed or is unavailable
-        if collected_content is None and openai_client:
-            logger.info("Falling back to OpenAI for code generation...")
-            api_used = "OpenAI"
-            error_message = None # Clear previous error
-            try:
-                 # Use async for loop correctly
-                async for content_chunk in try_openai_api(openai_messages):
-                    collected_content = content_chunk # Update collected content
-                    yield [
-                        f"```html\n{collected_content}\n```", # Show streaming progress
-                        _history,
-                        None,
-                        gr.update(active_key="loading"),
-                        gr.update(open=True)
-                    ]
-                    # No sleep needed
-                logger.info("OpenAI generation successful.")
-
-            except Exception as e:
-                logger.error(f"OpenAI API also failed: {e}", exc_info=True)
-                error_message = f"OpenAI API Error: {e}. Both APIs failed."
-                collected_content = None
-
-        # Process the final result
-        if collected_content:
-            logger.info(f"Code generation completed using {api_used}. Final content length: {len(collected_content)}")
-            # Clean the final generated code (remove potential markdown fences if LLM added them)
-            final_code = remove_code_block(collected_content)
-            if not final_code: # If remove_code_block failed or LLM output was just markdown
-                 final_code = collected_content # Use raw content as fallback
-
-            # Validate code length (using the raw code before optimization for check)
-            code_lines = final_code.count('\n') + 1
-            # Increased limit slightly based on system prompt
-            line_limit = 700
-            if code_lines > line_limit:
-                logger.warning(f"Generated code is too long: {code_lines} lines (limit: {line_limit}).")
-                warning_msg = f"""
-⚠️ **경고: 생성된 코드가 너무 깁니다 ({code_lines}줄 / {line_limit}줄 제한)**
-코드가 너무 길어 브라우저에서 느리거나 오류가 발생할 수 있습니다.
-더 간결한 게임을 요청하거나, "코드" 버튼으로 직접 실행해보세요.
-
-```html
-{html.escape(final_code[:2000])}
-... (코드가 너무 길어 일부만 표시) ...
-```"""
-                # Update history with the failure/warning? Or just show warning?
-                # Let's just show the warning in the code output for now.
-                yield [
-                    warning_msg,
-                    _history, # History remains unchanged on length warning
-                    None, # No sandbox for overly long code
-                    gr.update(active_key="empty"), # Go back to empty state
-                    gr.update(open=True) # Keep code drawer open to show warning
-                ]
-            else:
-                # Success: Update history and show code + sandbox
-                logger.info("Code length within limits. Preparing final output.")
-                # Prepare messages for history update (use the *original* query, not constrained one)
-                messages_for_history = messages + [{'role': Role.USER, 'content': query}, {'role': Role.ASSISTANT, 'content': final_code}]
-                _updated_history = messages_to_history(messages_for_history)
-
-                # Send final, cleaned code to sandbox
-                sandbox_html = send_to_sandbox(final_code)
-
-                yield [
-                    f"```html\n{final_code}\n```", # Show final code in code block
-                    _updated_history,
-                    sandbox_html, # Render in sandbox
-                    gr.update(active_key="render"), # Switch to render tab
-                    gr.update(open=True) # Keep code drawer open
-                ]
-        else:
-            # Both APIs failed
-            logger.error(f"Code generation failed using both APIs. Last error: {error_message}")
-            yield [
-                f"❌ 코드 생성 실패: {html.escape(error_message)}",
-                _history, # History remains unchanged on failure
-                None,
-                gr.update(active_key="empty"),
-                gr.update(open=False) # Close drawer on total failure
-            ]
-
-    def clear_history(self):
-        """Clears the conversation history."""
-        logger.info("Clear history called.")
-        # Also clear the code output and sandbox, and reset tabs
-        return (
-            [],                             # Cleared history state
-            "",                             # Clear code output
-            None,                           # Clear sandbox
-            gr.update(active_key="empty"),  # Reset tab to empty
-            gr.update(open=False),          # Close code drawer
-            gr.update(value=""),            # Clear input text
-            gr.update(value="배포 결과가 여기에 표시됩니다.") # Reset deploy result
-        )
-
-
-####################################################
-# Vercel Deployment Functions
-####################################################
-def deploy_to_vercel(code: str):
-    """Deploys the given HTML code to Vercel."""
-    logger.info(f"[deploy_to_vercel] Attempting deployment. Code length: {len(code)}")
-    vercel_token = os.getenv("VERCEL_API_TOKEN", "A8IFZmgW2cqA4yUNlLPnci0N") # Use env var first
-
-    if not vercel_token:
-        logger.error("[deploy_to_vercel] Vercel API token (VERCEL_API_TOKEN or hardcoded) not found.")
-        return "⚠️ **배포 실패:** Vercel API 토큰이 설정되지 않았습니다."
-
-    if not code or len(code.strip()) < 50: # Increased minimum length
-        logger.warning("[deploy_to_vercel] Code is too short or empty for deployment.")
-        return "⚠️ **배포 실패:** 배포할 코드가 너무 짧습니다 (최소 50자 필요)."
-
-    # Ensure code is wrapped in basic HTML if it isn't already
-    if not re.search(r'<!DOCTYPE html>', code, re.IGNORECASE) and not re.search(r'<html.*?>', code, re.IGNORECASE):
-        logger.debug("[deploy_to_vercel] Wrapping raw code in basic HTML structure for deployment.")
-        code = f"""<!DOCTYPE html>
-<html lang="en">
-<head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>Deployed Game</title></head>
-<body>{code}</body>
-</html>"""
-
-    project_name = 'gamecraft-' + ''.join(random.choices(string.ascii_lowercase + string.digits, k=8))
-    logger.info(f"[deploy_to_vercel] Generated project name: {project_name}")
-
-    deploy_url = "https://api.vercel.com/v13/deployments"
-    headers = {
-        "Authorization": f"Bearer {vercel_token}",
-        "Content-Type": "application/json"
-    }
-
-    # Define files for deployment (only index.html needed for simple static deployment)
-    files = [
-        {"file": "index.html", "data": code}
-    ]
-
-    # Define deployment data (simpler structure for static deployment)
-    deploy_data = {
-        "name": project_name,
-        "files": files,
-        "target": "production",
-         # Specify project settings to ensure it's treated as static
-        "projectSettings": {
-            "framework": None, # Explicitly set to null for static
-            "outputDirectory": None # Not needed if deploying files directly
-        }
-    }
-
-    try:
-        logger.debug("[deploy_to_vercel] Sending deployment request to Vercel API...")
-        deploy_response = requests.post(deploy_url, headers=headers, json=deploy_data, timeout=90) # Increased timeout
-        logger.debug(f"[deploy_to_vercel] Vercel API response status: {deploy_response.status_code}")
-
-        response_data = {}
-        try:
-            response_data = deploy_response.json()
-        except json.JSONDecodeError:
-            logger.warning("[deploy_to_vercel] Vercel response was not valid JSON.")
-
-        if deploy_response.status_code not in [200, 201]: # Vercel might return 201 Created
-            error_message = response_data.get('error', {}).get('message', deploy_response.text)
-            logger.error(f"[deploy_to_vercel] Deployment failed: {deploy_response.status_code} - {error_message}")
-            # Limit error message length shown to user
-            return f"⚠️ **배포 실패:** Vercel API 오류 ({deploy_response.status_code}).\n```\n{html.escape(error_message[:500])}\n```"
-
-        # Extract the deployment URL from the response
-        deployment_url = response_data.get('url')
-        if not deployment_url:
-             logger.error("[deploy_to_vercel] Deployment succeeded but URL not found in response.")
-             return "⚠️ **배포 실패:** 배포는 성공했지만 URL을 가져올 수 없습니다."
-
-        # Vercel usually adds https:// automatically, but ensure it's there
-        if not deployment_url.startswith(('http://', 'https://')):
-             deployment_url = f"https://{deployment_url}"
-
-        logger.info(f"[deploy_to_vercel] Deployment successful! URL: {deployment_url}")
-
-        # Return Markdown link
-        result_markdown = f"""
-✅ **배포 완료!**
-게임이 다음 주소에 배포되었습니다:
-[**{deployment_url}**]({deployment_url})
-
-*참고: 배포된 사이트가 활성화되기까지 몇 분 정도 소요될 수 있습니다.*
-"""
-        logger.debug("[deploy_to_vercel] Returning success Markdown.")
-        return result_markdown.strip() # Strip leading/trailing whitespace
-
-    except requests.exceptions.Timeout:
-        logger.error("[deploy_to_vercel] Request to Vercel API timed out.")
-        return "⚠️ **배포 실패:** Vercel API 요청 시간 초과."
-    except requests.exceptions.RequestException as e:
-        logger.error(f"[deploy_to_vercel] Network or Request Error: {e}", exc_info=True)
-        return f"⚠️ **배포 실패:** 네트워크 또는 요청 오류 발생.\n```\n{html.escape(str(e))}\n```"
-    except Exception as e:
-        logger.error(f"[deploy_to_vercel] Unexpected Error during deployment: {e}", exc_info=True)
-        return f"⚠️ **배포 실패:** 예상치 못한 오류 발생.\n```\n{html.escape(str(e))}\n```"
-
-
-def handle_deploy_click(code_output_value: Optional[str]):
-    """Handles the deploy button click event."""
-    logger.info("Deploy button clicked.")
-
-    # Add an immediate feedback message
-    yield "⏳ 배포를 시작합니다... Vercel API 호출 중..."
-
-    if not code_output_value:
-        logger.warning("[handle_deploy_click] No code available in code_output.")
-        yield "⚠️ **배포 실패:** 생성된 코드가 없습니다."
-        return
-
-    # Extract the actual code from the Markdown component's value
-    # The value might contain ```html ... ```, so remove it.
-    clean_code = remove_code_block(code_output_value)
-    logger.debug(f"[handle_deploy_click] Extracted code for deployment (length: {len(clean_code)}).")
-
-    if not clean_code or len(clean_code.strip()) < 50:
-        logger.warning("[handle_deploy_click] Cleaned code is too short for deployment.")
-        yield "⚠️ **배포 실패:** 배포할 유효한 코드가 부족합니다 (최소 50자 필요)."
-        return
-
-    # Call the deployment function
-    deployment_result = deploy_to_vercel(clean_code)
-    logger.info(f"[handle_deploy_click] Deployment result received.")
-
-    # Yield the final result to update the Markdown component
-    yield deployment_result
-
-
-# ------------------------
-# 8) Gradio / Modelscope UI 빌드
-# ------------------------
-demo_instance = Demo()
-theme = gr.themes.Soft(
-    primary_hue="blue",
-    secondary_hue="purple",
-    neutral_hue="slate",
-    spacing_size=gr.themes.sizes.spacing_md,
-    radius_size=gr.themes.sizes.radius_md,
-    text_size=gr.themes.sizes.text_md,
-)
-
-with gr.Blocks(css="app.css", theme=theme) as demo: # Use css parameter directly
-    # Removed header_html and integrated title/description into gr.Blocks or Markdown
-    gr.Markdown("""
-    <div class="app-header">
-        <h1>🎮 Vibe Game Craft</h1>
-        <p>설명을 입력하면 웹 기반 HTML5, JavaScript, CSS 게임을 생성합니다. 실시간 미리보기와 원클릭 배포 기능을 지원합니다.</p>
-    </div>
-    """, elem_classes="header-markdown") # Added class for potential styling
-
-    # State variables
-    history = gr.State([])
-    setting = gr.State({"system": SystemPrompt})
-    # Removed deploy_status state as we display directly in Markdown
-
-    with ms.Application() as app:
-        with antd.ConfigProvider(): # Provides context for Ant Design components
-
-            # Drawers for Code and History
-            with antd.Drawer(open=False, title="코드 보기", placement="left", width="50%") as code_drawer:
-                 # Use gr.Code for better syntax highlighting if legacy.Markdown causes issues
-                code_output = gr.Code(language="html", label="Generated Code", interactive=False)
-                # code_output = legacy.Markdown(elem_classes="code-output-markdown") # Keep if preferred
-
-            with antd.Drawer(open=False, title="히스토리", placement="left", width="60%") as history_drawer:
-                history_output = legacy.Chatbot(
-                    show_label=False,
-                    flushing=False, # Keep flushing false for standard updates
-                    height=800, # Adjust height as needed
-                    elem_classes="history_chatbot",
-                    show_copy_button=True # Add copy button to chat messages
-                )
-
-            # Drawer for Templates
-            with antd.Drawer(
-                open=False,
-                title="🎮 게임 템플릿",
-                placement="right",
-                width="60%", # Adjust width
-                elem_classes="session-drawer"
-            ) as session_drawer:
-
-
-                with antd.Flex(vertical=True, gap="middle"):
-                    # Use gr.HTML for the template display
-                    session_history_html = gr.HTML(elem_classes="session-history-html") # Renamed variable
-                    # Button inside the drawer to close it
-                    close_template_btn = antd.Button("닫기", type="default", elem_classes="close-btn")
-
-            # Main Layout (Row with two Columns)
-            with antd.Row(gutter=[16, 16], align="top", elem_classes="main-layout-row"): # Reduced gutter
-
-                # Left Column: Game Preview Area
-                with antd.Col(xs=24, sm=24, md=14, lg=15, xl=16, elem_classes="preview-column"): # Responsive spans
-                    with ms.Div(elem_classes="preview-panel panel"): # Use ms.Div or standard gr.Column/Group
-                        gr.HTML(r"""
-                        <div class="render_header">
-                            <span class="header_btn red"></span><span class="header_btn yellow"></span><span class="header_btn green"></span>
-                            <span class="render-title">Game Preview</span>
-                        </div>
-                        """, elem_classes="preview-header-html")
-                        # Tabs for different preview states
-                        with antd.Tabs(active_key="empty", render_tab_bar="() => null") as state_tab:
-                            with antd.Tabs.Item(key="empty"):
-                                antd.Empty(description="게임을 만들려면 설명을 입력하거나 템플릿을 선택하세요.", elem_classes="right_content")
-                            with antd.Tabs.Item(key="loading"):
-                                antd.Spin(True, tip="게임 코드 생성 중...", size="large", elem_classes="right_content")
-                            with antd.Tabs.Item(key="render"):
-                                # Use gr.HTML for the sandbox iframe
-                                sandbox = gr.HTML(elem_classes="html_content")
-
-
-
-                # Right Column: Controls and Input
-                with antd.Col(xs=24, sm=24, md=10, lg=9, xl=8, elem_classes="control-column"): # Responsive spans
-                    with antd.Flex(vertical=True, gap="middle", elem_classes="control-panel"): # Use Flex for vertical layout
-
-                        # Top Buttons (Code, History, Templates)
-                        with antd.Flex(gap="small", justify="space-between", elem_classes="top-buttons"):
-                            codeBtn = antd.Button("🧑‍💻 코드", type="default", icon="<i class='fas fa-code'></i>") # Use icon font if available or text
-                            historyBtn = antd.Button("📜 히스토리", type="default", icon="<i class='fas fa-history'></i>")
-                            template_btn = antd.Button("🎮 템플릿", type="default", icon="<i class='fas fa-gamepad'></i>")
-
-
-
-
-                        input_text = antd.InputTextarea(
-                            size="large",
-                            allow_clear=True,
-                            placeholder="예: 벽돌깨기 게임 만들어줘 (간단하게)", # Shorter placeholder
-                                # rows=6, # 이 줄 제거
-                            max_length=2000, # Sensible max length for input
-                            show_count=True, # Show character count
-                            elem_classes="main-input-textarea"
-                        )
-                        # Input Textarea
-       
-                        gr.HTML('<div class="help-text">💡 원하는 게임을 설명하거나 템플릿을 사용하세요. 간결할수록 좋습니다!</div>')
-
-                        # Action Buttons (Send, Boost, Execute, Deploy, Clear)
-                        with antd.Flex(gap="small", wrap='wrap', justify="space-between", elem_classes="action-buttons"): # Allow wrapping
-                            btn = antd.Button("🚀 생성", type="primary", size="middle") # Changed text, adjusted size
-                            boost_btn = antd.Button("✨ 증강", type="default", size="middle")
-                            execute_btn = antd.Button("▶️ 코드 실행", type="default", size="middle") # Changed text
-                            deploy_btn = antd.Button("☁️ 배포", type="default", size="middle")
-                            clear_btn = antd.Button("🧹 클리어", type="default", size="middle", danger=True) # Added danger style
-
-                        # Deployment Result Area
-                        gr.Markdown("---") # Separator
-                        gr.Markdown("### ☁️ 배포 결과", elem_classes="deploy-header")
-                        deploy_result_container = gr.Markdown(
-                            value="아직 배포된 게임이 없습니다. '배포' 버튼을 클릭하세요.",
-                            label="Deployment Result", # Label might not be visible depending on theme/CSS
-                            elem_classes="deploy-result-markdown" # Add class for styling
-                        )
-
-            # --- Event Listeners ---
-
-            # Drawer Controls
-            codeBtn.click(lambda: gr.update(open=True), inputs=[], outputs=[code_drawer])
-            # code_drawer.change(lambda x: gr.update(open=x), inputs=[code_drawer], outputs=[code_drawer]) # Close via change event if needed
-
-            historyBtn.click(history_render, inputs=[history], outputs=[history_drawer, history_output])
-            # history_drawer.change(lambda x: gr.update(open=x), inputs=[history_drawer], outputs=[history_drawer])
-
-            # Template Drawer Controls
-            template_btn.click(
-                fn=lambda: (gr.update(open=True), load_all_templates()),
-                outputs=[session_drawer, session_history_html], # Target the gr.HTML component
-                queue=False # No queue needed for simple UI update
-            )
-            # Close button inside the template drawer
-            close_template_btn.click(lambda: gr.update(open=False), outputs=[session_drawer])
-            # Also close when clicking outside (default drawer behavior) or via the 'X' icon
-
-            # Main Action: Generate Code
-            btn.click(
-                demo_instance.generation_code,
-                inputs=[input_text, setting, history],
-                outputs=[code_output, history, sandbox, state_tab, code_drawer], # Ensure code_drawer is opened
-                concurrency_limit=5 # Limit concurrent requests
-            )
-
-            # Clear Button
-            clear_btn.click(
-                demo_instance.clear_history,
-                inputs=[],
-                # Outputs: history state, code output, sandbox, state tab, code drawer, input text, deploy result
-                outputs=[history, code_output, sandbox, state_tab, code_drawer, input_text, deploy_result_container]
-            )
-
-            # Boost Button
-            boost_btn.click(
-                fn=handle_boost,
-                inputs=[input_text],
-                outputs=[input_text, state_tab], # Update input text, don't change tab
-                queue=False
-            )
-
-            # Execute Code Button
-            execute_btn.click(
-                fn=execute_code,
-                inputs=[input_text], # Takes code directly from input for execution
-                outputs=[sandbox, state_tab], # Updates sandbox and switches tab
-                queue=False
-            )
-
-            # Deploy Button
-            # Use the new handle_deploy_click function which is a generator
-            deploy_btn.click(
-                fn=handle_deploy_click,
-                inputs=[code_output], # Takes code from the code output drawer
-                outputs=[deploy_result_container], # Updates the deployment result Markdown
-                # queue=True # Enable queue as deployment can take time
-            )
-
-# ------------------------
-# 9) 실행
-# ------------------------
-if __name__ == "__main__":
-    logger.info("Starting Gradio application...")
-    try:
-        # demo_instance is already created
-        # Use share=True for public link if needed, debug=True for more logs
-        demo.queue(default_concurrency_limit=10).launch(
-            server_name="0.0.0.0", # Listen on all interfaces for docker/cloud
-            # share=True, # Uncomment for public link
-            debug=True, # Enable Gradio debug mode for more logs
-            # prevent_thread_lock=True # May help in some environments
-        )
-    except Exception as e:
-        logger.critical(f"Failed to launch Gradio demo: {e}", exc_info=True)
-        raise