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

agent_server/langchain/llm_factory.py

@@ -93,7 +93,6 @@ def _create_vllm_llm(llm_config: Dict[str, Any], callbacks):
     from langchain_openai import ChatOpenAI
 
     vllm_config = llm_config.get("vllm", {})
-    # User provides full base URL (e.g., https://openrouter.ai/api/v1)
     endpoint = vllm_config.get("endpoint", "http://localhost:8000/v1")
     model = vllm_config.get("model", "default")
     api_key = vllm_config.get("apiKey", "dummy")
@@ -140,9 +139,11 @@ def _create_vllm_llm(llm_config: Dict[str, Any], callbacks):
 
 
 def create_summarization_llm(llm_config: Dict[str, Any]):
-    """Create LLM for summarization middleware.
+    """Create LLM for summarization middleware and /compact feature.
 
-    Uses the same provider as the main LLM but with simpler configuration.
+    Priority:
+    1. If llm_config["summarization"]["enabled"] is True, use that config
+    2. Otherwise, fall back to main provider with default summarization model
 
     Args:
         llm_config: Configuration dictionary
@@ -150,60 +151,107 @@ def create_summarization_llm(llm_config: Dict[str, Any]):
     Returns:
         LLM instance suitable for summarization, or None if unavailable
     """
-    provider = llm_config.get("provider", "gemini")
-
     try:
-        if provider == "gemini":
-            from langchain_google_genai import ChatGoogleGenerativeAI
-
-            gemini_config = llm_config.get("gemini", {})
-            api_key = gemini_config.get("apiKey")
-            if api_key:
-                return ChatGoogleGenerativeAI(
-                    model="gemini-2.5-flash",
-                    google_api_key=api_key,
-                    temperature=0.0,
-                )
-        elif provider == "openai":
-            from langchain_openai import ChatOpenAI
-
-            openai_config = llm_config.get("openai", {})
-            api_key = openai_config.get("apiKey")
-            if api_key:
-                return ChatOpenAI(
-                    model="gpt-4o-mini",
-                    api_key=api_key,
-                    temperature=0.0,
-                )
-        elif provider == "vllm":
-            vllm_config = llm_config.get("vllm", {})
-            # User provides full base URL (e.g., https://openrouter.ai/api/v1)
-            endpoint = vllm_config.get("endpoint", "http://localhost:8000/v1")
-            model = vllm_config.get("model", "default")
-            api_key = vllm_config.get("apiKey", "dummy")
-
-            # Use ChatGPTOSS for gpt-oss models (but not via OpenRouter)
-            is_openrouter = "openrouter" in endpoint.lower()
-            if "gpt-oss" in model.lower() and not is_openrouter:
-                from agent_server.langchain.models import ChatGPTOSS
-
-                return ChatGPTOSS(
-                    model=model,
-                    base_url=endpoint,
-                    api_key=api_key,
-                    temperature=0.0,
-                )
-
-            from langchain_openai import ChatOpenAI
-
-            return ChatOpenAI(
-                model=model,
-                api_key=api_key,
-                base_url=endpoint,  # Use endpoint as-is
-                temperature=0.0,
+        # 1. Check for dedicated summarization config
+        summarization_config = llm_config.get("summarization", {})
+        if summarization_config.get("enabled"):
+            sum_provider = summarization_config.get("provider", "gemini")
+            sum_model = summarization_config.get("model")
+            logger.info(
+                f"Using dedicated summarization LLM: provider={sum_provider}, model={sum_model or 'default'}"
+            )
+            return _create_llm_for_provider(
+                llm_config, sum_provider, sum_model, for_summarization=True
             )
+
+        # 2. Fall back to main provider with default summarization model
+        provider = llm_config.get("provider", "gemini")
+        logger.info(f"Using main provider for summarization: {provider}")
+        return _create_llm_for_provider(
+            llm_config, provider, None, for_summarization=True
+        )
+
     except Exception as e:
         logger.warning(f"Failed to create summarization LLM: {e}")
         return None
 
-    return None
+
+def _create_llm_for_provider(
+    llm_config: Dict[str, Any],
+    provider: str,
+    model_override: str = None,
+    for_summarization: bool = False,
+):
+    """Create LLM instance for a specific provider.
+
+    Args:
+        llm_config: Full configuration dictionary (for credentials)
+        provider: Provider to use ('gemini', 'openai', 'vllm')
+        model_override: Optional model name override
+        for_summarization: If True, use lightweight default models
+
+    Returns:
+        LLM instance or None
+    """
+    if provider == "gemini":
+        from langchain_google_genai import ChatGoogleGenerativeAI
+
+        gemini_config = llm_config.get("gemini", {})
+        api_key = gemini_config.get("apiKey")
+        if not api_key:
+            logger.warning("No Gemini API key found")
+            return None
+
+        model = model_override or ("gemini-2.5-flash" if for_summarization else gemini_config.get("model", "gemini-2.5-flash"))
+        return ChatGoogleGenerativeAI(
+            model=model,
+            google_api_key=api_key,
+            temperature=0.0,
+        )
+
+    elif provider == "openai":
+        from langchain_openai import ChatOpenAI
+
+        openai_config = llm_config.get("openai", {})
+        api_key = openai_config.get("apiKey")
+        if not api_key:
+            logger.warning("No OpenAI API key found")
+            return None
+
+        model = model_override or ("gpt-4o-mini" if for_summarization else openai_config.get("model", "gpt-4"))
+        return ChatOpenAI(
+            model=model,
+            api_key=api_key,
+            temperature=0.0,
+        )
+
+    elif provider == "vllm":
+        vllm_config = llm_config.get("vllm", {})
+        endpoint = vllm_config.get("endpoint", "http://localhost:8000/v1")
+        api_key = vllm_config.get("apiKey", "dummy")
+        model = model_override or vllm_config.get("model", "default")
+
+        # Use ChatGPTOSS for gpt-oss models (but not via OpenRouter)
+        is_openrouter = "openrouter" in endpoint.lower()
+        if "gpt-oss" in model.lower() and not is_openrouter:
+            from agent_server.langchain.models import ChatGPTOSS
+
+            return ChatGPTOSS(
+                model=model,
+                base_url=endpoint,
+                api_key=api_key,
+                temperature=0.0,
+            )
+
+        from langchain_openai import ChatOpenAI
+
+        return ChatOpenAI(
+            model=model,
+            api_key=api_key,
+            base_url=endpoint,
+            temperature=0.0,
+        )
+
+    else:
+        logger.warning(f"Unknown provider: {provider}")
+        return None

agent_server/langchain/logging_utils.py

@@ -37,7 +37,7 @@ def disable_langchain_logging():
 
 
 # Auto-disable on import (comment this line to re-enable all logs)
-disable_langchain_logging()
+# disable_langchain_logging()  # TEMPORARILY ENABLED FOR DEBUGGING
 
 LOG_SEPARATOR = "=" * 96
 LOG_SUBSECTION = "-" * 96

agent_server/langchain/middleware/__init__.py

@@ -3,10 +3,14 @@ Middleware Module
 
 Custom middleware for the multi-agent architecture:
 - SubAgentMiddleware: Handles subagent delegation via task tool
+- ContentInjectionMiddleware: Injects generated code/SQL into tool args
 - SkillMiddleware: Progressive skill loading for code generation agents
 - Existing middleware from custom_middleware.py is also available
 """
 
