hdsp-jupyter-extension 2.0.16__py3-none-any.whl → 2.0.19__py3-none-any.whl

agent_server/langchain/agent_prompts/planner_prompt.py

@@ -23,24 +23,32 @@ PLANNER_SYSTEM_PROMPT = """당신은 작업을 조율하는 Main Agent입니다.
 | athena_query | SQL 쿼리 생성 | task_tool(agent_name="athena_query", description="매출 테이블 조회 쿼리") |
 | researcher | 정보 검색 | task_tool(agent_name="researcher", description="관련 문서 검색") |
 
-## Step 3: 결과 실행/표시 (필수!)
+## Step 3: 결과 실행/적용 (필수!)
 **task_tool을 호출 했다면, 호출 후 반드시 결과를 처리해야 함:**
 
-| 서브에이전트 | 처리 방법 | 예시 |
-|-------------|----------|------|
-| python_developer | jupyter_cell_tool로 실행 또는 write/edit/multiedit file tool로 적용 | jupyter_cell_tool(code=반환된_코드) |
-| athena_query | **markdown_tool로 SQL 표시** (필수) | markdown_tool(content="```sql\n반환된_쿼리\n```") |
-| researcher | 텍스트로 요약 | 직접 응답 |
+| 서브에이전트 | 작업 유형 | 처리 방법 | 예시 |
+|-------------|----------|----------|------|
+| python_developer | 코드 실행 (데이터 분석, 시각화) | jupyter_cell_tool | jupyter_cell_tool(code=반환된_코드) |
+| python_developer | **파일 생성/수정** | **write_file_tool 또는 multiedit_file_tool** | write_file_tool(path="script.js", content=반환된_코드) |
+| athena_query | SQL 표시 | markdown_tool | markdown_tool(content="```sql\n반환된_쿼리\n```") |
+| researcher | 텍스트 요약 | 직접 응답 | - |
 
-**중요**: task_tool 결과를 받은 후 바로 write_todos로 완료 처리하지 말고, 반드시 위 도구로 결과를 먼저 표시!
+**🔴 중요: 코드 저장 도구 선택**
+- **파일 생성/수정 요청** → `write_file_tool` 또는 `multiedit_file_tool` 사용
+- **코드 실행 요청** (데이터 분석, 차트 등) → `jupyter_cell_tool` 사용
+- **❌ markdown_tool은 코드 저장용이 아님!** (표시 전용)
+
+**중요**: task_tool 결과를 받은 후 바로 write_todos로 완료 처리하지 말고, 반드시 위 도구로 결과를 먼저 적용!
 
 # write_todos 규칙 [필수]
     - 한국어로 작성
     - **🔴 기존 todo 절대 삭제 금지**: 전체 리스트를 항상 포함하고 status만 변경
-    - 잘못된 예: [{"content": "작업 요약", "status": "completed"}] ← 기존 todo 삭제됨!
-    - 올바른 예: [{"content": "기존 작업1", "status": "completed"}, {"content": "작업 요약", "status": "completed"}]
-    - **일괄 업데이트**: 연속 완료된 todo는 한 번의 write_todos 호출로 처리
-    - in_progress **1개만** 유지
+    - **🔴 상태 전환 순서 필수**: pending → in_progress → completed (건너뛰기 금지!)
+    - **🔴 초기 생성 규칙**: 첫 write_todos 호출 시 첫 번째 todo만 in_progress, 나머지는 모두 pending
+      - 올바른 초기 예: [{"content": "작업1", "status": "in_progress"}, {"content": "작업2", "status": "pending"}, {"content": "작업 요약 및 다음 단계 제시", "status": "pending"}]
+      - 잘못된 초기 예: [{"content": "작업1", "status": "completed"}, ...] ← 실제 작업 없이 completed 금지!
+    - **🔴 completed 전환 조건**: 실제 도구(task_tool, jupyter_cell_tool 등)로 작업 수행 후에만 completed로 변경
+    - in_progress 상태는 **동시에 1개만** 허용 (completed, pending todo는 삭제하지 않고 모두 유지)
     - content에 도구(tool)명 언급 금지
     - **[필수] 마지막 todo는 반드시 "작업 요약 및 다음 단계 제시"**
 

agent_server/langchain/custom_middleware.py

@@ -444,63 +444,78 @@ def create_handle_empty_response_middleware(wrap_model_call):
                 )
 
                 if has_summary_pattern:
-                    # Try to extract and repair summary JSON from mixed content
-                    try:
-                        # Try to find JSON object containing summary
-                        import re
-                        json_match = re.search(r'\{[^{}]*"summary"[^{}]*"next_items"[^{}]*\}', content, re.DOTALL)
-                        if json_match:
-                            repaired_summary = repair_json(
-                                json_match.group(), return_objects=True
-                            )
-                        else:
-                            repaired_summary = repair_json(
-                                content, return_objects=True
-                            )
+                    # Check if pending todos exist - if so, don't force complete
+                    current_todos = request.state.get("todos", [])
+                    pending_todos = [
+                        t for t in current_todos
+                        if isinstance(t, dict) and t.get("status") == "pending"
+                    ]
+                    if pending_todos:
+                        logger.warning(
+                            "Summary JSON detected but pending todos remain - not forcing completion: %s",
+                            [t.get("content", "")[:30] for t in pending_todos],
+                        )
+                        # Don't synthesize completion, return response as-is
+                        # Let LLM continue working on pending todos
+                    else:
+                        # No pending todos, safe to synthesize completion
+                        # Try to extract and repair summary JSON from mixed content
+                        try:
+                            # Try to find JSON object containing summary
+                            import re
+                            json_match = re.search(r'\{[^{}]*"summary"[^{}]*"next_items"[^{}]*\}', content, re.DOTALL)
+                            if json_match:
+                                repaired_summary = repair_json(
+                                    json_match.group(), return_objects=True
+                                )
+                            else:
+                                repaired_summary = repair_json(
+                                    content, return_objects=True
+                                )
 
-                        if (
-                            isinstance(repaired_summary, dict)
-                            and "summary" in repaired_summary
-                            and "next_items" in repaired_summary
-                        ):
-                            # Create new message with repaired JSON content
-                            repaired_content = json.dumps(
-                                repaired_summary, ensure_ascii=False
-                            )
-                            logger.info(
-                                "Detected and repaired summary JSON in content (pattern-based detection)"
-                            )
-                            # Create message with repaired content
-                            repaired_response_message = AIMessage(
-                                content=repaired_content,
-                                tool_calls=getattr(
-                                    response_message, "tool_calls", []
+                            if (
+                                isinstance(repaired_summary, dict)
+                                and "summary" in repaired_summary
+                                and "next_items" in repaired_summary
+                            ):
+                                # Create new message with repaired JSON content
+                                repaired_content = json.dumps(
+                                    repaired_summary, ensure_ascii=False
                                 )
-                                or [],
-                            )
-                            synthetic_message = _create_synthetic_completion(
-                                request,
-                                repaired_response_message,
-                                has_content=True,
-                            )
-                            response = _replace_ai_message_in_response(
-                                response, synthetic_message
-                            )
-                            return response
-                    except Exception as e:
-                        logger.debug(f"Failed to extract summary JSON from mixed content: {e}")
+                                logger.info(
+                                    "Detected and repaired summary JSON in content (pattern-based detection)"
+                                )
+                                # Create message with repaired content
+                                repaired_response_message = AIMessage(
+                                    content=repaired_content,
+                                    tool_calls=getattr(
+                                        response_message, "tool_calls", []
+                                    )
+                                    or [],
+                                )
+                                synthetic_message = _create_synthetic_completion(
+                                    request,
+                                    repaired_response_message,
+                                    has_content=True,
+                                )
+                                response = _replace_ai_message_in_response(
+                                    response, synthetic_message
+                                )
+                                return response
+                        except Exception as e:
+                            logger.debug(f"Failed to extract summary JSON from mixed content: {e}")
 
-                    # Fallback: accept as-is if repair failed but looks like summary
-                    logger.info(
-                        "Detected summary JSON pattern in content - accepting and synthesizing write_todos"
-                    )
-                    synthetic_message = _create_synthetic_completion(
-                        request, response_message, has_content=True
-                    )
-                    response = _replace_ai_message_in_response(
-                        response, synthetic_message
-                    )
-                    return response
+                        # Fallback: accept as-is if repair failed but looks like summary
+                        logger.info(
+                            "Detected summary JSON pattern in content - accepting and synthesizing write_todos"
+                        )
+                        synthetic_message = _create_synthetic_completion(
+                            request, response_message, has_content=True
+                        )
+                        response = _replace_ai_message_in_response(
+                            response, synthetic_message
+                        )
+                        return response
 
                 # Legacy: Also check if current todo is a summary todo (backward compatibility)
                 todos = request.state.get("todos", [])
@@ -1009,17 +1024,51 @@ def create_normalize_tool_args_middleware(wrap_model_call, tools=None):
                                                     else:
                                                         found_first = True
 
-                                        # NOTE: Previously had logic to revert summary todo to in_progress
-                                        # if no summary JSON was found. This caused infinite loops
-                                        # where LLM kept calling write_todos repeatedly.
-                                        # Now we let the natural termination logic handle this.
-                                        #
-                                        # NOTE: Also removed logic to preserve todos when LLM tries to delete them.
-                                        # The LLM should be able to modify todos freely when:
-                                        # - User rejects code approval
-                                        # - User changes their request
-                                        # - Code execution fails
-                                        # We rely on prompts to guide proper todo management.
+                                        # Validate: "작업 요약 및 다음 단계 제시" cannot be in_progress if pending todos exist
+                                        # This prevents LLM from skipping pending tasks
+                                        summary_keywords = ["작업 요약", "다음 단계 제시"]
+                                        for i, todo in enumerate(todos):
+                                            if not isinstance(todo, dict):
+                                                continue
+                                            content = todo.get("content", "")
+                                            is_summary_todo = any(kw in content for kw in summary_keywords)
+
+                                            if is_summary_todo and todo.get("status") == "in_progress":
+                                                # Check if there are pending todos before this one
+                                                pending_before = [
+                                                    t for t in todos[:i]
+                                                    if isinstance(t, dict) and t.get("status") == "pending"
+                                                ]
+                                                if pending_before:
+                                                    # Revert summary todo to pending
+                                                    todo["status"] = "pending"
+                                                    # Set the first pending todo to in_progress
+                                                    for t in todos:
+                                                        if isinstance(t, dict) and t.get("status") == "pending":
+                                                            t["status"] = "in_progress"
+                                                            logger.warning(
+                                                                "Reverted summary todo to pending, set '%s' to in_progress (pending todos exist)",
+                                                                t.get("content", "")[:30],
+                                                            )
+                                                            break
+                                                    break
+
+                                # Clean AIMessage content when write_todos is called
+                                # Remove redundant todos JSON from content (keep summary JSON)
+                                if tool_name == "write_todos":
+                                    msg_content = getattr(msg, "content", "") or ""
+                                    if msg_content and '"todos"' in msg_content:
+                                        # Keep content only if it's summary JSON
+                                        is_summary_json = (
+                                            '"summary"' in msg_content
+                                            and '"next_items"' in msg_content
+                                        )
+                                        if not is_summary_json:
+                                            # Clear redundant todos content
+                                            msg.content = ""
+                                            logger.info(
+                                                "Cleared redundant todos JSON from AIMessage content (write_todos tool_call exists)"
+                                            )
 
         return response
 

agent_server/langchain/llm_factory.py

@@ -97,15 +97,14 @@ def _create_vllm_llm(llm_config: Dict[str, Any], callbacks):
     endpoint = vllm_config.get("endpoint", "http://localhost:8000/v1")
     model = vllm_config.get("model", "default")
     api_key = vllm_config.get("apiKey", "dummy")
-    use_responses_api = vllm_config.get("useResponsesApi", False)
 
-    logger.info(f"Creating vLLM LLM with model: {model}, endpoint: {endpoint}, use_responses_api: {use_responses_api}")
+    logger.info(f"Creating vLLM LLM with model: {model}, endpoint: {endpoint}")
 
     return ChatOpenAI(
         model=model,
         api_key=api_key,
         base_url=endpoint,  # Use endpoint as-is (no /v1 suffix added)
-        use_responses_api=use_responses_api,
+        streaming=False,  # Agent mode: disable LLM streaming (SSE handled by agent server)
         temperature=0.0,
         max_tokens=32768,
         callbacks=callbacks,
@@ -156,13 +155,11 @@ def create_summarization_llm(llm_config: Dict[str, Any]):
             endpoint = vllm_config.get("endpoint", "http://localhost:8000/v1")
             model = vllm_config.get("model", "default")
             api_key = vllm_config.get("apiKey", "dummy")
-            use_responses_api = vllm_config.get("useResponsesApi", False)
 
             return ChatOpenAI(
                 model=model,
                 api_key=api_key,
                 base_url=endpoint,  # Use endpoint as-is
-                use_responses_api=use_responses_api,
                 temperature=0.0,
             )
     except Exception as e:

agent_server/langchain/prompts.py

@@ -19,14 +19,15 @@ DEFAULT_SYSTEM_PROMPT = """You are an expert Python data scientist and Jupyter n
 # write_todos 규칙 [필수]
 - 한국어로 작성
 - **🔴 기존 todo 절대 삭제 금지**: 전체 리스트를 항상 포함하고 status만 변경
