hdsp-jupyter-extension 2.0.25__py3-none-any.whl → 2.0.26__py3-none-any.whl

agent_server/langchain/agent_factory.py

@@ -315,24 +315,24 @@ def create_main_agent(
         except Exception as e:
             logger.warning(f"Failed to add SummarizationMiddleware: {e}")
 
-    # Build system prompt - FORCE default prompt for testing
-    # TODO: Remove this override after frontend localStorage is cleared
-    # Original priority: system_prompt_override > agent_prompts.planner > default
-    # DEBUG: Log all prompt sources to find root cause of MALFORMED_FUNCTION_CALL
+    # Build system prompt with priority: system_prompt_override > agent_prompts.planner > default
     logger.info(
-        "DEBUG Main Agent prompt sources: system_prompt_override=%s, "
-        "agent_prompts.planner=%s, using=DEFAULT",
+        "Main Agent prompt sources: system_prompt_override=%s (len=%d), "
+        "agent_prompts.planner=%s",
         bool(system_prompt_override),
+        len(system_prompt_override) if system_prompt_override else 0,
         bool(agent_prompts.get("planner") if agent_prompts else None),
     )
-    if agent_prompts:
-        logger.info(
-            "DEBUG: agent_prompts keys=%s, planner prompt length=%d",
-            list(agent_prompts.keys()),
-            len(agent_prompts.get("planner", "") or ""),
-        )
-    system_prompt = PLANNER_SYSTEM_PROMPT
-    logger.info("Using PLANNER_SYSTEM_PROMPT (length=%d)", len(system_prompt))
+
+    if system_prompt_override and system_prompt_override.strip():
+        system_prompt = system_prompt_override.strip()
+        logger.info("Using system_prompt_override (length=%d)", len(system_prompt))
+    elif agent_prompts and agent_prompts.get("planner"):
+        system_prompt = agent_prompts["planner"]
+        logger.info("Using agent_prompts.planner (length=%d)", len(system_prompt))
+    else:
+        system_prompt = PLANNER_SYSTEM_PROMPT
+        logger.info("Using PLANNER_SYSTEM_PROMPT (length=%d)", len(system_prompt))
 
     # Log provider info for debugging
     provider = llm_config.get("provider", "")

agent_server/langchain/agent_prompts/planner_prompt.py

@@ -55,25 +55,19 @@ PLANNER_SYSTEM_PROMPT = """당신은 작업을 조율하는 Main Agent입니다.
     - content에 도구(tool)명 언급 금지
     - **[필수] 마지막 todo는 반드시 "작업 요약 및 다음 단계 제시"**
 
-# "작업 요약 및 다음 단계 제시" todo 작업 순서 [필수]
-    1. "작업 요약 및 다음 단계 제시"를 **in_progress**로 변경 (write_todos 호출)
-    2. **같은 응답에서** 아래 JSON을 텍스트로 출력:
-    {
-    "summary": "완료된 작업 요약",
-    "next_items": [
-     {
-       "subject": "제목",
-       "description": "설명"
-     }
-    ]
-    }
-    3. JSON 출력과 함께 "작업 요약 및 다음 단계 제시"를 **completed**로 변경
-     **중요**: JSON은 반드시 in_progress 상태일 때 출력! completed 먼저 표시 금지!
-     - next_items 3개 이상 필수
-     - **summary JSON 없이 종료 금지**
-     - **주의**: JSON은 todo 항목이 아닌 일반 텍스트 응답으로 출력
-
-     
+# "작업 요약 및 다음 단계 제시" todo 완료 시 [필수]
+1. "작업 요약 및 다음 단계 제시"를 **in_progress**로 변경 (write_todos 호출)
+2. **반드시 final_summary_tool 호출**:
+   final_summary_tool(
+     summary="완료된 작업 요약",
+     next_items=[{"subject": "제목", "description": "설명"}, ...]
+   )
+   
+3. final_summary_tool 호출 후 "작업 요약 및 다음 단계 제시"를 **completed**로 변경
+
+- next_items 3개 이상 필수
+- **final_summary_tool 호출 없이 종료 금지**
+
 # 도구 사용시 주의할 점
 
 ## 서브에이전트 호출 (코드/쿼리 생성 시 필수)

agent_server/langchain/custom_middleware.py

@@ -165,6 +165,22 @@ def try_extract_tool_calls_from_additional_kwargs(
     if not raw_tool_calls:
         return None
 
+    # IMPORTANT: Only use the first tool_call to prevent parallel execution issues
+    # LLM sometimes generates multiple tool_calls despite prompt instructions
+    if len(raw_tool_calls) > 1:
+        first_tc = raw_tool_calls[0]
+        first_name = first_tc.get("function", {}).get("name", "unknown")
+        ignored_names = [
+            tc.get("function", {}).get("name", "unknown") for tc in raw_tool_calls[1:]
+        ]
+        logger.warning(
+            "Multiple tool_calls in additional_kwargs (%d), using only first one: %s. Ignored: %s",
+            len(raw_tool_calls),
+            first_name,
+            ignored_names,
+        )
+        raw_tool_calls = raw_tool_calls[:1]
+
     repaired_tool_calls = []
     for tc in raw_tool_calls:
         func = tc.get("function", {})
@@ -316,8 +332,7 @@ def create_handle_empty_response_middleware(wrap_model_call):
         summary_todo_completed = all_todos_completed and last_todo_is_summary
 
         if not summary_todo_completed and any(
-            t.get("status") == "completed"
-            and "작업 요약" in t.get("content", "")
+            t.get("status") == "completed" and "작업 요약" in t.get("content", "")
             for t in todos
         ):
             logger.debug(
@@ -439,15 +454,16 @@ def create_handle_empty_response_middleware(wrap_model_call):
                     content = " ".join(str(p) for p in content)
 
                 # Check if content contains summary JSON pattern
-                has_summary_pattern = ('"summary"' in content or "'summary'" in content) and (
-                    '"next_items"' in content or "'next_items'" in content
-                )
+                has_summary_pattern = (
+                    '"summary"' in content or "'summary'" in content
+                ) and ('"next_items"' in content or "'next_items'" in content)
 
                 if has_summary_pattern:
                     # 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
+                        t
+                        for t in current_todos
                         if isinstance(t, dict) and t.get("status") == "pending"
                     ]
                     if pending_todos:
@@ -463,7 +479,12 @@ def create_handle_empty_response_middleware(wrap_model_call):
                         try:
                             # Try to find JSON object containing summary
                             import re
-                            json_match = re.search(r'\{[^{}]*"summary"[^{}]*"next_items"[^{}]*\}', content, re.DOTALL)
+
+                            json_match = re.search(
+                                r'\{[^{}]*"summary"[^{}]*"next_items"[^{}]*\}',
+                                content,
+                                re.DOTALL,
+                            )
                             if json_match:
                                 repaired_summary = repair_json(
                                     json_match.group(), return_objects=True
@@ -503,7 +524,9 @@ def create_handle_empty_response_middleware(wrap_model_call):
                                 )
                                 return response
                         except Exception as e:
-                            logger.debug(f"Failed to extract summary JSON from mixed content: {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(
@@ -543,7 +566,9 @@ def create_handle_empty_response_middleware(wrap_model_call):
                     is_summary_todo = any(
                         kw in current_todo.get("content", "") for kw in summary_keywords
                     )
-                    if is_summary_todo and ('"summary"' in content or "'summary'" in content):
+                    if is_summary_todo and (
+                        '"summary"' in content or "'summary'" in content
+                    ):
                         # This is a summary todo with summary content - accept it
                         logger.info(
                             "Summary todo with summary content detected - accepting"
@@ -785,7 +810,7 @@ def _create_synthetic_completion(request, response_message, has_content):
         logger.warning(
             "Force-completing %d pending todos that were never started: %s",
             pending_count,
-            [t.get("content") for t in todos if t.get("status") == "pending"]
+            [t.get("content") for t in todos if t.get("status") == "pending"],
         )
 
     # Mark all todos as completed
@@ -858,6 +883,21 @@ def create_limit_tool_calls_middleware(wrap_model_call):
                         )
                         msg.tool_calls = [tool_calls[0]]
 
+                    # Remove additional_kwargs["tool_calls"] entirely when
+                    # msg.tool_calls exists. ChatOpenAI duplicates tool_calls
+                    # into additional_kwargs, and leftover entries pollute the
+                    # conversation context - LLM sees them and assumes all
+                    # listed tool calls were executed.
+                    additional_kwargs = getattr(msg, "additional_kwargs", {})
+                    if msg.tool_calls and additional_kwargs.get("tool_calls"):
+                        removed_count = len(additional_kwargs["tool_calls"])
+                        del additional_kwargs["tool_calls"]
+                        logger.info(
+                            "Removed %d tool_calls from additional_kwargs "
+                            "(canonical source: msg.tool_calls)",
+                            removed_count,
+                        )
+
         return response
 
     return limit_tool_calls_to_one
@@ -1026,29 +1066,45 @@ def create_normalize_tool_args_middleware(wrap_model_call, tools=None):
 
                                         # Validate: "작업 요약 및 다음 단계 제시" cannot be in_progress if pending todos exist
                                         # This prevents LLM from skipping pending tasks
-                                        summary_keywords = ["작업 요약", "다음 단계 제시"]
+                                        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)
+                                            is_summary_todo = any(
+                                                kw in content for kw in summary_keywords
+                                            )
 
-                                            if is_summary_todo and todo.get("status") == "in_progress":
+                                            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"
+                                                    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":
+                                                        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],
+                                                                t.get("content", "")[
+                                                                    :30
+                                                                ],
                                                             )
                                                             break
                                                     break

agent_server/langchain/models/gpt_oss_chat.py

@@ -200,19 +200,20 @@ class ChatGPTOSS(BaseChatModel):
         tool_calls_list = []
 
         if message.tool_calls:
-            additional_kwargs["tool_calls"] = [
-                {
-                    "id": tc.id,
-                    "type": "function",
-                    "function": {
-                        "name": tc.function.name,
-                        "arguments": tc.function.arguments,
-                    },
-                }
-                for tc in message.tool_calls
-            ]
-            # Also convert to LangChain tool_calls format
-            for tc in message.tool_calls:
+            # IMPORTANT: Only use the first tool_call to prevent parallel execution issues
+            # LLM sometimes generates multiple tool_calls despite prompt instructions
+            tool_calls_to_use = message.tool_calls[:1]
+            if len(message.tool_calls) > 1:
+                logger.warning(
+                    "Multiple tool_calls detected (%d), using only first one: %s. Ignored: %s",
+                    len(message.tool_calls),
+                    message.tool_calls[0].function.name,
+                    [tc.function.name for tc in message.tool_calls[1:]],
+                )
+
+            # Convert to LangChain tool_calls format only
+            # Do NOT put tool_calls in additional_kwargs to avoid duplicate/conflicting data
+            for tc in tool_calls_to_use:
                 try:
                     args = json.loads(tc.function.arguments)
                 except json.JSONDecodeError:
@@ -327,9 +328,21 @@ class ChatGPTOSS(BaseChatModel):
             tool_call_chunks = []
 
             # Handle tool calls in streaming
+            # IMPORTANT: Only process the first tool_call (index 0) to prevent parallel execution
             if delta.tool_calls:
                 for tc in delta.tool_calls:
                     idx = tc.index
+                    # Only accumulate the first tool_call (index 0)
+                    if idx > 0:
+                        if idx == 1 and tc.function and tc.function.name:
+                            # Log warning only once when we first see index 1
+                            logger.warning(
+                                "Multiple tool_calls in stream, ignoring index %d: %s",
+                                idx,
+                                tc.function.name,
+                            )
+                        continue
+
                     if idx not in tool_calls_accum:
                         tool_calls_accum[idx] = {
                             "id": tc.id or "",

agent_server/langchain/prompts.py

@@ -31,12 +31,12 @@ DEFAULT_SYSTEM_PROMPT = """You are an expert Python data scientist and Jupyter n
 - **[중요] "작업 요약 및 다음 단계 제시"는 summary JSON 출력 후에만 completed 표시**
 
 # 모든 작업 완료 후 [필수]
-마지막 todo "작업 요약 및 다음 단계 제시"를 completed로 변경한 후,
-**텍스트 응답으로** 아래 JSON을 출력하세요 (todo content가 아님!):
-{"summary": "완료된 작업 요약", "next_items": [{"subject": "제목", "description": "설명"}]}
+마지막 todo "작업 요약 및 다음 단계 제시"를 완료할 때:
+**반드시 final_summary_tool을 호출**하여 요약과 다음 단계를 제시하세요.
+- final_summary_tool(summary="완료된 작업 요약", next_items=[{"subject": "제목", "description": "설명"}, ...])
 - next_items 3개 이상 필수
-- **summary JSON 없이 종료 금지**
-- **주의**: JSON은 todo 항목이 아닌 일반 텍스트 응답으로 출력
+- **final_summary_tool 호출 없이 종료 금지**
+- **주의**: 텍스트로 JSON 출력하지 말고, 반드시 도구 호출로!
 
 # 도구 사용
 - check_resource_tool: 대용량 파일/데이터프레임 작업 전 필수
@@ -94,9 +94,9 @@ TODO_LIST_TOOL_DESCRIPTION = """Todo 리스트 관리 도구.
 - in_progress 상태는 **동시에 1개만** 허용
 - **[필수] 마지막 todo는 반드시 "작업 요약 및 다음 단계 제시"로 생성**
 - **🔴 [실행 순서]**: todo는 반드시 리스트 순서대로 실행하고, "작업 요약 및 다음 단계 제시"는 맨 마지막에 실행
-- 이 "작업 요약 및 다음 단계 제시" todo 에서는 전체 작업 요약과 다음 단계를 제시하는 내용을 JSON 형태로 출력:
-  {"summary": "완료 요약", "next_items": [{"subject": "...", "description": "..."}]}
-  (next_items 3개 이상 필수)
+- 이 "작업 요약 및 다음 단계 제시" todo 완료 시 **반드시 final_summary_tool 호출**:
+  final_summary_tool(summary="완료 요약", next_items=[{"subject": "...", "description": "..."}])
+  (next_items 3개 이상 필수, 텍스트 JSON 출력 금지!)
 """
 
 # List of tools available to the agent
@@ -104,6 +104,7 @@ TOOL_LIST = [
     "jupyter_cell_tool",
     "markdown_tool",
     "ask_user_tool",
+    "final_summary_tool",
     "write_todos",
     "read_file_tool",
     "write_file_tool",
@@ -128,6 +129,8 @@ NON_HITL_TOOLS = {
     "search_notebook_cells_tool",
     "search_notebook_cells",
     "write_todos",
+    "final_summary_tool",
+    "final_summary",
     # LSP tools (read-only)
     "diagnostics_tool",
     "diagnostics",

agent_server/langchain/tools/jupyter_tools.py

@@ -172,9 +172,52 @@ def ask_user_tool(
     }
 
 
+class NextItem(BaseModel):
+    """Schema for a next step item"""
+
+    subject: str = Field(description="다음 단계 제목")
+    description: str = Field(description="다음 단계 설명")
+
+
+class FinalSummaryInput(BaseModel):
+    """Input schema for final_summary tool"""
+
+    summary: str = Field(description="완료된 작업에 대한 요약 (한국어)")
+    next_items: List[NextItem] = Field(
+        description="다음 단계 제안 목록 (3개 이상)", min_length=3
+    )
+
+
+@tool(args_schema=FinalSummaryInput)
+def final_summary_tool(
+    summary: str,
+    next_items: List[Dict[str, str]],
+) -> Dict[str, Any]:
+    """
+    모든 작업이 완료된 후 최종 요약과 다음 단계를 제시하는 도구.
+
+    이 도구는 반드시 모든 todo가 완료된 후, 마지막 "작업 요약 및 다음 단계 제시" todo를 처리할 때만 호출하세요.
+
+    Args:
+        summary: 완료된 작업에 대한 요약 (한국어로 작성)
+        next_items: 다음 단계 제안 목록 (각각 subject와 description 포함, 3개 이상)
+
+    Returns:
+        Dict containing the summary and next items for frontend display
+    """
+    return {
+        "tool": "final_summary",
+        "summary": summary,
+        "next_items": next_items,
+        "status": "completed",
+        "message": "작업 요약이 완료되었습니다.",
+    }
+
+
 # Export all tools
 JUPYTER_TOOLS = [
     jupyter_cell_tool,
     markdown_tool,
     ask_user_tool,
+    final_summary_tool,
 ]