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

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

@@ -116,7 +116,7 @@ def _with_middleware_logging(name: str):
 
 class LLMTraceLogger(BaseCallbackHandler):
     """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.
     """
@@ -126,7 +126,7 @@ class LLMTraceLogger(BaseCallbackHandler):
         # 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:
@@ -136,7 +136,7 @@ class LLMTraceLogger(BaseCallbackHandler):
         # 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 []
@@ -151,7 +151,7 @@ class LLMTraceLogger(BaseCallbackHandler):
             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:
@@ -161,13 +161,13 @@ class LLMTraceLogger(BaseCallbackHandler):
                     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):

agent_server/langchain/prompts.py

@@ -16,20 +16,16 @@ 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
+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:
@@ -40,16 +36,25 @@ You MUST ALWAYS call a tool in every response. After any tool result, you MUST:
 ## 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
 
+## 📂 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.
 
@@ -82,52 +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 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:
-- NEVER stop after calling write_todos - ALWAYS make another tool call immediately
+- 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
-- 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
+- **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
-- 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. For "다음 단계 제시" → mark completed, then call final_answer_tool with suggestions
+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 conversation
+❌ 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 = {
@@ -135,10 +148,6 @@ 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",

agent_server/langchain/tools/__init__.py

@@ -4,14 +4,11 @@ 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
 - 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)
+- 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
@@ -19,13 +16,11 @@ Tools available:
 
 from agent_server.langchain.tools.file_tools import (
     edit_file_tool,
-    list_files_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,
 )
