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

agent_server/langchain/prompts.py

@@ -13,30 +13,19 @@ DEFAULT_SYSTEM_PROMPT = """You are an expert Python data scientist and Jupyter n
    - 설명 없이 tool_call만 하면 안 됨
 
 # 작업 흐름
-1. 간단한 작업 (1-2단계): 바로 실행
-2. 복잡한 작업 (3단계+): write_todos로 계획 → 순차 실행
+1. 간단한 작업 (1-2단계): 바로 실행 → 완료 후 write_todos 사용하지 말고 바로 종료
+2. 복잡한 작업 (3단계+): write_todos로 계획 → 순차 실행 → 완료 시 final_summary_tool 호출
 
 # write_todos 규칙 [필수]
 - 한국어로 작성
 - **🔴 기존 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 전환 조건**: 실제 도구로 작업 수행 후에만 completed로 변경
 - in_progress는 **동시에 1개만** 유지
-- **[필수] 마지막 todo는 반드시 "작업 요약 및 다음 단계 제시"로 생성**
-- **🔴 [실행 순서 필수]**: "작업 요약 및 다음 단계 제시"는 **반드시 가장 마지막에 실행**
-  - 다른 모든 todo가 completed 상태가 된 후에만 이 todo를 in_progress로 변경
-- **[중요] "작업 요약 및 다음 단계 제시"는 summary JSON 출력 후에만 completed 표시**
-
-# 모든 작업 완료 후 [필수]
-마지막 todo "작업 요약 및 다음 단계 제시"를 완료할 때:
-**반드시 final_summary_tool을 호출**하여 요약과 다음 단계를 제시하세요.
-- final_summary_tool(summary="완료된 작업 요약", next_items=[{"subject": "제목", "description": "설명"}, ...])
-- next_items 3개 이상 필수
-- **final_summary_tool 호출 없이 종료 금지**
-- **주의**: 텍스트로 JSON 출력하지 말고, 반드시 도구 호출로!
+- **"작업 요약" todo 추가 금지**: 실제 작업만 todo로 생성 (요약은 시스템이 자동 처리)
 
 # 도구 사용
 - check_resource_tool: 대용량 파일/데이터프레임 작업 전 필수
@@ -57,8 +46,6 @@ DEFAULT_SYSTEM_PROMPT = """You are an expert Python data scientist and Jupyter n
 - 빈 응답 (도구 호출도 없고 내용도 없음)
 - 설명 없이 도구만 호출
 - pending/in_progress todo 남기고 종료
-- "작업 요약 및 다음 단계 제시" todo 없이 todo 리스트 생성
-- **🔴 다른 pending todo가 있는데 "작업 요약 및 다음 단계 제시"를 먼저 실행** (순서 위반)
 """
 
 JSON_TOOL_SCHEMA = """Respond with ONLY valid JSON:
@@ -92,11 +79,7 @@ TODO_LIST_TOOL_DESCRIPTION = """Todo 리스트 관리 도구.
 - **🔴 초기 생성**: 첫 호출 시 첫 번째만 in_progress, 나머지는 pending
 - **🔴 completed 조건**: 실제 도구로 작업 수행 후에만 completed로 변경
 - in_progress 상태는 **동시에 1개만** 허용
-- **[필수] 마지막 todo는 반드시 "작업 요약 및 다음 단계 제시"로 생성**
-- **🔴 [실행 순서]**: todo는 반드시 리스트 순서대로 실행하고, "작업 요약 및 다음 단계 제시"는 맨 마지막에 실행
-- 이 "작업 요약 및 다음 단계 제시" todo 완료 시 **반드시 final_summary_tool 호출**:
-  final_summary_tool(summary="완료 요약", next_items=[{"subject": "...", "description": "..."}])
-  (next_items 3개 이상 필수, 텍스트 JSON 출력 금지!)
+- **"작업 요약" todo 추가 금지**: 실제 작업만 todo로 생성 (요약은 시스템이 자동 처리)
 """
 
 # List of tools available to the agent

agent_server/langchain/state_schema.py

