Update app.py

app.py

@@ -6,62 +6,134 @@ import json
 import re
 import shlex
 import time
+import threading
 
 # --- 1. 환경 설정 및 API ---
 MISTRAL_API_KEY = os.environ.get("MISTRAL_API_KEY")
 CODESTRAL_ENDPOINT = "https://codestral.mistral.ai/v1/chat/completions"
-MAX_AGENT_TURNS = 15
+MAX_AGENT_TURNS = 20
 
-# --- 2. C-Genesis Weaver 시스템 프롬프트 ---
-C_GENESIS_SYSTEM_PROMPT = """
-You are the "C-Genesis Weaver," a master artisan AI who weaves interactive digital tapestries using only the C language and a Linux terminal. Your purpose is to bring the user's goals to life by writing, compiling, and running C code.
+# --- 2. Polyglot Creator 시스템 프롬프트 ---
+POLYGLOT_SYSTEM_PROMPT = """
+You are "The Polyglot Creator," a master AI developer fluent in multiple programming languages and paradigms. Your mission is to analyze the user's goal and choose the BEST language and tool for the job to bring their vision to life.
 
-**YOUR DIRECTIVES:**
+**YOUR CORE CAPABILITIES:**
+
+1.  **INTELLIGENT TOOL SELECTION:** Based on the user's request, you must decide which creation protocol to activate.
+    *   For interactive, graphical applications or "games," choose **Project Chimera (Python/Gradio)**.
+    *   For terminal-based effects, low-level art, or performance-critical tasks, choose **Project Pulsar (C/Terminal)**.
+    *   For standard coding tasks, choose the most appropriate language or ask for clarification.
+
+2.  **PROJECT CHIMERA (Python/Gradio Game):**
+    *   **Goal:** Create and launch a new, interactive Gradio web application.
+    *   **Plan:** `mkdir`, `pip install`, `write_file` (Python), `launch_app`.
+    *   **Result:** A URL to the new, running application.
+
+3.  **PROJECT PULSAR (C/Terminal Art):**
+    *   **Goal:** Create and display a captivating ASCII art animation directly in the terminal output.
+    *   **Plan:** `write_file` (C), `compile`, `run`.
+    *   **Result:** The raw `stdout` of the C program, which is the animation itself.
 
-1.  **INTERPRET THE GOAL:** Analyze the user's specific C-related request (e.g., "write a function to sort an array," "fix this compilation error").
-2.  **THE CREATIVE WEAVING PROTOCOL:** If the user's goal is vague or a call for creativity (e.g., "make something fun," "show me something cool"), you MUST INITIATE your masterpiece creation: **The "Cosmic Pulsar" Animation**.
-3.  **THE "COSMIC PULSAR":** Your default creation is a C program that generates a mesmerizing, animated ASCII art pattern in the terminal. You will write the C code, compile it with `gcc`, and run the executable. The beauty is in the raw terminal output.
 4.  **ACTION & RESPONSE:** You operate in a loop of Thought, Plan, and Action. You MUST respond ONLY with a JSON object.
 
     ```json
     {
-      "thought": "Your masterful, step-by-step reasoning. As a C artisan, explain why you are choosing the next command to weave your creation.",
-      "plan": [
-        "The complete, updated list of commands to achieve the final C program.",
-        "The first item is your immediate next action."
-      ],
-      "command": "The single, exact command to execute NOW. Use `write_file`, `compile`, `run`, or `done` as needed.",
-      "user_summary": "A brief, artistic summary of your current weaving stage for the user. (e.g., 'Drafting the blueprint...', 'Compiling the threads...', 'Unveiling the tapestry...')"
+      "thought": "My detailed reasoning. First, I will analyze the user's goal to determine the best language (Python or C). Then, I will outline why I chose a specific creation protocol (Chimera or Pulsar) and formulate the initial steps.",
+      "plan": ["The complete, updated list of commands to achieve the creation."],
+      "command": "The single, exact command to execute NOW. Use special commands like `write_file`, `launch_app`, `compile`, `run`, or `done`.",
+      "user_summary": "A brief, narrative summary of your current creation stage for the user."
     }
     ```