@@ -36,20 +31,16 @@ from agent_server.langchain.tools.lsp_tools import (
 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",
     "edit_file_tool",
     "multiedit_file_tool",
-    "list_files_tool",
-    "search_workspace_tool",
     "search_notebook_cells_tool",
     "execute_command_tool",
     "check_resource_tool",

agent_server/langchain/tools/file_tools.py

@@ -5,7 +5,6 @@ Provides tools for file system operations:
 - read_file: Read file content
 - write_file: Write content to file (requires approval)
 - edit_file: Edit file with string replacement (requires approval)
-- list_files: List directory contents
 """
 
 import os
@@ -70,21 +69,6 @@ class EditFileInput(BaseModel):
     )
 
 
-class ListFilesInput(BaseModel):
-    """Input schema for list_files tool"""
-
-    path: str = Field(default=".", description="Directory path to list")
-    recursive: bool = Field(default=False, description="Whether to list recursively")
-    pattern: Optional[str] = Field(
-        default=None,
-        description="Glob pattern to filter files (e.g., '*.py', '*.ipynb')",
-    )
-    execution_result: Optional[Dict[str, Any]] = Field(
-        default=None,
-        description="Optional execution result payload from the client",
-    )
-
-
 def _validate_path(path: str, workspace_root: str = ".") -> str:
     """
     Validate and resolve file path.
@@ -315,50 +299,13 @@ def edit_file_tool(
         }
 
 
-@tool(args_schema=ListFilesInput)
-def list_files_tool(
-    path: str = ".",
-    recursive: bool = False,
-    pattern: Optional[str] = None,
-    execution_result: Optional[Dict[str, Any]] = None,
-    workspace_root: str = ".",
-) -> Dict[str, Any]:
-    """
-    List files and directories.
-
-    Args:
-        path: Directory path to list (default: current directory)
-        recursive: Whether to list recursively
-        pattern: Optional glob pattern to filter (e.g., '*.py')
-
-    Returns:
-        Dict with list of files and directories
-    """
-    response: Dict[str, Any] = {
-        "tool": "list_files_tool",
-        "parameters": {
-            "path": path,
-            "recursive": recursive,
-            "pattern": pattern,
-        },
-        "status": "pending_execution",
-        "message": "File listing queued for execution by client",
-    }
-    if execution_result is not None:
-        response["execution_result"] = execution_result
-        response["status"] = "complete"
-        response["message"] = "File listing executed with client-reported results"
-    return response
-
-
 class EditOperation(BaseModel):
     """Single edit operation for multiedit_file tool"""
 
     old_string: str = Field(description="The exact string to find and replace")
     new_string: str = Field(description="The replacement string")
     replace_all: bool = Field(
-        default=False,
-        description="Whether to replace all occurrences (default: false)"
+        default=False, description="Whether to replace all occurrences (default: false)"
     )
 
 
@@ -456,12 +403,14 @@ def multiedit_file_tool(
 
             old_preview = (old_str[:50] + "...") if len(old_str) > 50 else old_str
             new_preview = (new_str[:50] + "...") if len(new_str) > 50 else new_str
-            edits_preview.append({
-                "index": i,
-                "old_preview": old_preview,
-                "new_preview": new_preview,
-                "replace_all": replace_all_val
-            })
+            edits_preview.append(
+                {
+                    "index": i,
+                    "old_preview": old_preview,
+                    "new_preview": new_preview,
+                    "replace_all": replace_all_val,
+                }
+            )
 
         # Convert all edits to dicts for serialization
         for edit in edits:
@@ -515,5 +464,4 @@ FILE_TOOLS = [
     write_file_tool,
     edit_file_tool,
     multiedit_file_tool,
-    list_files_tool,
 ]

agent_server/langchain/tools/jupyter_tools.py

@@ -139,5 +139,4 @@ def final_answer_tool(answer: str, summary: Optional[str] = None) -> Dict[str, A
 JUPYTER_TOOLS = [
     jupyter_cell_tool,
     markdown_tool,
-    final_answer_tool,
 ]

agent_server/langchain/tools/lsp_tools.py

@@ -103,7 +103,7 @@ def diagnostics_tool(
         return {
             "tool": "diagnostics_tool",
             "success": True,
-            "output": "LSP not available. Install jupyterlab-lsp for code diagnostics.\nUse search_workspace_tool for text-based code search instead.",
+            "output": "LSP not available. Install jupyterlab-lsp for code diagnostics.\nUse execute_command_tool with grep for text-based code search instead.",
             "counts": {"errors": 0, "warnings": 0, "total": 0},
         }
 
@@ -122,9 +122,7 @@ def diagnostics_tool(
 
     # Filter by severity if specified
     if severity_filter:
-        sorted_diags = [
-            d for d in sorted_diags if d.get("severity") == severity_filter
-        ]
+        sorted_diags = [d for d in sorted_diags if d.get("severity") == severity_filter]
 
     # Format output (Crush의 formatDiagnostics 패턴)
     formatted_lines = []
@@ -153,7 +151,7 @@ def diagnostics_tool(
     # Add summary
     summary = f"\n--- Summary: {errors} errors, {warnings} warnings, {total} total"
     if total > 10:
-        summary += f" (showing first 10)"
+        summary += " (showing first 10)"
 
     output = (
         "\n".join(formatted_lines) + summary
@@ -185,7 +183,7 @@ def references_tool(
     - Understand how a variable is used throughout the code
     - Find all usages before refactoring
 
-    If LSP is not available, falls back to search_workspace_tool.
+    If LSP is not available, falls back to execute_command_tool with grep.
 
     Args:
         symbol: Symbol name (function, class, variable)
@@ -218,7 +216,7 @@ def references_tool(
             return {
                 "tool": "references_tool",
                 "success": True,
-                "output": f"LSP not available. Use search_workspace_tool with pattern='{symbol}' for text-based search.",
+                "output": f"LSP not available. Use execute_command_tool with grep with pattern='{symbol}' for text-based search.",
                 "count": 0,
             }
         return {
@@ -238,7 +236,9 @@ def references_tool(
 
     # Format output
     method_note = " (grep-based)" if used_grep else " (LSP)"
-    formatted_lines = [f"Found {len(locations)} references to '{symbol}'{method_note}:\n"]
+    formatted_lines = [
+        f"Found {len(locations)} references to '{symbol}'{method_note}:\n"
+    ]
 
     for file, locs in sorted(by_file.items()):
         formatted_lines.append(f"\n📄 {file}")

agent_server/langchain/tools/resource_tools.py

@@ -46,7 +46,7 @@ def _build_file_size_command(files: List[str]) -> str:
     """
     if not files:
         return ""
-    
+
     # Use stat with format that works on both macOS and Linux
     # macOS: stat -f "%z %N"
     # Linux: stat -c "%s %n"
@@ -62,10 +62,10 @@ def _build_dataframe_check_code(dataframes: List[str]) -> str:
     """
     if not dataframes:
         return ""
-    
+
     df_checks = []
     for df_name in dataframes:
-        df_checks.append(f'''
+        df_checks.append(f"""
 try:
     _df = {df_name}
     _info = {{
@@ -79,14 +79,14 @@ try:
 except NameError:
     _info = {{"name": "{df_name}", "exists": False}}
 _results.append(_info)
-''')
-    
-    code = f'''
+""")
+
+    code = f"""
 import json
 _results = []
 {chr(10).join(df_checks)}
 print(json.dumps(_results))
-'''
+"""
     return code.strip()
 
 
@@ -137,20 +137,20 @@ def check_resource_tool(
         response["execution_result"] = execution_result
         response["status"] = "complete"
         response["message"] = "Resource check completed"
-        
+
         # Parse the execution result
         if isinstance(execution_result, dict):
             response["success"] = execution_result.get("success", False)
-            
+
             # System resources
             response["system"] = execution_result.get("system", {})
-            
+
             # File sizes
             response["files"] = execution_result.get("files", [])
-            
+
             # DataFrame info
             response["dataframes"] = execution_result.get("dataframes", [])
-            
+
             if "error" in execution_result:
                 response["error"] = execution_result["error"]