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

agent_server/langchain/ARCHITECTURE.md

@@ -151,13 +151,10 @@ jupyter_ext/
 ```python
 - jupyter_cell_tool            # Python 코드 실행
 - markdown_tool                # 마크다운 셀 추가
-- final_answer_tool            # 작업 완료 및 요약
 - read_file_tool               # 파일 읽기
 - write_file_tool              # 파일 쓰기
-- list_files_tool              # 디렉토리 목록
-- search_workspace_tool        # 워크스페이스 검색 (grep/rg)
 - search_notebook_cells_tool   # 노트북 셀 검색
-- execute_command_tool         # 쉘 명령 실행
+- execute_command_tool         # 쉘 명령 실행 (파일 검색은 find/grep 사용)
 - check_resource_tool          # 리소스 확인
 ```
 
@@ -441,8 +438,6 @@ non-HITL 도구 실행 후 continuation 프롬프트를 주입합니다.
 NON_HITL_TOOLS = {
     "markdown_tool",
     "read_file_tool",
-    "list_files_tool",
-    "search_workspace_tool",
     "search_notebook_cells_tool",
     "write_todos",
 }
@@ -508,8 +503,7 @@ LLM 호출 횟수를 제한합니다.
 
 **설정**:
 ```python
-- write_todos: run_limit=5, exit_behavior="continue"
-- list_files_tool: run_limit=5, exit_behavior="continue"
+- write_todos: run_limit=20, exit_behavior="continue"
 ```
 
 ### 9. `SummarizationMiddleware` (LangChain 내장)
@@ -634,52 +628,14 @@ Python 코드를 Jupyter 셀에서 실행합니다.
 **특징**:
 - HITL 대상 (사용자 승인 필요)
 
-#### `list_files_tool`
-디렉토리 목록을 가져옵니다.
-
-**파라미터**:
-- `path`: 디렉토리 경로 (기본 ".")
-- `recursive`: 재귀 탐색 여부 (기본 False)
-
-**반환**:
-```python
-{
-    "tool": "list_files",
-    "parameters": {"path": ".", "recursive": False},
-    "status": "completed",
-    "files": ["file1.py", "file2.csv", ...]
-}
-```
-
 ---
 
 ### Search Tools (`search_tools.py`)
 
-#### `search_workspace_tool`
-워크스페이스에서 패턴을 검색합니다 (grep/ripgrep).
-
-**파라미터**:
-- `pattern`: 정규식 패턴
-- `file_types`: 파일 타입 필터 (예: ["py", "md"])
-- `path`: 검색 경로 (기본 ".")
-
-**반환**:
-```python
-{
-    "tool": "search_workspace",
-    "parameters": {"pattern": "...", "file_types": ["py"], "path": "."},
-    "status": "completed",
-    "results": [
-        {"file": "file1.py", "line_number": 10, "line": "..."},
-        ...
-    ],
-    "command": "rg ... (또는 grep ...)"
-}
-```
-
-**특징**:
-- ripgrep 우선 사용 (속도)
-- 없으면 grep 사용
+> **Note**: 파일 검색 기능은 `execute_command_tool`을 통해 `find`/`grep` 명령을 직접 사용합니다.
+>
+> - 파일명 검색: `execute_command_tool(command="find . -iname '*pattern*' 2>/dev/null")`
+> - 파일 내용 검색: `execute_command_tool(command="grep -rn 'pattern' --include='*.py' .")`
 
 #### `search_notebook_cells_tool`
 Jupyter 노트북 셀에서 패턴을 검색합니다.
@@ -961,7 +917,7 @@ return
 - **HITL**: 사용자 승인 필요
   - `jupyter_cell_tool`, `execute_command_tool`, `write_file_tool`
 - **non-HITL**: 즉시 실행
-  - `markdown_tool`, `read_file_tool`, `list_files_tool`, `search_*_tool`
+  - `markdown_tool`, `read_file_tool`, `search_*_tool`
 - **클라이언트 실행**: 서버에서 실행하지 않음
   - `check_resource_tool`: CheckResourceHandler에서 처리
 

agent_server/langchain/agent.py

