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

agent_server/core/notebook_generator.py

@@ -118,9 +118,9 @@ JSON만 응답하세요:"""
 요청: {prompt}
 
 분석 결과:
-- 목표: {analysis['objective']}
-- 라이브러리: {', '.join(analysis['libraries'])}
-- 분석 유형: {analysis['analysis_type']}
+- 목표: {analysis["objective"]}
+- 라이브러리: {", ".join(analysis["libraries"])}
+- 분석 유형: {analysis["analysis_type"]}
 
 노트북의 각 셀에 대한 계획을 JSON 형식으로 작성해주세요:
 {{
@@ -171,7 +171,7 @@ JSON만 응답하세요:"""
             # Update progress (30% -> 80%)
             progress = 30 + int((idx / total_cells) * 50)
             self.task_manager.update_progress(
-                task_id, progress, f"셀 생성 중... ({idx+1}/{total_cells})"
+                task_id, progress, f"셀 생성 중... ({idx + 1}/{total_cells})"
             )
 
             cell_type = cell_plan.get("type", "code")

agent_server/langchain/custom_middleware.py

@@ -139,7 +139,8 @@ 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
+        # Check if all todos are completed - if so, return empty response to stop agent
+        # Method 1: Check state.todos
         todos = request.state.get("todos", [])
         if todos:
             pending_todos = [
@@ -147,10 +148,35 @@ def create_handle_empty_response_middleware(wrap_model_call):
             ]
             if not pending_todos:
                 logger.info(
-                    "All %d todos completed - skipping handle_empty_response middleware",
+                    "All %d todos completed (from state) - stopping agent (no LLM call)",
                     len(todos),
                 )
-                return handler(request)
+                return AIMessage(content="", tool_calls=[])
+
+        # Method 2: Check last message if it's a write_todos ToolMessage with all completed
+        messages = request.messages
+        if messages:
+            last_msg = messages[-1]
+            if getattr(last_msg, "type", "") == "tool":
+                tool_name = getattr(last_msg, "name", "") or ""
+                content = getattr(last_msg, "content", "") or ""
+                if tool_name == "write_todos" or "Updated todo list to" in content:
+                    # Extract todos from ToolMessage content
+                    try:
+                        import ast
+                        if "Updated todo list to" in content:
+                            list_text = content.split("Updated todo list to", 1)[1].strip()
+                            todos_from_msg = ast.literal_eval(list_text)
+                            if isinstance(todos_from_msg, list) and len(todos_from_msg) > 0:
+                                pending = [t for t in todos_from_msg if t.get("status") in ("pending", "in_progress")]
+                                if not pending:
+                                    logger.info(
+                                        "All %d todos completed (from ToolMessage) - stopping agent (no LLM call)",
+                                        len(todos_from_msg),
+                                    )
+                                    return AIMessage(content="", tool_calls=[])
+                    except Exception as e:
+                        logger.debug("Failed to parse todos from ToolMessage: %s", e)
 
         # 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
@@ -593,9 +619,17 @@ def create_normalize_tool_args_middleware(wrap_model_call, tools=None):
                                     todos = args["todos"]
                                     if isinstance(todos, list) and len(todos) > 0:
                                         # Check if any todo contains summary keywords
-                                        summary_keywords = ["작업 요약", "다음단계", "다음 단계", "요약 및"]
+                                        summary_keywords = [
+                                            "작업 요약",
+                                            "다음단계",
+                                            "다음 단계",
+                                            "요약 및",
+                                        ]
                                         has_summary = any(
-                                            any(kw in todo.get("content", "") for kw in summary_keywords)
+                                            any(
+                                                kw in todo.get("content", "")
+                                                for kw in summary_keywords
+                                            )
                                             for todo in todos
                                             if isinstance(todo, dict)
                                         )
