hdsp-jupyter-extension 2.0.23__py3-none-any.whl → 2.0.26__py3-none-any.whl

agent_server/routers/langchain_agent.py

@@ -24,6 +24,10 @@ from agent_server.langchain.agent import (
     create_agent_system,
 )
 from agent_server.langchain.llm_factory import create_llm
+from agent_server.langchain.logging_utils import (
+    LOG_RESPONSE_END,
+    LOG_RESPONSE_START,
+)
 from agent_server.langchain.middleware.code_history_middleware import (
     track_tool_execution,
 )
@@ -65,10 +69,12 @@ def get_subagent_debug_events():
     events = drain_subagent_events()
     sse_events = []
     for event in events:
-        sse_events.append({
-            "event": "debug",
-            "data": json.dumps(event.to_status_dict()),
-        })
+        sse_events.append(
+            {
+                "event": "debug",
+                "data": json.dumps(event.to_status_dict()),
+            }
+        )
     return sse_events
 
 
@@ -94,7 +100,7 @@ def _get_tool_status_message(
         nb_path = tool_args.get("notebook_path", "all notebooks")
         return {
             "status": f"노트북 검색: '{pattern}' in {nb_path or 'all notebooks'}",
-            "icon": "search"
+            "icon": "search",
         }
     elif tool_name_normalized in ("task", "task_tool"):
         # Show subagent delegation details with expand support
@@ -402,17 +408,22 @@ def _normalize_action_request(action: Dict[str, Any]) -> Dict[str, Any]:
         or {}
     )
     # Try to get description from action first, then from args (for jupyter_cell_tool etc)
-    description = action.get("description", "") or (args.get("description", "") if isinstance(args, dict) else "")
+    description = action.get("description", "") or (
+        args.get("description", "") if isinstance(args, dict) else ""
+    )
 
     # Auto-inject description for jupyter_cell_tool from python_developer's response
     # Only inject into args.description, keep top-level description as HITL default
     if name == "jupyter_cell_tool":
-        logger.info(f"[HITL] jupyter_cell_tool detected, current description: '{description[:50] if description else 'None'}'")
+        logger.info(
+            f"[HITL] jupyter_cell_tool detected, current description: '{description[:50] if description else 'None'}'"
+        )
         try:
             from agent_server.langchain.middleware.description_injector import (
                 clear_pending_description,
                 get_pending_description,
             )
+
             pending = get_pending_description()
             if pending:
                 # Inject into args.description only (for detailed description display)
@@ -421,7 +432,9 @@ def _normalize_action_request(action: Dict[str, Any]) -> Dict[str, Any]:
                     args = dict(args)
                     args["description"] = pending
                 clear_pending_description()
-                logger.info(f"[HITL] Auto-injected description into args: {pending[:80]}...")
+                logger.info(
+                    f"[HITL] Auto-injected description into args: {pending[:80]}..."
+                )
             else:
                 logger.info("[HITL] No pending description from python_developer")
         except Exception as e:
@@ -733,20 +746,31 @@ async def stream_agent(request: AgentRequest):
             logger.info("Agent mode: %s", agent_mode)
 
             # Get agent prompts (for multi-agent mode)
-            # ROOT CAUSE FOUND: Frontend sends both systemPrompt AND agentPrompts
-            # which creates different cache keys and causes MALFORMED_FUNCTION_CALL
-            # FIX: Ignore all custom prompts for multi-agent mode until frontend is fixed
             agent_prompts = None
             if agent_mode == "multi":
-                # For multi-agent mode, always use default prompts
+                # Multi-agent mode: Use agentPrompts for per-agent customization
+                # systemPrompt is for single-agent mode only (DEFAULT_SYSTEM_PROMPT)
                 if request.llmConfig and request.llmConfig.agent_prompts:
-                    logger.warning(
-                        "Multi-agent mode: Ignoring frontend agentPrompts to ensure consistent behavior"
+                    agent_prompts = {
+                        "planner": request.llmConfig.agent_prompts.planner,
+                        "python_developer": (
+                            request.llmConfig.agent_prompts.python_developer
+                        ),
+                        "researcher": request.llmConfig.agent_prompts.researcher,
+                        "athena_query": request.llmConfig.agent_prompts.athena_query,
+                    }
+                    agent_prompts = {k: v for k, v in agent_prompts.items() if v}
+                    logger.info(
+                        "Multi-agent mode: Using agentPrompts (%s)",
+                        list(agent_prompts.keys()),
                     )
-                # Also ignore system_prompt_override for multi-agent mode
+                # In multi-agent mode, DON'T use systemPrompt as override
+                # (systemPrompt = single-agent prompt, not planner prompt)
+                # Use agentPrompts.planner instead (handled by agent_factory)
                 if system_prompt_override:
-                    logger.warning(
-                        "Multi-agent mode: Ignoring systemPrompt override (len=%d)",
+                    logger.info(
+                        "Multi-agent mode: Ignoring systemPrompt override (len=%d) - "
+                        "use agentPrompts.planner instead",
                         len(system_prompt_override),
                     )
                     system_prompt_override = None
@@ -856,7 +880,11 @@ async def stream_agent(request: AgentRequest):
                     }
                     # Build previous todos context for LLM
                     if existing_todos:
-                        completed_items = [t.get("content", "") for t in existing_todos if t.get("status") == "completed"]
+                        completed_items = [
+                            t.get("content", "")
+                            for t in existing_todos
+                            if t.get("status") == "completed"
+                        ]
                         if completed_items:
                             items_summary = ", ".join(completed_items[:5])
                             if len(completed_items) > 5:
@@ -865,7 +893,10 @@ async def stream_agent(request: AgentRequest):
                                 f"[SYSTEM] 이전 todo list가 완료 혹은 취소되었습니다. 완료된 작업: {items_summary}. "
                                 f"새 작업을 시작합니다. 이전 todo list에 신규 작업을 append 하지 말고 새로운 todo list를 생성하세요."
                             )
-                            logger.info("Injecting previous todos context: %s", previous_todos_context[:100])
+                            logger.info(
+                                "Injecting previous todos context: %s",
+                                previous_todos_context[:100],
+                            )
                 except Exception as e:
                     logger.warning("Could not reset todos in agent state: %s", e)
 
@@ -883,7 +914,6 @@ async def stream_agent(request: AgentRequest):
             produced_output = False
             last_finish_reason = None
             last_signature = None
-            latest_todos: Optional[List[Dict[str, Any]]] = None
             # Initialize emitted contents set for this thread (clear any stale data)
             emitted_contents: set = set()
             _simple_agent_emitted_contents[thread_id] = emitted_contents
@@ -895,7 +925,10 @@ async def stream_agent(request: AgentRequest):
 
             # Initial status: waiting for LLM
             logger.info("SSE: Sending initial debug status 'LLM 응답 대기 중'")
-            yield {"event": "debug", "data": json.dumps({"status": "LLM 응답 대기 중", "icon": "thinking"})}
+            yield {
+                "event": "debug",
+                "data": json.dumps({"status": "LLM 응답 대기 중", "icon": "thinking"}),
+            }
 
             # Main streaming loop
             async for step in _async_stream_wrapper(
@@ -903,9 +936,16 @@ async def stream_agent(request: AgentRequest):
             ):
                 # Check if thread was cancelled by user
                 if is_thread_cancelled(thread_id):
