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

agent_server/routers/langchain_agent.py

@@ -702,6 +702,27 @@ async def stream_agent(request: AgentRequest):
                                     "event": "todos",
                                     "data": json.dumps({"todos": todos}),
                                 }
+                                # Check if all todos are completed - auto terminate
+                                all_completed = all(
+                                    t.get("status") == "completed" for t in todos
+                                )
+                                if all_completed and len(todos) > 0:
+                                    logger.info(
+                                        "All %d todos completed, auto-terminating agent",
+                                        len(todos),
+                                    )
+                                    yield {
+                                        "event": "debug_clear",
+                                        "data": json.dumps({}),
+                                    }
+                                    yield {
+                                        "event": "done",
+                                        "data": json.dumps(
+                                            {"reason": "all_todos_completed"}
+                                        ),
+                                    }
+                                    return  # Exit the generator
+
                             tool_name = getattr(last_message, "name", "") or ""
                             logger.info(
                                 "SimpleAgent ToolMessage name attribute: %s", tool_name
@@ -727,7 +748,7 @@ async def stream_agent(request: AgentRequest):
                                     final_answer = tool_result.get(
                                         "answer"
                                     ) or tool_result.get("parameters", {}).get("answer")
-                                    
+
                                     # Check for next_items in answer field (LLM may put JSON here)
                                     if final_answer:
                                         try:
@@ -735,25 +756,41 @@ async def stream_agent(request: AgentRequest):
                                             if "next_items" in answer_json:
                                                 next_items_block = f"\n\n```json\n{json.dumps(answer_json, ensure_ascii=False, indent=2)}\n```"
                                                 # Get summary for the main text
-                                                summary_text = tool_result.get(
-                                                    "summary"
-                                                ) or tool_result.get("parameters", {}).get("summary") or ""
-                                                final_answer = summary_text + next_items_block
-                                                logger.info("Extracted next_items from answer field")
+                                                summary_text = (
+                                                    tool_result.get("summary")
+                                                    or tool_result.get(
+                                                        "parameters", {}
+                                                    ).get("summary")
+                                                    or ""
+                                                )
+                                                final_answer = (
+                                                    summary_text + next_items_block
+                                                )
+                                                logger.info(
+                                                    "Extracted next_items from answer field"
+                                                )
                                         except (json.JSONDecodeError, TypeError):
                                             pass
-                                    
+
                                     # Check for next_items in summary field (Gemini puts JSON here)
                                     summary = tool_result.get(
                                         "summary"
-                                    ) or tool_result.get("parameters", {}).get("summary")
-                                    if summary and "next_items" not in (final_answer or ""):
+                                    ) or tool_result.get("parameters", {}).get(
+                                        "summary"
+                                    )
+                                    if summary and "next_items" not in (
+                                        final_answer or ""
+                                    ):
                                         try:
                                             summary_json = json.loads(summary)
                                             if "next_items" in summary_json:
                                                 next_items_block = f"\n\n```json\n{json.dumps(summary_json, ensure_ascii=False, indent=2)}\n```"
-                                                final_answer = (final_answer or "") + next_items_block
-                                                logger.info("Extracted next_items from summary field")
+                                                final_answer = (
+                                                    final_answer or ""
+                                                ) + next_items_block
+                                                logger.info(
+                                                    "Extracted next_items from summary field"
+                                                )
                                         except (json.JSONDecodeError, TypeError):
                                             pass
                                     if final_answer:
@@ -872,19 +909,32 @@ async def stream_agent(request: AgentRequest):
                                         "event": "todos",
                                         "data": json.dumps({"todos": todos}),
                                     }
+                                    # Check if all todos are completed - terminate early
+                                    all_completed = all(
+                                        t.get("status") == "completed" for t in todos
+                                    )
+                                    if all_completed and len(todos) > 0:
+                                        logger.info(
+                                            "All %d todos completed in AIMessage tool_calls, auto-terminating",
+                                            len(todos),
+                                        )
+                                        yield {
+                                            "event": "debug_clear",
+                                            "data": json.dumps({}),
+                                        }
+                                        yield {
+                                            "event": "done",
+                                            "data": json.dumps(
+                                                {"reason": "all_todos_completed"}
+                                            ),
+                                        }
+                                        return  # Exit before executing more tool calls
                                 for tool_call in tool_calls:
                                     tool_name = tool_call.get("name", "unknown")
                                     tool_args = tool_call.get("args", {})
 
                                     # Create detailed status message for search tools
                                     if tool_name in (
-                                        "search_workspace_tool",
-                                        "search_workspace",
-                                    ):
-                                        pattern = tool_args.get("pattern", "")
-                                        path = tool_args.get("path", ".")
-                                        status_msg = f"🔍 검색 실행: grep/rg '{pattern}' in {path}"
-                                    elif tool_name in (
                                         "search_notebook_cells_tool",
                                         "search_notebook_cells",
                                     ):