@@ -0,0 +1,44 @@
+"""
+HDSP Agent State Schema
+
+Extends LangChain AgentState with custom fields for state-based
+content passing between Main Agent and Subagents.
+
+Key fields:
+- generated_content: Python code or SQL query from subagents
+- generated_content_type: "python" | "sql" to determine injection target
+- content_description: [DESCRIPTION] section from subagent response
+
+This eliminates JSON serialization issues when passing code/SQL
+between agents — content flows through LangGraph State, not LLM JSON.
+"""
+
+from typing import Optional
+
+from langchain.agents import AgentState
+
+
+class HDSPAgentState(AgentState):
+    """Extended agent state for HDSP multi-agent architecture.
+
+    Adds fields for state-based content passing:
+    - Subagent writes generated_content via Command
+    - ContentInjectionMiddleware reads and injects into tool args
+    """
+
+    generated_content: Optional[str]
+    """Generated Python code or SQL query from subagent.
+    Set by task tool via Command(update={"generated_content": ...})."""
+
+    generated_content_type: Optional[str]
+    """Content type: "python" | "sql" | None.
+    Determines which tool receives the injection."""
+
+    content_description: Optional[str]
+    """Description extracted from [DESCRIPTION] section.
+    Injected alongside content into tool args."""
+
+    todo_active: bool
+    """True when todo list workflow is active.
+    Set to True by TodoActiveMiddleware when write_todos is called.
+    Set to False when final_summary_tool is called, user cancels, or new request starts."""

agent_server/langchain/tools/jupyter_tools.py

@@ -113,7 +113,7 @@ def markdown_tool(content: str) -> Dict[str, Any]:
             "content": content,
         },
         "status": "completed",
-        "message": "Markdown cell added successfully. Continue with the next task.",
+        "message": "Markdown cell added successfully.",
     }
 
 
