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

agent_server/langchain/tools/search_tools.py

@@ -1,19 +1,16 @@
 """
 Search Tools for LangChain Agent
 
-Provides tools for searching code in workspace and notebooks.
-These tools return pending_execution status and are executed on the client (Jupyter) side
-using subprocess (find/grep/ripgrep).
+Provides tools for searching notebook cells.
+For file searching, use execute_command_tool with find/grep commands.
 
 Key features:
 - Returns command info for client-side execution via subprocess
-- Supports ripgrep (rg) if available, falls back to grep
 - Executes immediately without user approval
 - Shows the command being executed in status messages
 """
 
 import logging
-import shutil
 from typing import Any, Dict, List, Optional
 
 from langchain_core.tools import tool
@@ -22,23 +19,6 @@ from pydantic import BaseModel, Field
 logger = logging.getLogger(__name__)
 
 
-class SearchWorkspaceInput(BaseModel):
-    """Input schema for search_workspace tool"""
-
-    pattern: str = Field(description="Search pattern (regex or text)")
-    file_types: List[str] = Field(
-        default=["*.py", "*.ipynb"],
-        description="File patterns to search (e.g., ['*.py', '*.ipynb'])",
-    )
-    path: str = Field(default=".", description="Directory to search in")
-    max_results: int = Field(default=50, description="Maximum number of results")
-    case_sensitive: bool = Field(default=False, description="Case-sensitive search")
-    execution_result: Optional[Dict[str, Any]] = Field(
-        default=None,
-        description="Execution result payload from the client",
-    )
-
-
 class SearchNotebookCellsInput(BaseModel):
     """Input schema for search_notebook_cells tool"""
 
@@ -58,72 +38,6 @@ class SearchNotebookCellsInput(BaseModel):
     )
 
 