+from agent_server.langchain.middleware.content_injection_middleware import (
+    ContentInjectionMiddleware,
+)
 from agent_server.langchain.middleware.skill_middleware import (
     SkillMiddleware,
     get_skill_middleware,
@@ -18,6 +22,7 @@ from agent_server.langchain.middleware.subagent_middleware import (
 
 __all__ = [
     "SubAgentMiddleware",
+    "ContentInjectionMiddleware",
     "create_task_tool",
     "SkillMiddleware",
     "get_skill_middleware",

agent_server/langchain/middleware/content_injection_middleware.py

@@ -0,0 +1,110 @@
+"""
+ContentInjectionMiddleware
+
+Injects generated_content from LangGraph state into target tool args.
+This eliminates JSON escaping issues when passing code/SQL between agents.
+
+Runs BEFORE HumanInTheLoopMiddleware so HITL shows the full injected content.
+
+Flow:
+1. Subagent generates code/SQL → stored in state via Command
+2. Main Agent calls target tool (e.g., jupyter_cell_tool) without args
+3. This middleware reads state and injects content into tool args
+4. HITL middleware sees full content for user approval
+
+content_type → tool injection mapping:
+- "python" → jupyter_cell_tool(code=...), write_file_tool(content=...)
+- "sql"    → markdown_tool(content="```sql\\n...\\n```")
+"""
+
+import logging
+from typing import Any, Callable, Union
+
+from langchain.agents.middleware import AgentMiddleware
+from langchain_core.messages import ToolMessage
+
+logger = logging.getLogger(__name__)
+
+
+class ContentInjectionMiddleware(AgentMiddleware):
+    """Inject state's generated_content into target tool call args.
+
+    When a subagent generates code/SQL via task_tool, it's stored in
+    LangGraph state (generated_content, generated_content_type, content_description).
+    This middleware reads the state and injects the content into the
+    appropriate tool's arguments before execution.
+
+    This ensures:
+    1. Code/SQL bypasses LLM JSON serialization (no escaping issues)
+    2. HITL middleware sees the full injected content for approval
+    3. Main Agent doesn't need to copy code into tool args
+
+    Usage in agent_factory.py:
+        middleware = [
+            ContentInjectionMiddleware(),  # BEFORE HITL
+            ...,
+            hitl_middleware,               # Sees injected content
+        ]
+    """
+
+    def wrap_tool_call(self, request, handler):
+        """Intercept tool calls and inject generated content from state.
+
+        Args:
+            request: ToolCallRequest with tool_call, state, runtime
+            handler: Next handler in middleware chain
+
+        Returns:
+            ToolMessage or Command from handler
+        """
+        state = request.state
+        if not state:
+            return handler(request)
+
+        content = state.get("generated_content") if isinstance(state, dict) else getattr(state, "generated_content", None)
+        content_type = state.get("generated_content_type") if isinstance(state, dict) else getattr(state, "generated_content_type", None)
+        desc = state.get("content_description") if isinstance(state, dict) else getattr(state, "content_description", None)
+
+        if not content or not content_type:
+            return handler(request)
+
+        tool_call = request.tool_call
+        tool_name = tool_call["name"]
+        args = tool_call.get("args", {})
+
+        new_args = None
+
+        # Python code injection
+        if content_type == "python":
+            if tool_name == "jupyter_cell_tool" and not args.get("code"):
+                new_args = {**args, "code": content}
+                if desc and not args.get("description"):
+                    new_args["description"] = desc
+                logger.info(
+                    "[ContentInjection] Injected python code (%d chars) into jupyter_cell_tool",
+                    len(content),
+                )
+            elif tool_name == "write_file_tool" and not args.get("content"):
+                new_args = {**args, "content": content}
+                logger.info(
+                    "[ContentInjection] Injected python code (%d chars) into write_file_tool",
+                    len(content),
+                )
+
+        # SQL query injection
+        elif content_type == "sql":
+            if tool_name == "markdown_tool" and not args.get("content"):
+                sql_markdown = f"```sql\n{content}\n```"
+                if desc:
+                    sql_markdown = f"{desc}\n\n{sql_markdown}"
+                new_args = {**args, "content": sql_markdown}
+                logger.info(
+                    "[ContentInjection] Injected SQL (%d chars) into markdown_tool",
+                    len(content),
+                )
+
+        if new_args is not None:
+            modified_call = {**tool_call, "args": new_args}
+            request = request.override(tool_call=modified_call)
+
+        return handler(request)

agent_server/langchain/middleware/subagent_events.py

@@ -42,35 +42,38 @@ class SubagentEvent:
         """Convert to debug message for UI display (legacy, for logging)."""
         if self.event_type == "subagent_start":
             desc_preview = self.description[:80] + "..." if self.description and len(self.description) > 80 else self.description
-            return f"Subagent - {self.subagent_name} - 작업 시작: {desc_preview}"
+            return f"Subagent-{self.subagent_name} 작업 시작: {desc_preview}"
         elif self.event_type == "subagent_tool_call":
-            return f"Subagent - {self.subagent_name} - Tool 실행: {self.tool_name}"
+            return f"Subagent-{self.subagent_name} Tool 실행: {self.tool_name}"
         elif self.event_type == "subagent_complete":
-            return f"Subagent - {self.subagent_name} - 완료"
+            return f"Subagent-{self.subagent_name} 완료"
         else:
-            return f"Subagent - {self.subagent_name} - {self.event_type}"
+            return f"Subagent-{self.subagent_name} {self.event_type}"
 
     def to_status_dict(self) -> Dict[str, Any]:
         """Convert to status dict with icon for SSE streaming."""
         if self.event_type == "subagent_start":
             desc_preview = self.description[:80] + "..." if self.description and len(self.description) > 80 else self.description
+            full_status = f"Subagent-{self.subagent_name} 작업 시작: {self.description}"
             return {
-                "status": f"Subagent - {self.subagent_name} - 작업 시작: {desc_preview}",
-                "icon": "subagentStart"
+                "status": f"Subagent-{self.subagent_name} 작업 시작: {desc_preview}",
+                "icon": "subagentStart",
+                "expandable": bool(self.description and len(self.description) > 80),
+                "full_text": full_status,
             }
         elif self.event_type == "subagent_tool_call":
             return {
-                "status": f"Subagent - {self.subagent_name} - Tool 실행: {self.tool_name}",
+                "status": f"Subagent-{self.subagent_name} Tool 실행: {self.tool_name}",
                 "icon": "tool"
             }
         elif self.event_type == "subagent_complete":
             return {
-                "status": f"Subagent - {self.subagent_name} - 완료",
+                "status": f"Subagent-{self.subagent_name} 완료",
                 "icon": "subagentComplete"
             }
         else:
             return {
-                "status": f"Subagent - {self.subagent_name} - {self.event_type}",
+                "status": f"Subagent-{self.subagent_name} {self.event_type}",
                 "icon": "info"
             }
 
@@ -169,3 +172,79 @@ def drain_subagent_events() -> List[SubagentEvent]:
 def get_pending_event_count() -> int:
     """Get the number of pending events in the queue."""
     return _event_queue.qsize()
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Summarization Events - For context compression status display
+# ═══════════════════════════════════════════════════════════════════════════
+
+@dataclass
+class SummarizationEvent:
+    """Represents a summarization event for UI display."""
+
+    event_type: str  # summarization_start, summarization_complete
+    message_count_before: Optional[int] = None
+    message_count_after: Optional[int] = None
+    timestamp: datetime = field(default_factory=datetime.now)
+
+    def to_status_dict(self) -> Dict[str, Any]:
+        """Convert to status dict with icon for SSE streaming."""
+        if self.event_type == "summarization_start":
+            return {
+                "status": "대화 컨텍스트 요약 중...",
+                "icon": "thinking"
+            }
+        elif self.event_type == "summarization_complete":
+            if self.message_count_before and self.message_count_after:
+                return {
+                    "status": f"대화가 자동으로 압축되었습니다. ({self.message_count_before} → {self.message_count_after} 메시지)",
+                    "icon": "check"
+                }
+            return {
+                "status": "대화가 자동으로 압축되었습니다.",
+                "icon": "check"
+            }
+        else:
+            return {
+                "status": f"Summarization {self.event_type}",
+                "icon": "info"
+            }
+
+
+# Separate queue for summarization events (to avoid mixing with subagent events)
+_summarization_queue: Queue = Queue()
+
+
+def emit_summarization_start() -> None:
+    """Emit a summarization start event."""
+    event = SummarizationEvent(event_type="summarization_start")
+    _summarization_queue.put(event)
+    logger.info("Summarization event: starting context compression")
+
+
+def emit_summarization_complete(before_count: int = 0, after_count: int = 0) -> None:
+    """Emit a summarization complete event."""
+    event = SummarizationEvent(
+        event_type="summarization_complete",
+        message_count_before=before_count,
+        message_count_after=after_count,
+    )
+    _summarization_queue.put(event)
+    logger.info(f"Summarization event: complete ({before_count} → {after_count} messages)")
+
+
+def drain_summarization_events() -> List[SummarizationEvent]:
+    """
+    Drain all pending summarization events from the queue.
+
+    Returns:
+        List of SummarizationEvent objects
+    """
+    events = []
+    while True:
+        try:
+            event = _summarization_queue.get_nowait()
+            events.append(event)
+        except Empty:
+            break
+    return events