@@ -23,14 +23,15 @@ from agent_server.langchain.prompts import (
 )
 from agent_server.langchain.tools import (
     check_resource_tool,
+    diagnostics_tool,
+    edit_file_tool,
     execute_command_tool,
-    final_answer_tool,
     jupyter_cell_tool,
-    list_files_tool,
     markdown_tool,
+    multiedit_file_tool,
     read_file_tool,
+    references_tool,
     search_notebook_cells_tool,
-    search_workspace_tool,
     write_file_tool,
 )
 
@@ -42,14 +43,15 @@ def _get_all_tools():
     return [
         jupyter_cell_tool,
         markdown_tool,
-        final_answer_tool,
         read_file_tool,
         write_file_tool,
-        list_files_tool,
-        search_workspace_tool,
+        edit_file_tool,
+        multiedit_file_tool,
         search_notebook_cells_tool,
         execute_command_tool,
         check_resource_tool,
+        diagnostics_tool,
+        references_tool,
     ]
 
 
@@ -107,7 +109,6 @@ def create_simple_chat_agent(
 
     # Configure middleware
     middleware = []
-
     # Add empty response handler middleware
     handle_empty_response = create_handle_empty_response_middleware(wrap_model_call)
     middleware.append(handle_empty_response)
@@ -117,7 +118,9 @@ def create_simple_chat_agent(
     middleware.append(limit_tool_calls)
 
     # Add tool args normalization middleware (convert list args to strings based on schema)
-    normalize_tool_args = create_normalize_tool_args_middleware(wrap_model_call, tools=tools)
+    normalize_tool_args = create_normalize_tool_args_middleware(
+        wrap_model_call, tools=tools
+    )
     middleware.append(normalize_tool_args)
 
     # Add continuation prompt middleware
@@ -156,22 +159,14 @@ def create_simple_chat_agent(
     logger.info("Added ModelCallLimitMiddleware with run_limit=30")
 
     # ToolCallLimitMiddleware: Prevent specific tools from being called too many times
-    # Limit write_todos to prevent loops
+    # run_limit resets automatically per user message
     write_todos_limit = ToolCallLimitMiddleware(
         tool_name="write_todos",
-        run_limit=5,  # Max 5 write_todos calls per user message
-        exit_behavior="continue",  # Let agent continue with other tools
-    )
-    middleware.append(write_todos_limit)
-
-    # Limit list_files_tool to prevent excessive directory listing
-    list_files_limit = ToolCallLimitMiddleware(
-        tool_name="list_files_tool",
-        run_limit=5,  # Max 5 list_files calls per user message
+        run_limit=20,  # Max 20 write_todos calls per user message
         exit_behavior="continue",
     )
-    middleware.append(list_files_limit)
-    logger.info("Added ToolCallLimitMiddleware for write_todos and list_files_tool")
+    middleware.append(write_todos_limit)
+    logger.info("Added ToolCallLimitMiddleware for write_todos (20/msg)")
 
     # Add SummarizationMiddleware to maintain context across cycles
     summary_llm = create_summarization_llm(llm_config)
@@ -210,6 +205,30 @@ Example: "데이터를 로드하겠습니다." then call jupyter_cell_tool.
         system_prompt = system_prompt + "\n" + gemini_content_prompt
         logger.info("Added Gemini 2.5 Flash specific prompt for content inclusion")
 
+    # Add vLLM/gpt-oss specific prompt for Korean responses and proper todo structure
+    provider = llm_config.get("provider", "")
+    if provider == "vllm":
+        vllm_prompt = """
+## 🔴 중요: 한국어로 응답하세요
+- 모든 응답, 설명, todo 항목은 반드시 한국어로 작성하세요.
+- 코드 주석과 출력 설명도 한국어로 작성하세요.
+- 영어로 응답하지 마세요.
+
+## 🔴 MANDATORY: Todo List Structure
+When creating todos with write_todos, you MUST:
+1. Write all todo items in Korean
+2. ALWAYS include "작업 요약 및 다음단계 제시" as the LAST todo item
+3. Example structure:
+   - 데이터 로드 및 확인
+   - 데이터 분석 수행
+   - 작업 요약 및 다음단계 제시  ← 반드시 마지막에 포함!
+
+## 🔴 IMPORTANT: Never return empty responses
+If you have nothing to say, call a tool instead. NEVER return an empty response.
+"""
+        system_prompt = system_prompt + "\n" + vllm_prompt
+        logger.info("Added vLLM/gpt-oss specific prompt for Korean responses")
+
     logger.info("SimpleChatAgent system_prompt: %s", system_prompt)
 
     # Create agent with checkpointer (required for HITL)

agent_server/langchain/custom_middleware.py

@@ -78,6 +78,20 @@ def parse_json_tool_call(text) -> Optional[Dict[str, Any]]:
     return None
 
 
+def normalize_tool_name(tool_name: str) -> str:
+    """Normalize tool name to match registered tool names.
+
+    Rules:
+    - write_todos_tool → write_todos (TodoListMiddleware exception)
+    - other tools without _tool suffix → add _tool suffix
+    """
+    if tool_name == "write_todos_tool":
+        return "write_todos"
+    if not tool_name.endswith("_tool") and tool_name != "write_todos":
+        return f"{tool_name}_tool"
+    return tool_name
+
+
 def create_tool_call_message(tool_name: str, arguments: Dict[str, Any]) -> AIMessage:
     """Create AIMessage with tool_calls from parsed JSON.
 
@@ -88,9 +102,7 @@ def create_tool_call_message(tool_name: str, arguments: Dict[str, Any]) -> AIMes
     Returns:
         AIMessage with properly formatted tool_calls
     """
-    # Normalize tool name
-    if not tool_name.endswith("_tool"):
-        tool_name = f"{tool_name}_tool"
+    tool_name = normalize_tool_name(tool_name)
 
     return AIMessage(
         content="",
@@ -127,6 +139,19 @@ def create_handle_empty_response_middleware(wrap_model_call):
     def handle_empty_response(request, handler):
         max_retries = 2
 
+        # Check if all todos are completed - if so, skip processing entirely
+        todos = request.state.get("todos", [])
+        if todos:
+            pending_todos = [
+                t for t in todos if t.get("status") in ("pending", "in_progress")
+            ]
+            if not pending_todos:
+                logger.info(
+                    "All %d todos completed - skipping handle_empty_response middleware",
+                    len(todos),
+                )
+                return handler(request)
+
         # Check if last message is final_answer_tool result - if so, don't retry/synthesize
         # This allows agent to naturally terminate after final_answer_tool
         messages = request.messages
@@ -194,6 +219,25 @@ def create_handle_empty_response_middleware(wrap_model_call):
             # Invalid response - retry with JSON schema prompt
             if response_message and attempt < max_retries:
                 reason = "text-only" if has_content else "empty"
+
+                json_prompt = _build_json_prompt(request, response_message, has_content)
+
+                # If _build_json_prompt returns None, skip retry and synthesize write_todos
+                # This happens when: all todos completed OR current todo is summary/next_steps
+                if json_prompt is None:
+                    logger.info(
+                        "Skipping retry for %s response, synthesizing write_todos with content",
+                        reason,
+                    )
+                    # Synthesize write_todos while preserving the content (summary)
+                    synthetic_message = _create_synthetic_final_answer(
+                        request, response_message, has_content
+                    )
+                    response = _replace_ai_message_in_response(
+                        response, synthetic_message
+                    )
+                    return response
+
                 logger.warning(
                     "Invalid AIMessage (%s) detected (attempt %d/%d). "
                     "Retrying with JSON schema prompt...",
@@ -202,16 +246,26 @@ def create_handle_empty_response_middleware(wrap_model_call):
                     max_retries + 1,
                 )
 
-                json_prompt = _build_json_prompt(request, response_message, has_content)
                 request = request.override(
                     messages=request.messages + [HumanMessage(content=json_prompt)]
                 )
                 continue
 
-            # Max retries exhausted - synthesize final_answer
+            # Max retries exhausted - synthesize write_todos to complete
             if response_message:
+                # Check if todos are already all completed - if so, just return
+                todos = request.state.get("todos", [])
+                pending_todos = [
+                    t for t in todos if t.get("status") in ("pending", "in_progress")
+                ]
+                if todos and not pending_todos:
+                    logger.info(
+                        "Max retries exhausted but all todos completed - returning response as-is"
+                    )
+                    return response
+
                 logger.warning(
-                    "Max retries exhausted. Synthesizing final_answer response."
+                    "Max retries exhausted. Synthesizing write_todos to complete."
                 )
                 synthetic_message = _create_synthetic_final_answer(
                     request, response_message, has_content
@@ -262,14 +316,33 @@ def _build_json_prompt(request, response_message, has_content):
     """Build JSON-forcing prompt based on context."""
     todos = request.state.get("todos", [])
     pending_todos = [t for t in todos if t.get("status") in ("pending", "in_progress")]
+    in_progress_todos = [t for t in todos if t.get("status") == "in_progress"]
 
     if has_content:
-        content_preview = response_message.content[:300]
+        # If all todos completed, don't force another tool call
+        if todos and not pending_todos:
+            return None  # Signal to skip retry
+
+        # If current in_progress todo is "작업 요약 및 다음단계 제시", accept text-only response
+        # The LLM is outputting the summary, we'll synthesize write_todos
+        if in_progress_todos:
+            current_todo = in_progress_todos[0].get("content", "")
+            if (
+                "작업 요약" in current_todo
+                or "다음단계" in current_todo
+                or "다음 단계" in current_todo
+            ):
+                logger.info(
+                    "Current todo is summary/next steps ('%s'), accepting text-only response",
+                    current_todo[:30],
+                )
+                return None  # Signal to skip retry - will synthesize write_todos with content
+
         return (
             f"{JSON_TOOL_SCHEMA}\n\n"
             f"Your previous response was text, not JSON. "
-            f"Wrap your answer in final_answer_tool:\n"
-            f'{{"tool": "final_answer_tool", "arguments": {{"answer": "{content_preview}..."}}}}'
+            f"Call the next appropriate tool to continue.\n"
+            f'Example: {{"tool": "jupyter_cell_tool", "arguments": {{"code": "print(\'hello\')"}}}}'
         )
     elif pending_todos:
         todo_list = ", ".join(t.get("content", "")[:20] for t in pending_todos[:3])
@@ -280,39 +353,62 @@ def _build_json_prompt(request, response_message, has_content):
             f"Call jupyter_cell_tool with Python code to complete the next task.\n"
             f"Example: {example_json}"
         )
+    elif not todos:
+        # No todos yet = new task starting, LLM must create todos or call a tool
+        # This happens when LLM returns empty response at the start of a new task
+        logger.info("No todos exist yet - forcing retry to create todos or call tool")
+        return (
+            f"{JSON_TOOL_SCHEMA}\n\n"
+            f"Your response was empty. You MUST call a tool to proceed.\n"
+            f"한국어로 응답하고, write_todos로 작업 목록을 만들거나 jupyter_cell_tool/read_file_tool을 호출하세요.\n"
+            f'Example: {{"tool": "write_todos", "arguments": {{"todos": [{{"content": "데이터 분석", "status": "in_progress"}}]}}}}'
+        )
     else:
+        # Todos exist but all completed - ask for summary
+        logger.info("All todos completed but response empty - asking for summary")
         return (
             f"{JSON_TOOL_SCHEMA}\n\n"
-            f"All tasks completed. Call final_answer_tool:\n"
-            f'{{"tool": "final_answer_tool", "arguments": {{"answer": "작업이 완료되었습니다."}}}}'
+            f"All tasks completed. Call markdown_tool to provide a summary in Korean.\n"
+            f"한국어로 작업 요약을 작성하세요.\n"
+            f'Example: {{"tool": "markdown_tool", "arguments": {{"content": "작업이 완료되었습니다."}}}}'
         )
 
 
 def _create_synthetic_final_answer(request, response_message, has_content):
-    """Create synthetic final_answer message."""
-    if has_content and response_message.content:
-        summary = response_message.content
+    """Create synthetic write_todos call to mark all todos as completed.
+
+    This triggers automatic session termination via router's all_todos_completed check.
+    Preserves the LLM's text content (summary) if present.
+    """
+    todos = request.state.get("todos", [])
+
+    # Mark all todos as completed
+    completed_todos = (
+        [{**todo, "status": "completed"} for todo in todos]
+        if todos
+        else [{"content": "작업 완료", "status": "completed"}]
+    )
+
+    # Preserve original content (summary JSON) if present
+    original_content = ""
+    if has_content and response_message and response_message.content:
+        original_content = response_message.content
         logger.info(
-            "Using LLM's text content as final answer (length=%d)",
-            len(summary),
+            "Creating synthetic write_todos with preserved content (length=%d)",
+            len(original_content),
         )
     else:
-        todos = request.state.get("todos", [])
-        completed_todos = [
-            t.get("content", "") for t in todos if t.get("status") == "completed"
-        ]
-        summary = (
-            f"작업이 완료되었습니다. 완료된 항목: {', '.join(completed_todos[:5])}"
-            if completed_todos
-            else "작업이 완료되었습니다."
+        logger.info(
+            "Creating synthetic write_todos to mark %d todos as completed",
+            len(completed_todos),
         )
 
     return AIMessage(
-        content="",
+        content=original_content,  # Preserve the summary content for UI
         tool_calls=[
             {
-                "name": "final_answer_tool",
-                "args": {"answer": summary},
+                "name": "write_todos",
+                "args": {"todos": completed_todos},
                 "id": str(uuid.uuid4()),
                 "type": "tool_call",
             }
@@ -363,70 +459,70 @@ def create_limit_tool_calls_middleware(wrap_model_call):
 
 def _get_string_params_from_tools(tools) -> Dict[str, set]:
     """Extract string parameter names from tool schemas.
-    
+
     Analyzes each tool's Pydantic args_schema to determine which parameters
     should be strings (not arrays).
-    
+
     Args:
         tools: List of LangChain tools
-        
+
     Returns:
         Dict mapping tool names to sets of string parameter names
     """
     from typing import get_args, get_origin
-    
+
     tool_string_params: Dict[str, set] = {}
-    
+
     for tool in tools:
-        tool_name = getattr(tool, 'name', None)
+        tool_name = getattr(tool, "name", None)
         if not tool_name:
             continue
-            
-        args_schema = getattr(tool, 'args_schema', None)
+
+        args_schema = getattr(tool, "args_schema", None)
         if not args_schema:
             continue
-            
+
         string_params = set()
-        
+
         # Get field annotations from Pydantic model
         try:
-            annotations = getattr(args_schema, '__annotations__', {})
+            annotations = getattr(args_schema, "__annotations__", {})
             for field_name, field_type in annotations.items():
                 origin = get_origin(field_type)
-                
+
                 # Check if it's a simple str type
                 if field_type is str:
                     string_params.add(field_name)
                 # Check if it's Optional[str] (Union[str, None])
-                elif origin is type(None) or str(origin) == 'typing.Union':
+                elif origin is type(None) or str(origin) == "typing.Union":
                     args = get_args(field_type)
                     if str in args:
                         string_params.add(field_name)
         except Exception as e:
             logger.debug("Failed to analyze schema for tool %s: %s", tool_name, e)
-            
+
         if string_params:
             tool_string_params[tool_name] = string_params
             logger.debug("Tool %s string params: %s", tool_name, string_params)
-    
+
     return tool_string_params
 
 
 def create_normalize_tool_args_middleware(wrap_model_call, tools=None):
     """Create middleware to normalize tool call arguments.
-    
+
     Gemini sometimes returns tool call arguments with list values instead of strings.
     This middleware converts list arguments to strings ONLY for parameters that
     are defined as str in the tool's Pydantic schema.
-    
+
     Args:
         wrap_model_call: LangChain's wrap_model_call decorator
         tools: Optional list of tools to analyze for type information
-    
+
     Returns:
         Middleware function
     """
-    
+
     # Build tool -> string params mapping from tool schemas
     tool_string_params: Dict[str, set] = {}
     if tools:
@@ -436,25 +532,37 @@ def create_normalize_tool_args_middleware(wrap_model_call, tools=None):
             len(tool_string_params),
             {k: list(v) for k, v in tool_string_params.items()},
         )
-    
+
     @wrap_model_call
     @_with_middleware_logging("normalize_tool_args")
     def normalize_tool_args(request, handler):
         response = handler(request)
-        
+
         if hasattr(response, "result"):
             result = response.result
             messages = result if isinstance(result, list) else [result]
-            
+
             for msg in messages:
                 if isinstance(msg, AIMessage) and hasattr(msg, "tool_calls"):
                     tool_calls = msg.tool_calls
                     if tool_calls:
                         for tool_call in tool_calls:
                             tool_name = tool_call.get("name", "")
+                            # Normalize tool name (e.g., write_todos_tool → write_todos)
+                            normalized_name = normalize_tool_name(tool_name)
+                            if normalized_name != tool_name:
+                                logger.info(
+                                    "Normalized tool name: %s → %s",
+                                    tool_name,
+                                    normalized_name,
+                                )
+                                tool_call["name"] = normalized_name
+                                tool_name = normalized_name
                             string_params = tool_string_params.get(tool_name, set())
-                            
-                            if "args" in tool_call and isinstance(tool_call["args"], dict):
+
+                            if "args" in tool_call and isinstance(
+                                tool_call["args"], dict
+                            ):
                                 args = tool_call["args"]
                                 # Normalize list arguments to strings for str-typed params
                                 for key, value in args.items():
@@ -464,9 +572,12 @@ def create_normalize_tool_args_middleware(wrap_model_call, tools=None):
                                         for part in value:
                                             if isinstance(part, str):
                                                 text_parts.append(part)
-                                            elif isinstance(part, dict) and part.get("type") == "text":
+                                            elif (
+                                                isinstance(part, dict)
+                                                and part.get("type") == "text"
+                                            ):
                                                 text_parts.append(part.get("text", ""))
-                                        
+
                                         if text_parts:
                                             normalized_value = "\n".join(text_parts)
                                             logger.info(
@@ -476,9 +587,33 @@ def create_normalize_tool_args_middleware(wrap_model_call, tools=None):
                                                 tool_name,
                                             )
                                             args[key] = normalized_value
-        
+
+                                # Ensure write_todos includes summary todo as last item
+                                if tool_name == "write_todos" and "todos" in args:
+                                    todos = args["todos"]
+                                    if isinstance(todos, list) and len(todos) > 0:
+                                        # Check if any todo contains summary keywords
+                                        summary_keywords = ["작업 요약", "다음단계", "다음 단계", "요약 및"]
+                                        has_summary = any(
+                                            any(kw in todo.get("content", "") for kw in summary_keywords)
+                                            for todo in todos
+                                            if isinstance(todo, dict)
+                                        )
+
+                                        if not has_summary:
+                                            # Add summary todo as last item
+                                            summary_todo = {
+                                                "content": "작업 요약 및 다음단계 제시",
+                                                "status": "pending"
+                                            }
+                                            todos.append(summary_todo)
+                                            logger.info(
+                                                "Auto-added '작업 요약 및 다음단계 제시' to write_todos (total: %d todos)",
+                                                len(todos),
+                                            )
+
         return response
-    
+
     return normalize_tool_args
 
 
@@ -516,16 +651,24 @@ def create_inject_continuation_middleware(wrap_model_call):
                     pass
 
             if tool_name in NON_HITL_TOOLS:
-                logger.info(
-                    "Injecting continuation prompt after non-HITL tool: %s",
-                    tool_name,
-                )
-
                 todos = request.state.get("todos", [])
                 pending_todos = [
                     t for t in todos if t.get("status") in ("pending", "in_progress")
                 ]
 
+                # If all todos are completed, don't inject continuation - let router handle termination
+                if not pending_todos and todos:
+                    logger.info(
+                        "All todos completed, skipping continuation for tool: %s",
+                        tool_name,
+                    )
+                    return handler(request)
+
+                logger.info(
+                    "Injecting continuation prompt after non-HITL tool: %s",
+                    tool_name,
+                )
+
                 if pending_todos:
                     pending_list = ", ".join(
                         t.get("content", "")[:30] for t in pending_todos[:3]
@@ -536,9 +679,10 @@ def create_inject_continuation_middleware(wrap_model_call):
                         f"Call jupyter_cell_tool or the next appropriate tool."
                     )
                 else:
+                    # No todos yet - let agent create them
                     continuation = (
-                        f"Tool '{tool_name}' completed. All tasks done. "
-                        f"Call final_answer_tool with a summary NOW."
+                        f"Tool '{tool_name}' completed. "
+                        f"Create a todo list with write_todos if needed."
                     )
 
                 new_messages = list(messages) + [