@@ -950,34 +1000,6 @@ async def stream_agent(request: AgentRequest):
                                                 }
                                             ),
                                         }
-                                    elif tool_name in (
-                                        "search_workspace_tool",
-                                        "search_workspace",
-                                    ):
-                                        # Search workspace - emit tool_call for client-side execution
-                                        produced_output = True
-                                        yield {
-                                            "event": "tool_call",
-                                            "data": json.dumps(
-                                                {
-                                                    "tool": "search_workspace",
-                                                    "pattern": tool_args.get(
-                                                        "pattern", ""
-                                                    ),
-                                                    "file_types": tool_args.get(
-                                                        "file_types",
-                                                        ["*.py", "*.ipynb"],
-                                                    ),
-                                                    "path": tool_args.get("path", "."),
-                                                    "max_results": tool_args.get(
-                                                        "max_results", 50
-                                                    ),
-                                                    "case_sensitive": tool_args.get(
-                                                        "case_sensitive", False
-                                                    ),
-                                                }
-                                            ),
-                                        }
                                     elif tool_name in (
                                         "search_notebook_cells_tool",
                                         "search_notebook_cells",
@@ -1030,16 +1052,31 @@ async def stream_agent(request: AgentRequest):
                                     content = "\n".join(text_parts)
 
                                 # Filter out raw JSON tool responses
+                                content_stripped = content.strip() if content else ""
+
+                                # Filter out tool call JSON (but allow summary/next_items JSON for frontend rendering)
+                                is_json_tool_response = (
+                                    content_stripped.startswith('{"tool":')
+                                    or content_stripped.startswith('{ "tool":')
+                                    or content_stripped.startswith('{"tool" :')
+                                    or content_stripped.startswith('{"status":')
+                                    or '"pending_execution"' in content
+                                    or '"status": "complete"' in content
+                                    or (
+                                        '"tool"' in content
+                                        and '"write_todos"' in content
+                                    )
+                                    or (
+                                        '"tool"' in content
+                                        and '"arguments"' in content
+                                        and content_stripped.startswith("{")
+                                    )
+                                )
                                 if (
                                     content
                                     and isinstance(content, str)
                                     and not has_final_answer_tool
-                                    and not (
-                                        content.strip().startswith('{"tool":')
-                                        or content.strip().startswith('{"status":')
-                                        or '"pending_execution"' in content
-                                        or '"status": "complete"' in content
-                                    )
+                                    and not is_json_tool_response
                                 ):
                                     # Check if we've already emitted this content (prevents duplicates)
                                     content_hash = hash(content)
@@ -1161,7 +1198,7 @@ async def stream_agent(request: AgentRequest):
                             content=(
                                 "You MUST respond with a valid tool call. "
                                 "Available tools: jupyter_cell_tool (for Python code), markdown_tool (for text), "
-                                "list_files_tool (to list files), read_file_tool (to read files). "
+                                "execute_command_tool (to search files with find/grep), read_file_tool (to read files). "
                                 "Choose the most appropriate tool and provide valid JSON arguments."
                             )
                         ),
@@ -1280,11 +1317,7 @@ async def stream_agent(request: AgentRequest):
                                     }
                                 ),
                             }
-                        elif tool_name in (
-                            "read_file_tool",
-                            "list_files_tool",
-                            "search_workspace_tool",
-                        ):
+                        elif tool_name == "read_file_tool":
                             # For file operations, generate code with the LLM
                             logger.info(
                                 "Fallback: Generating code for %s via LLM",
@@ -1447,11 +1480,13 @@ async def resume_agent(request: ResumeRequest):
                 )
                 yield {
                     "event": "error",
-                    "data": json.dumps({
-                        "error": "Session expired or not found",
-                        "code": "CHECKPOINT_NOT_FOUND",
-                        "message": "이전 세션을 찾을 수 없습니다. 서버가 재시작되었거나 세션이 만료되었습니다. 새로운 대화를 시작해주세요.",
-                    }),
+                    "data": json.dumps(
+                        {
+                            "error": "Session expired or not found",
+                            "code": "CHECKPOINT_NOT_FOUND",
+                            "message": "이전 세션을 찾을 수 없습니다. 서버가 재시작되었거나 세션이 만료되었습니다. 새로운 대화를 시작해주세요.",
+                        }
+                    ),
                 }
                 return
 
