Update app.py

app.py

@@ -1,449 +1,229 @@
 import os
 import gradio as gr
-import random
-import time
-import logging
+from gradio import ChatMessage
 from typing import Iterator
-
 import google.generativeai as genai
-from gradio import ChatMessage  # ChatMessage 구조 사용 (Thinking/Response 구분 가능)
-
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler("api_debug.log"),
-        logging.StreamHandler()
-    ]
-)
-logger = logging.getLogger("idea_generator")
+import time # Import time module for potential debugging/delay
 
-# Gemini API 키 설정
+# get Gemini API Key from the environ variable
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 genai.configure(api_key=GEMINI_API_KEY)
 
-# 사용할 Gemini 2.0 Flash 모델 (Thinking 기능 포함)
+# we will be using the Gemini 2.0 Flash model with Thinking capabilities
 model = genai.GenerativeModel("gemini-2.0-flash-thinking-exp-01-21")
 
-##############################################################################
-# 변환 문자열에서 슬래시("/")로 구분된 두 옵션 중 하나 선택
-##############################################################################
-def choose_alternative(transformation):
-    if "/" not in transformation:
-        return transformation
-    parts = transformation.split("/")
-    if len(parts) != 2:
-        return random.choice([part.strip() for part in parts])
-    left = parts[0].strip()
-    right = parts[1].strip()
-    if " " in left:
-        tokens = left.split(" ", 1)
-        prefix = tokens[0]
-        if not right.startswith(prefix):
-            option1 = left
-            option2 = prefix + " " + right
-        else:
-            option1 = left
-            option2 = right
-        return random.choice([option1, option2])
-    else:
-        return random.choice([left, right])
-
-##############################################################################
-# 카테고리 사전 (일부만 발췌 가능. 여기서는 예시로 3개만 유지)
-##############################################################################
-physical_transformation_categories = {
-    "공간 이동": [
-        "앞/뒤 이동", "좌/우 이동", "위/아래 이동", "세로축 회전(고개 끄덕임)", 
-        "가로축 회전(고개 젓기)", "길이축 회전(옆으로 기울임)", "원 운동", "나선형 이동", 
-        "관성에 의한 미끄러짐", "회전축 변화", "불규칙 회전", "흔들림 운동", "포물선 이동",
-        "무중력 부유", "수면 위 부유", "점프/도약", "슬라이딩", "롤링", "자유 낙하",
-        "왕복 운동", "탄성 튕김", "관통", "회피 움직임", "지그재그 이동", "스윙 운동"
-    ],
-    
-    "크기와 형태 변화": [
-        "부피 늘어남/줄어듦", "길이 늘어남/줄어듦", "너비 늘어남/줄어듦", "높이 늘어남/줄어듦",
-        "밀도 변화", "무게 증가/감소", "모양 변형", "상태 변화", "불균등 변형",
-        "복잡한 형태 변형", "비틀림/꼬임", "불균일한 확장/축소", "모서리 둥글게/날카롭게",
-        "깨짐/갈라짐", "여러 조각 나눠짐", "물 저항", "먼지 저항", "찌그러짐/복원",
-        "접힘/펼쳐짐", "압착/팽창", "늘어남/수축", "구겨짐/평평해짐", "뭉개짐/단단해짐",
-        "말림/펴짐", "꺾임/구부러짐"
-    ],
-    
-    "표면 및 외관 변화": [
-        "색상 변화", "질감 변화", "투명/불투명 변화", "반짝임/무광 변화", 
-        "빛 반사 정도 변화", "무늬 변화", "각도에 따른 색상 변화", "빛에 따른 색상 변화", 
-        "온도에 따른 색상 변화", "홀로그램 효과", "표면 각도별 빛 반사", "표면 모양 변형", 
-        "초미세 표면 구조 변화", "자가 세정 효과", "얼룩/패턴 생성", "흐림/선명함 변화",
-        "광택/윤기 변화", "색조/채도 변화", "발광/형광", "빛 산란 효과", 
-        "빛 흡수 변화", "반투명 효과", "그림자 효과 변화", "자외선 반응 변화",
-        "야광 효과"
-    ],
-    
-    "물질의 상태 변화": [
-        "고체/액체/기체 전환", "결정화/용해", "산화/부식", "딱딱해짐/부드러워짐", 
-        "특수 상태 전환", "무정형/결정형 전환", "성분 분리", "미세 입자 형성/분해", 
-        "젤 형성/풀어짐", "준안정 상태 변화", "분자 자가 정렬/분해", "상태변화 지연 현상", 
-        "녹음", "굳음", "증발/응축", "승화/증착", "침전/부유", "분산/응집",
-        "건조/습윤", "팽윤/수축", "동결/해동", "풍화/침식", "충전/방전",
-        "결합/분리", "발효/부패"
-    ],
-    
-    "열 관련 변화": [
-        "온도 상승/하강", "열에 의한 팽창/수축", "열 전달/차단", "압력 상승/하강", 
-        "열 변화에 따른 자화", "무질서도 변화", "열전기 현상", "자기장에 의한 열 변화", 
-        "상태변��� 중 열 저장/방출", "열 스트레스 발생/해소", "급격한 온도 변화 영향", 
-        "복사열에 의한 냉각/가열", "발열/흡열", "열 분포 변화", "열 반사/흡수",
-        "냉각 응축", "열 활성화", "열 변색", "열 팽창 계수 변화", "열 안정성 변화",
-        "내열성/내한성", "자기발열", "열적 평형/불균형", "열적 변형", "열 분산/집중"
-    ],
-    
-    "움직임 특성 변화": [
-        "가속/감속", "일정 속도 유지", "진동/진동 감소", "부딪힘/튕김", 
-        "회전 속도 증가/감소", "회전 방향 변화", "불규칙 움직임", "멈췄다 미끄러지는 현상", 
-        "공진/반공진", "유체 속 저항/양력 변화", "움직임 저항 변화", "복합 진동 움직임", 
-        "특수 유체 속 움직임", "회전-이동 연계 움직임", "관성 정지", "충격 흡수",
-        "충격 전달", "운동량 보존", "마찰력 변화", "관성 탈출", "불안정 균형",
-        "동적 안정성", "흔들림 감쇠", "경로 예측성", "회피 움직임"
-    ],
-    
-    "구조적 변화": [
-        "부품 추가/제거", "조립/분해", "접기/펴기", "변형/원상복구", "최적 구조 변화",
-        "자가 재배열", "자연 패턴 형성/소멸", "규칙적 패턴 변화", "모듈식 변형",
-        "복잡성 증가 구조", "원래 모양 기억 효과", "시간에 따른 형태 변화", "부분 제거", 
-        "부분 교체", "결합", "분리", "분할/통합", "중첩/겹침", "내부 구조 변화",
-        "외부 구조 변화", "중심축 이동", "균형점 변화", "계층 구조 변화", "지지 구조 변화",
-        "응력 분산 구조", "충격 흡수 구조", "그리드/매트릭스 구조 변화", "상호 연결성 변화"
-    ],
-    
-    "전기 및 자기 변화": [
-        "자성 생성/소멸", "전하량 증가/감소", "전기장 생성/소멸", "자기장 생성/소멸", 
-        "초전도 상태 전환", "강유전체 특성 변화", "양자 상태 변화", "플라즈마 상태 형성/소멸", 
-        "스핀파 전달", "빛에 의한 전기 발생", "압력에 의한 전기 발생", "자기장 속 전류 변화",
-        "전기 저항 변화", "전기 전도성 변화", "정전기 발생/방전", "전자기 유도",
-        "전자기파 방출/흡수", "전기 용량 변화", "자기 이력 현상", "전기적 분극",
-        "전자 흐름 방향 변화", "전기적 공명", "전기적 차폐/노출", "자기 차폐/노출",
-        "자기장 방향 정렬"
-    ],
-    
-    "화학적 변화": [
-        "표면 코팅 변화", "물질 성분 변화", "화학 반응 변화", "촉매 작용 시작/중단",
-        "빛에 의한 화학 반응", "전기에 의한 화학 반응", "단분자막 형성", "분자 수준 계산 변화",
-        "자연 모방 표면 변화", "환경 반응형 물질 변화", "주기적 화학 반응", "산화", "환원",
-        "고분자화", "물 분해", "화합", "방사선 영향", "산-염기 반응", "중화 반응",
-        "이온화", "화학적 흡착/탈착", "촉매 효율 변화", "효소 활성 변화", "발색 반응",
-        "pH 변화", "화학적 평형 이동", "결합 형성/분해", "용해도 변화"
-    ],
-    
-    "시간 관련 변화": [
-        "노화/풍화", "마모/부식", "색 바램/변색", "손상/회복", "수명 주기 변화",
-        "사용자 상호작용에 따른 적응", "학습 기반 형태 최적화", "시간에 따른 물성 변화", 
-        "집단 기억 효과", "문화적 의미 변화", "지연 반응", "이전 상태 의존 변화", 
-        "점진적 시간 변화", "진화적 변화", "주기적 재생", "계절 변화 적응",
-        "생체리듬 변화", "생애 주기 단계", "성장/퇴화", "자기 복구/재생", 
-        "자연 순환 적응", "지속성/일시성", "기억 효과", "지연된 작용", "누적 효과"
-    ],
-    
-    "빛과 시각 효과": [
-        "발광/소등", "빛 투과/차단", "빛 산란/집중", "색상 스펙트럼 변화", "빛 회절",
-        "빛 간섭", "홀로그램 생성", "레이저 효과", "빛 편광", "형광/인광",
-        "자외선/적외선 발광", "광학적 착시", "빛 굴절", "그림자 생성/제거",
-        "색수차 효과", "무지개 효과", "글로우 효과", "플래시 효과", "조명 패턴",
-        "빔 효과", "광 필터 효과", "빛의 방향성 변화", "투영 효과", "빛 감지/반응",
-        "광도 변화"
-    ],
-    
-    "소리와 진동 효과": [
-        "소리 발생/소멸", "소리 높낮이 변화", "소리 크기 변화", "음색 변화",
-        "공명/반공명", "음향 진동", "초음파/저음파 발생", "음향 집중/분산",
-        "음향 반사/흡수", "음향 도플러 효과", "음파 간섭", "음향 공진",
-        "진동 패턴 변화", "타악 효과", "음향 피드백", "음향 차폐/증폭",
-        "소리 지향성", "음향 왜곡", "비트 생성", "하모닉��� 생성", "주파수 변조",
-        "음향 충격파", "음향 필터링", "음파 전파 패턴", "진동 댐핑"
-    ],
-    
-    "생물학적 변화": [
-        "생장/위축", "세포 분열/사멸", "생물 발광", "신진대사 변화", "면역 반응",
-        "호르몬 분비", "신경 반응", "유전적 발현", "적응/진화", "생체리듬 변화",
-        "재생/치유", "노화/성숙", "생체 모방 변화", "바이오필름 형성", "생물학적 분해",
-        "효소 활성화/비활성화", "생물학적 신호 전달", "스트레스 반응", "체온 조절",
-        "생물학적 시계 변화", "세포외 기질 변화", "생체 역학적 반응", "세포 운동성",
-        "세포 극성 변화", "영양 상태 변화"
-    ],
-    
-    "환경 상호작용": [
-        "온도 반응", "습도 반응", "기압 반응", "중력 반응", "자기장 반응",
-        "빛 반응", "소리 반응", "화학 물질 감지", "기계적 자극 감지", "전기 자극 반응",
-        "방사선 반응", "진동 감지", "pH 반응", "용매 반응", "기체 교환",
-        "환경 오염 반응", "날씨 반응", "계절 변화 반응", "일주기 반응", "생태계 상호작용",
-        "공생/경쟁 반응", "포식/피식 관계", "군집 형성", "영역 설정", "이주/정착 패턴"
-    ],
-    
-    "센서 기능": [
-        "시각 센서/감지", "청각 센서/감지", "촉각 센서/감지", "미각 센서/감지", "후각 센서/감지",
-        "온도 센서/감지", "습도 센서/감지", "압력 센서/감지", "가속도 센서/감지", "회전 센서/감지",
-        "근접 센서/감지", "위치 센서/감지", "운동 센서/감지", "가스 센서/감지", "적외선 센서/감지",
-        "자외선 센서/감지", "방사선 센서/감지", "자기장 센서/감지", "전기장 센서/감지", "화학물질 센서/감지",
-        "생체신호 센서/감지", "진동 센서/감지", "소음 센서/감지", "빛 세기 센서/감지", "빛 파장 센서/감지",
-        "기울기 센서/감지", "pH 센서/감지", "전류 센서/감지", "전압 센서/감지", "이미지 센서/감지",
-        "거리 센서/감지", "깊이 센서/감지", "중력 센서/감지", "속도 센서/감지", "흐름 센서/감지",
-        "수위 센서/감지", "탁도 센서/감지", "염도 센서/감지", "금속 감지", "압전 센서/감지", 
-        "광전 센서/감지", "열전대 센서/감지", "홀 효과 센서/감지", "초음파 센서/감지", "레이더 센서/감지",
-        "라이다 센서/감지", "터치 센서/감지", "제스처 센서/감지", "심박 센서/감지", "혈압 센서/감지"
-    ]
-}
 