-  - 잘못된 예: [{"content": "작업 요약", "status": "completed"}] ← 기존 todo 삭제됨!
-  - 올바른 예: [{"content": "기존 작업1", "status": "completed"}, {"content": "기존 작업2", "status": "completed"}, {"content": "작업 요약", "status": "completed"}]
-- **일괄 업데이트**: 연속 완료된 todo는 한 번의 write_todos 호출로 처리
-- in_progress는 **1개만** 유지
+- **🔴 상태 전환 순서 필수**: pending → in_progress → completed (건너뛰기 금지!)
+- **🔴 초기 생성 규칙**: 첫 write_todos 호출 시 첫 번째 todo만 in_progress, 나머지는 모두 pending
+  - 올바른 초기 예: [{"content": "작업1", "status": "in_progress"}, {"content": "작업2", "status": "pending"}, {"content": "작업 요약 및 다음 단계 제시", "status": "pending"}]
+  - 잘못된 초기 예: [{"content": "작업1", "status": "completed"}, ...] ← 실제 작업 없이 completed 금지!
+- **🔴 completed 전환 조건**: 실제 도구로 작업 수행 후에만 completed로 변경
+- in_progress는 **동시에 1개만** 유지
 - **[필수] 마지막 todo는 반드시 "작업 요약 및 다음 단계 제시"로 생성**
 - **🔴 [실행 순서 필수]**: "작업 요약 및 다음 단계 제시"는 **반드시 가장 마지막에 실행**
   - 다른 모든 todo가 completed 상태가 된 후에만 이 todo를 in_progress로 변경