-                    logger.info(f"Thread {thread_id} cancelled by user, stopping stream")
+                    logger.info(
+                        f"Thread {thread_id} cancelled by user, stopping stream"
+                    )
                     clear_cancelled_thread(thread_id)
-                    yield {"event": "cancelled", "data": json.dumps({"message": "작업이 사용자에 의해 중단되었습니다."})}
+                    yield {
+                        "event": "cancelled",
+                        "data": json.dumps(
+                            {"message": "작업이 사용자에 의해 중단되었습니다."}
+                        ),
+                    }
                     return
 
                 if isinstance(step, dict):
@@ -915,7 +955,10 @@ async def stream_agent(request: AgentRequest):
                     # DEBUG: Check for __interrupt__ in every step
                     if "__interrupt__" in step:
                         logger.info("[DEBUG-INTERRUPT] Found __interrupt__ in step!")
-                        logger.info("[DEBUG-INTERRUPT] interrupt value: %s", str(step["__interrupt__"])[:500])
+                        logger.info(
+                            "[DEBUG-INTERRUPT] interrupt value: %s",
+                            str(step["__interrupt__"])[:500],
+                        )
 
                 # IMPORTANT: Process todos and messages BEFORE checking for interrupt
                 # This ensures todos/debug events are emitted even in interrupt steps
@@ -924,12 +967,10 @@ async def stream_agent(request: AgentRequest):
                 if isinstance(step, dict) and "todos" in step:
                     todos = step["todos"]
                     if todos:
-                        latest_todos = todos
                         yield {"event": "todos", "data": json.dumps({"todos": todos})}
                 elif isinstance(step, dict):
                     todos = _extract_todos(step)
                     if todos:
-                        latest_todos = todos
                         yield {"event": "todos", "data": json.dumps({"todos": todos})}
 
                 # Process messages (no continue statements to ensure interrupt check always runs)
@@ -979,8 +1020,10 @@ async def stream_agent(request: AgentRequest):
                             )
                             todos = _extract_todos(last_message.content)
                             if todos:
-                                latest_todos = todos
-                                yield {"event": "todos", "data": json.dumps({"todos": todos})}
+                                yield {
+                                    "event": "todos",
+                                    "data": json.dumps({"todos": todos}),
+                                }
                                 # Check if all todos are completed - auto terminate only if summary exists
                                 all_completed = all(
                                     t.get("status") == "completed" for t in todos
@@ -989,16 +1032,31 @@ async def stream_agent(request: AgentRequest):
                                     # Check if summary JSON exists in the CURRENT step's AIMessage
                                     # (not in history, to avoid false positives from previous tasks)
                                     summary_exists = False
-                                    step_messages = step.get("messages", []) if isinstance(step, dict) else []
+                                    step_messages = (
+                                        step.get("messages", [])
+                                        if isinstance(step, dict)
+                                        else []
+                                    )
                                     # Only check the AIMessage that called write_todos (should be right before this ToolMessage)
-                                    for recent_msg in step_messages[-3:]:  # Check only the most recent few messages
+                                    for recent_msg in step_messages[
+                                        -3:
+                                    ]:  # Check only the most recent few messages
                                         if isinstance(recent_msg, AIMessage):
-                                            recent_content = getattr(recent_msg, "content", "") or ""
+                                            recent_content = (
+                                                getattr(recent_msg, "content", "") or ""
+                                            )
                                             if isinstance(recent_content, list):
-                                                recent_content = " ".join(str(p) for p in recent_content)
-                                            if '"summary"' in recent_content and '"next_items"' in recent_content:
+                                                recent_content = " ".join(
+                                                    str(p) for p in recent_content
+                                                )
+                                            if (
+                                                '"summary"' in recent_content
+                                                and '"next_items"' in recent_content
+                                            ):
                                                 summary_exists = True
-                                                logger.info("Found summary in current AIMessage content")
+                                                logger.info(
+                                                    "Found summary in current AIMessage content"
+                                                )
                                                 break
 
                                     if summary_exists:
@@ -1010,24 +1068,54 @@ async def stream_agent(request: AgentRequest):
                                         # Find and emit the AIMessage content with summary
                                         for recent_msg in step_messages[-3:]:
                                             if isinstance(recent_msg, AIMessage):
-                                                step_content = getattr(recent_msg, "content", "") or ""
+                                                step_content = (
+                                                    getattr(recent_msg, "content", "")
+                                                    or ""
+                                                )
                                                 if isinstance(step_content, list):
-                                                    step_content = " ".join(str(p) for p in step_content)
-                                                if '"summary"' in step_content and '"next_items"' in step_content:
+                                                    step_content = " ".join(
+                                                        str(p) for p in step_content
+                                                    )
+                                                if (
+                                                    '"summary"' in step_content
+                                                    and '"next_items"' in step_content
+                                                ):
                                                     content_hash = hash(step_content)
-                                                    if content_hash not in emitted_contents:
-                                                        emitted_contents.add(content_hash)
-                                                        repaired_content = _repair_summary_json_content(step_content)
+                                                    if (
+                                                        content_hash
+                                                        not in emitted_contents
+                                                    ):
+                                                        emitted_contents.add(
+                                                            content_hash
+                                                        )
+                                                        repaired_content = _repair_summary_json_content(
+                                                            step_content
+                                                        )
                                                         logger.info(
                                                             "Step auto-terminate: EMITTING summary content (len=%d): %s",
                                                             len(repaired_content),
                                                             repaired_content[:100],
                                                         )
                                                         produced_output = True
-                                                        yield {"event": "token", "data": json.dumps({"content": repaired_content})}
+                                                        yield {
+                                                            "event": "token",
+                                                            "data": json.dumps(
+                                                                {
+                                                                    "content": repaired_content
+                                                                }
+                                                            ),
+                                                        }
                                                     break
-                                        yield {"event": "debug_clear", "data": json.dumps({})}
-                                        yield {"event": "done", "data": json.dumps({"reason": "all_todos_completed"})}
+                                        yield {
+                                            "event": "debug_clear",
+                                            "data": json.dumps({}),
+                                        }
+                                        yield {
+                                            "event": "done",
+                                            "data": json.dumps(
+                                                {"reason": "all_todos_completed"}
+                                            ),
+                                        }
                                         return  # Exit the generator
                                     else:
                                         logger.warning(
@@ -1056,49 +1144,37 @@ async def stream_agent(request: AgentRequest):
 
                         # Handle AIMessage
                         elif isinstance(last_message, AIMessage):
-                            # LLM Response separator for easy log reading
-                            print("\n" + "🔵" * 48, flush=True)
-                            print("=" * 96, flush=True)
-                            print("  ✨ LLM RESPONSE", flush=True)
-                            print("=" * 96, flush=True)
-                            logger.info(
-                                "SimpleAgent AIMessage content: %s",
-                                last_message.content or "",
-                            )
-                            logger.info(
-                                "SimpleAgent AIMessage tool_calls: %s",
-                                json.dumps(last_message.tool_calls, ensure_ascii=False)
+                            # LLM Response - structured JSON format
+                            print(LOG_RESPONSE_START, flush=True)
+                            response_data = {
+                                "type": "AIMessage",
+                                "content": last_message.content or "",
+                                "tool_calls": last_message.tool_calls
                                 if hasattr(last_message, "tool_calls")
-                                else "[]",
-                            )
-                            logger.info(
-                                "SimpleAgent AIMessage additional_kwargs: %s",
-                                json.dumps(
-                                    getattr(last_message, "additional_kwargs", {})
-                                    or {},
-                                    ensure_ascii=False,
-                                ),
-                            )
-                            logger.info(
-                                "SimpleAgent AIMessage response_metadata: %s",
-                                json.dumps(
-                                    getattr(last_message, "response_metadata", {})
-                                    or {},
-                                    ensure_ascii=False,
-                                ),
-                            )
-                            logger.info(
-                                "SimpleAgent AIMessage usage_metadata: %s",
+                                else [],
+                                "additional_kwargs": getattr(
+                                    last_message, "additional_kwargs", {}
+                                )
+                                or {},
+                                "response_metadata": getattr(
+                                    last_message, "response_metadata", {}
+                                )
+                                or {},
+                                "usage_metadata": getattr(
+                                    last_message, "usage_metadata", {}
+                                )
+                                or {},
+                            }
+                            print(
                                 json.dumps(
-                                    getattr(last_message, "usage_metadata", {}) or {},
+                                    response_data,
+                                    indent=2,
                                     ensure_ascii=False,
+                                    default=str,
                                 ),
+                                flush=True,
                             )
-                            # LLM Response end separator
-                            print("=" * 96, flush=True)
-                            print("  ✅ LLM RESPONSE END", flush=True)
-                            print("=" * 96, flush=True)
-                            print("🔵" * 48 + "\n", flush=True)
+                            print(LOG_RESPONSE_END, flush=True)
                             last_finish_reason = (
                                 getattr(last_message, "response_metadata", {}) or {}
                             ).get("finish_reason")
@@ -1157,10 +1233,22 @@ async def stream_agent(request: AgentRequest):
                                     logger.warning(
                                         "MALFORMED_FUNCTION_CALL with empty response - sending error to client"
                                     )
-                                    yield {"event": "token", "data": json.dumps({
+                                    yield {
+                                        "event": "token",
+                                        "data": json.dumps(
+                                            {
                                                 "content": "\n\n[경고] LLM이 잘못된 응답을 반환했습니다. 다시 시도해주세요.\n"
-                                            })}
-                                    yield {"event": "debug", "data": json.dumps({"status": "[경고] MALFORMED_FUNCTION_CALL 에러"})}
+                                            }
+                                        ),
+                                    }
+                                    yield {
+                                        "event": "debug",
+                                        "data": json.dumps(
+                                            {
+                                                "status": "[경고] MALFORMED_FUNCTION_CALL 에러"
+                                            }
+                                        ),
+                                    }
                                     produced_output = True
                                     # Continue to let agent retry on next iteration
 
@@ -1189,8 +1277,10 @@ async def stream_agent(request: AgentRequest):
                                         "SSE: Emitting todos event from AIMessage tool_calls: %d items",
                                         len(todos),
                                     )
-                                    latest_todos = todos
-                                    yield {"event": "todos", "data": json.dumps({"todos": todos})}
+                                    yield {
+                                        "event": "todos",
+                                        "data": json.dumps({"todos": todos}),
+                                    }
                                     # Check if all todos are completed - terminate early
                                     all_completed = all(
                                         t.get("status") == "completed" for t in todos
@@ -1202,7 +1292,7 @@ async def stream_agent(request: AgentRequest):
                                             "다음단계",
                                             "다음 단계",
                                         ]
-                                        has_summary_todo = any(
+                                        any(
                                             any(
                                                 kw in t.get("content", "")
                                                 for kw in summary_keywords
@@ -1232,7 +1322,9 @@ async def stream_agent(request: AgentRequest):
                                                 "## 다음 단계",
                                             ]
                                         )
-                                        has_summary = has_summary_json or has_markdown_summary
+                                        has_summary = (
+                                            has_summary_json or has_markdown_summary
+                                        )
 
                                         # Only check current AIMessage for summary (not history, to avoid false positives)
                                         if not has_summary:
@@ -1247,20 +1339,41 @@ async def stream_agent(request: AgentRequest):
                                             )
                                             # IMPORTANT: Emit the summary content BEFORE terminating
                                             # so the UI can display the summary JSON
-                                            if msg_content and isinstance(msg_content, str):
+                                            if msg_content and isinstance(
+                                                msg_content, str
+                                            ):
                                                 content_hash = hash(msg_content)
                                                 if content_hash not in emitted_contents:
                                                     emitted_contents.add(content_hash)
-                                                    repaired_content = _repair_summary_json_content(msg_content)
+                                                    repaired_content = (
+                                                        _repair_summary_json_content(
+                                                            msg_content
+                                                        )
+                                                    )
                                                     logger.info(
                                                         "Auto-terminate: EMITTING summary content (len=%d): %s",
                                                         len(repaired_content),
                                                         repaired_content[:100],
                                                     )
                                                     produced_output = True
-                                                    yield {"event": "token", "data": json.dumps({"content": repaired_content})}
-                                            yield {"event": "debug_clear", "data": json.dumps({})}
-                                            yield {"event": "done", "data": json.dumps({"reason": "all_todos_completed"})}
+                                                    yield {
+                                                        "event": "token",
+                                                        "data": json.dumps(
+                                                            {
+                                                                "content": repaired_content
+                                                            }
+                                                        ),
+                                                    }
+                                            yield {
+                                                "event": "debug_clear",
+                                                "data": json.dumps({}),
+                                            }
+                                            yield {
+                                                "event": "done",
+                                                "data": json.dumps(
+                                                    {"reason": "all_todos_completed"}
+                                                ),
+                                            }
                                             return  # Exit before executing more tool calls
                                 for tool_call in tool_calls:
                                     tool_name = tool_call.get("name", "unknown")
@@ -1275,7 +1388,10 @@ async def stream_agent(request: AgentRequest):
                                         "SSE: Emitting debug event for tool: %s",
                                         tool_name,
                                     )
-                                    yield {"event": "debug", "data": json.dumps(status_msg)}
+                                    yield {
+                                        "event": "debug",
+                                        "data": json.dumps(status_msg),
+                                    }
 
                                     # Send tool_call event with details for frontend to execute
                                     if tool_name in (
@@ -1283,37 +1399,55 @@ async def stream_agent(request: AgentRequest):
                                         "jupyter_cell",
                                     ):
                                         produced_output = True
-                                        yield {"event": "tool_call", "data": json.dumps({
+                                        yield {
+                                            "event": "tool_call",
+                                            "data": json.dumps(
+                                                {
                                                     "tool": "jupyter_cell",
                                                     "code": tool_args.get("code", ""),
                                                     "description": tool_args.get(
                                                         "description", ""
                                                     ),
-                                                })}
+                                                }
+                                            ),
+                                        }
                                     elif tool_name in ("markdown_tool", "markdown"):
                                         produced_output = True
-                                        yield {"event": "tool_call", "data": json.dumps({
+                                        yield {
+                                            "event": "tool_call",
+                                            "data": json.dumps(
+                                                {
                                                     "tool": "markdown",
                                                     "content": tool_args.get(
                                                         "content", ""
                                                     ),
-                                                })}
+                                                }
+                                            ),
+                                        }
                                     elif tool_name == "execute_command_tool":
                                         produced_output = True
-                                        yield {"event": "tool_call", "data": json.dumps({
+                                        yield {
+                                            "event": "tool_call",
+                                            "data": json.dumps(
+                                                {
                                                     "tool": "execute_command_tool",
                                                     "command": tool_args.get(
                                                         "command", ""
                                                     ),
                                                     "timeout": tool_args.get("timeout"),
-                                                })}
+                                                }
+                                            ),
+                                        }
                                     elif tool_name in (
                                         "search_notebook_cells_tool",
                                         "search_notebook_cells",
                                     ):
                                         # Search notebook cells - emit tool_call for client-side execution
                                         produced_output = True
-                                        yield {"event": "tool_call", "data": json.dumps({
+                                        yield {
+                                            "event": "tool_call",
+                                            "data": json.dumps(
+                                                {
                                                     "tool": "search_notebook_cells",
                                                     "pattern": tool_args.get(
                                                         "pattern", ""
@@ -1330,7 +1464,25 @@ async def stream_agent(request: AgentRequest):
                                                     "case_sensitive": tool_args.get(
                                                         "case_sensitive", False
                                                     ),
-                                                })}
+                                                }
+                                            ),
+                                        }
+                                    elif tool_name in (
+                                        "final_summary_tool",
+                                        "final_summary",
+                                    ):
+                                        # Final summary - emit summary event for frontend
+                                        produced_output = True
+                                        summary_data = {
+                                            "summary": tool_args.get("summary", ""),
+                                            "next_items": tool_args.get(
+                                                "next_items", []
+                                            ),
+                                        }
+                                        yield {
+                                            "event": "summary",
+                                            "data": json.dumps(summary_data),
+                                        }
 
                             # Only display content if it's not empty and not a JSON tool response
                             if (
@@ -1374,6 +1526,31 @@ async def stream_agent(request: AgentRequest):
                                         and content_stripped.startswith("{")
                                     )
                                 )
+
+                                # Check if this is summary/next_items with tool_calls (premature summary)
+                                has_summary_pattern = (
+                                    '"summary"' in content or "'summary'" in content
+                                ) and (
+                                    '"next_items"' in content
+                                    or "'next_items'" in content
+                                )
+                                tool_calls = (
+                                    getattr(last_message, "tool_calls", []) or []
+                                )
+                                # Check if any tool_call is NOT write_todos (work still in progress)
+                                has_non_todo_tool_calls = any(
+                                    tc.get("name")
+                                    not in ("write_todos", "write_todos_tool")
+                                    for tc in tool_calls
+                                )
+                                # Skip summary if non-write_todos tool_calls exist (work still in progress)
+                                if has_summary_pattern and has_non_todo_tool_calls:
+                                    logger.info(
+                                        "Initial: SKIPPING premature summary (has non-todo tool_calls): %s",
+                                        content[:100],
+                                    )
+                                    content = None  # Skip this content
+
                                 if (
                                     content
                                     and isinstance(content, str)
@@ -1399,7 +1576,12 @@ async def stream_agent(request: AgentRequest):
                                             repaired_content[:100],
                                         )
                                         produced_output = True
-                                        yield {"event": "token", "data": json.dumps({"content": repaired_content})}
+                                        yield {
+                                            "event": "token",
+                                            "data": json.dumps(
+                                                {"content": repaired_content}
+                                            ),
+                                        }
 
                 # Drain and emit any subagent events (tool calls from subagents)
                 for subagent_event in get_subagent_debug_events():
@@ -1418,7 +1600,12 @@ async def stream_agent(request: AgentRequest):
                             else interrupt
                         )
 
