hdsp-jupyter-extension 2.0.27__py3-none-any.whl → 2.0.29__py3-none-any.whl

agent_server/langchain/agent.py

@@ -1,282 +1,49 @@
 """
 LangChain Agent
 
-Main agent creation module for tool-driven chat execution.
-Supports both single-agent and multi-agent modes.
+Main agent creation module for multi-agent system.
 """
 
 import logging
-from typing import Any, Dict, Optional, Literal
+from typing import Any, Dict, Optional
 
-from agent_server.langchain.custom_middleware import (
-    create_handle_empty_response_middleware,
-    create_inject_continuation_middleware,
-    create_limit_tool_calls_middleware,
-    create_normalize_tool_args_middleware,
-    create_patch_tool_calls_middleware,
-)
-from agent_server.langchain.hitl_config import get_hitl_interrupt_config
-from agent_server.langchain.llm_factory import create_llm, create_summarization_llm
-from agent_server.langchain.prompts import (
-    DEFAULT_SYSTEM_PROMPT,
-    TODO_LIST_SYSTEM_PROMPT,
-    TODO_LIST_TOOL_DESCRIPTION,
-)
-from agent_server.langchain.tools import (
-    ask_user_tool,
-    check_resource_tool,
-    diagnostics_tool,
-    edit_file_tool,
-    execute_command_tool,
-    jupyter_cell_tool,
-    markdown_tool,
-    multiedit_file_tool,
-    read_file_tool,
-    references_tool,
-    search_notebook_cells_tool,
-    write_file_tool,
-)
+from agent_server.langchain.agent_factory import create_multi_agent_system
 
 logger = logging.getLogger(__name__)
 
 