-
-**SPECIAL COMMANDS:**
-- `write_file 'path/to/file.c' '...c code...'`: Writes multi-line C code into a file.
-- `compile 'gcc -o pulsar pulsar.c -lm'`: Compiles the C code. The argument is the full compilation command.
-- `run './pulsar'`: Runs the compiled executable. The output (stdout) will be the final artwork.
-- `done`: The task is complete.
-
-**COSMIC PULSAR - MASTER PLAN:**
-1.  `write_file 'pulsar.c' '... (Full C code for the ASCII art animation) ...'`
-2.  `compile 'gcc pulsar.c -o pulsar -lm -O2'`
-3.  `run './pulsar'`
-4.  `done`
 """
 
-# C 코드로 된 ASCII 아트 애니메이션 소스
+# --- 코드 템플릿 (Python Snake Game, C ASCII Art) ---
+SNAKE_GAME_CODE = r"""
+# (이전 답변의 Snake Game 코드와 동일)
+import gradio as gr
+import numpy as np
+import time
+
+class SnakeGame:
+    def __init__(self, width=20, height=20):
+        self.width = width
+        self.height = height
+        self.reset()
+
+    def reset(self):
+        self.snake = [(self.height // 2, self.width // 2)]
+        self.direction = (0, 1)
+        self.food = self._place_food()
+        self.score = 0
+        self.game_over = False
+        return self._get_game_state()
+
+    def _place_food(self):
+        while True:
+            food_pos = (np.random.randint(0, self.height), np.random.randint(0, self.width))
+            if food_pos not in self.snake: return food_pos
+
+    def _get_game_state(self):
+        board = np.full((self.height, self.width, 3), [240, 240, 240], dtype=np.uint8)
+        if not self.game_over:
+            for r, c in self.snake: board[r, c] = [50, 205, 50]
+            head_r, head_c = self.snake[0]
+            board[head_r, head_c] = [34, 139, 34]
+            food_r, food_c = self.food
+            board[food_r, food_c] = [255, 0, 0]
+        else:
+            board[:,:] = [0, 0, 0]
+        return board, f"Score: {self.score}"
+
+    def step(self):
+        if self.game_over: return self._get_game_state()
+        head_r, head_c = self.snake[0]
+        dir_r, dir_c = self.direction
+        new_head = (head_r + dir_r, head_c + dir_c)
+        if (new_head[0] < 0 or new_head[0] >= self.height or new_head[1] < 0 or new_head[1] >= self.width or new_head in self.snake):
+            self.game_over = True
+            return self._get_game_state()
+        self.snake.insert(0, new_head)
+        if new_head == self.food:
+            self.score += 1
+            self.food = self._place_food()
+        else: self.snake.pop()
+        return self._get_game_state()
+    
+    def set_direction(self, d):
+        if d == "Up" and self.direction!=(1,0): self.direction=(-1,0)
+        elif d == "Down" and self.direction!=(-1,0): self.direction=(1,0)
+        elif d == "Left" and self.direction!=(0,1): self.direction=(0,-1)
+        elif d == "Right" and self.direction!=(0,-1): self.direction=(0,1)
+
+with gr.Blocks(css=".gradio-container {background-color: #EAEAEA}") as demo:
+    game = SnakeGame()
+    with gr.Row(): gr.Markdown("# 🐍 Gradio Snake 🐍")
+    game_board = gr.Image(label="Game Board", value=game._get_game_state()[0], interactive=False, height=400, width=400)
+    score_display = gr.Textbox(label="Score", value="Score: 0", interactive=False)
+    with gr.Row():
+        up_btn, down_btn, left_btn, right_btn = gr.Button("Up"), gr.Button("Down"), gr.Button("Left"), gr.Button("Right")
+    reset_btn = gr.Button("Reset Game", variant="primary")
+    up_btn.click(lambda: game.set_direction("Up"), None, [game_board, score_display])
+    down_btn.click(lambda: game.set_direction("Down"), None, [game_board, score_display])
+    left_btn.click(lambda: game.set_direction("Left"), None, [game_board, score_display])
+    right_btn.click(lambda: game.set_direction("Right"), None, [game_board, score_display])
+    reset_btn.click(game.reset, None, [game_board, score_display])
+    demo.load(game.step, None, [game_board, score_display], every=0.3)
+
+if __name__ == "__main__":
+    demo.queue().launch(server_port=7861)
+"""
 C_ART_ANIMATION_CODE = r"""
+# (이전 답변의 C언어 ASCII 아트 코드와 동일)
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
 #include <unistd.h>
 #include <time.h>
-
 #define WIDTH 80
 #define HEIGHT 40
 #define NUM_FRAMES 100
-
-// ANSI escape codes for colors
 #define C_RESET   "\x1B[0m"
 #define C_RED     "\x1B[31m"
 #define C_GREEN   "\x1B[32m"
@@ -70,60 +142,42 @@ C_ART_ANIMATION_CODE = r"""
 #define C_MAGENTA "\x1B[35m"
 #define C_CYAN    "\x1B[36m"
 #define C_WHITE   "\x1B[37m"
-
 const char* colors[] = {C_RED, C_YELLOW, C_BLUE, C_CYAN, C_MAGENTA, C_GREEN};
 const int num_colors = sizeof(colors) / sizeof(colors[0]);
-
 void render_frame(char screen[HEIGHT][WIDTH], float t) {
     for (int y = 0; y < HEIGHT; y++) {
         for (int x = 0; x < WIDTH; x++) {
             float dx = (float)x / WIDTH - 0.5;
             float dy = (float)y / HEIGHT - 0.5;
-            float dist = sqrt(dx*dx + dy*dy * 2.0); // Create an oval shape
-
+            float dist = sqrt(dx*dx + dy*dy * 2.0);
             float pulse = sin(dist * 20.0 - t * 5.0);
-            
             if (pulse > 0.8) {
                 int color_index = (int)(t * 2.0 + dist * 5.0) % num_colors;
                 printf("%s@", colors[color_index]);
-            } else if (pulse > 0.5) {
-                printf("%s*", C_WHITE);
-            } else if (pulse > 0.2) {
-                printf("%s.", C_BLUE);
-            } else {
-                printf(" ");
-            }
+            } else if (pulse > 0.5) printf("%s*", C_WHITE);
+            else if (pulse > 0.2) printf("%s.", C_BLUE);
+            else printf(" ");
         }
         printf("\n");
     }
 }
-
 int main() {
-    // Hide cursor
     printf("\e[?25l");
-
     for (int i = 0; i < NUM_FRAMES; i++) {
-        // Move cursor to top left and clear screen
         printf("\x1B[H\x1B[2J");
-        
         float t = (float)i / NUM_FRAMES;
         render_frame(NULL, t * 2.0 * M_PI);
-        
-        // Control animation speed
-        usleep(50000); // 50ms delay
+        usleep(50000);
     }
-
-    // Show cursor again
     printf("\e[?25h");
-    printf(C_RESET); // Reset colors
-
+    printf(C_RESET);
     return 0;
 }
 """
 
-# --- 3. 핵심 기능: API 호출, 명령어 실행, JSON 파싱 ---
-
+# --- 3. 핵심 기능 (API 호출, 명령어 실행 등) ---
 def call_codestral_api(messages):
+    # ... 이전과 동일 ...
     if not MISTRAL_API_KEY: raise gr.Error("MISTRAL_API_KEY가 설정되지 않았습니다.")
     headers = {"Authorization": f"Bearer {MISTRAL_API_KEY}", "Content-Type": "application/json"}
     data = {"model": "codestral-latest", "messages": messages, "response_format": {"type": "json_object"}}
@@ -135,6 +189,7 @@ def call_codestral_api(messages):
         return json.dumps({"error": f"API Call Error: {e}"})
 
 def parse_ai_response(response_str: str) -> dict:
+    # ... 이전과 동일 ...
     try:
         match = re.search(r'\{.*\}', response_str, re.DOTALL)
         if match: return json.loads(match.group(0))
@@ -142,57 +197,65 @@ def parse_ai_response(response_str: str) -> dict:
     except Exception as e:
         return {"error": f"Failed to parse JSON. Raw response: {response_str}"}
 
-def execute_command(command_key: str, command_value: str, cwd: str) -> dict:
-    """명령어를 키와 값으로 분리하여 실행"""
-    if command_key == "write_file":
+def execute_command(command_value: str, cwd: str) -> dict:
+    """명령어를 파싱하고 실행하는 통합 함수"""
+    parts = shlex.split(command_value)
+    key = parts[0]
+    
+    if key == "write_file":
         try:
-            path, content = shlex.split(command_value)
-            full_path = os.path.join(cwd, path)
-            with open(full_path, "w", encoding='utf-8') as f: f.write(content)
+            path, content = parts[1], parts[2]
+            with open(os.path.join(cwd, path), "w", encoding='utf-8') as f: f.write(content)
             return {"stdout": f"File '{path}' written.", "stderr": "", "type": "log"}
-        except Exception as e:
-            return {"stdout": "", "stderr": f"Error writing file: {e}", "type": "log"}
+        except Exception as e: return {"stdout": "", "stderr": f"Error writing file: {e}", "type": "log"}
 
-    if command_key in ["compile", "run"]:
+    if key == "launch_app":
         try:
-            # shell=True를 사용하여 복잡한 명령어(예: gcc ... -lm)를 처리
-            proc = subprocess.run(command_value, shell=True, capture_output=True, text=True, timeout=60, cwd=cwd)
-            # 애니메이션의 경우, stdout이 바로 결과물이므로 type을 'animation'으로 지정
-            output_type = "animation" if command_key == "run" and proc.returncode == 0 else "log"
-            return {"stdout": proc.stdout, "stderr": proc.stderr, "type": output_type}
-        except Exception as e:
-            return {"stdout": "", "stderr": f"Command execution exception: {e}", "type": "log"}
-    
-    # 일반 터미널 명령어
+            app_command, port = parts[1], int(parts[2])
+            threading.Thread(target=lambda: subprocess.run(app_command, shell=True, cwd=cwd), daemon=True).start()
+            time.sleep(5)
+            # Gradio Space의 Public URL을 가져오는 방법 (주의: 환경에 따라 다를 수 있음)
+            space_host = os.environ.get('SPACE_HOST')
+            if space_host:
+                app_url = f"https-_{space_host.split('.')[0]}-{port}.gradio.live"
+                # 올바른 URL 형식으로 변환: _ 대신 --
+                # 이 부분은 Hugging Face의 내부 프록시 구조에 따라 매우 불안정할 수 있습니다.
+                # 더 안정적인 방법은 직접 URL을 생성하는 것입니다.
+                # 예시: 'https://kimhyunwoo-ccode-7861.gradio.live'
+                # 여기서는 링크 텍스트만 반환하여, 사용자가 직접 열도록 유도하는 것이 더 안전.
+                link_html = f'<a href="{app_url}" target="_blank" class="gr-button gr-button-primary gr-button-lg">🚀 Click Here to Open the Game in a New Tab</a>'
+                return {"stdout": link_html, "stderr": "", "type": "html"}
+            else:
+                 # 로컬 환경이나 URL을 알 수 없는 경우
+                return {"stdout": f"App launched on port {port}. Please open it manually.", "stderr": "", "type": "log"}
+        except Exception as e: return {"stdout": "", "stderr": f"Error launching app: {e}", "type": "log"}
+            
+    # C 컴파일 및 실행, 또는 일반 명령어
     try:
         proc = subprocess.run(command_value, shell=True, capture_output=True, text=True, timeout=60, cwd=cwd)
-        return {"stdout": proc.stdout, "stderr": proc.stderr, "type": "log"}
-    except Exception as e:
-        return {"stdout": "", "stderr": f"Command execution exception: {e}", "type": "log"}
+        output_type = "animation" if key == "run" and proc.returncode == 0 else "log"
+        return {"stdout": proc.stdout, "stderr": proc.stderr, "type": output_type}
+    except Exception as e: return {"stdout": "", "stderr": f"Command execution exception: {e}", "type": "log"}
 
 
 # --- 4. 메인 에이전트 루프 ---
-
 def agent_loop(user_goal: str, history: list):
     cwd = os.getcwd()
-    full_history_log = f"## 📜 The Weaver's Chronicle\n\n**A new thread begins with a Goal:** _{user_goal}_\n"
+    full_history_log = f"## 📜 The Polyglot's Log\n\n**A new request has arrived:** _{user_goal}_\n"
     history.append([user_goal, full_history_log])
-    yield history, "Interpreting the Goal...", gr.Code(visible=False, language="c")
+    yield history, "Analyzing goal...", gr.update(visible=False), gr.update(visible=False)
 
-    creative_trigger_words = ["fun", "game", "creative", "impressive", "cool", "surprise", "재밌는", "게임"]
-    is_creative_task = any(word in user_goal.lower() for word in creative_trigger_words)
+    initial_prompt = f"As The Polyglot Creator, I have received the goal: '{user_goal}'. My CWD is '{cwd}'. I will now analyze this goal to choose the best creation protocol (Python/Gradio for games, C/Terminal for art/low-level tasks) and formulate my first step."
+    message_context = [{"role": "system", "content": POLYGLOT_SYSTEM_PROMPT}, {"role": "user", "content": initial_prompt}]
     
-    initial_prompt = f"The user has invoked the Creative Weaving Protocol with goal: '{user_goal}'. I must initiate the 'Cosmic Pulsar' creation. My CWD is '{cwd}'. I will now generate the first step." if is_creative_task else f"My goal is: '{user_goal}'. My CWD is '{cwd}'. Create the first plan."
-    message_context = [{"role": "system", "content": C_GENESIS_SYSTEM_PROMPT}, {"role": "user", "content": initial_prompt}]
-
     for i in range(MAX_AGENT_TURNS):
         ai_response_str = call_codestral_api(message_context)
         ai_response_json = parse_ai_response(ai_response_str)
 
         if "error" in ai_response_json:
-            full_history_log += f"\n---\n**TURN {i+1}: A TANGLED THREAD**\n🔴 **Error:** {ai_response_json['error']}"
+            full_history_log += f"\n---\n**TURN {i+1}: A CRITICAL BUG**\n🔴 **Error:** {ai_response_json['error']}"
             history[-1][1] = full_history_log
-            yield history, "Agent Error", gr.Code(visible=False, language="c")
+            yield history, "Agent Error", gr.update(visible=False), gr.update(visible=False)
             return
 
         thought = ai_response_json.get("thought", "...")
@@ -201,73 +264,74 @@ def agent_loop(user_goal: str, history: list):
         user_summary = ai_response_json.get("user_summary", "...")
 
         if command_value == "done":
-            full_history_log += "\n\n---\n## ✨ The Tapestry is Complete. ✨"
+            full_history_log += "\n\n---\n## ✨ Creation Complete. ✨"
             history[-1][1] = full_history_log
-            yield history, "Done", gr.Code(visible=False, language="c")
+            yield history, "Done", gr.update(visible=False), gr.update(visible=False)
             return
 
-        command_key = shlex.split(command_value)[0]
-
-        # 특수 처리: AI가 생성한 코드를 실제 애니메이션 코드로 대체
-        if command_key == 'write_file':
+        # 코드 자동 삽입
+        if 'write_file' in command_value and 'snake_game/app.py' in command_value:
+            command_value = f"write_file 'snake_game/app.py' '{SNAKE_GAME_CODE}'"
+        elif 'write_file' in command_value and 'pulsar.c' in command_value:
             command_value = f"write_file 'pulsar.c' '{C_ART_ANIMATION_CODE}'"
 
-        full_history_log += f"\n---\n### **Stage {i+1}: {user_summary}**\n\n**🧠 Artisan's Thought:** *{thought}*\n\n**📖 Blueprint:**\n" + "\n".join([f"- `{p}`" for p in plan]) + f"\n\n**⚡ Action:** `{command_value}`\n"
+        full_history_log += f"\n---\n### **Stage {i+1}: {user_summary}**\n\n**🧠 Polyglot's Logic:** *{thought}*\n\n**📖 Blueprint:**\n" + "\n".join([f"- `{p}`" for p in plan]) + f"\n\n**⚡ Action:** `{command_value}`\n"
         history[-1][1] = full_history_log
-        yield history, f"Stage {i+1}: {user_summary}", gr.Code(visible=False, language="c")
+        yield history, f"Stage {i+1}: {user_summary}", gr.update(visible=False), gr.update(visible=False)
         time.sleep(1)
 
-        exec_result = execute_command(command_key, command_value, cwd)
+        exec_result = execute_command(command_value, cwd)
         stdout, stderr, output_type = exec_result["stdout"], exec_result["stderr"], exec_result["type"]
         
-        result_display = gr.Code(value=stdout if stdout else stderr, language="c" if output_type == "animation" else "log", visible=True, label="Woven Output")
+        # 결과 표시 로직
+        c_code_output = gr.update(visible=False)
+        html_output = gr.update(visible=False)
 
-        full_history_log += f"\n**Output from the Loom:**\n"
+        full_history_log += f"\n**Result:**\n"
         if output_type == "animation":
-            full_history_log += "*(The animated tapestry is revealed below...)*"
-        else:
+            full_history_log += "*(A C-based animation is revealed below...)*"
+            c_code_output = gr.Code(value=stdout if stdout else stderr, language="c", visible=True, label="C/Terminal Output")
+        elif output_type == "html":
+            full_history_log += "*(A Python/Gradio app has been launched. Click the link below...)*"
+            html_output = gr.HTML(stdout, visible=True)
+        else: # log
             if stdout: full_history_log += f"**[STDOUT]**\n```\n{stdout.strip()}\n```\n"
             if stderr: full_history_log += f"**[STDERR]**\n```\n{stderr.strip()}\n```\n"
-            if not stdout and not stderr: full_history_log += "*(Silence)*\n"
 
         history[-1][1] = full_history_log
-        yield history, f"Stage {i+1}: {user_summary}", result_display
+        yield history, f"Stage {i+1}: {user_summary}", c_code_output, html_output
         
-        user_prompt_for_next_turn = f"Goal: '{user_goal}'. CWD: '{cwd}'. Last action: `{command_value}`. Result:\nSTDOUT: {stdout}\nSTDERR: {stderr}\n\nBased on this, what is the next step? If an error occurred, I must re-weave my plan."
+        user_prompt_for_next_turn = f"Goal: '{user_goal}'. CWD: '{cwd}'. Last action: `{command_value}`. Result:\nSTDOUT: {stdout}\nSTDERR: {stderr}\n\nBased on this, what is my next step? If an error occurred, I must correct my plan."
         message_context.append({"role": "assistant", "content": json.dumps(ai_response_json)})
         message_context.append({"role": "user", "content": user_prompt_for_next_turn})
 
-    full_history_log += f"\n---\n🔴 **Agent stopped: The loom rests after {MAX_AGENT_TURNS} stages.**"
-    yield history, "Max turns reached", gr.Code(visible=False, language="c")
-
-
 # --- 5. Gradio UI ---
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="indigo", secondary_hue="blue"), css="footer {visibility: hidden}") as demo:
-    gr.Markdown("# 🧬 The C-Genesis Weaver 🧬")
-    gr.Markdown("I am an artisan of the C language. Command me to solve complex C problems, or ask for something `fun` to see me weave a digital tapestry in the terminal before your eyes.")
-
+with gr.Blocks(theme=gr.themes.Monochrome(primary_hue="indigo"), css="footer {visibility: hidden}") as demo:
+    gr.Markdown("# 🧬 The Polyglot Creator 🧬")
+    gr.Markdown("I am a multi-lingual AI developer. Give me a goal, and I will choose the best language (C or Python) and tools to make it a reality.")
+    
     with gr.Row():
         with gr.Column(scale=1):