@@ -1471,7 +1506,9 @@ async def resume_agent(request: ResumeRequest):
                     len(_simple_agent_instances),
                 )
             else:
-                logger.info("Resume: Creating new agent for key %s", agent_cache_key[:8])
+                logger.info(
+                    "Resume: Creating new agent for key %s", agent_cache_key[:8]
+                )
                 agent = create_simple_chat_agent(
                     llm_config=config_dict,
                     workspace_root=resolved_workspace_root,
@@ -1654,6 +1691,27 @@ async def resume_agent(request: ResumeRequest):
                                     "event": "todos",
                                     "data": json.dumps({"todos": todos}),
                                 }
+                                # Check if all todos are completed - auto terminate
+                                all_completed = all(
+                                    t.get("status") == "completed" for t in todos
+                                )
+                                if all_completed and len(todos) > 0:
+                                    logger.info(
+                                        "Resume: All %d todos completed, auto-terminating agent",
+                                        len(todos),
+                                    )
+                                    yield {
+                                        "event": "debug_clear",
+                                        "data": json.dumps({}),
+                                    }
+                                    yield {
+                                        "event": "done",
+                                        "data": json.dumps(
+                                            {"reason": "all_todos_completed"}
+                                        ),
+                                    }
+                                    return  # Exit the generator
+
                             tool_name = getattr(last_message, "name", "") or ""
                             logger.info(
                                 "Resume ToolMessage name attribute: %s", tool_name
@@ -1677,7 +1735,7 @@ async def resume_agent(request: ResumeRequest):
                                     final_answer = tool_result.get(
                                         "answer"
                                     ) or tool_result.get("parameters", {}).get("answer")
-                                    
+
                                     # Check for next_items in answer field (LLM may put JSON here)
                                     if final_answer:
                                         try:
@@ -1685,25 +1743,41 @@ async def resume_agent(request: ResumeRequest):
                                             if "next_items" in answer_json:
                                                 next_items_block = f"\n\n```json\n{json.dumps(answer_json, ensure_ascii=False, indent=2)}\n```"
                                                 # Get summary for the main text
-                                                summary_text = tool_result.get(
-                                                    "summary"
-                                                ) or tool_result.get("parameters", {}).get("summary") or ""
-                                                final_answer = summary_text + next_items_block
-                                                logger.info("Resume: Extracted next_items from answer field")
+                                                summary_text = (
+                                                    tool_result.get("summary")
+                                                    or tool_result.get(
+                                                        "parameters", {}
+                                                    ).get("summary")
+                                                    or ""
+                                                )
+                                                final_answer = (
+                                                    summary_text + next_items_block
+                                                )
+                                                logger.info(
+                                                    "Resume: Extracted next_items from answer field"
+                                                )
                                         except (json.JSONDecodeError, TypeError):
                                             pass
-                                    
+
                                     # Check for next_items in summary field (Gemini puts JSON here)
                                     summary = tool_result.get(
                                         "summary"
-                                    ) or tool_result.get("parameters", {}).get("summary")
-                                    if summary and "next_items" not in (final_answer or ""):
+                                    ) or tool_result.get("parameters", {}).get(
+                                        "summary"
+                                    )
+                                    if summary and "next_items" not in (
+                                        final_answer or ""
+                                    ):
                                         try:
                                             summary_json = json.loads(summary)
                                             if "next_items" in summary_json:
                                                 next_items_block = f"\n\n```json\n{json.dumps(summary_json, ensure_ascii=False, indent=2)}\n```"
-                                                final_answer = (final_answer or "") + next_items_block
-                                                logger.info("Resume: Extracted next_items from summary field")
+                                                final_answer = (
+                                                    final_answer or ""
+                                                ) + next_items_block
+                                                logger.info(
+                                                    "Resume: Extracted next_items from summary field"
+                                                )
                                         except (json.JSONDecodeError, TypeError):
                                             pass
                                     if final_answer:
@@ -1775,16 +1849,27 @@ async def resume_agent(request: ResumeRequest):
                                 content = "\n".join(text_parts)
 
                             # Filter out raw JSON tool responses