@@ -604,7 +638,7 @@ def create_normalize_tool_args_middleware(wrap_model_call, tools=None):
                                             # Add summary todo as last item
                                             summary_todo = {
                                                 "content": "작업 요약 및 다음단계 제시",
-                                                "status": "pending"
+                                                "status": "pending",
                                             }
                                             todos.append(summary_todo)
                                             logger.info(
@@ -612,6 +646,37 @@ def create_normalize_tool_args_middleware(wrap_model_call, tools=None):
                                                 len(todos),
                                             )
 
+                                        # Log warning if summary todo is completed without JSON (but don't block)
+                                        for todo in todos:
+                                            if not isinstance(todo, dict):
+                                                continue
+                                            content = todo.get("content", "")
+                                            status = todo.get("status", "")
+                                            is_summary_todo = any(
+                                                kw in content for kw in summary_keywords
+                                            )
+                                            if is_summary_todo and status == "completed":
+                                                # Check if AIMessage content has summary JSON
+                                                msg_content = getattr(msg, "content", "") or ""
+                                                if isinstance(msg_content, list):
+                                                    msg_content = " ".join(
+                                                        str(p) for p in msg_content
+                                                    )
+                                                has_summary_json = (
+                                                    '"summary"' in msg_content
+                                                    and '"next_items"' in msg_content
+                                                ) or (
+                                                    "'summary'" in msg_content
+                                                    and "'next_items'" in msg_content
+                                                )
+                                                if not has_summary_json:
+                                                    # Just log warning - don't block completion to avoid infinite loop
+                                                    logger.warning(
+                                                        "Summary todo marked completed but no summary JSON in content. "
+                                                        "Allowing completion to proceed. Content: %s",
+                                                        msg_content[:200],
+                                                    )
+
         return response
 
     return normalize_tool_args
@@ -651,18 +716,39 @@ def create_inject_continuation_middleware(wrap_model_call):
                     pass
 
             if tool_name in NON_HITL_TOOLS:
+                # Method 1: Check state.todos
                 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 all todos are completed, DON'T call LLM - return empty response to stop agent
                 if not pending_todos and todos:
                     logger.info(
-                        "All todos completed, skipping continuation for tool: %s",
+                        "All todos completed (from state) after tool: %s - stopping agent (no LLM call)",
                         tool_name,
                     )
-                    return handler(request)
+                    return AIMessage(content="", tool_calls=[])
+
+                # Method 2: Check ToolMessage content for write_todos
+                if tool_name == "write_todos" or "Updated todo list to" in (last_msg.content or ""):
+                    try:
+                        import ast
+                        content = last_msg.content or ""
+                        if "Updated todo list to" in content:
+                            list_text = content.split("Updated todo list to", 1)[1].strip()
+                            todos_from_msg = ast.literal_eval(list_text)
+                            if isinstance(todos_from_msg, list) and len(todos_from_msg) > 0:
+                                pending = [t for t in todos_from_msg if t.get("status") in ("pending", "in_progress")]
+                                if not pending:
+                                    logger.info(
+                                        "All %d todos completed (from ToolMessage) after tool: %s - stopping agent",
+                                        len(todos_from_msg),
+                                        tool_name,
+                                    )
+                                    return AIMessage(content="", tool_calls=[])
+                    except Exception as e:
+                        logger.debug("Failed to parse todos from ToolMessage: %s", e)
 
                 logger.info(
                     "Injecting continuation prompt after non-HITL tool: %s",

agent_server/langchain/hitl_config.py

@@ -58,6 +58,11 @@ def get_hitl_interrupt_config() -> Dict[str, Any]:
             "allowed_decisions": ["approve", "edit", "reject"],
             "description": "File edit requires approval",
         },
+        # Multi-edit requires approval (multiple string replacements atomically)
+        "multiedit_file_tool": {
+            "allowed_decisions": ["approve", "edit", "reject"],
+            "description": "Multi-edit requires approval",
+        },
         # Final answer doesn't need approval
         "final_answer_tool": False,
     }

agent_server/langchain/llm_factory.py

