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

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="",
@@ -363,70 +375,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 +448,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 +488,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 +503,9 @@ def create_normalize_tool_args_middleware(wrap_model_call, tools=None):
                                                 tool_name,
                                             )
                                             args[key] = normalized_value
-        
+
         return response
-    
+
     return normalize_tool_args
 
 

agent_server/langchain/hitl_config.py

@@ -59,7 +59,12 @@ def get_hitl_interrupt_config() -> Dict[str, Any]:
         # File write requires approval
         "write_file_tool": {
             "allowed_decisions": ["approve", "edit", "reject"],
-            "description": "⚠️ File write requires approval",
+            "description": "File write requires approval",
+        },
+        # File edit requires approval (string replacement with diff preview)
+        "edit_file_tool": {
+            "allowed_decisions": ["approve", "edit", "reject"],
+            "description": "File edit requires approval",
         },
         # Final answer doesn't need approval
         "final_answer_tool": False,

agent_server/langchain/logging_utils.py

@@ -115,8 +115,28 @@ def _with_middleware_logging(name: str):
 
 
 class LLMTraceLogger(BaseCallbackHandler):
-    """Log prompts, responses, tool calls, and tool messages."""
-
+    """Log prompts, responses, tool calls, and tool messages.
+    
+    Only logs newly added messages to avoid duplicate logging of conversation history.
+    Uses content hash of first message (usually system prompt) to identify conversation threads.
+    """
+
+    def __init__(self):
+        super().__init__()
+        # Track last logged message count per conversation thread
+        # Key: hash of first message content, Value: message count
+        self._last_message_counts: Dict[str, int] = {}
+    
+    def _get_conversation_key(self, batch) -> str:
+        """Get a stable key for the conversation based on first message content."""
+        if not batch:
+            return "empty"
+        first_msg = batch[0]
+        content = getattr(first_msg, "content", "")
+        # Use hash of first 200 chars of first message (usually system prompt)
+        content_preview = str(content)[:200] if content else ""
+        return str(hash(content_preview))
+    
     def _normalize_batches(self, messages):
         if not messages:
             return []
@@ -125,19 +145,38 @@ class LLMTraceLogger(BaseCallbackHandler):
         return [messages]
 
     def _log_prompt_batches(self, title: str, messages) -> None:
+        """Log only new messages that haven't been logged before."""
         for batch_idx, batch in enumerate(self._normalize_batches(messages)):
-            header = f"{title} (batch={batch_idx}, messages={len(batch)})"
-            logger.info("%s", _format_messages_block(header, batch))
-
-            tool_messages = [
-                msg
-                for msg in batch
-                if getattr(msg, "type", "") == "tool"
-                or msg.__class__.__name__ == "ToolMessage"
-            ]
-            if tool_messages:
-                tool_header = f"{title} TOOL MESSAGES (batch={batch_idx})"
-                logger.info("%s", _format_messages_block(tool_header, tool_messages))
+            # Get stable conversation key based on first message
+            conv_key = self._get_conversation_key(batch)
+            batch_key = f"{conv_key}_{batch_idx}"
+            last_count = self._last_message_counts.get(batch_key, 0)
+            
+            # Only log new messages
+            new_messages = batch[last_count:]
+            if not new_messages:
+                logger.debug(
+                    "Skipping duplicate log for batch %d (already logged %d messages)",
+                    batch_idx,
+                    last_count,
+                )
+                continue
+            
+            # Update count
+            self._last_message_counts[batch_key] = len(batch)
+            
+            # Log with offset info
+            header = f"{title} (batch={batch_idx}, new={len(new_messages)}, total={len(batch)})"
+            
+            # Format new messages with correct indices
+            lines = [LOG_SEPARATOR, header, LOG_SEPARATOR]
+            for idx, message in enumerate(new_messages, start=last_count):
+                lines.append(f"[{idx}] {message.__class__.__name__}")
+                lines.append(_pretty_json(_serialize_message(message)))
+                if idx < len(batch) - 1:
+                    lines.append(LOG_SUBSECTION)
+            lines.append(LOG_SEPARATOR)
+            logger.info("%s", "\n".join(lines))
 
     def on_chat_model_start(self, serialized, messages, **kwargs) -> None:
         if not messages:

agent_server/langchain/prompts.py

@@ -8,7 +8,14 @@ and middleware-specific prompts.
 DEFAULT_SYSTEM_PROMPT = """You are an expert Python data scientist and Jupyter notebook assistant.
 Your role is to help users with data analysis, visualization, and Python coding tasks in Jupyter notebooks. You can use only Korean
 
-## ⚠️ CRITICAL RULE: NEVER produce an empty response
+# Core Behavior
+Be concise and direct. Answer in fewer than 4 lines unless the user asks for detail.
+After working on a file, just stop - don't explain what you did unless asked.
+Avoid unnecessary introductions or conclusions.
+
+## Task Management
+Use write_todos for complex multi-step tasks (3+ steps). Mark tasks in_progress before starting, completed immediately after finishing.
+For simple 1-2 step tasks, just do them directly without todos.
 
 You MUST ALWAYS call a tool in every response. After any tool result, you MUST:
 1. Check your todo list - are there pending or in_progress items?
@@ -24,8 +31,6 @@ You MUST ALWAYS call a tool in every response. After any tool result, you MUST:
 }
 4. If ALL todos are completed → call final_answer_tool with a summary
 
-NEVER end your turn without calling a tool. NEVER produce an empty response.
-
 ## 🔴 MANDATORY: Resource Check Before Data Hanlding
 **ALWAYS call check_resource_tool FIRST** when the task involves:
 - Loading files: .csv, .parquet, .json, .xlsx, .pickle, .h5, .feather
@@ -45,11 +50,27 @@ NEVER end your turn without calling a tool. NEVER produce an empty response.
 - Ending without calling final_answer_tool
 - Leaving todos in "in_progress" or "pending" state without continuing
 
-## 🚫 execute_command_tool Rules
-**NEVER run long-running commands** with execute_command_tool (e.g., servers, daemons, watch processes).
-- ✅ Allowed: Quick commands like `ls`, `cat`, `grep`, `git status`
-- ❌ Forbidden: `jupyter lab`, `npm start`, `python app.py`, `watch`, background processes
-- For long tasks: Use jupyter_cell_tool instead or inform the user to run manually
+## 📖 File Reading Best Practices
+**CRITICAL**: When exploring codebases or reading files, use pagination to prevent context overflow.
+
+**Pattern for codebase exploration:**
+1. First scan: `read_file_tool(path, limit=100)` - See file structure and key sections
+2. Targeted read: `read_file_tool(path, offset=100, limit=200)` - Read specific sections if needed
+3. Full read: Only read without limit when necessary for immediate editing
+
+**When to paginate (use offset/limit):**
+- Reading any file >500 lines
+- Exploring unfamiliar codebases (always start with limit=100)
+- Reading multiple files in sequence
+- Any research or investigation task
+
+**When full read is OK:**
+- Small files (<500 lines)
+- Files you need to edit immediately after reading
+- After confirming file size with first scan
+
+## 🔧 Code Development
+For code generation/refactoring, use LSP tools (diagnostics_tool, references_tool) to check errors and find symbol usages. Use multiedit_file_tool for multiple changes in one file.
 """
 
 JSON_TOOL_SCHEMA = """You MUST respond with ONLY valid JSON matching this schema:
@@ -63,7 +84,7 @@ Available tools:
 - markdown_tool: Add markdown cell. Arguments: {"content": "<markdown>"}
 - final_answer_tool: Complete task. Arguments: {"answer": "<summary>"}
 - write_todos: Update task list. Arguments: {"todos": [{"content": "...", "status": "pending|in_progress|completed"}]}
-- read_file_tool: Read file. Arguments: {"path": "<file_path>"}
+- read_file_tool: Read file with pagination. Arguments: {"path": "<file_path>", "offset": 0, "limit": 500}
 - write_file_tool: Write file. Arguments: {"path": "<path>", "content": "<content>", "overwrite": false}
 - list_files_tool: List directory. Arguments: {"path": ".", "recursive": false}
 - search_workspace_tool: Search files. Arguments: {"pattern": "<regex>", "file_types": ["py"], "path": "."}
@@ -75,27 +96,32 @@ Output ONLY the JSON object, no markdown, no explanation."""
 
 TODO_LIST_SYSTEM_PROMPT = """
 ## CRITICAL WORKFLOW RULES - MUST FOLLOW:
-1. NEVER stop after calling write_todos - ALWAYS make another tool call immediately
-2. write_todos is ONLY for tracking progress - it does NOT complete any work
-3. After EVERY write_todos call, you MUST call another tool (jupyter_cell_tool, markdown_tool, or final_answer_tool)
+- NEVER stop after calling write_todos - ALWAYS make another tool call immediately
+- For simple 1-2 step tasks, just do them directly without todos.
+
+## 🔴 NEW USER MESSAGE = FRESH START:
+- When user sends a NEW message, treat it as a COMPLETELY NEW TASK
+- IGNORE any previous todo completion history - start fresh
+- Do NOT assume any work was already done based on past conversations
+- Create a NEW todo list for the new request, even if similar items existed before
+- "다음 단계 제시" from a previous task is NOT completed for the new task
 
 ## Todo List Management:
 - Before complex tasks, use write_todos to create a task list
 - Update todos as you complete each step (mark 'in_progress' → 'completed')
-- Each todo item should be specific and descriptive (30-60 characters)
+- Each todo item should be specific and descriptive
 - All todo items must be written in Korean
 - ALWAYS include "다음 단계 제시" as the LAST item
 
 ## Task Completion Flow:
 1. When current task is done → mark it 'completed' with write_todos
-2. IMMEDIATELY call the next tool (jupyter_cell_tool for code, markdown_tool for text)
-3. For "다음 단계 제시" → mark completed, then call final_answer_tool with suggestions
-4. NEVER end your turn after write_todos - you MUST continue with actual work
+2. For "다음 단계 제시" → mark completed, then call final_answer_tool with suggestions
 
 ## FORBIDDEN PATTERNS:
 ❌ Calling write_todos and then stopping
 ❌ Updating todo status without doing the actual work
 ❌ Ending turn without calling final_answer_tool when all tasks are done
+❌ Marking a todo as 'completed' without actually executing it in THIS conversation
 """
 
 TODO_LIST_TOOL_DESCRIPTION = """Update the task list for tracking progress.
@@ -116,4 +142,9 @@ NON_HITL_TOOLS = {
     "search_notebook_cells_tool",
     "search_notebook_cells",
     "write_todos",
+    # LSP tools (read-only)
+    "diagnostics_tool",
+    "diagnostics",
+    "references_tool",
+    "references",
 }

agent_server/langchain/tools/__init__.py

@@ -7,15 +7,20 @@ Tools available:
 - final_answer: Complete the task
 - read_file: Read file content
 - write_file: Write file content
+- edit_file: Edit file with string replacement
 - list_files: List directory contents
 - search_workspace: Search files in workspace
 - search_notebook_cells: Search cells in notebooks
 - execute_command_tool: Run shell commands (client-executed)
 - check_resource_tool: Check resources before data processing (client-executed)
+- diagnostics_tool: Get LSP diagnostics (errors, warnings)
+- references_tool: Find symbol references via LSP
 """
 
 from agent_server.langchain.tools.file_tools import (
+    edit_file_tool,
     list_files_tool,
+    multiedit_file_tool,
     read_file_tool,
     write_file_tool,
 )
@@ -24,6 +29,10 @@ from agent_server.langchain.tools.jupyter_tools import (
     jupyter_cell_tool,
     markdown_tool,
 )
+from agent_server.langchain.tools.lsp_tools import (
+    diagnostics_tool,
+    references_tool,
+)
 from agent_server.langchain.tools.resource_tools import check_resource_tool
 from agent_server.langchain.tools.search_tools import (
     search_notebook_cells_tool,
@@ -37,9 +46,13 @@ __all__ = [
     "final_answer_tool",
     "read_file_tool",
     "write_file_tool",
+    "edit_file_tool",
+    "multiedit_file_tool",
     "list_files_tool",
     "search_workspace_tool",
     "search_notebook_cells_tool",
     "execute_command_tool",
     "check_resource_tool",
+    "diagnostics_tool",
+    "references_tool",
 ]