+                            content_stripped = content.strip() if content else ""
+                            # Filter out tool call JSON (but allow summary/next_items JSON for frontend rendering)
+                            is_json_tool_response = (
+                                content_stripped.startswith('{"tool":')
+                                or content_stripped.startswith('{ "tool":')
+                                or content_stripped.startswith('{"tool" :')
+                                or content_stripped.startswith('{"status":')
+                                or '"pending_execution"' in content
+                                or '"status": "complete"' in content
+                                or ('"tool"' in content and '"write_todos"' in content)
+                                or (
+                                    '"tool"' in content
+                                    and '"arguments"' in content
+                                    and content_stripped.startswith("{")
+                                )
+                            )
                             if (
                                 content
                                 and isinstance(content, str)
                                 and not has_final_answer_tool
-                                and not (
-                                    content.strip().startswith('{"tool":')
-                                    or content.strip().startswith('{"status":')
-                                    or '"pending_execution"' in content
-                                    or '"status": "complete"' in content
-                                )
+                                and not is_json_tool_response
                             ):
                                 # Check if we've already emitted this content (prevents duplicates)
                                 content_hash = hash(content)
@@ -1835,6 +1920,26 @@ async def resume_agent(request: ResumeRequest):
                                         "event": "todos",
                                         "data": json.dumps({"todos": todos}),
                                     }
+                                    # Check if all todos are completed - terminate early
+                                    all_completed = all(
+                                        t.get("status") == "completed" for t in todos
+                                    )
+                                    if all_completed and len(todos) > 0:
+                                        logger.info(
+                                            "Resume: All %d todos completed in AIMessage tool_calls, auto-terminating",
+                                            len(todos),
+                                        )
+                                        yield {
+                                            "event": "debug_clear",
+                                            "data": json.dumps({}),
+                                        }
+                                        yield {
+                                            "event": "done",
+                                            "data": json.dumps(
+                                                {"reason": "all_todos_completed"}
+                                            ),
+                                        }
+                                        return  # Exit before executing more tool calls
 
                                 # Process tool calls
                                 for tool_call in new_tool_calls:
@@ -1850,13 +1955,6 @@ async def resume_agent(request: ResumeRequest):
 
                                     # Create detailed status message for search tools
                                     if tool_name in (
-                                        "search_workspace_tool",
-                                        "search_workspace",
-                                    ):
-                                        pattern = tool_args.get("pattern", "")
-                                        path = tool_args.get("path", ".")
-                                        status_msg = f"🔍 검색 실행: grep/rg '{pattern}' in {path}"
-                                    elif tool_name in (
                                         "search_notebook_cells_tool",
                                         "search_notebook_cells",
                                     ):
@@ -1914,33 +2012,6 @@ async def resume_agent(request: ResumeRequest):
                                                 }
                                             ),
                                         }
-                                    elif tool_name in (
-                                        "search_workspace_tool",
-                                        "search_workspace",
-                                    ):
-                                        # Search workspace - emit tool_call for client-side execution
-                                        yield {
-                                            "event": "tool_call",
-                                            "data": json.dumps(
-                                                {
-                                                    "tool": "search_workspace",
-                                                    "pattern": tool_args.get(
-                                                        "pattern", ""
-                                                    ),
-                                                    "file_types": tool_args.get(
-                                                        "file_types",
-                                                        ["*.py", "*.ipynb"],
-                                                    ),
-                                                    "path": tool_args.get("path", "."),
-                                                    "max_results": tool_args.get(
-                                                        "max_results", 50
-                                                    ),
-                                                    "case_sensitive": tool_args.get(
-                                                        "case_sensitive", False
-                                                    ),
-                                                }
-                                            ),
-                                        }
                                     elif tool_name in (
                                         "search_notebook_cells_tool",
                                         "search_notebook_cells",
@@ -2057,20 +2128,24 @@ async def resume_agent(request: ResumeRequest):
                 )
                 yield {
                     "event": "error",
-                    "data": json.dumps({
-                        "error": "Session state lost",
-                        "code": "CONTENTS_NOT_SPECIFIED",
-                        "error_type": type(e).__name__,
-                        "message": "세션 상태가 손실되었습니다. 서버가 재시작되었거나 세션이 만료되었습니다. 새로운 대화를 시작해주세요.",
-                    }),
+                    "data": json.dumps(
+                        {
+                            "error": "Session state lost",
+                            "code": "CONTENTS_NOT_SPECIFIED",
+                            "error_type": type(e).__name__,
+                            "message": "세션 상태가 손실되었습니다. 서버가 재시작되었거나 세션이 만료되었습니다. 새로운 대화를 시작해주세요.",
+                        }
+                    ),
                 }
             else:
                 yield {
                     "event": "error",
-                    "data": json.dumps({
-                        "error": error_msg,
-                        "error_type": type(e).__name__,
-                    }),
+                    "data": json.dumps(
+                        {
+                            "error": error_msg,
+                            "error_type": type(e).__name__,
+                        }
+                    ),
                 }
 
     return EventSourceResponse(event_generator())

hdsp_agent_core/__init__.py

@@ -15,77 +15,76 @@ Modules:
 __version__ = "1.0.0"
 
 # Models
