hdsp-jupyter-extension 2.0.8__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/routers/langchain_agent.py

@@ -702,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
@@ -727,7 +748,7 @@ 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:
@@ -735,25 +756,41 @@ async def stream_agent(request: AgentRequest):
                                             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")
+                                                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 and "next_items" not in (final_answer or ""):
+                                    ) 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:
@@ -878,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",
                                     ):
@@ -950,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",
@@ -1161,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."
                             )
                         ),
@@ -1280,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",
@@ -1447,11 +1445,13 @@ async def resume_agent(request: ResumeRequest):
                 )
                 yield {
                     "event": "error",
-                    "data": json.dumps({
-                        "error": "Session expired or not found",
-                        "code": "CHECKPOINT_NOT_FOUND",
-                        "message": "이전 세션을 찾을 수 없습니다. 서버가 재시작되었거나 세션이 만료되었습니다. 새로운 대화를 시작해주세요.",
-                    }),
+                    "data": json.dumps(
+                        {
+                            "error": "Session expired or not found",
+                            "code": "CHECKPOINT_NOT_FOUND",
+                            "message": "이전 세션을 찾을 수 없습니다. 서버가 재시작되었거나 세션이 만료되었습니다. 새로운 대화를 시작해주세요.",
+                        }
+                    ),
                 }
                 return
 
@@ -1471,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,
@@ -1654,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
@@ -1677,7 +1700,7 @@ 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:
@@ -1685,25 +1708,41 @@ async def resume_agent(request: ResumeRequest):
                                             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")
+                                                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 and "next_items" not in (final_answer or ""):
+                                    ) 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:
@@ -1850,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",
                                     ):
@@ -1914,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",
@@ -2057,20 +2062,24 @@ async def resume_agent(request: ResumeRequest):
                 )
                 yield {
                     "event": "error",
-                    "data": json.dumps({
-                        "error": "Session state lost",
-                        "code": "CONTENTS_NOT_SPECIFIED",
-                        "error_type": type(e).__name__,
-                        "message": "세션 상태가 손실되었습니다. 서버가 재시작되었거나 세션이 만료되었습니다. 새로운 대화를 시작해주세요.",
-                    }),
+                    "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__,
-                    }),
+                    "data": json.dumps(
+                        {
+                            "error": error_msg,
+                            "error_type": type(e).__name__,
+                        }
+                    ),
                 }
 
     return EventSourceResponse(event_generator())

{hdsp_jupyter_extension-2.0.8.data → hdsp_jupyter_extension-2.0.10.data}/data/share/jupyter/labextensions/hdsp-agent/build_log.json

@@ -722,7 +722,7 @@
             "@mui/material": {},
             "react-markdown": {},
             "hdsp-agent": {
-              "version": "2.0.8",
+              "version": "2.0.10",
               "singleton": true,
               "import": "/Users/a421721/Desktop/hdsp/hdsp_agent/extensions/jupyter/lib/index.js"
             }

{hdsp_jupyter_extension-2.0.8.data → hdsp_jupyter_extension-2.0.10.data}/data/share/jupyter/labextensions/hdsp-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hdsp-agent",
-  "version": "2.0.8",
+  "version": "2.0.10",
   "description": "HDSP Agent JupyterLab Extension - Thin client for Agent Server",
   "keywords": [
     "jupyter",
@@ -127,7 +127,7 @@
       }
     },
     "_build": {
-      "load": "static/remoteEntry.020cdb0b864cfaa4e41e.js",
+      "load": "static/remoteEntry.4a252df3ade74efee8d6.js",
       "extension": "./extension",
       "style": "./style"
     }