hdsp-jupyter-extension 2.0.5__py3-none-any.whl → 2.0.7__py3-none-any.whl

agent_server/routers/langchain_agent.py

@@ -8,8 +8,9 @@ Provides streaming and non-streaming endpoints for agent execution.
 import asyncio
 import json
 import logging
+import os
 import uuid
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 from fastapi import APIRouter, HTTPException
 from langchain_core.messages import AIMessage, HumanMessage, SystemMessage, ToolMessage
@@ -18,15 +19,37 @@ from pydantic import BaseModel, ConfigDict, Field
 from sse_starlette.sse import EventSourceResponse
 
 from agent_server.langchain.agent import (
-    _create_llm,
     _get_all_tools,
     create_simple_chat_agent,
 )
+from agent_server.langchain.llm_factory import create_llm
 
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/langchain", tags=["langchain-agent"])
 
 
+def _find_project_root(start_path: str) -> str:
+    current = os.path.abspath(start_path)
+    while True:
+        if os.path.isdir(os.path.join(current, "extensions")) and os.path.isdir(
+            os.path.join(current, "agent-server")
+        ):
+            return current
+        parent = os.path.dirname(current)
+        if parent == current:
+            return os.path.abspath(start_path)
+        current = parent
+
+
+def _resolve_workspace_root(workspace_root: Optional[str]) -> str:
+    normalized = os.path.normpath(workspace_root or ".")
+    if normalized == ".":
+        return _find_project_root(os.getcwd())
+    if not os.path.isabs(normalized):
+        return os.path.abspath(os.path.join(os.getcwd(), normalized))
+    return os.path.abspath(normalized)
+
+
 # ============ Request/Response Models ============
 
 
@@ -44,6 +67,11 @@ class LLMConfig(BaseModel):
         alias="systemPrompt",
         description="Override system prompt for LangChain agent",
     )
+    resource_context: Optional[Union[Dict[str, Any], str]] = Field(
+        default=None,
+        alias="resourceContext",
+        description="Client resource usage snapshot for prompt injection",
+    )
 
 
 class NotebookContext(BaseModel):
@@ -140,8 +168,45 @@ class AgentResponse(BaseModel):
 # ============ Agent Instance Cache ============
 
 
+_simple_agent_instances: Dict[str, Any] = {}  # Cache agent instances by cache key
 _simple_agent_checkpointers: Dict[str, Any] = {}
 _simple_agent_pending_actions: Dict[str, List[Dict[str, Any]]] = {}
+_simple_agent_last_signatures: Dict[
+    str, str
+] = {}  # Track last message signature per thread
+_simple_agent_emitted_contents: Dict[
+    str, set
+] = {}  # Track emitted content hashes per thread to prevent duplicates
+
+
+def _get_agent_cache_key(
+    llm_config: Dict[str, Any],
+    workspace_root: str,
+    system_prompt_override: Optional[str] = None,
+) -> str:
+    """Generate cache key for agent instance.
+
+    Agent instances are cached based on LLM config, workspace root, and system prompt.
+    Different configurations require different agent instances.
+
+    Args:
+        llm_config: LLM configuration dictionary
+        workspace_root: Workspace root directory
+        system_prompt_override: Optional custom system prompt
+
+    Returns:
+        MD5 hash of the configuration as cache key
+    """
+    import hashlib
+
+    # Serialize config to deterministic string
+    config_str = json.dumps(llm_config, sort_keys=True)
+    prompt_str = system_prompt_override or ""
+
+    cache_data = f"{config_str}|{workspace_root}|{prompt_str}"
+    cache_key = hashlib.md5(cache_data.encode()).hexdigest()
+
+    return cache_key
 
 
 def _normalize_action_request(action: Dict[str, Any]) -> Dict[str, Any]:
@@ -253,12 +318,36 @@ def _normalize_tool_calls(raw_tool_calls: Any) -> List[Dict[str, Any]]:
 
 
 def _message_signature(message: Any) -> str:
-    """Create a stable signature to de-duplicate repeated streamed messages."""
+    """Create a stable signature to de-duplicate repeated streamed messages.
+
+    NOTE: We normalize tool_calls by removing 'execution_result' from args,
+    because the same AIMessage can be streamed again with execution results
+    added to the tool_calls args after HITL approval.
+    """
     content = getattr(message, "content", "") or ""
     tool_calls = getattr(message, "tool_calls", None)
     if tool_calls:
         try:
-            tool_calls = json.dumps(tool_calls, ensure_ascii=False, sort_keys=True)
+            # Normalize tool_calls: remove execution_result from args to ensure
+            # the same logical message has the same signature before and after execution
+            normalized_calls = []
+            for tc in tool_calls:
+                if isinstance(tc, dict):
+                    normalized_tc = {k: v for k, v in tc.items() if k != "args"}
+                    args = tc.get("args", {})
+                    if isinstance(args, dict):
+                        # Remove execution_result from args
+                        normalized_tc["args"] = {
+                            k: v for k, v in args.items() if k != "execution_result"
+                        }
+                    else:
+                        normalized_tc["args"] = args
+                    normalized_calls.append(normalized_tc)
+                else:
+                    normalized_calls.append(tc)
+            tool_calls = json.dumps(
+                normalized_calls, ensure_ascii=False, sort_keys=True
+            )
         except TypeError:
             tool_calls = str(tool_calls)
     else:
@@ -274,6 +363,45 @@ def _complete_todos(todos: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     ]
 
 
+async def _async_stream_wrapper(agent, input_data, config, stream_mode="values"):
+    """
+    Wrap synchronous agent.stream() in an async generator using asyncio.Queue.
+
+    This prevents blocking the event loop, allowing SSE events to be flushed
+    immediately instead of being buffered until the stream completes.
+    """
+    from concurrent.futures import ThreadPoolExecutor
+
+    queue: asyncio.Queue = asyncio.Queue()
+    loop = asyncio.get_running_loop()
+
+    def run_stream():
+        try:
+            for step in agent.stream(input_data, config, stream_mode=stream_mode):
+                # Put step into queue from sync thread
+                asyncio.run_coroutine_threadsafe(
+                    queue.put(("step", step)), loop
+                ).result()
+        except Exception as e:
+            asyncio.run_coroutine_threadsafe(queue.put(("error", e)), loop).result()
+        finally:
+            asyncio.run_coroutine_threadsafe(queue.put(("done", None)), loop).result()
+
+    # Run sync stream in a separate thread
+    executor = ThreadPoolExecutor(max_workers=1)
+    loop.run_in_executor(executor, run_stream)
+
+    # Async yield steps from queue
+    while True:
+        event_type, data = await queue.get()
+        if event_type == "done":
+            break
+        elif event_type == "error":
+            raise data
+        else:
+            yield data
+
+
 async def _generate_fallback_code(
     llm: Any,
     tool_name: str,
@@ -337,13 +465,22 @@ async def stream_agent(request: AgentRequest):
     - error: Error events
     """
 
-    logger.info(f"Agent stream request: {request.request[:100]}...")
+    logger.info(
+        "Agent stream request received: length=%d chars, first 100='%s...'",
+        len(request.request),
+        request.request[:100],
+    )
 
     if not request.request:
         raise HTTPException(status_code=400, detail="Request is required")
 
     # Generate thread_id if not provided
     thread_id = request.threadId or str(uuid.uuid4())
+    logger.info(
+        "Stream request - threadId from request: %s, using thread_id: %s",
+        request.threadId,
+        thread_id,
+    )
 
     async def event_generator():
         try:
@@ -371,23 +508,76 @@ async def stream_agent(request: AgentRequest):
                     config_dict["openai"] = request.llmConfig.openai
                 if request.llmConfig.vllm:
                     config_dict["vllm"] = request.llmConfig.vllm
+                if request.llmConfig.resource_context:
+                    config_dict["resource_context"] = request.llmConfig.resource_context
             system_prompt_override = (
                 request.llmConfig.system_prompt if request.llmConfig else None
             )
 
-            agent = create_simple_chat_agent(
+            # Get or create checkpointer for this thread
+            is_existing_thread = thread_id in _simple_agent_checkpointers
+            checkpointer = _simple_agent_checkpointers.setdefault(
+                thread_id, InMemorySaver()
+            )
+            logger.info(
+                "Checkpointer for thread %s: existing=%s, total_threads=%d",
+                thread_id,
+                is_existing_thread,
+                len(_simple_agent_checkpointers),
+            )
+
+            resolved_workspace_root = _resolve_workspace_root(request.workspaceRoot)
+
+            # Get or create cached agent
+            agent_cache_key = _get_agent_cache_key(
                 llm_config=config_dict,
-                workspace_root=request.workspaceRoot or ".",
-                enable_hitl=True,
-                checkpointer=_simple_agent_checkpointers.setdefault(
-                    thread_id, InMemorySaver()
-                ),
+                workspace_root=resolved_workspace_root,
                 system_prompt_override=system_prompt_override,
             )
 
+            if agent_cache_key in _simple_agent_instances:
+                agent = _simple_agent_instances[agent_cache_key]
+                logger.info(
+                    "Using cached agent for key %s (total cached: %d)",
+                    agent_cache_key[:8],
+                    len(_simple_agent_instances),
+                )
+            else:
+                logger.info("Creating new agent for key %s", agent_cache_key[:8])
+                agent = create_simple_chat_agent(
+                    llm_config=config_dict,
+                    workspace_root=resolved_workspace_root,
+                    enable_hitl=True,
+                    checkpointer=checkpointer,
+                    system_prompt_override=system_prompt_override,
+                )
+                _simple_agent_instances[agent_cache_key] = agent
+                logger.info(
+                    "Agent cached for key %s (total cached: %d)",
+                    agent_cache_key[:8],
+                    len(_simple_agent_instances),
+                )
+
             # Prepare config with thread_id
             config = {"configurable": {"thread_id": thread_id}}
 
+            # Debug: Check if there's existing state for this thread
+            try:
+                existing_state = checkpointer.get(config)
+                if existing_state:
+                    existing_messages = existing_state.get("channel_values", {}).get(
+                        "messages", []
+                    )
+                    logger.info(
+                        "Existing state for thread %s: %d messages found",
+                        thread_id,
+                        len(existing_messages),
+                    )
+                else:
+                    logger.info("No existing state for thread %s", thread_id)
+            except Exception as e:
+                logger.warning("Could not check existing state: %s", e)
+
             # Prepare input
             agent_input = {"messages": [{"role": "user", "content": request.request}]}
 
@@ -399,63 +589,27 @@ async def stream_agent(request: AgentRequest):
             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
 
             # Initial status: waiting for LLM
+            logger.info("SSE: Sending initial debug status '🤔 LLM 응답 대기 중'")
             yield {
                 "event": "debug",
                 "data": json.dumps({"status": "🤔 LLM 응답 대기 중"}),
             }
 
-            for step in agent.stream(agent_input, config, stream_mode="values"):
+            async for step in _async_stream_wrapper(
+                agent, agent_input, config, stream_mode="values"
+            ):
                 if isinstance(step, dict):
                     logger.info(
                         "SimpleAgent step keys: %s", ",".join(sorted(step.keys()))
                     )
-                # Check for interrupt
-                if isinstance(step, dict) and "__interrupt__" in step:
-                    interrupts = step["__interrupt__"]
-
-                    yield {
-                        "event": "debug",
-                        "data": json.dumps({"status": "⏸️ 사용자 승인 대기 중"}),
-                    }
-
-                    # Process interrupts
-                    for interrupt in interrupts:
-                        interrupt_value = (
-                            interrupt.value
-                            if hasattr(interrupt, "value")
-                            else interrupt
-                        )
-
-                        # Extract action requests
-                        action_requests = interrupt_value.get("action_requests", [])
-                        normalized_actions = [
-                            _normalize_action_request(a) for a in action_requests
-                        ]
-                        if normalized_actions:
-                            _simple_agent_pending_actions[thread_id] = (
-                                normalized_actions
-                            )
-
-                        total_actions = len(normalized_actions)
-                        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,
-                                    }
-                                ),
-                            }
 
-                    # Stop streaming - wait for resume
-                    return
+                # IMPORTANT: Process todos and messages BEFORE checking for interrupt
+                # This ensures todos/debug events are emitted even in interrupt steps
 
                 # Check for todos in state and stream them
                 if isinstance(step, dict) and "todos" in step:
@@ -475,107 +629,129 @@ async def stream_agent(request: AgentRequest):
                             "data": json.dumps({"todos": todos}),
                         }
 
-                # Process messages
+                # Process messages (no continue statements to ensure interrupt check always runs)
                 if isinstance(step, dict) and "messages" in step:
                     messages = step["messages"]
+                    should_process_message = False
                     if messages:
                         last_message = messages[-1]
                         signature = _message_signature(last_message)
-                        if signature == last_signature:
-                            continue
-                        last_signature = signature
-                    logger.info(
-                        "SimpleAgent last_message type=%s has_content=%s tool_calls=%s",
-                        type(last_message).__name__,
-                        bool(getattr(last_message, "content", None)),
-                        bool(getattr(last_message, "tool_calls", None)),
-                    )
-
-                    # Skip HumanMessage - don't echo user's input back
-                    if isinstance(last_message, HumanMessage):
-                        continue
-
-                    # Handle ToolMessage - extract final_answer result
-                    if isinstance(last_message, ToolMessage):
-                        logger.info(
-                            "SimpleAgent ToolMessage content: %s",
-                            last_message.content,
-                        )
-                        todos = _extract_todos(last_message.content)
-                        if todos:
-                            latest_todos = todos
-                            yield {
-                                "event": "todos",
-                                "data": json.dumps({"todos": todos}),
-                            }
-                        tool_name = getattr(last_message, "name", "") or ""
                         logger.info(
-                            "SimpleAgent ToolMessage name attribute: %s", tool_name
+                            "Initial: Signature comparison - current: %s, last: %s, match: %s",
+                            signature[:100] if signature else None,
+                            last_signature[:100] if last_signature else None,
+                            signature == last_signature,
                         )
-
-                        # Also check content for tool name if name attribute is empty
-                        if not tool_name:
-                            try:
-                                content_json = json.loads(last_message.content)
-                                tool_name = content_json.get("tool", "")
+                        # Only process if this is a new message (not duplicate)
+                        if signature != last_signature:
+                            last_signature = signature
+                            # Skip HumanMessage
+                            if not isinstance(last_message, HumanMessage):
+                                should_process_message = True
                                 logger.info(
-                                    "SimpleAgent ToolMessage tool from content: %s",
-                                    tool_name,
+                                    "SimpleAgent last_message type=%s has_content=%s tool_calls=%s",
+                                    type(last_message).__name__,
+                                    bool(getattr(last_message, "content", None)),
+                                    bool(getattr(last_message, "tool_calls", None)),
                                 )
-                            except (json.JSONDecodeError, TypeError):
-                                pass
 
-                        if tool_name in ("final_answer_tool", "final_answer"):
-                            # Extract the final answer from the tool result
-                            try:
-                                tool_result = json.loads(last_message.content)
-                                # Check both direct "answer" and "parameters.answer"
-                                final_answer = tool_result.get(
-                                    "answer"
-                                ) or tool_result.get("parameters", {}).get("answer")
-                                if final_answer:
-                                    yield {
-                                        "event": "token",
-                                        "data": json.dumps({"content": final_answer}),
-                                    }
-                                else:
-                                    # Fallback to raw content if no answer found
-                                    yield {
-                                        "event": "token",
-                                        "data": json.dumps(
-                                            {"content": last_message.content}
-                                        ),
-                                    }
-                            except json.JSONDecodeError:
-                                # If not JSON, use content directly
-                                if last_message.content:
+                    # Process message only if it's new and not HumanMessage
+                    if should_process_message:
+                        # Handle ToolMessage - extract final_answer result
+                        if isinstance(last_message, ToolMessage):
+                            logger.info(
+                                "SimpleAgent ToolMessage content: %s",
+                                last_message.content,
+                            )
+                            todos = _extract_todos(last_message.content)
+                            if todos:
+                                latest_todos = todos
+                                yield {
+                                    "event": "todos",
+                                    "data": json.dumps({"todos": todos}),
+                                }
+                            tool_name = getattr(last_message, "name", "") or ""
+                            logger.info(
+                                "SimpleAgent ToolMessage name attribute: %s", tool_name
+                            )
+
+                            # Also check content for tool name if name attribute is empty
+                            if not tool_name:
+                                try:
+                                    content_json = json.loads(last_message.content)
+                                    tool_name = content_json.get("tool", "")
+                                    logger.info(
+                                        "SimpleAgent ToolMessage tool from content: %s",
+                                        tool_name,
+                                    )
+                                except (json.JSONDecodeError, TypeError):
+                                    pass
+
+                            if tool_name in ("final_answer_tool", "final_answer"):
+                                # Extract the final answer from the tool result
+                                try:
+                                    tool_result = json.loads(last_message.content)
+                                    # Check both direct "answer" and "parameters.answer"
+                                    final_answer = tool_result.get(
+                                        "answer"
+                                    ) or tool_result.get("parameters", {}).get("answer")
+                                    # Check for next_items in summary field (Gemini puts JSON here)
+                                    summary = tool_result.get(
+                                        "summary"
+                                    ) or tool_result.get("parameters", {}).get("summary")
+                                    if summary:
+                                        try:
+                                            summary_json = json.loads(summary)
+                                            if "next_items" in summary_json:
+                                                next_items_block = f"\n\n```json\n{json.dumps(summary_json, ensure_ascii=False, indent=2)}\n```"
+                                                final_answer = (final_answer or "") + next_items_block
+                                                logger.info("Extracted next_items from summary field")
+                                        except (json.JSONDecodeError, TypeError):
+                                            pass
+                                    if final_answer:
+                                        yield {
+                                            "event": "token",
+                                            "data": json.dumps(
+                                                {"content": final_answer}
+                                            ),
+                                        }
+                                    else:
+                                        # Fallback to raw content if no answer found
+                                        yield {
+                                            "event": "token",
+                                            "data": json.dumps(
+                                                {"content": last_message.content}
+                                            ),
+                                        }
+                                except json.JSONDecodeError:
+                                    # If not JSON, use content directly
+                                    if last_message.content:
+                                        yield {
+                                            "event": "token",
+                                            "data": json.dumps(
+                                                {"content": last_message.content}
+                                            ),
+                                        }
+                                if latest_todos:
                                     yield {
-                                        "event": "token",
+                                        "event": "todos",
                                         "data": json.dumps(
-                                            {"content": last_message.content}
+                                            {"todos": _complete_todos(latest_todos)}
                                         ),
                                     }
-                            if latest_todos:
+                                # End stream after final answer
+                                yield {"event": "debug_clear", "data": json.dumps({})}
                                 yield {
-                                    "event": "todos",
+                                    "event": "complete",
                                     "data": json.dumps(
-                                        {"todos": _complete_todos(latest_todos)}
+                                        {"success": True, "thread_id": thread_id}
                                     ),
                                 }
-                            # End stream after final answer
-                            yield {"event": "debug_clear", "data": json.dumps({})}
-                            yield {
-                                "event": "complete",
-                                "data": json.dumps(
-                                    {"success": True, "thread_id": thread_id}
-                                ),
-                            }
-                            return
-                        # Skip other tool messages (jupyter_cell, markdown results)
-                        continue
+                                return
+                            # Other ToolMessages: don't skip with continue, just don't process further
 
                         # Handle AIMessage
-                        if isinstance(last_message, AIMessage):
+                        elif isinstance(last_message, AIMessage):
                             logger.info(
                                 "SimpleAgent AIMessage content: %s",
                                 last_message.content or "",
@@ -630,9 +806,19 @@ async def stream_agent(request: AgentRequest):
                                     ).get("function_call")
                                 tool_calls = _normalize_tool_calls(raw_tool_calls)
 
+                            has_final_answer_tool = False
                             if tool_calls:
+                                has_final_answer_tool = any(
+                                    (call.get("name") or call.get("tool") or "")
+                                    in ("final_answer_tool", "final_answer")
+                                    for call in tool_calls
+                                )
                                 todos = _emit_todos_from_tool_calls(tool_calls)
                                 if todos:
+                                    logger.info(
+                                        "SSE: Emitting todos event from AIMessage tool_calls: %d items",
+                                        len(todos),
+                                    )
                                     latest_todos = todos
                                     yield {
                                         "event": "todos",
@@ -642,11 +828,33 @@ async def stream_agent(request: AgentRequest):
                                     tool_name = tool_call.get("name", "unknown")
                                     tool_args = tool_call.get("args", {})
 
+                                    # Create detailed status message for search tools
+                                    if tool_name in (
+                                        "search_workspace_tool",
+                                        "search_workspace",
+                                    ):
+                                        pattern = tool_args.get("pattern", "")
+                                        path = tool_args.get("path", ".")
+                                        status_msg = f"🔍 검색 실행: grep/rg '{pattern}' in {path}"
+                                    elif tool_name in (
+                                        "search_notebook_cells_tool",
+                                        "search_notebook_cells",
+                                    ):
+                                        pattern = tool_args.get("pattern", "")
+                                        nb_path = tool_args.get(
+                                            "notebook_path", "all notebooks"
+                                        )
+                                        status_msg = f"🔍 노트북 검색: '{pattern}' in {nb_path or 'all notebooks'}"
+                                    else:
+                                        status_msg = f"🔧 Tool 실행: {tool_name}"
+
+                                    logger.info(
+                                        "SSE: Emitting debug event for tool: %s",
+                                        tool_name,
+                                    )
                                     yield {
                                         "event": "debug",
-                                        "data": json.dumps(
-                                            {"status": f"🔧 Tool 실행: {tool_name}"}
-                                        ),
+                                        "data": json.dumps({"status": status_msg}),
                                     }
 
                                     # Send tool_call event with details for frontend to execute
@@ -680,6 +888,77 @@ async def stream_agent(request: AgentRequest):
                                                 }
                                             ),
                                         }
+                                    elif tool_name == "execute_command_tool":
+                                        produced_output = True
+                                        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_workspace_tool",
+                                        "search_workspace",
+                                    ):
+                                        # Search workspace - emit tool_call for client-side execution
+                                        produced_output = True
+                                        yield {
+                                            "event": "tool_call",
+                                            "data": json.dumps(
+                                                {
+                                                    "tool": "search_workspace",
+                                                    "pattern": tool_args.get(
+                                                        "pattern", ""
+                                                    ),
+                                                    "file_types": tool_args.get(
+                                                        "file_types",
+                                                        ["*.py", "*.ipynb"],
+                                                    ),
+                                                    "path": tool_args.get("path", "."),
+                                                    "max_results": tool_args.get(
+                                                        "max_results", 50
+                                                    ),
+                                                    "case_sensitive": tool_args.get(
+                                                        "case_sensitive", False
+                                                    ),
+                                                }
+                                            ),
+                                        }
+                                    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(
+                                                {
+                                                    "tool": "search_notebook_cells",
+                                                    "pattern": tool_args.get(
+                                                        "pattern", ""
+                                                    ),
+                                                    "notebook_path": tool_args.get(
+                                                        "notebook_path"
+                                                    ),
+                                                    "cell_type": tool_args.get(
+                                                        "cell_type"
+                                                    ),
+                                                    "max_results": tool_args.get(
+                                                        "max_results", 30
+                                                    ),
+                                                    "case_sensitive": tool_args.get(
+                                                        "case_sensitive", False
+                                                    ),
+                                                }
+                                            ),
+                                        }
 
                             # Only display content if it's not empty and not a JSON tool response
                             if (
@@ -688,29 +967,126 @@ async def stream_agent(request: AgentRequest):
                             ):
                                 content = last_message.content
 
+                                # Handle list content (e.g., multimodal responses)
+                                if isinstance(content, list):
+                                    # Extract text content from list
+                                    text_parts = []
+                                    for part in content:
+                                        if isinstance(part, str):
+                                            text_parts.append(part)
+                                        elif (
+                                            isinstance(part, dict)
+                                            and part.get("type") == "text"
+                                        ):
+                                            text_parts.append(part.get("text", ""))
+                                    content = "\n".join(text_parts)
+
                                 # Filter out raw JSON tool responses
-                                if not (
-                                    content.strip().startswith('{"tool":')
-                                    or content.strip().startswith('{"status":')
-                                    or '"pending_execution"' in content
-                                    or '"status": "complete"' in content
+                                if (
+                                    content
+                                    and isinstance(content, str)
+                                    and not has_final_answer_tool
+                                    and not (
+                                        content.strip().startswith('{"tool":')
+                                        or content.strip().startswith('{"status":')
+                                        or '"pending_execution"' in content
+                                        or '"status": "complete"' in content
+                                    )
                                 ):
-                                    produced_output = True
-                                    yield {
-                                        "event": "token",
-                                        "data": json.dumps({"content": content}),
-                                    }
+                                    # Check if we've already emitted this content (prevents duplicates)
+                                    content_hash = hash(content)
+                                    if content_hash in emitted_contents:
+                                        logger.info(
+                                            "Initial: SKIPPING duplicate content (len=%d): %s",
+                                            len(content),
+                                            content[:100],
+                                        )
+                                    else:
+                                        emitted_contents.add(content_hash)
+                                        logger.info(
+                                            "Initial: EMITTING token content (len=%d): %s",
+                                            len(content),
+                                            content[:100],
+                                        )
+                                        produced_output = True
+                                        yield {
+                                            "event": "token",
+                                            "data": json.dumps({"content": content}),
+                                        }
 
-            if not produced_output and last_finish_reason == "MALFORMED_FUNCTION_CALL":
-                logger.info(
-                    "SimpleAgent fallback: retrying tool call generation after malformed function call"
-                )
-                try:
-                    fallback_config = json.loads(json.dumps(config_dict))
-                    if fallback_config.get(
-                        "provider"
-                    ) == "gemini" and fallback_config.get("gemini", {}).get(
-                        "model", ""
+                # Check for interrupt AFTER processing todos and messages
+                # This ensures todos/debug events are emitted even in interrupt steps
+                if isinstance(step, dict) and "__interrupt__" in step:
+                    interrupts = step["__interrupt__"]
+
+                    yield {
+                        "event": "debug",
+                        "data": json.dumps({"status": "⏸️ 사용자 승인 대기 중"}),
+                    }
+
+                    # Process interrupts
+                    for interrupt in interrupts:
+                        interrupt_value = (
+                            interrupt.value
+                            if hasattr(interrupt, "value")
+                            else interrupt
+                        )
+
+                        # Extract action requests
+                        action_requests = interrupt_value.get("action_requests", [])
+                        normalized_actions = [
+                            _normalize_action_request(a) for a in action_requests
+                        ]
+                        if normalized_actions:
+                            _simple_agent_pending_actions[thread_id] = (
+                                normalized_actions
+                            )
+
+                        total_actions = len(normalized_actions)
+                        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,
+                                    }
+                                ),
+                            }
+
+                    # Save last signature for resume to avoid duplicate content
+                    if last_signature:
+                        _simple_agent_last_signatures[thread_id] = last_signature
+                        logger.info(
+                            "Interrupt: Saved signature for thread %s: %s",
+                            thread_id,
+                            last_signature[:100] if last_signature else None,
+                        )
+                    # Save emitted contents for resume
+                    _simple_agent_emitted_contents[thread_id] = emitted_contents
+                    logger.info(
+                        "Interrupt: Saved %d emitted content hashes for thread %s",
+                        len(emitted_contents),
+                        thread_id,
+                    )
+
+                    # Stop streaming - wait for resume
+                    return
+
+            if not produced_output and last_finish_reason == "MALFORMED_FUNCTION_CALL":
+                logger.info(
+                    "SimpleAgent fallback: retrying tool call generation after malformed function call"
+                )
+                try:
+                    fallback_config = json.loads(json.dumps(config_dict))
+                    if fallback_config.get(
+                        "provider"
+                    ) == "gemini" and fallback_config.get("gemini", {}).get(
+                        "model", ""
                     ).endswith("flash"):
                         fallback_config.setdefault("gemini", {})["model"] = (
                             "gemini-2.5-pro"
@@ -719,7 +1095,7 @@ async def stream_agent(request: AgentRequest):
                             "SimpleAgent fallback: switching model to gemini-2.5-pro"
                         )
 
-                    llm = _create_llm(fallback_config)
+                    llm = create_llm(fallback_config)
                     tools = _get_all_tools()
                     # Force tool calling - use tool_config for Gemini, tool_choice for others
                     provider = config_dict.get("provider", "gemini")
@@ -838,6 +1214,24 @@ async def stream_agent(request: AgentRequest):
                                     }
                                 ),
                             }
+                        elif tool_name == "execute_command_tool":
+                            produced_output = True
+                            yield {
+                                "event": "debug",
+                                "data": json.dumps(
+                                    {"status": f"🔧 Tool 실행: {tool_name}"}
+                                ),
+                            }
+                            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 (
                             "read_file_tool",
                             "list_files_tool",
@@ -987,48 +1381,54 @@ async def resume_agent(request: ResumeRequest):
                     config_dict["openai"] = request.llmConfig.openai
                 if request.llmConfig.vllm:
                     config_dict["vllm"] = request.llmConfig.vllm
+                if request.llmConfig.resource_context:
+                    config_dict["resource_context"] = request.llmConfig.resource_context
             system_prompt_override = (
                 request.llmConfig.system_prompt if request.llmConfig else None
             )
+            # Get or create cached agent
+            resolved_workspace_root = _resolve_workspace_root(request.workspaceRoot)
+            checkpointer = _simple_agent_checkpointers.setdefault(
+                request.threadId, InMemorySaver()
+            )
 
-            # Create agent (will use same checkpointer)
-            agent = create_simple_chat_agent(
+            agent_cache_key = _get_agent_cache_key(
                 llm_config=config_dict,
-                workspace_root=request.workspaceRoot or ".",
-                enable_hitl=True,
-                checkpointer=_simple_agent_checkpointers.setdefault(
-                    request.threadId, InMemorySaver()
-                ),
+                workspace_root=resolved_workspace_root,
                 system_prompt_override=system_prompt_override,
             )
 
+            if agent_cache_key in _simple_agent_instances:
+                agent = _simple_agent_instances[agent_cache_key]
+                logger.info(
+                    "Resume: Using cached agent for key %s (total cached: %d)",
+                    agent_cache_key[:8],
+                    len(_simple_agent_instances),
+                )
+            else:
+                logger.info("Resume: Creating new agent for key %s", agent_cache_key[:8])
+                agent = create_simple_chat_agent(
+                    llm_config=config_dict,
+                    workspace_root=resolved_workspace_root,
+                    enable_hitl=True,
+                    checkpointer=checkpointer,
+                    system_prompt_override=system_prompt_override,
+                )
+                _simple_agent_instances[agent_cache_key] = agent
+                logger.info(
+                    "Resume: Agent cached for key %s (total cached: %d)",
+                    agent_cache_key[:8],
+                    len(_simple_agent_instances),
+                )
+
             # Prepare config with thread_id
             config = {"configurable": {"thread_id": request.threadId}}
 
             pending_actions = _simple_agent_pending_actions.get(request.threadId, [])
-            num_pending = len(pending_actions)
-            num_decisions = len(request.decisions)
-
-            # If user provides fewer decisions than pending actions,
-            # reject remaining actions to avoid multiple state updates per step
-            # This prevents "Can receive only one value per step" errors for todos
-            decisions_to_process = list(request.decisions)
-            if num_decisions < num_pending and num_decisions > 0:
-                logger.info(
-                    f"Have {num_decisions} decision(s) but {num_pending} pending action(s). "
-                    f"Auto-rejecting remaining {num_pending - num_decisions} action(s)."
-                )
-                # Create reject decisions for remaining actions
-                for i in range(num_pending - num_decisions):
-                    reject_decision = ResumeDecision(
-                        type="reject",
-                        feedback="Auto-rejected: only one action can be processed at a time"
-                    )
-                    decisions_to_process.append(reject_decision)
 
             # Convert decisions to LangChain format
             langgraph_decisions = []
-            for index, decision in enumerate(decisions_to_process):
+            for index, decision in enumerate(request.decisions):
                 if decision.type == "approve":
                     langgraph_decisions.append({"type": "approve"})
                 elif decision.type == "edit":
@@ -1049,8 +1449,8 @@ async def resume_agent(request: ResumeRequest):
                     langgraph_decisions.append(
                         {
                             "type": "reject",
-                            "feedback": decision.feedback
-                            or "User rejected this action",
+                            # LangChain HITL middleware expects 'message' key for reject feedback
+                            "message": decision.feedback or "User rejected this action",
                         }
                     )
 
@@ -1066,8 +1466,22 @@ async def resume_agent(request: ResumeRequest):
             processed_tool_call_ids: set[str] = set()
             latest_todos: Optional[List[Dict[str, Any]]] = None
 
-            # Resume with Command
-            last_signature = None
+            # Resume with Command - use saved signature to avoid duplicate content
+            last_signature = _simple_agent_last_signatures.get(request.threadId)
+            logger.info(
+                "Resume: Restored signature for thread %s: %s",
+                request.threadId,
+                last_signature[:100] if last_signature else None,
+            )
+            # Restore emitted contents set to prevent duplicate content emission
+            emitted_contents = _simple_agent_emitted_contents.get(
+                request.threadId, set()
+            )
+            logger.info(
+                "Resume: Restored %d emitted content hashes for thread %s",
+                len(emitted_contents),
+                request.threadId,
+            )
 
             # Status: waiting for LLM response
             yield {
@@ -1076,7 +1490,9 @@ async def resume_agent(request: ResumeRequest):
             }
 
             step_count = 0
-            for step in agent.stream(
+
+            async for step in _async_stream_wrapper(
+                agent,
                 Command(resume={"decisions": langgraph_decisions}),
                 config,
                 stream_mode="values",
@@ -1090,47 +1506,8 @@ async def resume_agent(request: ResumeRequest):
                     step_keys,
                 )
 
-                # Check for another interrupt
-                if isinstance(step, dict) and "__interrupt__" in step:
-                    interrupts = step["__interrupt__"]
-
-                    yield {
-                        "event": "debug",
-                        "data": json.dumps({"status": "⏸️ 사용자 승인 대기 중"}),
-                    }
-
-                    for interrupt in interrupts:
-                        interrupt_value = (
-                            interrupt.value
-                            if hasattr(interrupt, "value")
-                            else interrupt
-                        )
-                        action_requests = interrupt_value.get("action_requests", [])
-                        normalized_actions = [
-                            _normalize_action_request(a) for a in action_requests
-                        ]
-                        if normalized_actions:
-                            _simple_agent_pending_actions[request.threadId] = (
-                                normalized_actions
-                            )
-
-                        total_actions = len(normalized_actions)
-                        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,
-                                    }
-                                ),
-                            }
-
-                    return
+                # IMPORTANT: Process todos and messages BEFORE checking for interrupt
+                # This ensures todos/debug events are emitted even in interrupt steps
 
                 # Check for todos in state and stream them
                 if isinstance(step, dict) and "todos" in step:
@@ -1144,16 +1521,63 @@ async def resume_agent(request: ResumeRequest):
                         latest_todos = todos
                         yield {"event": "todos", "data": json.dumps({"todos": todos})}
 
-                # Process messages
+                # Process messages (no continue statements to ensure interrupt check always runs)
                 if isinstance(step, dict) and "messages" in step:
                     messages = step["messages"]
+                    should_process_message = False
                     if messages:
                         last_message = messages[-1]
                         signature = _message_signature(last_message)
-                        if signature == last_signature:
-                            continue
-                        last_signature = signature
+                        # Debug: Show full signature details when mismatch occurs
+                        if signature != last_signature and last_signature:
+                            logger.info(
+                                "Resume: Signature MISMATCH - len(current)=%d, len(last)=%d",
+                                len(signature),
+                                len(last_signature) if last_signature else 0,
+                            )
+                            # Find first difference position
+                            min_len = min(len(signature), len(last_signature))
+                            diff_pos = next(
+                                (
+                                    i
+                                    for i in range(min_len)
+                                    if signature[i] != last_signature[i]
+                                ),
+                                min_len,
+                            )
+                            logger.info(
+                                "Resume: First diff at pos %d: current[%d:%d]='%s', last[%d:%d]='%s'",
+                                diff_pos,
+                                max(0, diff_pos - 20),
+                                min(len(signature), diff_pos + 30),
+                                signature[
+                                    max(0, diff_pos - 20) : min(
+                                        len(signature), diff_pos + 30
+                                    )
+                                ],
+                                max(0, diff_pos - 20),
+                                min(len(last_signature), diff_pos + 30),
+                                last_signature[
+                                    max(0, diff_pos - 20) : min(
+                                        len(last_signature), diff_pos + 30
+                                    )
+                                ]
+                                if last_signature
+                                else "",
+                            )
+                        logger.info(
+                            "Resume: Signature comparison - current: %s, last: %s, match: %s",
+                            signature[:100] if signature else None,
+                            last_signature[:100] if last_signature else None,
+                            signature == last_signature,
+                        )
+                        # Only process if this is a new message (not duplicate)
+                        if signature != last_signature:
+                            last_signature = signature
+                            should_process_message = True
 
+                    # Process message only if it's new
+                    if should_process_message:
                         if isinstance(last_message, ToolMessage):
                             logger.info(
                                 "Resume ToolMessage content: %s", last_message.content
@@ -1188,6 +1612,19 @@ async def resume_agent(request: ResumeRequest):
                                     final_answer = tool_result.get(
                                         "answer"
                                     ) or tool_result.get("parameters", {}).get("answer")
+                                    # Check for next_items in summary field (Gemini puts JSON here)
+                                    summary = tool_result.get(
+                                        "summary"
+                                    ) or tool_result.get("parameters", {}).get("summary")
+                                    if summary:
+                                        try:
+                                            summary_json = json.loads(summary)
+                                            if "next_items" in summary_json:
+                                                next_items_block = f"\n\n```json\n{json.dumps(summary_json, ensure_ascii=False, indent=2)}\n```"
+                                                final_answer = (final_answer or "") + next_items_block
+                                                logger.info("Resume: Extracted next_items from summary field")
+                                        except (json.JSONDecodeError, TypeError):
+                                            pass
                                     if final_answer:
                                         yield {
                                             "event": "token",
@@ -1224,23 +1661,69 @@ async def resume_agent(request: ResumeRequest):
                                     ),
                                 }
                                 return
-                            # Skip other ToolMessages (jupyter_cell, markdown, etc.) - don't emit their content
-                            continue
+                            # Other ToolMessages: don't process further (no continue to ensure interrupt check runs)
 
-                        if hasattr(last_message, "content") and last_message.content:
+                        # Handle AIMessage (use elif to avoid processing after ToolMessage)
+                        elif hasattr(last_message, "content") and last_message.content:
+                            message_tool_calls = (
+                                last_message.tool_calls
+                                if hasattr(last_message, "tool_calls")
+                                and last_message.tool_calls
+                                else []
+                            )
+                            has_final_answer_tool = any(
+                                (call.get("name") or call.get("tool") or "")
+                                in ("final_answer_tool", "final_answer")
+                                for call in message_tool_calls
+                                if isinstance(call, dict)
+                            )
                             content = last_message.content
 
+                            # Handle list content (e.g., multimodal responses)
+                            if isinstance(content, list):
+                                # Extract text content from list
+                                text_parts = []
+                                for part in content:
+                                    if isinstance(part, str):
+                                        text_parts.append(part)
+                                    elif (
+                                        isinstance(part, dict)
+                                        and part.get("type") == "text"
+                                    ):
+                                        text_parts.append(part.get("text", ""))
+                                content = "\n".join(text_parts)
+
                             # Filter out raw JSON tool responses
-                            if not (
-                                content.strip().startswith('{"tool":')
-                                or content.strip().startswith('{"status":')
-                                or '"pending_execution"' in content
-                                or '"status": "complete"' in content
+                            if (
+                                content
+                                and isinstance(content, str)
+                                and not has_final_answer_tool
+                                and not (
+                                    content.strip().startswith('{"tool":')
+                                    or content.strip().startswith('{"status":')
+                                    or '"pending_execution"' in content
+                                    or '"status": "complete"' in content
+                                )
                             ):
-                                yield {
-                                    "event": "token",
-                                    "data": json.dumps({"content": content}),
-                                }
+                                # Check if we've already emitted this content (prevents duplicates)
+                                content_hash = hash(content)
+                                if content_hash in emitted_contents:
+                                    logger.info(
+                                        "Resume: SKIPPING duplicate content (len=%d): %s",
+                                        len(content),
+                                        content[:100],
+                                    )
+                                else:
+                                    emitted_contents.add(content_hash)
+                                    logger.info(
+                                        "Resume: EMITTING token content (len=%d): %s",
+                                        len(content),
+                                        content[:100],
+                                    )
+                                    yield {
+                                        "event": "token",
+                                        "data": json.dumps({"content": content}),
+                                    }
 
                         if (
                             hasattr(last_message, "tool_calls")
@@ -1253,66 +1736,218 @@ async def resume_agent(request: ResumeRequest):
                                 if tc.get("id") not in processed_tool_call_ids
                             ]
 
-                            if not new_tool_calls:
-                                # All tool calls already processed, skip
-                                continue
-
-                            # Mark these tool calls as processed
-                            for tc in new_tool_calls:
-                                if tc.get("id"):
-                                    processed_tool_call_ids.add(tc["id"])
+                            # Only process if there are new tool calls (no continue to ensure interrupt check runs)
+                            if new_tool_calls:
+                                # Mark these tool calls as processed
+                                for tc in new_tool_calls:
+                                    if tc.get("id"):
+                                        processed_tool_call_ids.add(tc["id"])
 
-                            logger.info(
-                                "Resume AIMessage tool_calls: %s",
-                                json.dumps(new_tool_calls, ensure_ascii=False),
-                            )
-                            todos = _emit_todos_from_tool_calls(new_tool_calls)
-                            if todos:
-                                latest_todos = todos
-                                yield {
-                                    "event": "todos",
-                                    "data": json.dumps({"todos": todos}),
-                                }
-                        for tool_call in new_tool_calls:
-                            tool_name = tool_call.get("name", "unknown")
-                            tool_args = tool_call.get("args", {})
-                            if tool_args.get("execution_result"):
                                 logger.info(
-                                    "Resume tool_call includes execution_result; skipping client execution for %s",
-                                    tool_name,
+                                    "Resume AIMessage tool_calls: %s",
+                                    json.dumps(new_tool_calls, ensure_ascii=False),
                                 )
-                                continue
+                                todos = _emit_todos_from_tool_calls(new_tool_calls)
+                                if todos:
+                                    latest_todos = todos
+                                    yield {
+                                        "event": "todos",
+                                        "data": json.dumps({"todos": todos}),
+                                    }
+
+                                # Process tool calls
+                                for tool_call in new_tool_calls:
+                                    tool_name = tool_call.get("name", "unknown")
+                                    tool_args = tool_call.get("args", {})
+                                    # Skip tool calls with execution_result (continue is OK here - inner loop)
+                                    if tool_args.get("execution_result"):
+                                        logger.info(
+                                            "Resume tool_call includes execution_result; skipping client execution for %s",
+                                            tool_name,
+                                        )
+                                        continue
+
+                                    # Create detailed status message for search tools
+                                    if tool_name in (
+                                        "search_workspace_tool",
+                                        "search_workspace",
+                                    ):
+                                        pattern = tool_args.get("pattern", "")
+                                        path = tool_args.get("path", ".")
+                                        status_msg = f"🔍 검색 실행: grep/rg '{pattern}' in {path}"
+                                    elif tool_name in (
+                                        "search_notebook_cells_tool",
+                                        "search_notebook_cells",
+                                    ):
+                                        pattern = tool_args.get("pattern", "")
+                                        nb_path = tool_args.get(
+                                            "notebook_path", "all notebooks"
+                                        )
+                                        status_msg = f"🔍 노트북 검색: '{pattern}' in {nb_path or 'all notebooks'}"
+                                    else:
+                                        status_msg = f"🔧 Tool 실행: {tool_name}"
+
+                                    yield {
+                                        "event": "debug",
+                                        "data": json.dumps({"status": status_msg}),
+                                    }
+
+                                    if tool_name in (
+                                        "jupyter_cell_tool",
+                                        "jupyter_cell",
+                                    ):
+                                        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(
+                                                {
+                                                    "tool": "markdown",
+                                                    "content": tool_args.get(
+                                                        "content", ""
+                                                    ),
+                                                }
+                                            ),
+                                        }
+                                    elif tool_name == "execute_command_tool":
+                                        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_workspace_tool",
+                                        "search_workspace",
+                                    ):
+                                        # Search workspace - emit tool_call for client-side execution
+                                        yield {
+                                            "event": "tool_call",
+                                            "data": json.dumps(
+                                                {
+                                                    "tool": "search_workspace",
+                                                    "pattern": tool_args.get(
+                                                        "pattern", ""
+                                                    ),
+                                                    "file_types": tool_args.get(
+                                                        "file_types",
+                                                        ["*.py", "*.ipynb"],
+                                                    ),
+                                                    "path": tool_args.get("path", "."),
+                                                    "max_results": tool_args.get(
+                                                        "max_results", 50
+                                                    ),
+                                                    "case_sensitive": tool_args.get(
+                                                        "case_sensitive", False
+                                                    ),
+                                                }
+                                            ),
+                                        }
+                                    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(
+                                                {
+                                                    "tool": "search_notebook_cells",
+                                                    "pattern": tool_args.get(
+                                                        "pattern", ""
+                                                    ),
+                                                    "notebook_path": tool_args.get(
+                                                        "notebook_path"
+                                                    ),
+                                                    "cell_type": tool_args.get(
+                                                        "cell_type"
+                                                    ),
+                                                    "max_results": tool_args.get(
+                                                        "max_results", 30
+                                                    ),
+                                                    "case_sensitive": tool_args.get(
+                                                        "case_sensitive", False
+                                                    ),
+                                                }
+                                            ),
+                                        }
+
+                # Check for interrupt AFTER processing todos and messages
+                # This ensures todos/debug events are emitted even in interrupt steps
+                if isinstance(step, dict) and "__interrupt__" in step:
+                    interrupts = step["__interrupt__"]
+
+                    yield {
+                        "event": "debug",
+                        "data": json.dumps({"status": "⏸️ 사용자 승인 대기 중"}),
+                    }
+
+                    for interrupt in interrupts:
+                        interrupt_value = (
+                            interrupt.value
+                            if hasattr(interrupt, "value")
+                            else interrupt
+                        )
+                        action_requests = interrupt_value.get("action_requests", [])
+                        normalized_actions = [
+                            _normalize_action_request(a) for a in action_requests
+                        ]
+                        if normalized_actions:
+                            _simple_agent_pending_actions[request.threadId] = (
+                                normalized_actions
+                            )
 
+                        total_actions = len(normalized_actions)
+                        for idx, action in enumerate(normalized_actions):
                             yield {
-                                "event": "debug",
+                                "event": "interrupt",
                                 "data": json.dumps(
-                                    {"status": f"🔧 Tool 실행: {tool_name}"}
+                                    {
+                                        "thread_id": request.threadId,
+                                        "action": action.get("name", "unknown"),
+                                        "args": action.get("arguments", {}),
+                                        "description": action.get("description", ""),
+                                        "action_index": idx,
+                                        "total_actions": total_actions,
+                                    }
                                 ),
                             }
 
-                            if tool_name in ("jupyter_cell_tool", "jupyter_cell"):
-                                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(
-                                        {
-                                            "tool": "markdown",
-                                            "content": tool_args.get("content", ""),
-                                        }
-                                    ),
-                                }
+                    # Save last signature for next resume to avoid duplicate content
+                    if last_signature:
+                        _simple_agent_last_signatures[request.threadId] = last_signature
+                        logger.info(
+                            "Resume Interrupt: Saved signature for thread %s: %s",
+                            request.threadId,
+                            last_signature[:100] if last_signature else None,
+                        )
+                    # Save emitted contents for next resume
+                    _simple_agent_emitted_contents[request.threadId] = emitted_contents
+                    logger.info(
+                        "Resume Interrupt: Saved %d emitted content hashes for thread %s",
+                        len(emitted_contents),
+                        request.threadId,
+                    )
+
+                    # Stop streaming - wait for resume
+                    return
 
             # Clear debug status before completion
             yield {"event": "debug_clear", "data": json.dumps({})}
@@ -1365,7 +2000,8 @@ async def search_workspace(
     """
     from agent_server.langchain.executors.notebook_searcher import NotebookSearcher
 
-    searcher = NotebookSearcher(workspace_root)
+    resolved_workspace_root = _resolve_workspace_root(workspace_root)
+    searcher = NotebookSearcher(resolved_workspace_root)
 
     if notebook_path:
         results = searcher.search_notebook(
@@ -1397,9 +2033,9 @@ async def health_check() -> Dict[str, Any]:
 @router.delete("/cache")
 async def clear_agent_cache() -> Dict[str, Any]:
     """Clear the agent instance cache"""
-    global _agent_cache
-    count = len(_agent_cache)
-    _agent_cache.clear()
+    global _simple_agent_instances
+    count = len(_simple_agent_instances)
+    _simple_agent_instances.clear()
 
     return {
         "status": "ok",