+# Knowledge
+from hdsp_agent_core.knowledge import (
+    LIBRARY_DESCRIPTIONS,
+    DocumentChunker,
+    KnowledgeBase,
+    KnowledgeLoader,
+    LibraryDetector,
+    chunk_file,
+    get_knowledge_base,
+    get_knowledge_loader,
+    get_library_detector,
+)
+
+# LLM
+from hdsp_agent_core.llm import (
+    LLMService,
+    call_llm,
+    call_llm_stream,
+)
+
+# Managers
+from hdsp_agent_core.managers import (
+    ConfigManager,
+    SessionManager,
+    get_config_manager,
+    get_session_manager,
+)
 from hdsp_agent_core.models import (
     # Common
     APIResponse,
+    # Chat
+    ChatRequest,
+    ChatResponse,
+    # RAG
+    ChunkingConfig,
+    EmbeddingConfig,
     ErrorInfo,
+    # Agent
+    ExecutionPlan,
     GeminiConfig,
+    IndexStatusResponse,
     LLMConfig,
     NotebookContext,
     OpenAIConfig,
-    ToolCall,
-    VLLMConfig,
-    # Agent
-    ExecutionPlan,
     PlanRequest,
     PlanResponse,
     PlanStep,
-    RefineRequest,
-    RefineResponse,
-    ReplanRequest,
-    ReplanResponse,
-    ValidationIssue,
-    # Chat
-    ChatRequest,
-    ChatResponse,
-    StreamChunk,
-    # RAG
-    ChunkingConfig,
-    EmbeddingConfig,
-    IndexStatusResponse,
     QdrantConfig,
     RAGConfig,
+    RefineRequest,
+    RefineResponse,
     ReindexRequest,
     ReindexResponse,
+    ReplanRequest,
+    ReplanResponse,
     SearchRequest,
     SearchResponse,
+    StreamChunk,
+    ToolCall,
+    ValidationIssue,
+    VLLMConfig,
     WatchdogConfig,
 )
 
-# Managers
-from hdsp_agent_core.managers import (
-    ConfigManager,
-    SessionManager,
-    get_config_manager,
-    get_session_manager,
-)
-
-# LLM
-from hdsp_agent_core.llm import (
-    LLMService,
-    call_llm,
-    call_llm_stream,
-)
-
-# Knowledge
-from hdsp_agent_core.knowledge import (
-    DocumentChunker,
-    KnowledgeBase,
-    KnowledgeLoader,
-    LibraryDetector,
-    chunk_file,
-    get_knowledge_base,
-    get_knowledge_loader,
-    get_library_detector,
-    LIBRARY_DESCRIPTIONS,
-)
-
 # Prompts
 from hdsp_agent_core.prompts import (
-    PLAN_GENERATION_PROMPT,
+    ADAPTIVE_REPLAN_PROMPT,
     CODE_GENERATION_PROMPT,
     ERROR_REFINEMENT_PROMPT,
-    ADAPTIVE_REPLAN_PROMPT,
+    PLAN_GENERATION_PROMPT,
     format_plan_prompt,
     format_refine_prompt,
     format_replan_prompt,

hdsp_agent_core/factory.py

@@ -21,8 +21,9 @@ logger = logging.getLogger(__name__)
 
 class AgentMode(Enum):
     """Agent execution mode"""
+
     EMBEDDED = "embedded"  # Direct in-process execution
-    PROXY = "proxy"        # HTTP proxy to external server
+    PROXY = "proxy"  # HTTP proxy to external server
 
 
 class ServiceFactory:
@@ -84,9 +85,7 @@ class ServiceFactory:
         elif mode_str == "proxy":
             return AgentMode.PROXY
         else:
-            logger.warning(
-                f"Unknown HDSP_AGENT_MODE '{mode_str}', defaulting to proxy"
-            )
+            logger.warning(f"Unknown HDSP_AGENT_MODE '{mode_str}', defaulting to proxy")
             return AgentMode.PROXY
 
     @property
@@ -164,16 +163,13 @@ class ServiceFactory:
 
         # Create proxy service instances
         self._agent_service = ProxyAgentService(
-            base_url=self._server_url,
-            timeout=self._timeout
+            base_url=self._server_url, timeout=self._timeout
         )
         self._chat_service = ProxyChatService(
-            base_url=self._server_url,
-            timeout=self._timeout
+            base_url=self._server_url, timeout=self._timeout
         )
         self._rag_service = ProxyRAGService(
-            base_url=self._server_url,
-            timeout=self._timeout
+            base_url=self._server_url, timeout=self._timeout
         )
 
         # Optionally validate connectivity