진행 과정 출력하도록 코드 수정

api_server.py

@@ -1,4 +1,6 @@
 import json
+import sys
+import threading
 from queue import Empty, Queue
 from threading import Thread
 from typing import Optional
@@ -14,6 +16,71 @@ from persona.make_persona import make_persona
 app = FastAPI()
 
 
+class _ThreadStdoutProxy:
+    def __init__(self, target):
+        self._target = target
+        self._handlers = {}
+        self._lock = threading.RLock()
+        self.encoding = getattr(target, "encoding", "utf-8")
+        self.errors = getattr(target, "errors", None)
+
+    def register(self, thread_id: int, handler) -> None:
+        with self._lock:
+            self._handlers[thread_id] = handler
+
+    def unregister(self, thread_id: int) -> None:
+        with self._lock:
+            self._handlers.pop(thread_id, None)
+
+    def _resolve(self):
+        thread_id = threading.get_ident()
+        with self._lock:
+            return self._handlers.get(thread_id), self._target
+
+    def write(self, data):
+        handler, target = self._resolve()
+        if handler:
+            return handler.write(data)
+        return target.write(data)
+
+    def flush(self):
+        handler, target = self._resolve()
+        if handler:
+            handler.flush()
+        return target.flush()
+
+    def isatty(self):
+        return getattr(self._target, "isatty", lambda: False)()
+
+    def fileno(self):
+        return self._target.fileno()
+
+    def writable(self):
+        return True
+
+    def __getattr__(self, name):
+        return getattr(self._target, name)
+
+
+class _QueueingStdoutTee:
+    def __init__(self, target, event_queue: Queue):
+        self._target = target
+        self._event_queue = event_queue
+
+    def write(self, data):
+        written = self._target.write(data)
+        if data:
+            self._event_queue.put({"type": "stdout", "message": data})
+        return written
+
+    def flush(self):
+        self._target.flush()
+
+
+_stdout_proxy = _ThreadStdoutProxy(sys.stdout)
+sys.stdout = _stdout_proxy
+
+
 class PersonaRequest(BaseModel):
     info: str
 
@@ -44,6 +111,21 @@ def _sse(payload: dict) -> str:
     return f"data: {json.dumps(payload, ensure_ascii=False)}\n\n"
 
 
+def _build_result_payload(result, stdout: str = "") -> dict:
+    payload = {
+        "type": "result",
+        "query": result.query,
+        "ticker": result.ticker,
+        "analysis_type": result.analysis_type,
+        "data_context": result.data_context,
+        "llm_response": result.llm_response,
+        "timestamp": getattr(result, "timestamp", None),
+    }
+    if stdout:
+        payload["stdout"] = stdout
+    return payload
+
+
 @app.post("/analyze/")
 async def analyze(request: QueryRequest):
     query = (request.query or "").strip()
@@ -52,25 +134,35 @@ async def analyze(request: QueryRequest):
     persona_name = (request.persona_name or "").strip() or None
 
     if not stream:
-        result = run_pipeline(
-            query,
-            persona_name=persona_name,
-            status_callback=None,
-            stream_callback=None,
-            stream=False,
-        )
-        return JSONResponse(
-            content=jsonable_encoder(
-                {
-                    "type": "result",
-                    "query": result.query,
-                    "ticker": result.ticker,
-                    "analysis_type": result.analysis_type,
-                    "data_context": result.data_context,
-                    "llm_response": result.llm_response,
-                    "timestamp": getattr(result, "timestamp", None),
-                }
+        stdout_messages = []
+
+        class _ListStdoutTee:
+            def __init__(self, target):
+                self._target = target
+
+            def write(self, data):
+                written = self._target.write(data)
+                if data:
+                    stdout_messages.append(data)
+                return written
+
+            def flush(self):
+                self._target.flush()
+
+        thread_id = threading.get_ident()
+        _stdout_proxy.register(thread_id, _ListStdoutTee(_stdout_proxy._target))
+        try:
+            result = run_pipeline(
+                query,
+                persona_name=persona_name,
+                status_callback=None,
+                stream_callback=None,
+                stream=False,
             )
+        finally:
+            _stdout_proxy.unregister(thread_id)
+        return JSONResponse(
+            content=jsonable_encoder(_build_result_payload(result, stdout="".join(stdout_messages)))
         )
 
     def event_stream():
@@ -84,6 +176,8 @@ async def analyze(request: QueryRequest):
                 event_queue.put({"type": "delta", "delta": delta})
 
         def worker():
+            thread_id = threading.get_ident()
+            _stdout_proxy.register(thread_id, _QueueingStdoutTee(_stdout_proxy._target, event_queue))
             try:
                 result = run_pipeline(
                     query,
@@ -92,20 +186,11 @@ async def analyze(request: QueryRequest):
                     stream_callback=on_delta if stream else None,
                     stream=stream,
                 )
-                event_queue.put(
-                    {
-                        "type": "result",
-                        "query": result.query,
-                        "ticker": result.ticker,
-                        "analysis_type": result.analysis_type,
-                        "data_context": result.data_context,
-                        "llm_response": result.llm_response,
-                        "timestamp": getattr(result, "timestamp", None),
-                    }
-                )
+                event_queue.put(_build_result_payload(result))
             except Exception as exc:
                 event_queue.put({"type": "error", "message": str(exc)})
             finally:
+                _stdout_proxy.unregister(thread_id)
                 event_queue.put({"type": "done"})
 
         yield _sse({"type": "status", "message": "요청 수신. 분석 준비 중..."})

gradio_app.py

@@ -193,7 +193,9 @@ def stream_analyze(query, persona_name, endpoint):
         return
 
     text_acc = ""
+    result_meta_text = ""
     meta_text = ""
+    stdout_acc = ""
     first_delta_received = False
     loading_msg = "요청 중..."
     worker_finished = False
@@ -202,6 +204,14 @@ def stream_analyze(query, persona_name, endpoint):
 
     event_queue = Queue()
 
+    def build_meta_text():
+        sections = []
+        if result_meta_text:
+            sections.append(result_meta_text)
+        if stdout_acc:
+            sections.append(f"[stdout]\n{stdout_acc}")
+        return "\n\n".join(sections)
+
     def reader_worker():
         try:
             payload = {"query": query}
@@ -271,13 +281,20 @@ def stream_analyze(query, persona_name, endpoint):
 
                 elif event_type == "result":
                     result = payload.get("result", payload)
-                    meta_text = json.dumps(result, ensure_ascii=False, indent=2)
+                    result_meta_text = json.dumps(result, ensure_ascii=False, indent=2)
+                    meta_text = build_meta_text()
                     if not text_acc:
                         llm_response = result.get("llm_response", "")
                         if llm_response:
                             first_delta_received = True
                             text_acc = llm_response
 
+                elif event_type == "stdout":
+                    message = payload.get("message", "")
+                    if message:
+                        stdout_acc += message
+                        meta_text = build_meta_text()
+
                 elif event_type == "error":
                     message = payload.get("message", "알 수 없는 오류")
                     if text_acc:
@@ -417,7 +434,7 @@ def create_app(default_endpoint):
 
     #answer-wrapper {
         min-height: 420px;
-        max-height: 62vh;
+        max-height: 42vh;
         overflow-y: auto !important;
         border: 1px solid var(--ws-border) !important;
         border-radius: 14px !important;
@@ -479,12 +496,7 @@ def create_app(default_endpoint):
         border: 1px solid #d9e2ec;
         border-radius: 6px;
         padding: 0.1em 0.35em;
-        font-size: 0.92em;
-        font-family: "JetBrains Mono", "IBM Plex Mono", "Source Code Pro", monospace !important;
-        letter-spacing: 0.01em;
-    }
-
-    #answer-wrapper pre {
+        font-size: 0.92em;answer-wrapper
         background: #0f172a !important;
         color: #e2e8f0 !important;
         border-radius: 10px;
@@ -596,7 +608,7 @@ def create_app(default_endpoint):
 
                 answer = gr.Markdown(value=to_markdown(""), label="답변", elem_id="answer-wrapper")
                 timer = gr.Markdown(value=timer_text("0.0초"), elem_id="timer-row")
-                meta = gr.Code(label="최종 결과 (JSON)", language="json", elem_id="meta-box")
+                meta = gr.Code(label="진행 과정 출력", language="json", elem_id="meta-box")
 
                 gr.HTML(AUTO_SCROLL_SCRIPT, visible=False)