-                    yield {"event": "debug", "data": json.dumps({"status": "사용자 승인 대기 중", "icon": "pause"})}
+                    yield {
+                        "event": "debug",
+                        "data": json.dumps(
+                            {"status": "사용자 승인 대기 중", "icon": "pause"}
+                        ),
+                    }
 
                     # Process regular HITL interrupts (non-subagent)
                     for interrupt in interrupts:
@@ -1430,7 +1617,9 @@ async def stream_agent(request: AgentRequest):
 
                         # Extract action requests
                         action_requests = interrupt_value.get("action_requests", [])
-                        logger.info(f"[INTERRUPT] action_requests count: {len(action_requests)}, first: {str(action_requests[0])[:200] if action_requests else 'none'}")
+                        logger.info(
+                            f"[INTERRUPT] action_requests count: {len(action_requests)}, first: {str(action_requests[0])[:200] if action_requests else 'none'}"
+                        )
                         normalized_actions = [
                             _normalize_action_request(a) for a in action_requests
                         ]
@@ -1443,14 +1632,16 @@ async def stream_agent(request: AgentRequest):
                         for idx, action in enumerate(normalized_actions):
                             yield {
                                 "event": "interrupt",
-                                "data": json.dumps({
-                                    "thread_id": thread_id,
-                                    "action": action.get("name", "unknown"),
-                                    "args": action.get("arguments", {}),
-                                    "description": action.get("description", ""),
-                                    "action_index": idx,
-                                    "total_actions": total_actions,
-                                }),
+                                "data": json.dumps(
+                                    {
+                                        "thread_id": thread_id,
+                                        "action": action.get("name", "unknown"),
+                                        "args": action.get("arguments", {}),
+                                        "description": action.get("description", ""),
+                                        "action_index": idx,
+                                        "total_actions": total_actions,
+                                    }
+                                ),
                             }
 
                     # Save last signature for resume to avoid duplicate content
@@ -1541,9 +1732,14 @@ async def stream_agent(request: AgentRequest):
                         )
                 except asyncio.TimeoutError:
                     logger.error("SimpleAgent fallback timed out after 30s")
-                    yield {"event": "token", "data": json.dumps({
+                    yield {
+                        "event": "token",
+                        "data": json.dumps(
+                            {
                                 "content": "모델이 도구 호출을 생성하지 못했습니다. 다시 시도해주세요."
-                            })}
+                            }
+                        ),
+                    }
                     produced_output = True
                     fallback_response = None
                 except Exception as fallback_error:
@@ -1552,9 +1748,47 @@ async def stream_agent(request: AgentRequest):
                         fallback_error,
                         exc_info=True,
                     )
-                    yield {"event": "token", "data": json.dumps({"content": f"오류가 발생했습니다: {str(fallback_error)}"})}
+                    yield {
+                        "event": "token",
+                        "data": json.dumps(
+                            {"content": f"오류가 발생했습니다: {str(fallback_error)}"}
+                        ),
+                    }
                     produced_output = True
                     fallback_response = None
+                if isinstance(fallback_response, AIMessage):
+                    # LLM Response - structured JSON format
+                    print(LOG_RESPONSE_START, flush=True)
+                    response_data = {
+                        "type": "AIMessage",
+                        "content": fallback_response.content or "",
+                        "tool_calls": fallback_response.tool_calls
+                        if hasattr(fallback_response, "tool_calls")
+                        else [],
+                        "additional_kwargs": getattr(
+                            fallback_response, "additional_kwargs", {}
+                        )
+                        or {},
+                        "response_metadata": getattr(
+                            fallback_response, "response_metadata", {}
+                        )
+                        or {},
+                        "usage_metadata": getattr(
+                            fallback_response, "usage_metadata", {}
+                        )
+                        or {},
+                    }
+                    print(
+                        json.dumps(
+                            response_data,
+                            indent=2,
+                            ensure_ascii=False,
+                            default=str,
+                        ),
+                        flush=True,
+                    )
+                    print(LOG_RESPONSE_END, flush=True)
+
                 if isinstance(fallback_response, AIMessage) and getattr(
                     fallback_response, "tool_calls", None
                 ):
@@ -1566,27 +1800,68 @@ async def stream_agent(request: AgentRequest):
 
                         if tool_name in ("jupyter_cell_tool", "jupyter_cell"):
                             produced_output = True