-def _get_all_tools():
-    """Get all available tools for the agent."""
-    return [
-        jupyter_cell_tool,
-        markdown_tool,
-        ask_user_tool,  # HITL - waits for user response
-        read_file_tool,
-        write_file_tool,
-        edit_file_tool,
-        multiedit_file_tool,
-        search_notebook_cells_tool,
-        execute_command_tool,
-        check_resource_tool,
-        diagnostics_tool,
-        references_tool,
-    ]
-
-
-def create_simple_chat_agent(
+def create_agent_system(
     llm_config: Dict[str, Any],
     workspace_root: str = ".",
     enable_hitl: bool = True,
     enable_todo_list: bool = True,
     checkpointer: Optional[object] = None,
     system_prompt_override: Optional[str] = None,
+    agent_prompts: Optional[Dict[str, str]] = None,
 ):
     """
-    Create a simple chat agent using LangChain's create_agent with Human-in-the-Loop.
+    Create a multi-agent system (Planner + Subagents).
 
-    This is a simplified version for chat mode that uses LangChain's built-in
-    HumanInTheLoopMiddleware and TodoListMiddleware.
+    This is the main entry point for creating agents.
 
     Args:
         llm_config: LLM configuration
-        workspace_root: Root directory
+        workspace_root: Root directory for file operations
         enable_hitl: Enable Human-in-the-Loop for code execution
         enable_todo_list: Enable TodoListMiddleware for task planning
         checkpointer: Optional checkpointer for state persistence
         system_prompt_override: Optional custom system prompt
+        agent_prompts: Optional dict of per-agent prompts
 
     Returns:
-        Configured agent with HITL and TodoList middleware
+        Configured multi-agent system
     """
-    try:
-        from langchain.agents import create_agent
-        from langchain.agents.middleware import (
-            AgentMiddleware,
-            HumanInTheLoopMiddleware,
-            ModelCallLimitMiddleware,
-            SummarizationMiddleware,
-            TodoListMiddleware,
-            ToolCallLimitMiddleware,
-            wrap_model_call,
-        )
-        from langchain_core.messages import ToolMessage as LCToolMessage
-        from langgraph.checkpoint.memory import InMemorySaver
-        from langgraph.types import Overwrite
-    except ImportError as e:
-        logger.error(f"Failed to import LangChain agent components: {e}")
-        raise ImportError(
-            "LangChain agent components not available. "
-            "Install with: pip install langchain langgraph"
-        ) from e
-
-    # Create LLM
-    llm = create_llm(llm_config)
-
-    # Get tools
-    tools = _get_all_tools()
-
-    # Configure middleware
-    middleware = []
-    # Add empty response handler middleware
-    handle_empty_response = create_handle_empty_response_middleware(wrap_model_call)
-    middleware.append(handle_empty_response)
-
-    # Add tool call limiter middleware
-    limit_tool_calls = create_limit_tool_calls_middleware(wrap_model_call)
-    middleware.append(limit_tool_calls)
-
-    # Add tool args normalization middleware (convert list args to strings based on schema)
-    normalize_tool_args = create_normalize_tool_args_middleware(
-        wrap_model_call, tools=tools
-    )
-    middleware.append(normalize_tool_args)
-
-    # Add continuation prompt middleware
-    inject_continuation = create_inject_continuation_middleware(wrap_model_call)
-    middleware.append(inject_continuation)
-
-    # Add patch tool calls middleware
-    patch_tool_calls = create_patch_tool_calls_middleware(
-        AgentMiddleware, LCToolMessage, Overwrite
-    )
-    middleware.append(patch_tool_calls)
-
-    # Add TodoListMiddleware for task planning
-    # NOTE: system_prompt removed to avoid multi-part content array
-    # that causes Gemini MALFORMED_FUNCTION_CALL error
-    if enable_todo_list:
-        todo_middleware = TodoListMiddleware(
-            tool_description=TODO_LIST_TOOL_DESCRIPTION,
-        )
-        middleware.append(todo_middleware)
-
-    if enable_hitl:
-        # Add Human-in-the-Loop middleware for code execution
-        hitl_middleware = HumanInTheLoopMiddleware(
-            interrupt_on=get_hitl_interrupt_config(),
-            description_prefix="Tool execution pending approval",
-        )
-        middleware.append(hitl_middleware)
-
-    # Add loop prevention middleware
-    # ModelCallLimitMiddleware: Prevent infinite LLM calls
-    model_limit_middleware = ModelCallLimitMiddleware(
-        run_limit=30,  # Max 30 LLM calls per user message
-        exit_behavior="end",  # Gracefully end when limit reached
-    )
-    middleware.append(model_limit_middleware)
-    logger.info("Added ModelCallLimitMiddleware with run_limit=30")
-
-    # ToolCallLimitMiddleware: Prevent specific tools from being called too many times
-    # run_limit resets automatically per user message
-    write_todos_limit = ToolCallLimitMiddleware(
-        tool_name="write_todos",
-        run_limit=20,  # Max 20 write_todos calls per user message
-        exit_behavior="continue",
-    )
-    middleware.append(write_todos_limit)
-    logger.info("Added ToolCallLimitMiddleware for write_todos (20/msg)")
-
-    # Add SummarizationMiddleware to maintain context across cycles
-    summary_llm = create_summarization_llm(llm_config)
-    if summary_llm:
-        try:
-            summarization_middleware = SummarizationMiddleware(
-                model=summary_llm,
-                trigger=("tokens", 8000),  # Trigger when exceeding 8000 tokens
-                keep=("messages", 10),  # Keep last 10 messages intact
-            )
-            middleware.append(summarization_middleware)
-            logger.info(
-                "Added SummarizationMiddleware with model=%s, trigger=8000 tokens, keep=10 msgs",
-                getattr(summary_llm, "model", str(summary_llm)),
-            )
-        except Exception as e:
-            logger.warning("Failed to add SummarizationMiddleware: %s", e)
-
-    # System prompt for the agent (override applies only to LangChain agent)
-    if system_prompt_override and system_prompt_override.strip():
-        system_prompt = system_prompt_override.strip()
-        logger.info("SimpleChatAgent using custom system prompt override")
-    else:
-        system_prompt = DEFAULT_SYSTEM_PROMPT
-
-    # Add vLLM/gpt-oss specific prompt (minimal - main rules are in DEFAULT_SYSTEM_PROMPT)
-    provider = llm_config.get("provider", "")
-    if provider == "vllm":
-        vllm_prompt = """
-## 🔴 추가 강조
-- 반드시 한국어로 응답
-- 빈 응답 절대 금지 - 항상 도구 호출 필수
-"""
-        system_prompt = system_prompt + "\n" + vllm_prompt
-        logger.info("Added vLLM-specific prompt")
-
-    logger.info("SimpleChatAgent system_prompt: %s", system_prompt)
-
-    # Create agent with checkpointer (required for HITL)
-    agent = create_agent(
-        model=llm,
-        tools=tools,
-        middleware=middleware,
-        checkpointer=checkpointer or InMemorySaver(),  # Required for interrupt/resume
-        system_prompt=system_prompt,  # Tell the agent to use tools
+    logger.info("Creating multi-agent system (Planner + Subagents)")
+    return create_multi_agent_system(
+        llm_config=llm_config,
+        checkpointer=checkpointer,
+        enable_hitl=enable_hitl,
+        enable_todo_list=enable_todo_list,
+        system_prompt_override=system_prompt_override,
+        agent_prompts=agent_prompts,
     )
-
-    return agent
-
-
-# =============================================================================
-# Multi-Agent System Support
-# =============================================================================
-
-
-def create_agent_system(
-    llm_config: Dict[str, Any],
-    workspace_root: str = ".",
-    enable_hitl: bool = True,
-    enable_todo_list: bool = True,
-    checkpointer: Optional[object] = None,
-    system_prompt_override: Optional[str] = None,
-    agent_mode: Literal["single", "multi"] = "single",
-    agent_prompts: Optional[Dict[str, str]] = None,
-):
-    """
-    Create an agent system based on the specified mode.
-    
-    This is the main entry point for creating agents. It supports both:
-    - "single": Traditional single-agent with all tools (backward compatible)
-    - "multi": Multi-agent system with Planner supervising subagents
-    
-    Args:
-        llm_config: LLM configuration
-        workspace_root: Root directory for file operations
-        enable_hitl: Enable Human-in-the-Loop for code execution
-        enable_todo_list: Enable TodoListMiddleware for task planning
-        checkpointer: Optional checkpointer for state persistence
-        system_prompt_override: Optional custom system prompt
-        agent_mode: "single" for traditional mode, "multi" for multi-agent
-        agent_prompts: Optional dict of per-agent prompts (for multi-agent mode)
-    
-    Returns:
-        Configured agent (single or Planner for multi-agent)
-    """
-    if agent_mode == "multi":
-        # Use multi-agent system with Planner + Subagents
-        from agent_server.langchain.agent_factory import create_multi_agent_system
-        
-        logger.info("Creating multi-agent system (Planner + Subagents)")
-        return create_multi_agent_system(
-            llm_config=llm_config,
-            checkpointer=checkpointer,
-            enable_hitl=enable_hitl,
-            enable_todo_list=enable_todo_list,
-            system_prompt_override=system_prompt_override,
-            agent_prompts=agent_prompts,
-        )
-    else:
-        # Use traditional single-agent mode
-        logger.info("Creating single-agent system (all tools in one agent)")
-        return create_simple_chat_agent(
-            llm_config=llm_config,
-            workspace_root=workspace_root,
-            enable_hitl=enable_hitl,
-            enable_todo_list=enable_todo_list,
-            checkpointer=checkpointer,
-            system_prompt_override=system_prompt_override,
-        )

agent_server/langchain/agent_factory.py

@@ -29,11 +29,16 @@ from agent_server.langchain.custom_middleware import (
 )
 from agent_server.langchain.hitl_config import get_hitl_interrupt_config
 from agent_server.langchain.llm_factory import create_llm, create_summarization_llm
+from agent_server.langchain.middleware.content_injection_middleware import (
+    ContentInjectionMiddleware,
+)
 from agent_server.langchain.middleware.skill_middleware import get_skill_middleware
 from agent_server.langchain.middleware.subagent_middleware import (
+    _create_main_task_tool,
     create_task_tool,
     set_subagent_factory,
 )
+from agent_server.langchain.state_schema import HDSPAgentState
 from agent_server.langchain.subagents.base import (
     get_available_subagents_for_planner,
     get_subagent_config,
@@ -146,6 +151,7 @@ def create_subagent(
         middleware=middleware,
         checkpointer=checkpointer or InMemorySaver(),  # Needed for HITL
         system_prompt=system_prompt,
+        state_schema=HDSPAgentState,
     )
 
     logger.info(
@@ -229,11 +235,11 @@ def create_main_agent(
     # Using "planner" for backward compatibility with tool_registry
     tools = get_tools_for_agent("planner")
 
-    # Create task tool for calling subagents
+    # Create task tool for calling subagents (Main Agent version with Command/State)
     available_subagents = [
         config.name for config in get_available_subagents_for_planner()
     ]
-    task_tool = create_task_tool(
+    task_tool = _create_main_task_tool(
         caller_name="planner",
         allowed_subagents=None,  # Main Agent (Planner) can call all non-restricted subagents
     )
@@ -242,6 +248,13 @@ def create_main_agent(
     # Configure middleware
     middleware = []
 
+    # Add ContentInjectionMiddleware FIRST (before HITL)
+    # Injects generated code/SQL from state into tool args
+    # so HITL sees the full content for user approval
+    content_injection = ContentInjectionMiddleware()
+    middleware.append(content_injection)
+    logger.info("Added ContentInjectionMiddleware (before HITL)")
+
     # Add empty response handler middleware (critical for Gemini compatibility)
     handle_empty_response = create_handle_empty_response_middleware(wrap_model_call)
     middleware.append(handle_empty_response)
@@ -268,6 +281,14 @@ def create_main_agent(
     )
     middleware.append(patch_tool_calls)
 
+    # Add TodoActiveMiddleware BEFORE TodoListMiddleware
+    # TodoActiveMiddleware wraps around TodoListMiddleware to intercept
+    # write_todos/final_summary_tool results and set todo_active state flag
+    from agent_server.langchain.custom_middleware import TodoActiveMiddleware
+
+    todo_active_middleware = TodoActiveMiddleware()
+    middleware.append(todo_active_middleware)
+
     # Add TodoListMiddleware for task planning
     # NOTE: system_prompt removed to avoid multi-part content array
     if enable_todo_list:
@@ -307,8 +328,8 @@ def create_main_agent(
         try:
             summarization = SummarizationMiddleware(
                 model=summary_llm,
-                trigger=("tokens", 10000),  # Higher trigger for multi-agent
-                keep=("messages", 15),
+                trigger=("tokens", 30000),  # Trigger when tokens exceed this threshold
+                keep=("messages", 15),  # Keep last 15 messages after compaction
             )
             middleware.append(summarization)
             logger.info("Added SummarizationMiddleware to Main Agent")
@@ -345,6 +366,7 @@ def create_main_agent(
         middleware=middleware,
         checkpointer=checkpointer or InMemorySaver(),
         system_prompt=system_prompt,
+        state_schema=HDSPAgentState,
     )
 
     logger.info(

agent_server/langchain/agent_prompts/planner_prompt.py

@@ -5,15 +5,16 @@ Main Agent (Supervisor) System Prompt for Multi-Agent Mode
 PLANNER_SYSTEM_PROMPT = """당신은 작업을 조율하는 Main Agent입니다. 한국어로 응답하세요.
 
 # 핵심 원칙
-1. 3단계 이상의 복잡한 작업을 요청받은 경우에만 write_todos 로 작업 목록 관리
-2. **직접 코드, 쿼리 작성 금지** - 모든 코드/쿼리 생성은 task_tool로 서브에이전트에게 위임
-3. 서브에이전트가 반환한 코드를 적절한 도구로 실행
-4. 모든 응답 content는 2~3줄 내외로 핵심만 명확하게 전달
+1. **간단한 작업 (1-2단계)**: write_todos 사용 금지 → 바로 실행하고 종료
+2. **복잡한 작업 (3단계+)**: write_todos로 계획 → 순차 실행 → 완료 시 final_summary_tool 호출
+3. **직접 코드, 쿼리 작성 금지** - 모든 코드/쿼리 생성은 task_tool로 서브에이전트에게 위임
+4. 서브에이전트가 반환한 코드를 적절한 도구로 실행
 
 # 작업 흐름
 
 ## Step 1: 계획 수립
-3단계 이상의 복잡한 작업을 요청받은 경우에만 write_todos로 작업 목록 생성 (마지막 항목은 반드시 "작업 요약 및 다음 단계 제시")
+- **간단한 작업 (1-2단계)**: write_todos 없이 바로 실행. 완료 후 추가 도구 호출 없이 종료.
+- **복잡한 작업 (3단계+)**: write_todos로 작업 목록 생성 (실제 작업만 포함, 요약은 시스템이 자동 처리)
 
 ## Step 2: 코드/쿼리 생성 요청
 필요한 경우, task_tool을 호출하여 서브에이전트에게 위임:
@@ -25,18 +26,20 @@ PLANNER_SYSTEM_PROMPT = """당신은 작업을 조율하는 Main Agent입니다.
 | researcher | 정보 검색 | task_tool(agent_name="researcher", description="관련 문서 검색") |
 
 ## Step 3: 결과 실행/적용 (필수!)
-**task_tool을 호출 했다면, 호출 후 반드시 결과를 처리해야 함:**
+**task_tool 호출 후 반드시 결과를 처리해야 함. 코드/SQL은 자동 주입됩니다:**
 
-| 서브에이전트 | 작업 유형 | 처리 방법 | 예시 |
-|-------------|----------|----------|------|
-| 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```") |
+| 서브에이전트 | 작업 유형 | 처리 방법 | 호출 방법 |
+|-------------|----------|----------|----------|
+| python_developer | 코드 실행 (데이터 분석, 시각화) | jupyter_cell_tool | jupyter_cell_tool() ← 코드 자동 주입, code 파라미터 불필요 |
+| python_developer | **파일 생성/수정** | **write_file_tool** | write_file_tool(path="파일경로") ← content 자동 주입 |
+| athena_query | SQL 표시 | markdown_tool | markdown_tool() ← SQL 자동 주입, content 파라미터 불필요 |
 | researcher | 텍스트 요약 | 직접 응답 | - |
 
-**🔴 중요: 코드 저장 도구 선택**
-- **파일 생성/수정 요청** → `write_file_tool` 또는 `multiedit_file_tool` 사용
-- **코드 실행 요청** (데이터 분석, 차트 등) → `jupyter_cell_tool` 사용
+**🔴 중요: 코드/SQL 자동 주입**
+- task_tool이 생성한 코드/SQL은 **State를 통해 자동 주입**됩니다
+- **코드를 직접 복사하거나 인자로 전달할 필요 없음** — 도구만 호출하면 됨
+- **파일 생성/수정 요청** → `write_file_tool(path=...)` 사용 (content 자동 주입)
+- **코드 실행 요청** (데이터 분석, 차트 등) → `jupyter_cell_tool()` 사용 (code 자동 주입)
 - **❌ markdown_tool은 코드 저장용이 아님!** (표시 전용)
 
 **중요**: task_tool 결과를 받은 후 바로 write_todos로 완료 처리하지 말고, 반드시 위 도구로 결과를 먼저 적용!
@@ -49,34 +52,22 @@ PLANNER_SYSTEM_PROMPT = """당신은 작업을 조율하는 Main Agent입니다.
     - **🔴 기존 todo 절대 삭제 금지**: 전체 리스트를 항상 포함하고 status만 변경
     - **🔴 상태 전환 순서 필수**: 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": "in_progress"}, {"content": "작업2", "status": "pending"}]
       - 잘못된 초기 예: [{"content": "작업1", "status": "completed"}, ...] ← 실제 작업 없이 completed 금지!
     - **🔴 completed 전환 조건**: 실제 도구(task_tool, jupyter_cell_tool 등)로 작업 수행 후에만 completed로 변경
     - in_progress 상태는 **동시에 1개만** 허용 (completed, pending todo는 삭제하지 않고 모두 유지)
     - content에 도구(tool)명 언급 금지
-    - **[필수] 마지막 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 호출 없이 종료 금지**
+    - **"작업 요약" todo 추가 금지**: 실제 작업만 todo로 생성 (요약은 시스템이 자동 처리)
 
 # 도구 사용시 주의할 점
 ## 파일 위치 모를 때 탐색 순서: search_files_tool → list_workspace_tool → 재검색 → ask_user_tool 순서로!)
-## list_workspace_tool로 전체 디렉토리 파일 목록 검색 금지! 최대한 pattern 으로 drill down 해서 검색할 것 
+## list_workspace_tool로 전체 디렉토리 파일 목록 검색 금지! 최대한 pattern 으로 drill down 해서 검색할 것
 
 # 금지 사항
 - 직접 코드/SQL 작성 (반드시 task_tool 사용)
 - task_tool 없이 jupyter_cell_tool 호출
-- **task_tool 결과를 표시하지 않고 바로 완료 처리** (athena_query → markdown_tool 필수)
+- **task_tool 결과를 처리하지 않고 바로 완료** (python_developer → jupyter_cell_tool, athena_query → markdown_tool 필수)
+- jupyter_cell_tool에 code 인자를 직접 전달 (자동 주입되므로 불필요)
 - 빈 응답
 """