hdsp-jupyter-extension 2.0.21__py3-none-any.whl → 2.0.22__py3-none-any.whl

agent_server/routers/langchain_agent.py

@@ -895,10 +895,7 @@ 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(
@@ -908,10 +905,7 @@ async def stream_agent(request: AgentRequest):
                 if is_thread_cancelled(thread_id):
                     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):
@@ -931,18 +925,12 @@ async def stream_agent(request: AgentRequest):
                     todos = step["todos"]
                     if todos:
                         latest_todos = todos
-                        yield {
-                            "event": "todos",
-                            "data": json.dumps({"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}),
-                        }
+                        yield {"event": "todos", "data": json.dumps({"todos": todos})}
 
                 # Process messages (no continue statements to ensure interrupt check always runs)
                 if isinstance(step, dict) and "messages" in step:
@@ -992,10 +980,7 @@ 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
@@ -1039,21 +1024,10 @@ 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})}
                                                     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(
@@ -1183,20 +1157,10 @@ 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
 
@@ -1226,10 +1190,7 @@ async def stream_agent(request: AgentRequest):
                                         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
@@ -1297,20 +1258,9 @@ async def stream_agent(request: AgentRequest):
                                                         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")
@@ -1325,10 +1275,7 @@ 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 (
@@ -1336,55 +1283,37 @@ 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", ""
@@ -1401,9 +1330,7 @@ async def stream_agent(request: AgentRequest):
                                                     "case_sensitive": tool_args.get(
                                                         "case_sensitive", False
                                                     ),
-                                                }
-                                            ),
-                                        }
+                                                })}
 
                             # Only display content if it's not empty and not a JSON tool response
                             if (
@@ -1472,12 +1399,7 @@ 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():
@@ -1496,10 +1418,7 @@ 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:
@@ -1524,16 +1443,14 @@ 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
@@ -1624,14 +1541,9 @@ 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:
@@ -1640,12 +1552,7 @@ 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) and getattr(
@@ -1659,57 +1566,27 @@ 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 == "read_file_tool":
                             # For file operations, generate code with the LLM
                             logger.info(
@@ -1741,32 +1618,20 @@ 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
@@ -1775,11 +1640,9 @@ 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 (
@@ -1791,41 +1654,25 @@ 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())
 
@@ -1879,16 +1726,11 @@ 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)
@@ -1998,10 +1840,7 @@ 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)
 
@@ -2027,10 +1866,7 @@ 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
 
@@ -2044,10 +1880,7 @@ async def resume_agent(request: ResumeRequest):
                 if is_thread_cancelled(request.threadId):
                     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
@@ -2149,10 +1982,7 @@ 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
@@ -2195,21 +2025,10 @@ async def resume_agent(request: ResumeRequest):
                                                             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(
@@ -2301,12 +2120,7 @@ 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")
@@ -2333,10 +2147,7 @@ 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
@@ -2403,20 +2214,9 @@ async def resume_agent(request: ResumeRequest):
                                                         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
@@ -2436,61 +2236,40 @@ 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", ""
@@ -2507,9 +2286,7 @@ async def resume_agent(request: ResumeRequest):
                                                     "case_sensitive": tool_args.get(
                                                         "case_sensitive", False
                                                     ),
-                                                }
-                                            ),
-                                        }
+                                                })}
 
                 # Drain and emit any subagent events (tool calls from subagents)
                 for subagent_event in get_subagent_debug_events():
@@ -2520,10 +2297,7 @@ 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 = (
@@ -2545,16 +2319,14 @@ 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
@@ -2587,10 +2359,7 @@ 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)
@@ -2601,27 +2370,17 @@ 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())