-                            yield {"event": "debug", "data": json.dumps(_get_tool_status_message(tool_name, tool_args))}
-                            yield {"event": "tool_call", "data": json.dumps({
+                            yield {
+                                "event": "debug",
+                                "data": json.dumps(
+                                    _get_tool_status_message(tool_name, tool_args)
+                                ),
+                            }
+                            yield {
+                                "event": "tool_call",
+                                "data": json.dumps(
+                                    {
                                         "tool": "jupyter_cell",
                                         "code": tool_args.get("code", ""),
                                         "description": tool_args.get("description", ""),
-                                    })}
+                                    }
+                                ),
+                            }
                         elif tool_name in ("markdown_tool", "markdown"):
                             produced_output = True
-                            yield {"event": "debug", "data": json.dumps(_get_tool_status_message(tool_name, tool_args))}
-                            yield {"event": "tool_call", "data": json.dumps({
+                            yield {
+                                "event": "debug",
+                                "data": json.dumps(
+                                    _get_tool_status_message(tool_name, tool_args)
+                                ),
+                            }
+                            yield {
+                                "event": "tool_call",
+                                "data": json.dumps(
+                                    {
                                         "tool": "markdown",
                                         "content": tool_args.get("content", ""),
-                                    })}
+                                    }
+                                ),
+                            }
                         elif tool_name == "execute_command_tool":
                             produced_output = True
-                            yield {"event": "debug", "data": json.dumps(_get_tool_status_message(tool_name, tool_args))}
-                            yield {"event": "tool_call", "data": json.dumps({
+                            yield {
+                                "event": "debug",
+                                "data": json.dumps(
+                                    _get_tool_status_message(tool_name, tool_args)
+                                ),
+                            }
+                            yield {
+                                "event": "tool_call",
+                                "data": json.dumps(
+                                    {
                                         "tool": "execute_command_tool",
                                         "command": tool_args.get("command", ""),
                                         "timeout": tool_args.get("timeout"),
-                                    })}
+                                    }
+                                ),
+                            }
+                        elif tool_name in ("final_summary_tool", "final_summary"):
+                            # Final summary - emit summary event for frontend
+                            produced_output = True
+                            summary_data = {
+                                "summary": tool_args.get("summary", ""),
+                                "next_items": tool_args.get("next_items", []),
+                            }
+                            yield {
+                                "event": "summary",
+                                "data": json.dumps(summary_data),
+                            }
                         elif tool_name == "read_file_tool":
                             # For file operations, generate code with the LLM
                             logger.info(
@@ -1618,20 +1893,32 @@ async def stream_agent(request: AgentRequest):
                                 )
 
                             if not code:
-                                yield {"event": "token", "data": json.dumps({
+                                yield {
+                                    "event": "token",
+                                    "data": json.dumps(
+                                        {
                                             "content": "도구 실행을 위한 코드를 생성하지 못했습니다. 다시 시도해주세요."
-                                        })}
+                                        }
+                                    ),
+                                }
                                 produced_output = True
                                 continue
 
-                            yield {"event": "debug", "data": json.dumps({"status": "[변환] Jupyter Cell로 변환 중"})}
+                            yield {
+                                "event": "debug",
+                                "data": json.dumps(
+                                    {"status": "[변환] Jupyter Cell로 변환 중"}
+                                ),
+                            }
                             yield {
                                 "event": "tool_call",
-                                "data": json.dumps({
-                                    "tool": "jupyter_cell",
-                                    "code": code,
-                                    "description": f"Converted from {tool_name}",
-                                }),
+                                "data": json.dumps(
+                                    {
+                                        "tool": "jupyter_cell",
+                                        "code": code,
+                                        "description": f"Converted from {tool_name}",
+                                    }
+                                ),
                             }
                         else:
                             # Unknown tool - skip and show message
@@ -1640,9 +1927,11 @@ async def stream_agent(request: AgentRequest):
                             )
                             yield {
                                 "event": "token",
-                                "data": json.dumps({
-                                    "content": f"알 수 없는 도구 '{tool_name}'입니다. jupyter_cell_tool을 사용해주세요."
-                                }),
+                                "data": json.dumps(
+                                    {
+                                        "content": f"알 수 없는 도구 '{tool_name}'입니다. jupyter_cell_tool을 사용해주세요."
+                                    }
+                                ),
                             }
                             produced_output = True
                 elif (
@@ -1654,25 +1943,41 @@ async def stream_agent(request: AgentRequest):
                     repaired_content = _repair_summary_json_content(
                         fallback_response.content
                     )
-                    yield {"event": "token", "data": json.dumps({"content": repaired_content})}
+                    yield {
+                        "event": "token",
+                        "data": json.dumps({"content": repaired_content}),
+                    }
                 elif fallback_response is not None and not produced_output:
-                    yield {"event": "token", "data": json.dumps({
+                    yield {
+                        "event": "token",
+                        "data": json.dumps(
+                            {
                                 "content": "모델이 도구 호출을 생성하지 못했습니다. 다시 시도해주세요."
-                            })}
+                            }
+                        ),
+                    }
                     produced_output = True
 
             # Clear debug status before completion
             yield {"event": "debug_clear", "data": json.dumps({})}
 
             # No interrupt - execution completed
-            yield {"event": "complete", "data": json.dumps({"success": True, "thread_id": thread_id})}
+            yield {
+                "event": "complete",
+                "data": json.dumps({"success": True, "thread_id": thread_id}),
+            }
 
         except Exception as e:
             logger.error(f"Stream error: {e}", exc_info=True)
-            yield {"event": "error", "data": json.dumps({
+            yield {
+                "event": "error",
+                "data": json.dumps(
+                    {
                         "error": str(e),
                         "error_type": type(e).__name__,
-                    })}
+                    }
+                ),
+            }
 
     return EventSourceResponse(event_generator())
 
@@ -1726,11 +2031,16 @@ async def resume_agent(request: ResumeRequest):
                     "Server may have restarted or session expired.",
                     request.threadId,
                 )
-                yield {"event": "error", "data": json.dumps({
+                yield {
+                    "event": "error",
+                    "data": json.dumps(
+                        {
                             "error": "Session expired or not found",
                             "code": "CHECKPOINT_NOT_FOUND",
                             "message": "이전 세션을 찾을 수 없습니다. 서버가 재시작되었거나 세션이 만료되었습니다. 새로운 대화를 시작해주세요.",
-                        })}
+                        }
+                    ),
+                }
                 return
 
             checkpointer = _simple_agent_checkpointers.get(request.threadId)
@@ -1740,14 +2050,28 @@ async def resume_agent(request: ResumeRequest):
             logger.info("Resume: Agent mode: %s", agent_mode)
 
             # Get agent prompts (for multi-agent mode)
-            # ROOT CAUSE: Frontend sends both systemPrompt AND agentPrompts
-            # FIX: Ignore all custom prompts for multi-agent mode
             agent_prompts = None
             if agent_mode == "multi":
                 if request.llmConfig and request.llmConfig.agent_prompts:
-                    logger.warning("Resume: Multi-agent mode - ignoring agentPrompts")
+                    agent_prompts = {
+                        "planner": request.llmConfig.agent_prompts.planner,
+                        "python_developer": (
+                            request.llmConfig.agent_prompts.python_developer
+                        ),
+                        "researcher": request.llmConfig.agent_prompts.researcher,
+                        "athena_query": request.llmConfig.agent_prompts.athena_query,
+                    }
+                    agent_prompts = {k: v for k, v in agent_prompts.items() if v}
+                    logger.info(
+                        "Resume: Multi-agent mode - using agentPrompts (%s)",
+                        list(agent_prompts.keys()),
+                    )
+                # In multi-agent mode, DON'T use systemPrompt as override
                 if system_prompt_override:
-                    logger.warning("Resume: Multi-agent mode - ignoring systemPrompt")
+                    logger.info(
+                        "Resume: Multi-agent mode - ignoring systemPrompt (len=%d)",
+                        len(system_prompt_override),
+                    )
                     system_prompt_override = None
 
             agent_cache_key = _get_agent_cache_key(
@@ -1822,7 +2146,12 @@ async def resume_agent(request: ResumeRequest):
                     )
                     # Track code execution for history (injected into subagent context)
                     tool_name = edited_action.get("name", "")
-                    if tool_name in ("jupyter_cell_tool", "write_file_tool", "edit_file_tool", "multiedit_file_tool"):
+                    if tool_name in (
+                        "jupyter_cell_tool",
+                        "write_file_tool",
+                        "edit_file_tool",
+                        "multiedit_file_tool",
+                    ):
                         track_tool_execution(tool_name, args)
                     langgraph_decisions.append(
                         {
@@ -1840,7 +2169,10 @@ async def resume_agent(request: ResumeRequest):
                     )
 
             # Resume execution
-            yield {"event": "debug", "data": json.dumps({"status": "실행 재개 중", "icon": "play"})}
+            yield {
+                "event": "debug",
+                "data": json.dumps({"status": "실행 재개 중", "icon": "play"}),
+            }
 
             _simple_agent_pending_actions.pop(request.threadId, None)
 
@@ -1866,7 +2198,10 @@ async def resume_agent(request: ResumeRequest):
             )
 
             # Status: waiting for LLM response
-            yield {"event": "debug", "data": json.dumps({"status": "LLM 응답 대기 중", "icon": "thinking"})}
+            yield {
+                "event": "debug",
+                "data": json.dumps({"status": "LLM 응답 대기 중", "icon": "thinking"}),
+            }
 
             step_count = 0
 
@@ -1878,9 +2213,16 @@ async def resume_agent(request: ResumeRequest):
             ):
                 # Check if thread was cancelled by user
                 if is_thread_cancelled(request.threadId):
-                    logger.info(f"Thread {request.threadId} cancelled by user, stopping resume stream")
+                    logger.info(
+                        f"Thread {request.threadId} cancelled by user, stopping resume stream"
+                    )
                     clear_cancelled_thread(request.threadId)
-                    yield {"event": "cancelled", "data": json.dumps({"message": "작업이 사용자에 의해 중단되었습니다."})}
+                    yield {
+                        "event": "cancelled",
+                        "data": json.dumps(
+                            {"message": "작업이 사용자에 의해 중단되었습니다."}
+                        ),
+                    }
                     return
 
                 step_count += 1
@@ -1982,7 +2324,10 @@ async def resume_agent(request: ResumeRequest):
                             todos = _extract_todos(last_message.content)
                             if todos:
                                 latest_todos = todos
-                                yield {"event": "todos", "data": json.dumps({"todos": todos})}
+                                yield {
+                                    "event": "todos",
+                                    "data": json.dumps({"todos": todos}),
+                                }
                                 # Check if all todos are completed - auto terminate only if summary exists
                                 all_completed = all(
                                     t.get("status") == "completed" for t in todos
@@ -1991,16 +2336,31 @@ async def resume_agent(request: ResumeRequest):
                                     # Check if summary JSON exists in the CURRENT step's AIMessage
                                     # (not in history, to avoid false positives from previous tasks)
                                     summary_exists = False
-                                    step_messages = step.get("messages", []) if isinstance(step, dict) else []
+                                    step_messages = (
+                                        step.get("messages", [])
+                                        if isinstance(step, dict)
+                                        else []
+                                    )
                                     # Only check the AIMessage that called write_todos (should be right before this ToolMessage)
-                                    for recent_msg in step_messages[-3:]:  # Check only the most recent few messages
+                                    for recent_msg in step_messages[
+                                        -3:
+                                    ]:  # Check only the most recent few messages
                                         if isinstance(recent_msg, AIMessage):
-                                            recent_content = getattr(recent_msg, "content", "") or ""
+                                            recent_content = (
+                                                getattr(recent_msg, "content", "") or ""
+                                            )
                                             if isinstance(recent_content, list):
-                                                recent_content = " ".join(str(p) for p in recent_content)
-                                            if '"summary"' in recent_content and '"next_items"' in recent_content:
+                                                recent_content = " ".join(
+                                                    str(p) for p in recent_content
+                                                )
+                                            if (
+                                                '"summary"' in recent_content
+                                                and '"next_items"' in recent_content
+                                            ):
                                                 summary_exists = True
-                                                logger.info("Resume: Found summary in current AIMessage content")
+                                                logger.info(
+                                                    "Resume: Found summary in current AIMessage content"
+                                                )
                                                 break
 
                                     if summary_exists:
@@ -2012,23 +2372,53 @@ async def resume_agent(request: ResumeRequest):
                                         # Find and emit the AIMessage content with summary
                                         for recent_msg in step_messages[-3:]:
                                             if isinstance(recent_msg, AIMessage):
-                                                step_content = getattr(recent_msg, "content", "") or ""
+                                                step_content = (
+                                                    getattr(recent_msg, "content", "")
+                                                    or ""
+                                                )
                                                 if isinstance(step_content, list):
-                                                    step_content = " ".join(str(p) for p in step_content)
-                                                if '"summary"' in step_content and '"next_items"' in step_content:
+                                                    step_content = " ".join(
+                                                        str(p) for p in step_content
+                                                    )
+                                                if (
+                                                    '"summary"' in step_content
+                                                    and '"next_items"' in step_content
+                                                ):
                                                     content_hash = hash(step_content)
-                                                    if content_hash not in emitted_contents:
-                                                        emitted_contents.add(content_hash)
-                                                        repaired_content = _repair_summary_json_content(step_content)
+                                                    if (
+                                                        content_hash
+                                                        not in emitted_contents
+                                                    ):
+                                                        emitted_contents.add(
+                                                            content_hash
+                                                        )
+                                                        repaired_content = _repair_summary_json_content(
+                                                            step_content
+                                                        )
                                                         logger.info(
                                                             "Resume step auto-terminate: EMITTING summary content (len=%d): %s",
                                                             len(repaired_content),
                                                             repaired_content[:100],
                                                         )
-                                                        yield {"event": "token", "data": json.dumps({"content": repaired_content})}
+                                                        yield {
+                                                            "event": "token",
+                                                            "data": json.dumps(
+                                                                {
+                                                                    "content": repaired_content
+                                                                }
+                                                            ),
+                                                        }
                                                     break
-                                        yield {"event": "debug_clear", "data": json.dumps({})}
-                                        yield {"event": "done", "data": json.dumps({"reason": "all_todos_completed"})}
+                                        yield {
+                                            "event": "debug_clear",
+                                            "data": json.dumps({}),
+                                        }
+                                        yield {
+                                            "event": "done",
+                                            "data": json.dumps(
+                                                {"reason": "all_todos_completed"}
+                                            ),
+                                        }
                                         return  # Exit the generator
                                     else:
                                         logger.warning(
@@ -2056,7 +2446,39 @@ async def resume_agent(request: ResumeRequest):
                             # ToolMessage processing continues (no final_answer_tool)
 
                         # Handle AIMessage (use elif to avoid processing after ToolMessage)
-                        elif hasattr(last_message, "content") and last_message.content:
+                        elif isinstance(last_message, AIMessage):
+                            # LLM Response - structured JSON format
+                            print(LOG_RESPONSE_START, flush=True)
+                            response_data = {
+                                "type": "AIMessage",
+                                "content": last_message.content or "",
+                                "tool_calls": last_message.tool_calls
+                                if hasattr(last_message, "tool_calls")
+                                else [],
+                                "additional_kwargs": getattr(
+                                    last_message, "additional_kwargs", {}
+                                )
+                                or {},
+                                "response_metadata": getattr(
+                                    last_message, "response_metadata", {}
+                                )
+                                or {},
+                                "usage_metadata": getattr(
+                                    last_message, "usage_metadata", {}
+                                )
+                                or {},
+                            }
+                            print(
+                                json.dumps(
+                                    response_data,
+                                    indent=2,
+                                    ensure_ascii=False,
+                                    default=str,
+                                ),
+                                flush=True,
+                            )
+                            print(LOG_RESPONSE_END, flush=True)
+
                             content = last_message.content
 
                             # Handle list content (e.g., multimodal responses)
@@ -2090,6 +2512,28 @@ async def resume_agent(request: ResumeRequest):
                                     and content_stripped.startswith("{")
                                 )
                             )