@@ -194,13 +194,12 @@ def final_summary_tool(
     next_items: List[Dict[str, str]],
 ) -> Dict[str, Any]:
     """
-    모든 작업이 완료된 후 최종 요약과 다음 단계를 제시하는 도구.
-
-    이 도구는 반드시 모든 todo가 완료된 후, 마지막 "작업 요약 및 다음 단계 제시" todo를 처리할 때만 호출하세요.
+    모든 todo가 completed 상태가 된 후 호출하는 마무리 도구.
+    별도의 "요약" todo를 만들지 말고, 실제 작업 todo가 모두 완료되면 바로 이 도구를 호출하세요.
 
     Args:
         summary: 완료된 작업에 대한 요약 (한국어로 작성)
-        next_items: 다음 단계 제안 목록 (각각 subject와 description 포함, 3개 이상)
+        next_items: 후속 작업 제안 목록 (각각 subject와 description 포함, 3개 이상)
 
     Returns:
         Dict containing the summary and next items for frontend display

agent_server/langchain/tools/tool_registry.py

@@ -22,6 +22,7 @@ from agent_server.langchain.tools.file_tools import (
 )
 from agent_server.langchain.tools.jupyter_tools import (
     ask_user_tool,
+    final_summary_tool,
     jupyter_cell_tool,
     markdown_tool,
 )
@@ -46,6 +47,7 @@ ALL_TOOLS = {
     "jupyter_cell_tool": jupyter_cell_tool,
     "markdown_tool": markdown_tool,
     "ask_user_tool": ask_user_tool,
+    "final_summary_tool": final_summary_tool,
     # File tools
     "read_file_tool": read_file_tool,
     "write_file_tool": write_file_tool,
@@ -95,6 +97,8 @@ AGENT_TOOLS_CONFIG = {
             "multiedit_file_tool",
             # Shell for additional operations
             "execute_command_tool",
+            # Final summary (auto-triggered by middleware when all todos done)
+            "final_summary_tool",
         ],
         # write_todos and task tools are added by middleware
         "description": "Main Agent executes code and manages files directly",
@@ -118,6 +122,8 @@ AGENT_TOOLS_CONFIG = {
             "multiedit_file_tool",
             # Shell
             "execute_command_tool",
+            # Final summary (auto-triggered by middleware when all todos done)
+            "final_summary_tool",
         ],
         "description": "Alias for main_agent (backward compatibility)",
     },

agent_server/routers/chat.py

@@ -8,16 +8,97 @@ Supports @file context injection for including file contents in prompts.
 import json
 import logging
 import os
-from typing import Any, AsyncGenerator, Dict
+from typing import Any, AsyncGenerator, Dict, Optional
 
 from fastapi import APIRouter, HTTPException
 from fastapi.responses import StreamingResponse
 from hdsp_agent_core.managers.config_manager import ConfigManager
-from hdsp_agent_core.managers.session_manager import get_session_manager
+from hdsp_agent_core.managers.session_manager import ChatMessage, get_session_manager
 from hdsp_agent_core.models.chat import ChatRequest, ChatResponse
+from pydantic import BaseModel
 
 from agent_server.context_providers import ContextProcessor
 from agent_server.core.llm_service import LLMService
+from agent_server.langchain.llm_factory import create_summarization_llm
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Auto-Compact Configuration (Aligned with Agent mode SummarizationMiddleware)
+# ═══════════════════════════════════════════════════════════════════════════
+# These values should match agent_factory.py SummarizationMiddleware settings
+AUTO_COMPACT_TOKEN_THRESHOLD = 30000  # Trigger when tokens exceed this threshold
+AUTO_COMPACT_KEEP_MESSAGES = 15  # Keep last N messages after compaction
+
+# Approximate tokens per character (for Korean/English mixed text)
+CHARS_PER_TOKEN = 3.5  # Conservative estimate
+
+
+def _estimate_tokens(text: str) -> int:
+    """Estimate token count from text length."""
+    return int(len(text) / CHARS_PER_TOKEN)
+
+
+def _estimate_session_tokens(messages: list) -> int:
+    """Estimate total tokens in session messages."""
+    total_chars = sum(len(m.content) for m in messages)
+    return int(total_chars / CHARS_PER_TOKEN)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Summarization Prompt (Claude Code Benchmark)
+# ═══════════════════════════════════════════════════════════════════════════
+SUMMARIZATION_PROMPT = """다음 대화 내용을 요약하여 향후 컨텍스트 윈도우에서 작업을 효율적으로 재개할 수 있도록 해주세요.
+이 요약은 대화 히스토리를 대체하므로, 구조화되고 간결하며 실행 가능해야 합니다.
+
+요약에 반드시 포함할 내용:
+
+## 완료된 작업
+- 완료된 태스크와 주요 결과물
+- 생성/수정된 파일 목록
+
+## 현재 상태
+- 진행 중인 작업
+- 마지막으로 논의된 주제
+
+## 다음 단계
+- 명확한 후속 액션 항목
+- 보류 중인 결정 사항
+
+## 핵심 맥락
+- 사용자 선호사항 및 제약조건
+- 중요한 기술적 결정사항
+- 작업 재개에 필수적인 정보
+
+작성 지침:
+- 간결하되, 작업이 끊김 없이 계속될 수 있을 정도의 세부사항은 보존
+- 불필요한 인사말, 확인 메시지, 중복 내용은 제외
+- 코드 스니펫은 핵심적인 경우에만 포함
+- 한국어로 작성
+
+대화 내용:
+{conversation}
+
+요약:"""
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Compact Request/Response Models
+# ═══════════════════════════════════════════════════════════════════════════
+class CompactRequest(BaseModel):
+    """Request for conversation compaction."""
+
+    conversationId: str
+    llmConfig: Optional[dict] = None
+
+
+class CompactResponse(BaseModel):
+    """Response from conversation compaction."""
+
+    success: bool
+    message: str
+    originalMessages: int
+    compressedMessages: int
+    summary: Optional[str] = None
 
 router = APIRouter()
 logger = logging.getLogger(__name__)
@@ -81,6 +162,98 @@ def _store_messages(
     session_manager.store_messages(conversation_id, user_message, assistant_response)
 
 
+async def _auto_compact_if_needed(
+    conversation_id: str, llm_config: Dict[str, Any]
+) -> Optional[str]:
+    """
+    Automatically compact conversation if token threshold exceeded.
+
+    Aligned with Agent mode SummarizationMiddleware:
+    - Trigger: Token count exceeds AUTO_COMPACT_TOKEN_THRESHOLD
+    - Keep: Last AUTO_COMPACT_KEEP_MESSAGES messages
+    - Result: [summary] + [recent messages]
+
+    Returns:
+        Summary string if compacted, None otherwise
+    """
+    from datetime import datetime
+
+    session_manager = get_session_manager()
+    session = session_manager.get_session(conversation_id)
+
+    if not session or not session.messages:
+        return None
+
+    # Estimate tokens in session
+    estimated_tokens = _estimate_session_tokens(session.messages)
+
+    # Check if auto-compact needed (token-based, same as Agent mode)
+    if estimated_tokens <= AUTO_COMPACT_TOKEN_THRESHOLD:
+        return None
+
+    # Need at least more messages than we keep
+    if len(session.messages) <= AUTO_COMPACT_KEEP_MESSAGES:
+        return None
+
+    logger.info(
+        f"[Chat] Auto-compact triggered for {conversation_id}: "
+        f"~{estimated_tokens} tokens > {AUTO_COMPACT_TOKEN_THRESHOLD} threshold, "
+        f"{len(session.messages)} messages"
+    )
+
+    try:
+        # Split messages: older (to summarize) vs recent (to keep)
+        messages_to_summarize = session.messages[:-AUTO_COMPACT_KEEP_MESSAGES]
+        recent_messages = session.messages[-AUTO_COMPACT_KEEP_MESSAGES:]
+
+        # Build conversation text for summarization
+        conversation_text = "\n".join(
+            [
+                f"{'사용자' if m.role == 'user' else '어시스턴트'}: {m.content}"
+                for m in messages_to_summarize
+            ]
+        )
+
+        # Create summarization LLM (uses settings from llm_config)
+        summarization_llm = create_summarization_llm(llm_config)
+
+        if not summarization_llm:
+            logger.warning("[Chat] Auto-compact skipped: no summarization LLM available")
+            return None
+
+        # Generate summary using LLM
+        prompt = SUMMARIZATION_PROMPT.format(conversation=conversation_text)
+        response = await summarization_llm.ainvoke(prompt)
+        summary = response.content if hasattr(response, "content") else str(response)
+
+        # Create summary message
+        summary_message = ChatMessage(
+            role="assistant",
+            content=f"[이전 대화 요약]\n\n{summary}",
+            timestamp=datetime.now().timestamp(),
+        )
+
+        # Replace session messages: [summary] + [last N]
+        original_count = len(session.messages)
+        session.messages = [summary_message] + list(recent_messages)
+        session.updated_at = datetime.now().timestamp()
+
+        # NOTE: Session save disabled - sessions are not loaded/used by frontend
+        # session_manager._save_sessions()
+
+        compressed_count = len(session.messages)
+        logger.info(
+            f"[Chat] Auto-compacted {conversation_id}: "
+            f"{original_count} -> {compressed_count} messages"
+        )
+
+        return summary
+
+    except Exception as e:
+        logger.error(f"[Chat] Auto-compact failed: {e}", exc_info=True)
+        return None
+
+
 @router.post("/message", response_model=ChatResponse)
 async def chat_message(request: ChatRequest) -> Dict[str, Any]:
     """