-##############################################################################
-# 스트리밍용 Gemini API 함수:
-# - 'Thinking' 단계(아이디어 내부 추론)와 최종 'Response' 단계로 구성
-##############################################################################
-def query_gemini_api_stream(prompt: str) -> Iterator[str]:
+def format_chat_history(messages: list) -> list:
     """
-    Gemini 2.0 Flash with 'Thinking' 부분과 'Response' 부분을 
-    분리하여 스트리밍(Chunk)으로 제공한다.
+    Formats the chat history into a structure Gemini can understand
     """
-    # chat 초기화 (history 없이 단발성 호출)
-    chat = model.start_chat(history=[])
-    response = chat.send_message(prompt, stream=True)
-
-    thought_buffer = ""
-    response_buffer = ""
-    thinking_complete = False
-
-    for chunk in response:
-        # 각 chunk에는 candidates[0].content.parts가 들어있다
-        parts = chunk.candidates[0].content.parts
-        
-        # 예시) parts가 2개이면 (0: Thinking, 1: Response 시작)
-        # 그 외에는 1개씩 끊어서 들어올 수 있음
-        if len(parts) == 2 and not thinking_complete:
-            # 아직 Thinking 중인데, 완성된 Thinking + Response 시작이 한 번에 옴
-            thought_buffer += parts[0].text
-            yield f"[Thinking Chunk] {parts[0].text}"
-            
-            response_buffer = parts[1].text
-            yield f"[Response Start] {parts[1].text}"
-            
-            thinking_complete = True
-        elif thinking_complete:
-            # 이미 Thinking은 끝남 → Response를 이어서 스트리밍
-            current_chunk = parts[0].text
-            response_buffer += current_chunk
-            yield current_chunk
-        else:
-            # Thinking 진행 중 (parts가 1개씩 추가됨)
-            current_chunk = parts[0].text
-            thought_buffer += current_chunk
-            yield f"[Thinking Chunk] {current_chunk}"
-
-    # 스트리밍 완료 후 최종 결과 한번에 제공할 수도 있음
-    yield f"\n[Final Response]\n{response_buffer}"
-
-##############################################################################
-# 카테고리별 간단 설명을 'Thinking' + 'Response'로 확장 (스트리밍)
-##############################################################################
-def enhance_with_llm_stream(base_description, obj_name, category) -> Iterator[str]:
+    formatted_history = []
+    for message in messages:
+        # Skip thinking messages (messages with metadata)
+        if not (message.get("role") == "assistant" and "metadata" in message):
+            formatted_history.append({
+                "role": "user" if message.get("role") == "user" else "assistant",
+                "parts": [message.get("content", "")]
+            })
+    return formatted_history
+
+def stream_gemini_response(user_message: str, messages: list) -> Iterator[list]:
     """
-    기존 enhance_with_llm를 스트리밍 형태로 바꾼 함수:
-    'Thinking' + 'Response' 단계를 chunk로 순차 전달
+    Streams thoughts and response with conversation history support for text input only.
     """