+
+                            # Check if this is summary/next_items with tool_calls (premature summary)
+                            has_summary_pattern = (
+                                '"summary"' in content or "'summary'" in content
+                            ) and (
+                                '"next_items"' in content or "'next_items'" in content
+                            )
+                            tool_calls = getattr(last_message, "tool_calls", []) or []
+                            # Check if any tool_call is NOT write_todos (work still in progress)
+                            has_non_todo_tool_calls = any(
+                                tc.get("name")
+                                not in ("write_todos", "write_todos_tool")
+                                for tc in tool_calls
+                            )
+                            # Skip summary if non-write_todos tool_calls exist (work still in progress)
+                            if has_summary_pattern and has_non_todo_tool_calls:
+                                logger.info(
+                                    "Resume: SKIPPING premature summary (has non-todo tool_calls): %s",
+                                    content[:100],
+                                )
+                                content = None  # Skip this content
+
                             if (
                                 content
                                 and isinstance(content, str)
@@ -2120,7 +2564,12 @@ async def resume_agent(request: ResumeRequest):
                                         len(repaired_content),
                                         log_preview,
                                     )
-                                    yield {"event": "token", "data": json.dumps({"content": repaired_content})}
+                                    yield {
+                                        "event": "token",
+                                        "data": json.dumps(
+                                            {"content": repaired_content}
+                                        ),
+                                    }
 
                         if (
                             hasattr(last_message, "tool_calls")
@@ -2147,7 +2596,10 @@ async def resume_agent(request: ResumeRequest):
                                 todos = _emit_todos_from_tool_calls(new_tool_calls)
                                 if todos:
                                     latest_todos = todos
-                                    yield {"event": "todos", "data": json.dumps({"todos": todos})}
+                                    yield {
+                                        "event": "todos",
+                                        "data": json.dumps({"todos": todos}),
+                                    }
                                     # Check if all todos are completed - terminate early
                                     all_completed = all(
                                         t.get("status") == "completed" for t in todos
@@ -2159,7 +2611,7 @@ async def resume_agent(request: ResumeRequest):
                                             "다음단계",
                                             "다음 단계",
                                         ]
-                                        has_summary_todo = any(
+                                        any(
                                             any(
                                                 kw in t.get("content", "")
                                                 for kw in summary_keywords
@@ -2189,7 +2641,9 @@ async def resume_agent(request: ResumeRequest):
                                                 "## 다음 단계",
                                             ]
                                         )
-                                        has_summary = has_summary_json or has_markdown_summary
+                                        has_summary = (
+                                            has_summary_json or has_markdown_summary
+                                        )
 
                                         # Only check current AIMessage for summary (not history, to avoid false positives)
                                         if not has_summary:
@@ -2204,19 +2658,40 @@ async def resume_agent(request: ResumeRequest):
                                             )
                                             # IMPORTANT: Emit the summary content BEFORE terminating
                                             # so the UI can display the summary JSON
-                                            if msg_content and isinstance(msg_content, str):
+                                            if msg_content and isinstance(
+                                                msg_content, str
+                                            ):
                                                 content_hash = hash(msg_content)
                                                 if content_hash not in emitted_contents:
                                                     emitted_contents.add(content_hash)
-                                                    repaired_content = _repair_summary_json_content(msg_content)
+                                                    repaired_content = (
+                                                        _repair_summary_json_content(
+                                                            msg_content
+                                                        )
+                                                    )
                                                     logger.info(
                                                         "Resume auto-terminate: EMITTING summary content (len=%d): %s",
                                                         len(repaired_content),
                                                         repaired_content[:100],
                                                     )
-                                                    yield {"event": "token", "data": json.dumps({"content": repaired_content})}
-                                            yield {"event": "debug_clear", "data": json.dumps({})}
-                                            yield {"event": "done", "data": json.dumps({"reason": "all_todos_completed"})}
+                                                    yield {
+                                                        "event": "token",
+                                                        "data": json.dumps(
+                                                            {
+                                                                "content": repaired_content
+                                                            }
+                                                        ),
+                                                    }
+                                            yield {
+                                                "event": "debug_clear",
+                                                "data": json.dumps({}),
+                                            }
+                                            yield {
+                                                "event": "done",
+                                                "data": json.dumps(
+                                                    {"reason": "all_todos_completed"}
+                                                ),
+                                            }
                                             return  # Exit before executing more tool calls
 
                                 # Process tool calls
@@ -2236,40 +2711,61 @@ async def resume_agent(request: ResumeRequest):
                                         tool_name, tool_args
                                     )
 
-                                    yield {"event": "debug", "data": json.dumps(status_msg)}
+                                    yield {
+                                        "event": "debug",
+                                        "data": json.dumps(status_msg),
+                                    }
 
                                     if tool_name in (
                                         "jupyter_cell_tool",
                                         "jupyter_cell",
                                     ):
-                                        yield {"event": "tool_call", "data": json.dumps({
+                                        yield {
+                                            "event": "tool_call",
+                                            "data": json.dumps(
+                                                {
                                                     "tool": "jupyter_cell",
                                                     "code": tool_args.get("code", ""),
                                                     "description": tool_args.get(
                                                         "description", ""
                                                     ),
-                                                })}
+                                                }
+                                            ),
+                                        }
                                     elif tool_name in ("markdown_tool", "markdown"):
-                                        yield {"event": "tool_call", "data": json.dumps({
+                                        yield {
+                                            "event": "tool_call",
+                                            "data": json.dumps(
+                                                {
                                                     "tool": "markdown",
                                                     "content": tool_args.get(
                                                         "content", ""
                                                     ),
-                                                })}
+                                                }
+                                            ),
+                                        }
                                     elif tool_name == "execute_command_tool":