-  - 비슷한 이름의 다른 작업(보고서 검토, 결과 정리 등)과 혼동 금지
 - **[중요] "작업 요약 및 다음 단계 제시"는 summary JSON 출력 후에만 completed 표시**
 
 # 모든 작업 완료 후 [필수]
@@ -85,8 +86,11 @@ TODO_LIST_TOOL_DESCRIPTION = """Todo 리스트 관리 도구.
 - 진행 상황 추적이 필요할 때
 
 규칙:
-- in_progress는 1개만
-- 완료 즉시 completed로 변경
+- **🔴 기존 todo 삭제 금지**: status만 변경하고 전체 리스트 유지
+- **🔴 상태 전환 순서 필수**: pending → in_progress → completed (건너뛰기 금지!)
+- **🔴 초기 생성**: 첫 호출 시 첫 번째만 in_progress, 나머지는 pending
+- **🔴 completed 조건**: 실제 도구로 작업 수행 후에만 completed로 변경
+- in_progress 상태는 **동시에 1개만** 허용
 - **[필수] 마지막 todo는 반드시 "작업 요약 및 다음 단계 제시"로 생성**
 - **🔴 [실행 순서]**: todo는 반드시 리스트 순서대로 실행하고, "작업 요약 및 다음 단계 제시"는 맨 마지막에 실행
 - 이 "작업 요약 및 다음 단계 제시" todo 에서는 전체 작업 요약과 다음 단계를 제시하는 내용을 JSON 형태로 출력:

{hdsp_jupyter_extension-2.0.16.data → hdsp_jupyter_extension-2.0.19.data}/data/share/jupyter/labextensions/hdsp-agent/build_log.json

@@ -722,7 +722,7 @@
             "@mui/material": {},
             "react-markdown": {},
             "hdsp-agent": {
-              "version": "2.0.16",
+              "version": "2.0.19",
               "singleton": true,
               "import": "/Users/a421721/Desktop/hdsp/hdsp_agent/extensions/jupyter/lib/index.js"
             }

{hdsp_jupyter_extension-2.0.16.data → hdsp_jupyter_extension-2.0.19.data}/data/share/jupyter/labextensions/hdsp-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hdsp-agent",
-  "version": "2.0.16",
+  "version": "2.0.19",
   "description": "HDSP Agent JupyterLab Extension - Thin client for Agent Server",
   "keywords": [
     "jupyter",
@@ -132,7 +132,7 @@
       }
     },
     "_build": {
-      "load": "static/remoteEntry.44355425a0862dac7bd1.js",
+      "load": "static/remoteEntry.d686ab71eb65b5ef8f15.js",
       "extension": "./extension",
       "style": "./style"
     }