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

agent_server/context_providers/__init__.py

@@ -2,11 +2,11 @@
 Context Providers Module
 
 Provides context injection for LLM prompts (e.g., @file, @notebook, @selection).
-Also provides action commands (e.g., @reset).
+Also provides action commands (e.g., /reset).
 Inspired by jupyter-ai's context provider architecture.
 """
 
-from .actions import ResetContextProvider
+from .actions import CompactContextProvider, HelpContextProvider, ResetContextProvider
 from .base import BaseContextProvider, ContextCommand, find_commands
 from .file import FileContextProvider
 from .processor import ContextProcessor, process_context_commands
@@ -16,6 +16,8 @@ __all__ = [
     "BaseContextProvider",
     "FileContextProvider",
     "ResetContextProvider",
+    "CompactContextProvider",
+    "HelpContextProvider",
     "ContextProcessor",
     "find_commands",
     "process_context_commands",

agent_server/context_providers/actions.py

@@ -1,7 +1,7 @@
 """
 Action Context Providers
 
-These providers handle action commands like @reset that perform actions
+These providers handle action commands like /reset that perform actions
 rather than providing context to the LLM.
 """
 
@@ -13,11 +13,11 @@ class ResetContextProvider(BaseContextProvider):
     Action provider for resetting the session.
 
     Usage:
-        @reset - Clear conversation history and recreate agent
+        /reset - Clear conversation history and recreate agent
     """
 
-    id = "@reset"
-    description = "Clear session and reset agent"
+    id = "/reset"
+    description = "세션 초기화 및 에이전트 리셋"
     requires_arg = False
     only_start = False
 
@@ -25,15 +25,15 @@ class ResetContextProvider(BaseContextProvider):
         super().__init__(base_dir)
 
     def get_arg_options(self, arg_prefix: str) -> list[ListOptionsEntry]:
-        """No arguments for @reset."""
+        """No arguments for /reset."""
         return []
 
     def make_context(self, command: ContextCommand) -> str:
-        """@reset doesn't provide context - it's an action command."""
+        """/reset doesn't provide context - it's an action command."""
         return ""
 
     def replace_command(self, command: ContextCommand) -> str:
-        """Replace @reset with empty string (it's an action, not context)."""
+        """Replace /reset with empty string (it's an action, not context)."""
         return ""
 
     def is_action_command(self) -> bool:
@@ -43,3 +43,69 @@ class ResetContextProvider(BaseContextProvider):
 
 # Add more action commands here as needed
 # Example: @clear, @help, @history, etc.
+
+
+class CompactContextProvider(BaseContextProvider):
+    """
+    Action provider for compacting conversation history.
+
+    Usage:
+        /compact - Summarize older messages, keep recent 3 intact
+    """
+
+    id = "/compact"
+    description = "대화 기록 압축 및 요약"
+    requires_arg = False
+    only_start = False
+
+    def __init__(self, base_dir: str = "."):
+        super().__init__(base_dir)
+
+    def get_arg_options(self, arg_prefix: str) -> list[ListOptionsEntry]:
+        """No arguments for /compact."""
+        return []
+
+    def make_context(self, command: ContextCommand) -> str:
+        """/compact doesn't provide context - it's an action command."""
+        return ""
+
+    def replace_command(self, command: ContextCommand) -> str:
+        """Replace /compact with empty string (it's an action, not context)."""
+        return ""
+
+    def is_action_command(self) -> bool:
+        """Indicate this is an action command."""
+        return True
+
+
+class HelpContextProvider(BaseContextProvider):
+    """
+    Action provider for displaying help information.
+
+    Usage:
+        /help - Show available commands and features guide
+    """
+
+    id = "/help"
+    description = "도움말 및 사용 가이드"
+    requires_arg = False
+    only_start = False
+
+    def __init__(self, base_dir: str = "."):
+        super().__init__(base_dir)
+
+    def get_arg_options(self, arg_prefix: str) -> list[ListOptionsEntry]:
+        """No arguments for /help."""
+        return []
+
+    def make_context(self, command: ContextCommand) -> str:
+        """/help doesn't provide context - it's an action command."""
+        return ""
+
+    def replace_command(self, command: ContextCommand) -> str:
+        """Replace /help with empty string (it's an action, not context)."""
+        return ""
+
+    def is_action_command(self) -> bool:
+        """Indicate this is an action command."""
+        return True

agent_server/context_providers/file.py

@@ -73,7 +73,7 @@ class FileContextProvider(BaseContextProvider):
     """
 
     id = "@file"
-    description = "Include file contents in the prompt"
+    description = "파일 내용을 프롬프트에 포함"
     requires_arg = True
     only_start = False
 
@@ -152,7 +152,7 @@ class FileContextProvider(BaseContextProvider):
                 ListOptionsEntry(
                     id=self.command_id,
                     label=f"{self.command_id}:{label_path}",
-                    description="Directory"
+                    description="디렉토리"
                     if is_dir
                     else self._get_file_description(path),
                     only_start=self.only_start,
@@ -168,26 +168,26 @@ class FileContextProvider(BaseContextProvider):
         basename = os.path.basename(filepath)
 
         descriptions = {
-            ".py": "Python file",
-            ".ipynb": "Jupyter notebook",
-            ".md": "Markdown file",
-            ".txt": "Text file",
-            ".json": "JSON file",
-            ".yaml": "YAML file",
-            ".yml": "YAML file",
-            ".toml": "TOML file",
-            ".js": "JavaScript file",
-            ".ts": "TypeScript file",
-            ".tsx": "TypeScript React file",
-            ".jsx": "JavaScript React file",
-            ".html": "HTML file",
-            ".css": "CSS file",
-            ".sql": "SQL file",
-            ".sh": "Shell script",
-            ".csv": "CSV file",
-            ".r": "R file",
-            ".R": "R file",
-            ".jl": "Julia file",
+            ".py": "Python 파일",
+            ".ipynb": "Jupyter 노트북",
+            ".md": "Markdown 파일",
+            ".txt": "텍스트 파일",
+            ".json": "JSON 파일",
+            ".yaml": "YAML 파일",
+            ".yml": "YAML 파일",
+            ".toml": "TOML 파일",
+            ".js": "JavaScript 파일",
+            ".ts": "TypeScript 파일",
+            ".tsx": "TypeScript React 파일",
+            ".jsx": "JavaScript React 파일",
+            ".html": "HTML 파일",
+            ".css": "CSS 파일",
+            ".sql": "SQL 파일",
+            ".sh": "셸 스크립트",
+            ".csv": "CSV 파일",
+            ".r": "R 파일",
+            ".R": "R 파일",
+            ".jl": "Julia 파일",
         }
 
         # Check special filenames
@@ -196,7 +196,7 @@ class FileContextProvider(BaseContextProvider):
         if basename == "Makefile":
             return "Makefile"
 
-        return descriptions.get(ext, "File")
+        return descriptions.get(ext, "파일")
 
     def make_context(self, command: ContextCommand) -> str:
         """

agent_server/langchain/__init__.py

@@ -12,7 +12,7 @@ Architecture:
 - state.py: Agent state management
 """
 
-from agent_server.langchain.agent import create_simple_chat_agent, create_agent_system
+from agent_server.langchain.agent import create_agent_system
 from agent_server.langchain.state import AgentState
 
-__all__ = ["create_simple_chat_agent", "create_agent_system", "AgentState"]
+__all__ = ["create_agent_system", "AgentState"]

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(