@@ -4,7 +4,6 @@ LLM Factory for LangChain agent.
 Provides functions to create LangChain LLM instances from configuration.
 """
 
-import json
 import logging
 from typing import Any, Dict
 
@@ -13,74 +12,6 @@ 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.
 
@@ -168,22 +99,7 @@ def _create_vllm_llm(llm_config: Dict[str, Any], callbacks):
 
     logger.info(f"Creating vLLM LLM with model: {model}, endpoint: {endpoint}")
 
-    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(
+    return ChatOpenAI(
         model=model,
         api_key=api_key,
         base_url=f"{endpoint}/v1",

agent_server/langchain/prompts.py

@@ -5,142 +5,119 @@ Contains system prompts, JSON schema for fallback tool calling,
 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
-
-# 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 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:
-- Loading files: .csv, .parquet, .json, .xlsx, .pickle, .h5, .feather
-- Handling datasets(dataframe) with pandas, polars, dask, or similar libraries
-- Training ML models on data files
-
-## Mandatory Workflow
-1. After EVERY tool result, immediately call the next tool
-2. Continue until ALL todos show status: "completed"
-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
-- 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.
-
-**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.
+DEFAULT_SYSTEM_PROMPT = """You are an expert Python data scientist and Jupyter notebook assistant. Respond in Korean only.
+
+# Core Rules
+1. Be concise (≤4 lines unless detail requested)
+2. ALWAYS call a tool in every response - never respond with text only
+3. ALWAYS include a brief Korean explanation before tool calls
+
+# Task Workflow
+
+## Simple Tasks (1-2 steps)
+Execute directly without todos.
+
+## Complex Tasks (3+ steps)
+1. Create todos with write_todos (all items in Korean)
+2. ALWAYS include "작업 요약 및 다음단계 제시" as the LAST item
+3. After each tool result: check todos → call next tool → repeat
+4. **Final todo ("작업 요약 및 다음단계 제시")**:
+   - FIRST: Output summary JSON in your content (REQUIRED!)
+   - THEN: Call write_todos to mark all as completed
+   - Both must be in the SAME response
+
+### Summary JSON Format (MUST output before marking complete)
+```json
+{"summary": "실행된 작업 요약", "next_items": [{"subject": "제목", "description": "설명"}]}
+```
+Suggest 3-5 next items. **You CANNOT mark "작업 요약" as completed without outputting this JSON first.**
+
+# Mandatory Checks
+
+## Resource Check (BEFORE data operations)
+Call `check_resource_tool` FIRST when:
+- Loading files (.csv, .parquet, .json, .xlsx, .pickle, .h5, .feather)
+- Using pandas/polars/dask for dataframes
+- Training ML models
+
+# Tool Usage
+
+## File Search (execute_command_tool)
+```bash
+find . -iname '*filename*.csv' 2>/dev/null     # Find by name
+grep -rn 'pattern' --include='*.py' .           # Search contents
+```
+
+## File Reading (read_file_tool)
+- Large files: `read_file_tool(path, limit=100)` first
+- Use `offset` for pagination
+- Small files (<500 lines): Read without limit
+
+## Code Output
+- For plots/charts: Use English labels only
+- Use LSP tools for error checking and symbol lookup
+- Use multiedit_file_tool for multiple changes
+
+# Forbidden
+- Empty responses (no tool call AND no content)
+- Tool calls without Korean explanation
+- Stopping with pending/in_progress todos
 """
 
-JSON_TOOL_SCHEMA = """You MUST respond with ONLY valid JSON matching this schema:
-{
-  "tool": "<tool_name>",
-  "arguments": {"arg1": "value1", ...}
-}
+JSON_TOOL_SCHEMA = """Respond with ONLY valid JSON:
+{"tool": "<name>", "arguments": {...}}
 
-Available tools:
-- jupyter_cell_tool: Execute Python code. Arguments: {"code": "<python_code>"}
-- markdown_tool: Add markdown cell. Arguments: {"content": "<markdown>"}
-- 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}
-- search_notebook_cells_tool: Search notebook cells. Arguments: {"pattern": "<regex>"}
-- 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>"]}
+Tools:
+- jupyter_cell_tool: {"code": "<python>"}
+- markdown_tool: {"content": "<markdown>"}
+- write_todos: {"todos": [{"content": "한국어 내용", "status": "pending|in_progress|completed"}]}
+- read_file_tool: {"path": "<path>", "offset": 0, "limit": 500}
+- write_file_tool: {"path": "<path>", "content": "<content>", "overwrite": false}
+- search_notebook_cells_tool: {"pattern": "<regex>"}
+- execute_command_tool: {"command": "<cmd>"}
+- check_resource_tool: {"files": ["<path>"], "dataframes": ["<var>"]}
 
-Output ONLY the JSON object, no markdown, no explanation."""
+No markdown wrapping. JSON only."""
 
 TODO_LIST_SYSTEM_PROMPT = """