-    prompt = f"""
-다음은 '{obj_name}'의 '{category}' 관련 간단한 설명입니다:
-"{base_description}"
-위 내용을 보다 구체화하여, 
-1) 창의적인 모델/컨셉/형상의 변화에 대한 이해, 
-2) 혁신 포인트와 기능성 등을 중심으로 
-3~4문장의 아이디어로 확장해 주세요.
-"""
-    # query_gemini_api_stream()로부터 chunk를 받아 그대로 yield
-    for chunk in query_gemini_api_stream(prompt):
-        yield chunk
-
-##############################################################################
-# 한 키워드(오브젝트)에 대한 기본 아이디어(카테고리별) 생성
-##############################################################################
-def generate_single_object_transformations(obj):
-    results = {}
-    for category, transformations in physical_transformation_categories.items():
-        transformation = choose_alternative(random.choice(transformations))
-        base_description = f"{obj}이(가) {transformation} 현상을 보인다"
-        results[category] = {"base": base_description, "enhanced": ""}
-    return results
-
-##############################################################################
-# 2개 키워드 상호작용
-##############################################################################
-def generate_two_objects_interaction(obj1, obj2):
-    results = {}
-    for category, transformations in physical_transformation_categories.items():
-        transformation = choose_alternative(random.choice(transformations))
-        template = random.choice([
-            "{obj1}이(가) {obj2}에 결합하여 {change}가 발생했다",
-            "{obj1}과(와) {obj2}이(가) 충돌하면서 {change}가 일어났다"
-        ])
-        base_description = template.format(obj1=obj1, obj2=obj2, change=transformation)
-        results[category] = {"base": base_description, "enhanced": ""}
-    return results
-
-##############################################################################
-# 3개 키워드 상호작용
-##############################################################################
-def generate_three_objects_interaction(obj1, obj2, obj3):
-    results = {}
-    for category, transformations in physical_transformation_categories.items():
-        transformation = choose_alternative(random.choice(transformations))
-        template = random.choice([
-            "{obj1}, {obj2}, {obj3}이(가) 삼각형 구조로 결합하여 {change}가 발생했다",
-            "{obj1}이(가) {obj2}와(과) {obj3} 사이에서 매개체 역할을 하며 {change}를 촉진했다"
-        ])
-        base_description = template.format(obj1=obj1, obj2=obj2, obj3=obj3, change=transformation)
-        results[category] = {"base": base_description, "enhanced": ""}
-    return results
-
-##############################################################################
-# 실제 변환 생성 로직
-##############################################################################
-def generate_transformations(text1, text2=None, text3=None):
-    if text2 and text3:
-        results = generate_three_objects_interaction(text1, text2, text3)
-        objects = [text1, text2, text3]
-    elif text2:
-        results = generate_two_objects_interaction(text1, text2)
-        objects = [text1, text2]
-    else:
-        results = generate_single_object_transformations(text1)
-        objects = [text1]
-    return results, objects
-
-##############################################################################
-# 스트리밍: 각 카테고리별로 'Thinking' + 'Response' 부분을 실시간 전달
-##############################################################################
-def process_inputs_stream(text1, text2, text3) -> Iterator[list]:
-    """
-    Gradio의 Chatbot 형식에 맞춰서,
-    [(role='assistant'|'user', content=...), ...] 형태로 yield한다.
-    생각(Thinking) 단계와 최종 응답을 분리해서 실시간 전송.
-    """
-    messages = []
+    if not user_message.strip(): # Robust check: if text message is empty or whitespace
+        messages.append(ChatMessage(role="assistant", content="Please provide a non-empty text message. Empty input is not allowed.")) # More specific message
+        yield messages
+        return
 