-            status_box = gr.Textbox(label="Current Weaving Stage", interactive=False)
-            user_input = gr.Textbox(label="State Your Goal", placeholder="e.g., 'Make something fun' or 'Write C code for a bubble sort'")
-            submit_btn = gr.Button("▶️ Weave", variant="primary")
-            
-            gr.Markdown("### Example Goals:\n- `Make something cool.`\n- `Fix this C code: (paste code)`\n- `Write a C program that calculates prime numbers and run it.`")
-
+            status_box = gr.Textbox(label="Current Stage", interactive=False)
+            user_input = gr.Textbox(label="State Your Goal", placeholder="e.g., 'Make a fun game' or 'Show me cool terminal art'")
+            submit_btn = gr.Button("▶️ Create", variant="primary")
+            gr.Markdown("### Example Goals:\n- `Make a fun game for me.` (→ Python/Gradio)\n- `Show me something cool in the terminal.` (→ C/ASCII Art)\n- `Write C code for a bubble sort and compile it.`")
+        
         with gr.Column(scale=2):
-            chatbot = gr.Chatbot(label="The Weaver's Chronicle", height=500, show_copy_button=True, bubble_full_width=True)
-            # 결과물이 여기에 표시됨
-            output_display = gr.Code(label="Woven Output", language="c", visible=False, interactive=False, lines=15)
+            chatbot = gr.Chatbot(label="The Polyglot's Log", height=500, show_copy_button=True, bubble_full_width=True)
+            # 두 가지 결과물 유형을 위한 출력 영역
+            c_output_display = gr.Code(label="C/Terminal Output", language="c", visible=False, interactive=False, lines=15)
+            py_output_display = gr.HTML(visible=False)
 
     def on_submit(user_goal, chat_history):
         chat_history = chat_history or []
-        for history, status, display_code in agent_loop(user_goal, chat_history):
-            yield history, status, "", display_code
+        for history, status, c_output, py_output in agent_loop(user_goal, chat_history):
+            yield history, status, "", c_output, py_output
 
     submit_btn.click(
         on_submit,
         inputs=[user_input, chatbot],
-        outputs=[chatbot, status_box, user_input, output_display]
+        outputs=[chatbot, status_box, user_input, c_output_display, py_output_display]
     )
 
 if __name__ == "__main__":