-                                        yield {"event": "tool_call", "data": json.dumps({
+                                        yield {
+                                            "event": "tool_call",
+                                            "data": json.dumps(
+                                                {
                                                     "tool": "execute_command_tool",
                                                     "command": tool_args.get(
                                                         "command", ""
                                                     ),
                                                     "timeout": tool_args.get("timeout"),
-                                                })}
+                                                }
+                                            ),
+                                        }
                                     elif tool_name in (
                                         "search_notebook_cells_tool",
                                         "search_notebook_cells",
                                     ):
                                         # Search notebook cells - emit tool_call for client-side execution
-                                        yield {"event": "tool_call", "data": json.dumps({
+                                        yield {
+                                            "event": "tool_call",
+                                            "data": json.dumps(
+                                                {
                                                     "tool": "search_notebook_cells",
                                                     "pattern": tool_args.get(
                                                         "pattern", ""
@@ -2286,7 +2782,24 @@ async def resume_agent(request: ResumeRequest):
                                                     "case_sensitive": tool_args.get(
                                                         "case_sensitive", False
                                                     ),
-                                                })}
+                                                }
+                                            ),
+                                        }
+                                    elif tool_name in (
+                                        "final_summary_tool",
+                                        "final_summary",
+                                    ):
+                                        # Final summary - emit summary event for frontend
+                                        summary_data = {
+                                            "summary": tool_args.get("summary", ""),
+                                            "next_items": tool_args.get(
+                                                "next_items", []
+                                            ),
+                                        }
+                                        yield {
+                                            "event": "summary",
+                                            "data": json.dumps(summary_data),
+                                        }
 
                 # Drain and emit any subagent events (tool calls from subagents)
                 for subagent_event in get_subagent_debug_events():
@@ -2297,7 +2810,12 @@ async def resume_agent(request: ResumeRequest):
                 if isinstance(step, dict) and "__interrupt__" in step:
                     interrupts = step["__interrupt__"]
 
-                    yield {"event": "debug", "data": json.dumps({"status": "사용자 승인 대기 중", "icon": "pause"})}
+                    yield {
+                        "event": "debug",
+                        "data": json.dumps(
+                            {"status": "사용자 승인 대기 중", "icon": "pause"}
+                        ),
+                    }
 
                     for interrupt in interrupts:
                         interrupt_value = (
@@ -2306,7 +2824,9 @@ async def resume_agent(request: ResumeRequest):
                             else interrupt
                         )
                         action_requests = interrupt_value.get("action_requests", [])
-                        logger.info(f"[RESUME INTERRUPT] action_requests count: {len(action_requests)}, first: {str(action_requests[0])[:200] if action_requests else 'none'}")
+                        logger.info(
+                            f"[RESUME INTERRUPT] action_requests count: {len(action_requests)}, first: {str(action_requests[0])[:200] if action_requests else 'none'}"
+                        )
                         normalized_actions = [
                             _normalize_action_request(a) for a in action_requests
                         ]
@@ -2319,14 +2839,16 @@ async def resume_agent(request: ResumeRequest):
                         for idx, action in enumerate(normalized_actions):
                             yield {
                                 "event": "interrupt",
-                                "data": json.dumps({
-                                    "thread_id": request.threadId,
-                                    "action": action.get("name", "unknown"),
-                                    "args": action.get("arguments", {}),
-                                    "description": action.get("description", ""),
-                                    "action_index": idx,
-                                    "total_actions": total_actions,
-                                }),
+                                "data": json.dumps(
+                                    {
+                                        "thread_id": request.threadId,
+                                        "action": action.get("name", "unknown"),
+                                        "args": action.get("arguments", {}),
+                                        "description": action.get("description", ""),
+                                        "action_index": idx,
+                                        "total_actions": total_actions,
+                                    }
+                                ),
                             }
 
                     # Save last signature for next resume to avoid duplicate content
@@ -2359,7 +2881,10 @@ async def resume_agent(request: ResumeRequest):
                 last_signature,
                 latest_todos,
             )
-            yield {"event": "complete", "data": json.dumps({"success": True, "thread_id": request.threadId})}
+            yield {
+                "event": "complete",
+                "data": json.dumps({"success": True, "thread_id": request.threadId}),
+            }
 
         except Exception as e:
             error_msg = str(e)
@@ -2370,17 +2895,27 @@ async def resume_agent(request: ResumeRequest):
                 logger.warning(
                     "Detected 'contents is not specified' error - likely session state loss"
                 )
-                yield {"event": "error", "data": json.dumps({
+                yield {
+                    "event": "error",
+                    "data": json.dumps(
+                        {
                             "error": "Session state lost",
                             "code": "CONTENTS_NOT_SPECIFIED",
                             "error_type": type(e).__name__,
                             "message": "세션 상태가 손실되었습니다. 서버가 재시작되었거나 세션이 만료되었습니다. 새로운 대화를 시작해주세요.",
-                        })}
+                        }
+                    ),
+                }
             else:
-                yield {"event": "error", "data": json.dumps({
+                yield {
+                    "event": "error",
+                    "data": json.dumps(
+                        {
                             "error": error_msg,
                             "error_type": type(e).__name__,
-                        })}
+                        }
+                    ),
+                }
 
     return EventSourceResponse(event_generator())
 
@@ -2437,6 +2972,7 @@ async def health_check() -> Dict[str, Any]:
 
 class CancelRequest(BaseModel):
     """Request to cancel a running agent thread"""
+
     thread_id: str
 
 
@@ -2463,3 +2999,70 @@ async def clear_agent_cache() -> Dict[str, Any]:
         "cleared": count,
         "message": f"Cleared {count} cached agent instances",
     }
+
+
+class ResetRequest(BaseModel):
+    """Request to reset a thread (clear session and recreate agent)"""
+
+    thread_id: str
+
+
+@router.post("/reset")
+async def reset_agent_thread(request: ResetRequest) -> Dict[str, Any]:
+    """
+    Reset an agent thread by clearing all session state.
+
+    This will:
+    - Clear the checkpointer (conversation history)
+    - Clear pending actions
+    - Clear emitted contents
+    - Clear last signatures
+    - Remove from cancelled threads set
+
+    The agent instance itself is not cleared (it's shared across threads),
+    but the thread state is completely reset.
+    """
+    thread_id = request.thread_id
+
+    # Track what was cleared
+    cleared = []
+
+    # Clear checkpointer (conversation history)
+    if thread_id in _simple_agent_checkpointers:
+        del _simple_agent_checkpointers[thread_id]
+        cleared.append("checkpointer")
+
+    # Clear pending actions
+    if thread_id in _simple_agent_pending_actions:
+        del _simple_agent_pending_actions[thread_id]
+        cleared.append("pending_actions")
+
+    # Clear last signatures
+    if thread_id in _simple_agent_last_signatures:
+        del _simple_agent_last_signatures[thread_id]
+        cleared.append("last_signatures")
+
+    # Clear emitted contents
+    if thread_id in _simple_agent_emitted_contents:
+        del _simple_agent_emitted_contents[thread_id]
+        cleared.append("emitted_contents")
+
+    # Remove from cancelled threads
+    if thread_id in _cancelled_threads:
+        _cancelled_threads.discard(thread_id)
+        cleared.append("cancelled_flag")
+
+    logger.info(
+        "Reset thread %s: cleared %s",
+        thread_id,
+        ", ".join(cleared) if cleared else "nothing (thread not found)",
+    )
+
+    return {
+        "status": "ok",
+        "thread_id": thread_id,
+        "cleared": cleared,
+        "message": f"Thread {thread_id} has been reset"
+        if cleared
+        else f"Thread {thread_id} had no state to clear",
+    }