-    # 1) 입력값 확인
-    yield [("assistant", "입력값 확인 중...")]
-    time.sleep(0.3)
+    try:
+        print(f"\n=== New Request (Text) ===")
+        print(f"User message: {user_message}")
+
+        # Format chat history for Gemini
+        chat_history = format_chat_history(messages)
+
+        # Initialize Gemini chat
+        chat = model.start_chat(history=chat_history)
+        response = chat.send_message(user_message, stream=True)
+
+        # Initialize buffers and flags
+        thought_buffer = ""
+        response_buffer = ""
+        thinking_complete = False
+
+        # Add initial thinking message
+        messages.append(
+            ChatMessage(
+                role="assistant",
+                content="",
+                metadata={"title": "⚙️ Thinking: *The thoughts produced by the model are experimental"}
+            )
+        )
+
+        for chunk in response:
+            parts = chunk.candidates[0].content.parts
+            current_chunk = parts[0].text
 
-    text1 = text1.strip() if text1 else None
-    text2 = text2.strip() if text2 else None
-    text3 = text3.strip() if text3 else None
-    if not text1:
-        yield [("assistant", "오류: 최소 하나의 키워드를 입력해주세요.")]
-        return
+            if len(parts) == 2 and not thinking_complete:
+                # Complete thought and start response
+                thought_buffer += current_chunk
+                print(f"\n=== Complete Thought ===\n{thought_buffer}")
+
+                messages[-1] = ChatMessage(
+                    role="assistant",
+                    content=thought_buffer,
+                    metadata={"title": "⚙️ Thinking: *The thoughts produced by the model are experimental"}
+                )
+                yield messages
+
+                # Start response
+                response_buffer = parts[1].text
+                print(f"\n=== Starting Response ===\n{response_buffer}")
+
+                messages.append(
+                    ChatMessage(
+                        role="assistant",
+                        content=response_buffer
+                    )
+                )
+                thinking_complete = True
+
+            elif thinking_complete:
+                # Stream response
+                response_buffer += current_chunk
+                print(f"\n=== Response Chunk ===\n{current_chunk}")
+
+                messages[-1] = ChatMessage(
+                    role="assistant",
+                    content=response_buffer
+                )
 