-## CRITICAL WORKFLOW RULES - MUST FOLLOW:
-- 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
-
-## Task Completion Flow:
-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:
-❌ Updating todo status without doing the actual work
-❌ 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 Rules
+
+## New Message = Fresh Start
+- Each user message is a NEW task
+- Ignore completion status from chat history
+- Execute ALL current todos from scratch
+
+## Structure
+All todo items must be in Korean. Always end with:
+- 작업 요약 및 다음단계 제시  ← 필수 마지막 항목!
+
+## Workflow
+1. Find pending/in_progress todo
+2. Execute it NOW in THIS response
+3. Mark completed
+4. Repeat until all done
+
+## 🔴 Final Todo ("작업 요약 및 다음단계 제시") - CRITICAL
+When executing this todo, you MUST:
+1. Output the summary JSON in your content FIRST:
+   {"summary": "작업 내용 요약", "next_items": [{"subject": "...", "description": "..."}]}
+2. THEN call write_todos to mark all as completed
+3. If you don't output the JSON, the todo will NOT be marked as completed!
+
+## Completion Check
+- ✅ Done: Executed in THIS response
+- ❌ Not done: Only visible in chat history
+- ❌ "작업 요약" cannot be completed without outputting summary JSON
+
+## Forbidden
+- Marking complete without executing in THIS response
+- Marking "작업 요약" complete without outputting JSON summary
+- Todos without "작업 요약 및 다음단계 제시" as final item
 """
 
-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.
-- 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"""
+TODO_LIST_TOOL_DESCRIPTION = """Update task list for tracking progress.
+This tool ONLY tracks status - does NOT execute tasks.
+After calling: immediately call next action tool (unless ALL completed)."""
 
 # Non-HITL tools that execute immediately without user approval
 NON_HITL_TOOLS = {

agent_server/prompts/file_action_prompts.py

@@ -20,9 +20,9 @@ def format_file_fix_prompt(
         for rf in related_files:
             if rf.get("content"):
                 related_context += f"""
-### {rf['path']}
+### {rf["path"]}
 ```python
-{rf['content']}
+{rf["content"]}
 ```
 """
 
@@ -33,9 +33,9 @@ def format_file_fix_prompt(
 {error_output}
 ```
 
-## 메인 파일: {main_file['path']}
+## 메인 파일: {main_file["path"]}
 ```python
-{main_file['content']}
+{main_file["content"]}
 ```
 {related_context}
 
@@ -97,17 +97,17 @@ def format_file_custom_prompt(
         for rf in related_files:
             if rf.get("content"):
                 related_context += f"""
-### {rf['path']}
+### {rf["path"]}
 ```python
-{rf['content']}
+{rf["content"]}
 ```
 """
 
     return f"""{custom_prompt}
 
-## 메인 파일: {main_file['path']}
+## 메인 파일: {main_file["path"]}
 ```python
-{main_file['content']}
+{main_file["content"]}
 ```
 {related_context}
 """