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

agent_server/langchain/hitl_config.py

@@ -32,17 +32,9 @@ def get_hitl_interrupt_config() -> Dict[str, Any]:
             "allowed_decisions": ["approve", "edit"],
             "description": "📄 파일 읽기 실행 중",
         },
-        "list_files_tool": {
-            "allowed_decisions": ["approve", "edit"],
-            "description": "📂 파일 목록 조회 중",
-        },
         "write_todos": False,  # Todo updates don't need approval
         # Search tools need HITL for client-side execution (auto-approved by frontend)
         # Uses 'edit' decision to pass execution_result back
-        "search_workspace_tool": {
-            "allowed_decisions": ["approve", "edit"],
-            "description": "🔍 Searching workspace files",
-        },
         "search_notebook_cells_tool": {
             "allowed_decisions": ["approve", "edit"],
             "description": "🔍 Searching notebook cells",
@@ -59,7 +51,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/llm_factory.py

@@ -4,6 +4,7 @@ LLM Factory for LangChain agent.
 Provides functions to create LangChain LLM instances from configuration.
 """
 
+import json
 import logging
 from typing import Any, Dict
 
@@ -12,6 +13,74 @@ from agent_server.langchain.logging_utils import LLMTraceLogger
 logger = logging.getLogger(__name__)
 
 
+def _stringify_content(content: Any) -> str:
+    if content is None:
+        return ""
+    if isinstance(content, list):
+        parts = []
+        for part in content:
+            if isinstance(part, str):
+                parts.append(part)
+            elif isinstance(part, dict):
+                if part.get("type") == "text":
+                    parts.append(part.get("text", ""))
+                elif "text" in part:
+                    parts.append(part.get("text", ""))
+        return "\n".join(p for p in parts if p)
+    return str(content)
+
+
+def _summarize_payload(
+    payload: Dict[str, Any],
+    max_preview: int = 200,
+    max_items: int = 12,
+) -> Dict[str, Any]:
+    summary: Dict[str, Any] = {}
+
+    def summarize_messages(key: str) -> None:
+        items = payload.get(key)
+        if not isinstance(items, list):
+            return
+        summarized = []
+        for item in items[:max_items]:
+            if not isinstance(item, dict):
+                summarized.append({"type": type(item).__name__})
+                continue
+            content_text = _stringify_content(item.get("content", ""))
+            entry = {
+                "role": item.get("role"),
+                "content_len": len(content_text),
+                "content_preview": content_text[:max_preview],
+            }
+            tool_calls = item.get("tool_calls")
+            if isinstance(tool_calls, list):
+                entry["tool_calls"] = [
+                    tc.get("function", {}).get("name") or tc.get("name")
+                    for tc in tool_calls
+                    if isinstance(tc, dict)
+                ]
+            summarized.append(entry)
+        if len(items) > max_items:
+            summarized.append({"truncated": len(items) - max_items})
+        summary[key] = summarized
+
+    summarize_messages("messages")
+    summarize_messages("input")
+
+    tools = payload.get("tools")
+    if isinstance(tools, list):
+        summary["tools"] = [
+            tool.get("function", {}).get("name") or tool.get("name")
+            for tool in tools
+            if isinstance(tool, dict)
+        ]
+
+    if "tool_choice" in payload:
+        summary["tool_choice"] = payload.get("tool_choice")
+
+    return summary
+
+
 def create_llm(llm_config: Dict[str, Any]):
     """Create LangChain LLM from config.
 
@@ -99,7 +168,22 @@ def _create_vllm_llm(llm_config: Dict[str, Any], callbacks):
 
     logger.info(f"Creating vLLM LLM with model: {model}, endpoint: {endpoint}")
 
-    return ChatOpenAI(
+    llm_class = ChatOpenAI
+    if "gpt-oss" in model.lower():
+
+        class ChatOpenAIGptOss(ChatOpenAI):
+            def _get_request_payload(self, input_, *, stop=None, **kwargs):
+                payload = super()._get_request_payload(input_, stop=stop, **kwargs)
+                summary = _summarize_payload(payload)
+                logger.info(
+                    "gpt-oss payload summary: %s",
+                    json.dumps(summary, ensure_ascii=False),
+                )
+                return payload
+
+        llm_class = ChatOpenAIGptOss
+
+    return llm_class(
         model=model,
         api_key=api_key,
         base_url=f"{endpoint}/v1",

agent_server/langchain/logging_utils.py

@@ -115,7 +115,27 @@ 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:
@@ -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,23 +8,24 @@ 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.
+When creating a todo list, ALWAYS include "작업 요약 및 다음단계 제시" as the LAST todo item.
 
 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?
 2. If YES → call the next appropriate tool (jupyter_cell_tool, markdown_tool, etc.)
-3. When you suggest next steps for todo item '다음 단계 제시', you MUST create next steps in json format matching this schema:
-{
-  "next_items": [
-    {
-        "subject": "<subject for next step>",
-        "description": "<detailed description for the next step>"
-    }, ...
-  ]
-}
-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.
+3. When executing "작업 요약 및 다음단계 제시" (final todo):
+   - Output this JSON as text content: {"summary": "실행된 작업 요약", "next_items": [{"subject": "제목", "description": "설명"}]}
+   - Suggest 3~5 next items
+   - AND call write_todos to mark all as 'completed' IN THE SAME RESPONSE
+   - Both content AND tool call must be in ONE response
 
 ## 🔴 MANDATORY: Resource Check Before Data Hanlding
 **ALWAYS call check_resource_tool FIRST** when the task involves:
@@ -35,21 +36,46 @@ NEVER end your turn without calling a tool. NEVER produce an empty response.
 ## Mandatory Workflow
 1. After EVERY tool result, immediately call the next tool
 2. Continue until ALL todos show status: "completed"
-3. ONLY THEN call final_answer_tool to summarize
-4. Only use jupyter_cell_tool for Python code or when the user explicitly asks to run in a notebook cell
-5. For plots and charts, use English text only.
+3. Only use jupyter_cell_tool for Python code or when the user explicitly asks to run in a notebook cell
+4. For plots and charts, use English text only.
 
 ## ❌ FORBIDDEN (will break the workflow)
 - Producing an empty response (no tool call, no content)
 - Stopping after any tool without calling the next tool
-- 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 Search Best Practices
+**CRITICAL**: Use `execute_command_tool` with find/grep commands for file searching.
+
+**To find files by NAME** (e.g., find titanic.csv):
+- `execute_command_tool(command="find . -iname '*titanic*.csv' 2>/dev/null")`
+- `execute_command_tool(command="find . -name '*.csv' 2>/dev/null")` - find all CSV files
+
+**To search file CONTENTS** (e.g., find code containing "import pandas"):
+- `execute_command_tool(command="grep -rn 'import pandas' --include='*.py' .")`
+- `execute_command_tool(command="grep -rn 'def train_model' --include='*.py' --include='*.ipynb' .")`
+
+## 📖 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:
@@ -61,47 +87,60 @@ JSON_TOOL_SCHEMA = """You MUST respond with ONLY valid JSON matching this schema
 Available tools:
 - jupyter_cell_tool: Execute Python code. Arguments: {"code": "<python_code>"}
 - 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": "."}
 - search_notebook_cells_tool: Search notebook cells. Arguments: {"pattern": "<regex>"}
-- execute_command_tool: Execute shell command. Arguments: {"command": "<command>", "stdin": "<input_for_prompts>"}
+- execute_command_tool: Execute shell command. Use for file search with find/grep. Arguments: {"command": "<command>", "stdin": "<input_for_prompts>"}
 - check_resource_tool: Check resources before data processing. Arguments: {"files": ["<path>"], "dataframes": ["<var_name>"]}
 
 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 (unless ALL todos are completed)
+- 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
+- **CRITICAL**: Previous conversation history shows PAST work, NOT current work
+- Even if you see a similar todo was "completed" before, you MUST do it again NOW
+- The completion status in chat history is IRRELEVANT to current todos
+- Each todo in the CURRENT list must be executed from scratch, regardless of history
+
+## 🔴 MANDATORY Todo List Structure:
+When creating todos, ALWAYS include "작업 요약 및 다음단계 제시" as the LAST item:
+- 실제 작업 항목들...
+- 작업 요약 및 다음단계 제시  ← 반드시 마지막에 포함!
 
 ## Todo List Management:
+- 반드시 모든 todo item 은 한국어로 생성.
 - 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)
-- All todo items must be written in Korean
-- ALWAYS include "다음 단계 제시" as the LAST item
+- Each todo item should be specific and descriptive
 
 ## 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
+1. Check CURRENT todo list status (not chat history!) → find 'pending' or 'in_progress' item
+2. Execute the task yourself in THIS response → then mark 'completed'
+3. For "작업 요약 및 다음단계 제시" → output summary JSON as plain text, then mark completed
+4. When ALL todos are 'completed' → session ends automatically
+
+⚠️ HOW TO CHECK IF TODO IS DONE:
+- ✅ Done: You executed it in THIS response (you made the tool call, you got the result)
+- ❌ Not done: You only SEE it was done in previous messages (that's history, not your work)
 
 ## 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 response
+❌ Creating todo list WITHOUT "작업 요약 및 다음단계 제시" as final item
+❌ Skipping ANY todo because a similar one was completed in PREVIOUS messages - past history ≠ current work
+❌ Assuming work is done based on chat history - you must ALWAYS execute todos yourself
 """
 
 TODO_LIST_TOOL_DESCRIPTION = """Update the task list for tracking progress.
 ⚠️ CRITICAL: This tool is ONLY for tracking - it does NOT do any actual work.
-After calling this tool, you MUST IMMEDIATELY call another tool (jupyter_cell_tool, markdown_tool, or final_answer_tool).
-NEVER end your response after calling write_todos - always continue with the next action tool."""
+- If there are still pending/in_progress todos: call the next action tool immediately after
+- If ALL todos are 'completed': output summary text BEFORE calling this tool, then call this to end the session"""
 
 # Non-HITL tools that execute immediately without user approval
 NON_HITL_TOOLS = {
@@ -109,11 +148,12 @@ NON_HITL_TOOLS = {
     "markdown",
     "read_file_tool",
     "read_file",
-    "list_files_tool",
-    "list_files",
-    "search_workspace_tool",
-    "search_workspace",
     "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

@@ -4,42 +4,46 @@ LangChain Tools for Jupyter Agent
 Tools available:
 - jupyter_cell: Execute Python code in notebook
 - markdown: Add markdown cell
-- final_answer: Complete the task
 - read_file: Read file content
 - write_file: Write file content
-- list_files: List directory contents
-- search_workspace: Search files in workspace
+- edit_file: Edit file with string replacement
 - search_notebook_cells: Search cells in notebooks
-- execute_command_tool: Run shell commands (client-executed)
+- execute_command_tool: Run shell commands (client-executed, also for file search)
 - 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 (
-    list_files_tool,
+    edit_file_tool,
+    multiedit_file_tool,
     read_file_tool,
     write_file_tool,
 )
 from agent_server.langchain.tools.jupyter_tools import (
-    final_answer_tool,
     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,
-    search_workspace_tool,
 )
 from agent_server.langchain.tools.shell_tools import execute_command_tool
 
 __all__ = [
     "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",
 ]