-    # 2) 아이디어 생성
-    yield [("assistant", "창의적인 모델/컨셉/형상 변화 아이디어 생성 중... (카테고리별 분석)")]
-    time.sleep(0.3)
-    results, objects = generate_transformations(text1, text2, text3)
-
-    # 카테고리별 스트리밍 처리
-    obj_name = " 및 ".join([obj for obj in objects if obj])
-
-    for i, (category, result_dict) in enumerate(results.items(), start=1):
-        base_desc = result_dict["base"]
-
-        # 카테고리 안내 출력
-        yield [("assistant", f"**[{i}/{len(results)}] 카테고리:** {category}\n\n기본 아이디어: {base_desc}\n\n지금부터 Thinking + Response를 단계적으로 스트리밍합니다...")]
-        time.sleep(0.5)
-
-        # 스트리밍 LLM 호출
-        thinking_text = ""
-        response_text = ""
-        is_thinking_done = False
-
-        # enhance_with_llm_stream 호출
-        for chunk in enhance_with_llm_stream(base_desc, obj_name, category):
-            if chunk.startswith("[Thinking Chunk]"):
-                # 생각 파트
-                thinking_text += chunk.replace("[Thinking Chunk]", "")
-                messages_to_user = f"**[Thinking]**\n{thinking_text}"
-                yield [("assistant", messages_to_user)]
-            elif chunk.startswith("[Response Start]"):
-                # 응답 시작 시점
-                is_thinking_done = True
-                # 남아있는 부분은 response_text로
-                partial = chunk.replace("[Response Start]", "")
-                response_text += partial
-                messages_to_user = f"**[Final Response 시작]**\n{partial}"
-                yield [("assistant", messages_to_user)]
-            elif chunk.startswith("[Final Response]"):
-                # 최종 종료
-                final = chunk.replace("[Final Response]", "")
-                response_text += f"\n{final}"
-                yield [("assistant", f"**[최종 Response]**\n{response_text.strip()}")]
             else:
-                # 일반 응답 스트리밍
-                if is_thinking_done:
-                    response_text += chunk
-                    yield [("assistant", f"**[응답 진행]**\n{response_text}") ]
-                else:
-                    thinking_text += chunk
-                    yield [("assistant", f"**[Thinking]**\n{thinking_text}")]
+                # Stream thinking
+                thought_buffer += current_chunk
+                print(f"\n=== Thinking Chunk ===\n{current_chunk}")
 
-        # 한 카테고리 응답 완료
-        result_dict["enhanced"] = response_text
+                messages[-1] = ChatMessage(
+                    role="assistant",
+                    content=thought_buffer,
+                    metadata={"title": "⚙️ Thinking: *The thoughts produced by the model are experimental"}
+                )
+            #time.sleep(0.05) #Optional: Uncomment this line to add a slight delay for debugging/visualization of streaming. Remove for final version
 
-    # 3) 전체 카테고리 완료
-    yield [("assistant", "**모든 카테고리에 대한 스트리밍이 완료되었습니다!**")]
+            yield messages
 
+        print(f"\n=== Final Response ===\n{response_buffer}")
 
-##############################################################################
-# Gradio UI
-##############################################################################
-with gr.Blocks(title="스트리밍 예제: Gemini 2.0 Flash Thinking", 
-               theme=gr.themes.Soft(primary_hue="teal", secondary_hue="slate", neutral_hue="neutral")) as demo:
+    except Exception as e:
+        print(f"\n=== Error ===\n{str(e)}")
+        messages.append(
+            ChatMessage(
+                role="assistant",
+                content=f"I apologize, but I encountered an error: {str(e)}"
+            )
+        )
+        yield messages
 