-def _is_ripgrep_available() -> bool:
-    """Check if ripgrep (rg) is installed and available."""
-    return shutil.which("rg") is not None
-
-
-def _build_grep_command(
-    pattern: str,
-    file_types: List[str],
-    path: str,
-    case_sensitive: bool,
-    max_results: int,
-) -> tuple[str, str]:
-    """
-    Build a grep/ripgrep command for searching files.
-
-    Returns:
-        Tuple of (command_string, tool_name) where tool_name is 'rg' or 'grep'
-    """
-    # Check ripgrep availability (this check will also be done on client)
-    use_ripgrep = _is_ripgrep_available()
-
-    if use_ripgrep:
-        # Build ripgrep command
-        cmd_parts = ["rg", "--line-number", "--with-filename"]
-
-        if not case_sensitive:
-            cmd_parts.append("--ignore-case")
-
-        # Add file type filters using glob patterns
-        for ft in file_types:
-            cmd_parts.extend(["--glob", ft])
-
-        # Limit results
-        cmd_parts.extend(["--max-count", str(max_results)])
-
-        # Escape pattern for shell
-        escaped_pattern = pattern.replace("'", "'\\''")
-        cmd_parts.append(f"'{escaped_pattern}'")
-        cmd_parts.append(path)
-
-        return " ".join(cmd_parts), "rg"
-    else:
-        # Build find + grep command for cross-platform compatibility
-        find_parts = ["find", path, "-type", "f", "("]
-
-        for i, ft in enumerate(file_types):
-            if i > 0:
-                find_parts.append("-o")
-            find_parts.extend(["-name", f"'{ft}'"])
-
-        find_parts.append(")")
-
-        # Add grep with proper flags
-        grep_flags = "-n"  # Line numbers
-        if not case_sensitive:
-            grep_flags += "i"
-
-        # Escape pattern for shell
-        escaped_pattern = pattern.replace("'", "'\\''")
-
-        # Combine with xargs for efficiency
-        cmd = f"{' '.join(find_parts)} 2>/dev/null | xargs grep -{grep_flags} '{escaped_pattern}' 2>/dev/null | head -n {max_results}"
-
-        return cmd, "grep"
-
-
 def _build_notebook_search_command(
     pattern: str,
     notebook_path: Optional[str],
@@ -139,74 +53,6 @@ def _build_notebook_search_command(
         )
 
 
-@tool(args_schema=SearchWorkspaceInput)
-def search_workspace_tool(
-    pattern: str,
-    file_types: List[str] = None,
-    path: str = ".",
-    max_results: int = 50,
-    case_sensitive: bool = False,
-    execution_result: Optional[Dict[str, Any]] = None,
-    workspace_root: str = ".",
-) -> Dict[str, Any]:
-    """
-    Search for a pattern across files in the workspace.
-
-    This tool is executed on the client side using subprocess (grep/ripgrep).
-    Searches both regular files and Jupyter notebooks.
-
-    Args:
-        pattern: Search pattern (regex or text)
-        file_types: File patterns to search (default: ['*.py', '*.ipynb'])
-        path: Directory to search in (relative to workspace)
-        max_results: Maximum number of results to return
-        case_sensitive: Whether search is case-sensitive
-
-    Returns:
-        Dict with search results or pending_execution status
-    """
-    if file_types is None:
-        file_types = ["*.py", "*.ipynb"]
-
-    # Build the search command
-    command, tool_used = _build_grep_command(
-        pattern=pattern,
-        file_types=file_types,
-        path=path,
-        case_sensitive=case_sensitive,
-        max_results=max_results,
-    )
-
-    response: Dict[str, Any] = {
-        "tool": "search_workspace_tool",
-        "parameters": {
-            "pattern": pattern,
-            "file_types": file_types,
-            "path": path,
-            "max_results": max_results,
-            "case_sensitive": case_sensitive,
-        },
-        "command": command,
-        "tool_used": tool_used,
-        "status": "pending_execution",
-        "message": "Search queued for execution by client",
-    }
-
-    if execution_result is not None:
-        response["execution_result"] = execution_result
-        response["status"] = "complete"
-        response["message"] = "Search executed with client-reported results"
-        # Parse the execution result to extract search results
-        if isinstance(execution_result, dict):
-            response["success"] = execution_result.get("success", False)
-            response["results"] = execution_result.get("results", [])
-            response["total_results"] = execution_result.get("total_results", 0)
-            if "error" in execution_result:
-                response["error"] = execution_result["error"]
-
-    return response
-
-
 @tool(args_schema=SearchNotebookCellsInput)
 def search_notebook_cells_tool(
     pattern: str,
@@ -281,11 +127,10 @@ def create_search_tools(workspace_root: str = ".") -> List:
     Note: workspace_root is not used since tools return pending_execution
     and actual execution happens on the client side.
     """
-    return [search_workspace_tool, search_notebook_cells_tool]
+    return [search_notebook_cells_tool]
 
 
 # Export all tools
 SEARCH_TOOLS = [
-    search_workspace_tool,
     search_notebook_cells_tool,
 ]

agent_server/main.py

@@ -32,6 +32,13 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
+# Reduce verbose logging from LangChain/LangGraph
+# These libraries log entire message histories which creates excessive duplicate logs
+logging.getLogger("langchain").setLevel(logging.WARNING)
+logging.getLogger("langchain_core").setLevel(logging.WARNING)
+logging.getLogger("langgraph").setLevel(logging.WARNING)
+logging.getLogger("langsmith").setLevel(logging.WARNING)
+
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):

agent_server/routers/langchain_agent.py

@@ -561,23 +561,50 @@ async def stream_agent(request: AgentRequest):
             # Prepare config with thread_id
             config = {"configurable": {"thread_id": thread_id}}
 
-            # Debug: Check if there's existing state for this thread
+            # Check existing state and reset todos if all completed
+            should_reset_todos = False
             try:
                 existing_state = checkpointer.get(config)
                 if existing_state:
-                    existing_messages = existing_state.get("channel_values", {}).get(
-                        "messages", []
-                    )
+                    channel_values = existing_state.get("channel_values", {})
+                    existing_messages = channel_values.get("messages", [])
+                    existing_todos = channel_values.get("todos", [])
                     logger.info(
-                        "Existing state for thread %s: %d messages found",
+                        "Existing state for thread %s: %d messages, %d todos found",
                         thread_id,
                         len(existing_messages),
+                        len(existing_todos),
                     )
+                    # Check if all todos are completed - if so, reset them
+                    if existing_todos:
+                        all_completed = all(
+                            t.get("status") == "completed" for t in existing_todos
+                        )
+                        if all_completed:
+                            should_reset_todos = True
+                            logger.info(
+                                "All %d todos are completed, will reset for new task",
+                                len(existing_todos),
+                            )
                 else:
                     logger.info("No existing state for thread %s", thread_id)
             except Exception as e:
                 logger.warning("Could not check existing state: %s", e)
 
+            # Reset todos in agent state if all were completed
+            todos_reset_event = None
+            if should_reset_todos:
+                try:
+                    agent.update_state(config, {"todos": []})
+                    logger.info("Reset todos in agent state for thread %s", thread_id)
+                    # Prepare event to notify frontend (will be yielded after function setup)
+                    todos_reset_event = {
+                        "event": "todos",
+                        "data": json.dumps({"todos": [], "reset": True}),
+                    }
+                except Exception as e:
+                    logger.warning("Could not reset todos in agent state: %s", e)
+
             # Prepare input
             agent_input = {"messages": [{"role": "user", "content": request.request}]}
 
@@ -593,6 +620,11 @@ async def stream_agent(request: AgentRequest):
             emitted_contents: set = set()
             _simple_agent_emitted_contents[thread_id] = emitted_contents
 
+            # Emit todos reset event if needed (before starting the stream)
+            if todos_reset_event:
+                logger.info("SSE: Emitting todos reset event")
+                yield todos_reset_event
+
             # Initial status: waiting for LLM
             logger.info("SSE: Sending initial debug status '🤔 LLM 응답 대기 중'")
             yield {
@@ -670,6 +702,27 @@ async def stream_agent(request: AgentRequest):
                                     "event": "todos",
                                     "data": json.dumps({"todos": todos}),
                                 }
+                                # Check if all todos are completed - auto terminate
+                                all_completed = all(
+                                    t.get("status") == "completed" for t in todos
+                                )
+                                if all_completed and len(todos) > 0:
+                                    logger.info(
+                                        "All %d todos completed, auto-terminating agent",
+                                        len(todos),
+                                    )
+                                    yield {
+                                        "event": "debug_clear",
+                                        "data": json.dumps({}),
+                                    }
+                                    yield {
+                                        "event": "done",
+                                        "data": json.dumps(
+                                            {"reason": "all_todos_completed"}
+                                        ),
+                                    }
+                                    return  # Exit the generator
+
                             tool_name = getattr(last_message, "name", "") or ""
                             logger.info(
                                 "SimpleAgent ToolMessage name attribute: %s", tool_name
@@ -695,17 +748,49 @@ async def stream_agent(request: AgentRequest):
                                     final_answer = tool_result.get(
                                         "answer"
                                     ) or tool_result.get("parameters", {}).get("answer")
+
+                                    # Check for next_items in answer field (LLM may put JSON here)
+                                    if final_answer:
+                                        try:
+                                            answer_json = json.loads(final_answer)
+                                            if "next_items" in answer_json:
+                                                next_items_block = f"\n\n```json\n{json.dumps(answer_json, ensure_ascii=False, indent=2)}\n```"
+                                                # Get summary for the main text
+                                                summary_text = (
+                                                    tool_result.get("summary")
+                                                    or tool_result.get(
+                                                        "parameters", {}
+                                                    ).get("summary")
+                                                    or ""
+                                                )
+                                                final_answer = (
+                                                    summary_text + next_items_block
+                                                )
+                                                logger.info(
+                                                    "Extracted next_items from answer field"
+                                                )
+                                        except (json.JSONDecodeError, TypeError):
+                                            pass
+
                                     # 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:
+                                    ) or tool_result.get("parameters", {}).get(
+                                        "summary"
+                                    )
+                                    if summary and "next_items" not in (
+                                        final_answer or ""
+                                    ):
                                         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")
+                                                final_answer = (
+                                                    final_answer or ""
+                                                ) + next_items_block
+                                                logger.info(
+                                                    "Extracted next_items from summary field"
+                                                )
                                         except (json.JSONDecodeError, TypeError):
                                             pass
                                     if final_answer:
@@ -830,13 +915,6 @@ async def stream_agent(request: AgentRequest):
 
                                     # 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",
                                     ):
@@ -902,34 +980,6 @@ async def stream_agent(request: AgentRequest):
                                                 }
                                             ),
                                         }
-                                    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",
@@ -1113,7 +1163,7 @@ async def stream_agent(request: AgentRequest):
                             content=(
                                 "You MUST respond with a valid tool call. "
                                 "Available tools: jupyter_cell_tool (for Python code), markdown_tool (for text), "
-                                "list_files_tool (to list files), read_file_tool (to read files). "
+                                "execute_command_tool (to search files with find/grep), read_file_tool (to read files). "
                                 "Choose the most appropriate tool and provide valid JSON arguments."
                             )
                         ),
@@ -1232,11 +1282,7 @@ async def stream_agent(request: AgentRequest):
                                     }
                                 ),
                             }
-                        elif tool_name in (
-                            "read_file_tool",
-                            "list_files_tool",
-                            "search_workspace_tool",
-                        ):
+                        elif tool_name == "read_file_tool":
                             # For file operations, generate code with the LLM
                             logger.info(
                                 "Fallback: Generating code for %s via LLM",
@@ -1388,9 +1434,28 @@ async def resume_agent(request: ResumeRequest):
             )
             # Get or create cached agent
             resolved_workspace_root = _resolve_workspace_root(request.workspaceRoot)
-            checkpointer = _simple_agent_checkpointers.setdefault(
-                request.threadId, InMemorySaver()
-            )
+
+            # CRITICAL: Validate checkpoint exists before resume
+            # InMemorySaver is volatile - server restart loses all checkpoints
+            if request.threadId not in _simple_agent_checkpointers:
+                logger.warning(
+                    "Resume failed: No checkpoint found for thread %s. "
+                    "Server may have restarted or session expired.",
+                    request.threadId,
+                )
+                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)
 
             agent_cache_key = _get_agent_cache_key(
                 llm_config=config_dict,
@@ -1406,7 +1471,9 @@ async def resume_agent(request: ResumeRequest):
                     len(_simple_agent_instances),
                 )
             else:
-                logger.info("Resume: Creating new agent for key %s", agent_cache_key[:8])
+                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,
@@ -1589,6 +1656,27 @@ async def resume_agent(request: ResumeRequest):
                                     "event": "todos",
                                     "data": json.dumps({"todos": todos}),
                                 }
+                                # Check if all todos are completed - auto terminate
+                                all_completed = all(
+                                    t.get("status") == "completed" for t in todos
+                                )
+                                if all_completed and len(todos) > 0:
+                                    logger.info(
+                                        "Resume: All %d todos completed, auto-terminating agent",
+                                        len(todos),
+                                    )
+                                    yield {
+                                        "event": "debug_clear",
+                                        "data": json.dumps({}),
+                                    }
+                                    yield {
+                                        "event": "done",
+                                        "data": json.dumps(
+                                            {"reason": "all_todos_completed"}
+                                        ),
+                                    }
+                                    return  # Exit the generator
+
                             tool_name = getattr(last_message, "name", "") or ""
                             logger.info(
                                 "Resume ToolMessage name attribute: %s", tool_name
@@ -1612,17 +1700,49 @@ async def resume_agent(request: ResumeRequest):
                                     final_answer = tool_result.get(
                                         "answer"
                                     ) or tool_result.get("parameters", {}).get("answer")
+
+                                    # Check for next_items in answer field (LLM may put JSON here)
+                                    if final_answer:
+                                        try:
+                                            answer_json = json.loads(final_answer)
+                                            if "next_items" in answer_json:
+                                                next_items_block = f"\n\n```json\n{json.dumps(answer_json, ensure_ascii=False, indent=2)}\n```"
+                                                # Get summary for the main text
+                                                summary_text = (
+                                                    tool_result.get("summary")
+                                                    or tool_result.get(
+                                                        "parameters", {}
+                                                    ).get("summary")
+                                                    or ""
+                                                )
+                                                final_answer = (
+                                                    summary_text + next_items_block
+                                                )
+                                                logger.info(
+                                                    "Resume: Extracted next_items from answer field"
+                                                )
+                                        except (json.JSONDecodeError, TypeError):
+                                            pass
+
                                     # 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:
+                                    ) or tool_result.get("parameters", {}).get(
+                                        "summary"
+                                    )
+                                    if summary and "next_items" not in (
+                                        final_answer or ""
+                                    ):
                                         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")
+                                                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:
@@ -1769,13 +1889,6 @@ async def resume_agent(request: ResumeRequest):
 
                                     # 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",
                                     ):
@@ -1833,33 +1946,6 @@ async def resume_agent(request: ResumeRequest):
                                                 }
                                             ),
                                         }
-                                    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",
@@ -1966,16 +2052,35 @@ async def resume_agent(request: ResumeRequest):
             }
 
         except Exception as e:
-            logger.error(f"Resume error: {e}", exc_info=True)
-            yield {
-                "event": "error",
-                "data": json.dumps(
-                    {
-                        "error": str(e),
-                        "error_type": type(e).__name__,
-                    }
-                ),
-            }
+            error_msg = str(e)
+            logger.error(f"Resume error: {error_msg}", exc_info=True)
+
+            # Detect specific Gemini error for empty contents
+            if "contents is not specified" in error_msg.lower():
+                logger.warning(
+                    "Detected 'contents is not specified' error - likely session state loss"
+                )
+                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(
+                        {
+                            "error": error_msg,
+                            "error_type": type(e).__name__,
+                        }
+                    ),
+                }
 
     return EventSourceResponse(event_generator())