@@ -138,6 +311,9 @@ async def chat_message(request: ChatRequest) -> Dict[str, Any]:
         # Store messages (use cleaned message for history)
         _store_messages(conversation_id, cleaned_message, response)
 
+        # Auto-compact if token threshold exceeded
+        auto_compact_summary = await _auto_compact_if_needed(conversation_id, config)
+
         # Get model info
         provider = config.get("provider", "unknown")
         model = config.get(provider, {}).get("model", "unknown")
@@ -148,6 +324,10 @@ async def chat_message(request: ChatRequest) -> Dict[str, Any]:
             "model": f"{provider}/{model}",
         }
 
+        # Include auto-compact info if triggered
+        if auto_compact_summary:
+            result["autoCompacted"] = True
+
         # Include context errors if any
         if context_errors:
             result["contextErrors"] = context_errors
@@ -221,6 +401,22 @@ async def chat_stream(request: ChatRequest) -> StreamingResponse:
             # Store messages after streaming complete (use cleaned message)
             _store_messages(conversation_id, cleaned_message, full_response)
 
+            # Check if auto-compact is needed and send status updates
+            session_manager = get_session_manager()
+            session = session_manager.get_session(conversation_id)
+            if session and session.messages:
+                estimated_tokens = _estimate_session_tokens(session.messages)
+                if estimated_tokens > AUTO_COMPACT_TOKEN_THRESHOLD and len(session.messages) > AUTO_COMPACT_KEEP_MESSAGES:
+                    # Send status: compacting in progress
+                    yield f"data: {json.dumps({'status': '대화 컨텍스트 요약 중...', 'icon': 'thinking'})}\n\n"
+
+                    # Auto-compact
+                    auto_compact_summary = await _auto_compact_if_needed(conversation_id, config)
+
+                    # Send status: compact complete
+                    if auto_compact_summary:
+                        yield f"data: {json.dumps({'status': '대화가 자동으로 압축되었습니다.', 'icon': 'check'})}\n\n"
+
             # Send final chunk with conversation ID
             yield f"data: {json.dumps({'content': '', 'done': True, 'conversationId': conversation_id})}\n\n"
 