-    gr.Markdown("# 🚀 키워드 기반 창의적 변화 아이디어 (Gemini 2.0 Flash Thinking, Streaming)")
-    gr.Markdown("키워드 1~3개를 입력하면, **카테고리별로** 'Thinking'과 'Response'가 실시간 스트리밍됩니다.")
+def user_message(msg: str, history: list) -> tuple[str, list]:
+    """Adds user message to chat history"""
+    history.append(ChatMessage(role="user", content=msg))
+    return "", history
 
-    chatbot = gr.Chatbot(
-        label="카테고리별 아이디어(Thinking + Response) 스트리밍",
-        type="tuple",  # (role, content) 쌍의 리스트로 전달
-        render_markdown=True
-    )
-
-    with gr.Row():
-        with gr.Column(scale=1):
-            text_input1 = gr.Textbox(label="키워드 1 (필수)", placeholder="예: 자동차")
-            text_input2 = gr.Textbox(label="키워드 2 (선택)", placeholder="예: 로봇")
-            text_input3 = gr.Textbox(label="키워드 3 (선택)", placeholder="예: 인공지능")
-            submit_button = gr.Button("아이디어 생성하기")
 
-            clear_button = gr.Button("대화 지우기")
-        
-        with gr.Column(scale=2):
-            # 이미 chatbot이 자리를 차지하므로 패스
-            pass
+# Create the Gradio interface
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="slate", neutral_hue="neutral")) as demo: # Using Soft theme with adjusted hues for a refined look
+    gr.Markdown("# Chat with Gemini 2.0 Flash and See its Thoughts 💭")
 
-    def clear_chat():
-        return []
+    
+    gr.HTML("""<a href="https://visitorbadge.io/status?path=https%3A%2F%2Faiqcamp-Gemini2-Flash-Thinking.hf.space">
+               <img src="https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2Faiqcamp-Gemini2-Flash-Thinking.hf.space&countColor=%23263759" />
+               </a>""")
 
-    examples = [
+    
+    chatbot = gr.Chatbot(
+        type="messages",
+        label="Gemini2.0 'Thinking' Chatbot (Streaming Output)", #Label now indicates streaming
+        render_markdown=True,
+        scale=1,
+        avatar_images=(None,"https://lh3.googleusercontent.com/oxz0sUBF0iYoN4VvhqWTmux-cxfD1rxuYkuFEfm1SFaseXEsjjE4Je_C_V3UQPuJ87sImQK3HfQ3RXiaRnQetjaZbjJJUkiPL5jFJ1WRl5FKJZYibUA=w214-h214-n-nu")
+    )
 
-        ["자동차", "", ""],
-        ["스마트폰", "인공지능", ""],
-        ["드론", "인공지능", ""],
-        ["운동화", "웨어러블", "건강"],        
+    with gr.Row(equal_height=True):
+        input_box = gr.Textbox(
+            lines=1,
+            label="Chat Message",
+            placeholder="Type your message here...",
+            scale=4
+        )
+
+        clear_button = gr.Button("Clear Chat", scale=1)
+
+    # Add example prompts - removed file upload examples. Kept text focused examples.
+    example_prompts = [
+        ["Write a short poem about the sunset."],
+        ["Explain the theory of relativity in simple terms."],
+        ["If a train leaves Chicago at 6am traveling at 60mph, and another train leaves New York at 8am traveling at 80mph, at what time will they meet?"],
+        ["Summarize the plot of Hamlet."],
+        ["Write a haiku about a cat."]
     ]
-    gr.Examples(examples=examples, inputs=[text_input1, text_input2, text_input3])
 
-    submit_button.click(
-        fn=process_inputs_stream,
-        inputs=[text_input1, text_input2, text_input3],
-        outputs=chatbot,
-        stream=True  # 스트리밍 출력
+    gr.Examples(
+        examples=example_prompts,
+        inputs=input_box,
+        label="Examples: Try these prompts to see Gemini's thinking!",
+        examples_per_page=5 # Adjust as needed
     )
 
-    clear_button.click(
-        fn=clear_chat,
+
+    # Set up event handlers
+    msg_store = gr.State("")  # Store for preserving user message
+
+    input_box.submit(
+        lambda msg: (msg, msg, ""),  # Store message and clear input
+        inputs=[input_box],
+        outputs=[msg_store, input_box, input_box],
+        queue=False
+    ).then(
+        user_message,  # Add user message to chat
+        inputs=[msg_store, chatbot],
+        outputs=[input_box, chatbot],
+        queue=False
+    ).then(
+        stream_gemini_response,  # Generate and stream response
+        inputs=[msg_store, chatbot],
         outputs=chatbot
     )
 
+    clear_button.click(
+        lambda: ([], "", ""),
+        outputs=[chatbot, input_box, msg_store],
+        queue=False
+    )
+
+    gr.Markdown(  # Description moved to the bottom - updated for text-only
+        """
+        <br><br><br>  <!-- Add some vertical space -->
+        ---
+        ### About this Chatbot
+        This chatbot demonstrates the experimental 'thinking' capability of the **Gemini 2.0 Flash** model.
+        You can observe the model's thought process as it generates responses, displayed with the "⚙️ Thinking" prefix.
+        **Try out the example prompts below to see Gemini in action!**
+        **Key Features:**
+        *   Powered by Google's **Gemini 2.0 Flash** model.
+        *   Shows the model's **thoughts** before the final answer (experimental feature).
+        *   Supports **conversation history** for multi-turn chats.
+        *   Uses **streaming** for a more interactive experience.
+        **Instructions:**
+        1.  Type your message in the input box below or select an example.
+        2.  Press Enter or click Submit to send.
+        3.  Observe the chatbot's "Thinking" process followed by the final response.
+        4.  Use the "Clear Chat" button to start a new conversation.
+        *Please note*: The 'thinking' feature is experimental and the quality of thoughts may vary.
+        """
+    )
+
+
+# Launch the interface
 if __name__ == "__main__":
-    demo.launch(debug=True)
+    demo.launch(debug=True)