@@ -237,3 +433,110 @@ async def chat_stream(request: ChatRequest) -> StreamingResponse:
             "X-Accel-Buffering": "no",  # Disable nginx buffering
         },
     )
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Compact Endpoint - LLM-based conversation summarization
+# ═══════════════════════════════════════════════════════════════════════════
+@router.post("/compact", response_model=CompactResponse)
+async def compact_conversation(request: CompactRequest) -> CompactResponse:
+    """
+    Compact conversation history by summarizing older messages.
+
+    Strategy (Claude Code benchmark):
+    - Keep the last 3 messages intact
+    - Summarize all older messages using LLM
+    - Replace history with [summary] + [last 3 messages]
+    """
+    logger.info(f"Compact request for conversation: {request.conversationId}")
+
+    session_manager = get_session_manager()
+    session = session_manager.get_session(request.conversationId)
+
+    if not session:
+        return CompactResponse(
+            success=False,
+            message="세션을 찾을 수 없습니다.",
+            originalMessages=0,
+            compressedMessages=0,
+        )
+
+    original_count = len(session.messages)
+
+    # Already minimal - no compaction needed
+    if original_count <= 3:
+        return CompactResponse(
+            success=True,
+            message="이미 최소 상태입니다. 압축이 필요하지 않습니다.",
+            originalMessages=original_count,
+            compressedMessages=original_count,
+        )
+
+    try:
+        # Split messages: older (to summarize) vs recent (to keep)
+        messages_to_summarize = session.messages[:-3]
+        recent_messages = session.messages[-3:]
+
+        # Build conversation text for summarization
+        conversation_text = "\n".join(
+            [
+                f"{'사용자' if m.role == 'user' else '어시스턴트'}: {m.content}"
+                for m in messages_to_summarize
+            ]
+        )
+
+        # Create summarization LLM
+        llm_config = request.llmConfig or _get_config()
+        summarization_llm = create_summarization_llm(llm_config)
+
+        if not summarization_llm:
+            return CompactResponse(
+                success=False,
+                message="요약용 LLM을 생성할 수 없습니다. API 키를 확인해주세요.",
+                originalMessages=original_count,
+                compressedMessages=original_count,
+            )
+
+        # Generate summary using LLM
+        prompt = SUMMARIZATION_PROMPT.format(conversation=conversation_text)
+        response = await summarization_llm.ainvoke(prompt)
+        summary = response.content if hasattr(response, "content") else str(response)
+
+        # Create summary message
+        from datetime import datetime
+
+        summary_message = ChatMessage(
+            role="assistant",
+            content=f"[이전 대화 요약]\n\n{summary}",
+            timestamp=datetime.now().timestamp(),
+        )
+
+        # Replace session messages: [summary] + [last 3]
+        session.messages = [summary_message] + list(recent_messages)
+        session.updated_at = datetime.now().timestamp()
+
+        # Persist changes
+        session_manager._save_sessions()
+
+        compressed_count = len(session.messages)
+        logger.info(
+            f"Compacted conversation {request.conversationId}: "
+            f"{original_count} -> {compressed_count} messages"
+        )
+
+        return CompactResponse(
+            success=True,
+            message=f"대화가 압축되었습니다. ({original_count}개 → {compressed_count}개 메시지)",
+            originalMessages=original_count,
+            compressedMessages=compressed_count,
+            summary=summary,
+        )
+
+    except Exception as e:
+        logger.error(f"Compact failed: {e}", exc_info=True)
+        return CompactResponse(
+            success=False,
+            message=f"압축 중 오류가 발생했습니다: {str(e)}",
+            originalMessages=original_count,
+            compressedMessages=original_count,
+        )