hdsp-jupyter-extension 2.0.5__py3-none-any.whl → 2.0.7__py3-none-any.whl

agent_server/langchain/executors/notebook_searcher.py

@@ -22,6 +22,7 @@ logger = logging.getLogger(__name__)
 @dataclass
 class SearchMatch:
     """Single search match result"""
+
     file_path: str
     cell_index: Optional[int] = None
     cell_type: Optional[str] = None
@@ -47,6 +48,7 @@ class SearchMatch:
 @dataclass
 class SearchResults:
     """Collection of search results"""
+
     query: str
     total_matches: int
     files_searched: int
@@ -66,14 +68,14 @@ class SearchResults:
 class NotebookSearcher:
     """
     Searches notebooks and workspace files for patterns.
-    
+
     Features:
     - Search across all files in workspace
     - Search within specific notebooks
     - Filter by cell type (code/markdown)
     - Regex or literal text matching
     - Context lines around matches
-    
+
     Usage:
         searcher = NotebookSearcher(workspace_root="/path/to/workspace")
         results = searcher.search_workspace("import pandas")
@@ -137,7 +139,7 @@ class NotebookSearcher:
         end = min(len(lines), line_idx + context_lines + 1)
 
         before = "\n".join(lines[start:line_idx])
-        after = "\n".join(lines[line_idx + 1:end])
+        after = "\n".join(lines[line_idx + 1 : end])
 
         return before, after
 
@@ -153,7 +155,7 @@ class NotebookSearcher:
     ) -> SearchResults:
         """
         Search within a specific notebook.
-        
+
         Args:
             notebook_path: Path to notebook (relative to workspace)
             pattern: Search pattern
@@ -162,7 +164,7 @@ class NotebookSearcher:
             is_regex: Treat pattern as regex
             max_results: Maximum matches to return
             context_lines: Context lines around matches
-            
+
         Returns:
             SearchResults with matches
         """
@@ -200,16 +202,18 @@ class NotebookSearcher:
                 if compiled.search(line):
                     before, after = self._get_context(lines, line_idx, context_lines)
 
-                    matches.append(SearchMatch(
-                        file_path=notebook_path,
-                        cell_index=idx,
-                        cell_type=current_type,
-                        line_number=line_idx + 1,
-                        content=line.strip()[:200],
-                        context_before=before[:100],
-                        context_after=after[:100],
-                        match_type="line",
-                    ))
+                    matches.append(
+                        SearchMatch(
+                            file_path=notebook_path,
+                            cell_index=idx,
+                            cell_type=current_type,
+                            line_number=line_idx + 1,
+                            content=line.strip()[:200],
+                            context_before=before[:100],
+                            context_after=after[:100],
+                            match_type="line",
+                        )
+                    )
 
                     if len(matches) >= max_results:
                         break
@@ -238,7 +242,7 @@ class NotebookSearcher:
     ) -> SearchResults:
         """
         Search across workspace files.
-        
+
         Args:
             pattern: Search pattern
             file_patterns: File glob patterns to include (e.g., ["*.py", "*.ipynb"])
@@ -248,7 +252,7 @@ class NotebookSearcher:
             max_results: Maximum matches to return
             include_notebooks: Search in .ipynb files
             include_python: Search in .py files
-            
+
         Returns:
             SearchResults with matches
         """
@@ -335,14 +339,16 @@ class NotebookSearcher:
                     if line_idx < len(lines) - 1:
                         after = lines[line_idx + 1].strip()[:100]
 
-                    matches.append(SearchMatch(
-                        file_path=rel_path,
-                        line_number=line_idx + 1,
-                        content=line.strip()[:200],
-                        context_before=before,
-                        context_after=after,
-                        match_type="line",
-                    ))
+                    matches.append(
+                        SearchMatch(
+                            file_path=rel_path,
+                            line_number=line_idx + 1,
+                            content=line.strip()[:200],
+                            context_before=before,
+                            context_after=after,
+                            match_type="line",
+                        )
+                    )
 
                     if len(matches) >= max_results:
                         break
@@ -360,14 +366,14 @@ class NotebookSearcher:
     ) -> List[Dict[str, Any]]:
         """
         Search cells in the current notebook.
-        
+
         Convenience method for quick cell search in active notebook.
-        
+
         Args:
             notebook_path: Current notebook path
             pattern: Search pattern
             cell_type: Optional cell type filter
-            
+
         Returns:
             List of matching cells with their indices and content
         """
@@ -390,22 +396,24 @@ class NotebookSearcher:
                     "matching_lines": [],
                 }
 
-            cells_by_index[idx]["matching_lines"].append({
-                "line_number": match.line_number,
-                "content": match.content,
-            })
+            cells_by_index[idx]["matching_lines"].append(
+                {
+                    "line_number": match.line_number,
+                    "content": match.content,
+                }
+            )
 
         return list(cells_by_index.values())
 
     def get_notebook_structure(self, notebook_path: str) -> Dict[str, Any]:
         """
         Get structural overview of a notebook.
-        
+
         Returns information about cells, imports, and defined symbols.
-        
+
         Args:
             notebook_path: Path to notebook
-            
+
         Returns:
             Dict with notebook structure information
         """
@@ -420,9 +428,9 @@ class NotebookSearcher:
         imports = set()
         definitions = set()
 
-        import_pattern = re.compile(r'^(?:import|from)\s+([\w.]+)', re.MULTILINE)
-        def_pattern = re.compile(r'^(?:def|class)\s+(\w+)', re.MULTILINE)
-        var_pattern = re.compile(r'^(\w+)\s*=', re.MULTILINE)
+        import_pattern = re.compile(r"^(?:import|from)\s+([\w.]+)", re.MULTILINE)
+        def_pattern = re.compile(r"^(?:def|class)\s+(\w+)", re.MULTILINE)
+        var_pattern = re.compile(r"^(\w+)\s*=", re.MULTILINE)
 
         for idx, cell in enumerate(cells):
             cell_type = cell.get("cell_type", "code")

agent_server/langchain/hitl_config.py

@@ -0,0 +1,66 @@
+"""
+Human-in-the-Loop (HITL) configuration for LangChain agent.
+
+Defines which tools require user approval and their approval settings.
+"""
+
+from typing import Any, Dict
+
+
+def get_hitl_interrupt_config() -> Dict[str, Any]:
+    """Return HITL interrupt config for client-side tool execution.
+
+    Returns:
+        Dictionary mapping tool names to their HITL configuration:
+        - False: No approval needed, execute immediately
+        - Dict with allowed_decisions and description: Require approval
+
+    The allowed_decisions can include:
+        - "approve": Execute the tool as requested
+        - "edit": Modify the tool arguments before execution
+        - "reject": Cancel the tool execution
+    """
+    return {
+        # Require approval before executing code
+        "jupyter_cell_tool": {
+            "allowed_decisions": ["approve", "edit", "reject"],
+            "description": "🔍 Code execution requires approval",
+        },
+        # Safe operations - no approval needed
+        "markdown_tool": False,
+        "read_file_tool": {
+            "allowed_decisions": ["approve", "edit"],
+            "description": "📄 파일 읽기 실행 중",
+        },
+        "list_files_tool": {
+            "allowed_decisions": ["approve", "edit"],
+            "description": "📂 파일 목록 조회 중",
+        },
+        "write_todos": False,  # Todo updates don't need approval
+        # Search tools need HITL for client-side execution (auto-approved by frontend)
+        # Uses 'edit' decision to pass execution_result back
+        "search_workspace_tool": {
+            "allowed_decisions": ["approve", "edit"],
+            "description": "🔍 Searching workspace files",
+        },
+        "search_notebook_cells_tool": {
+            "allowed_decisions": ["approve", "edit"],
+            "description": "🔍 Searching notebook cells",
+        },
+        # Resource check tool for client-side execution (auto-approved by frontend)
+        "check_resource_tool": {
+            "allowed_decisions": ["approve", "edit"],
+            "description": "📊 Checking system resources",
+        },
+        "execute_command_tool": {
+            "allowed_decisions": ["approve", "edit", "reject"],
+            "description": "🖥️ Shell command requires approval",
+        },
+        # File write requires approval
+        "write_file_tool": {
+            "allowed_decisions": ["approve", "edit", "reject"],
+            "description": "⚠️ File write requires approval",
+        },
+        # Final answer doesn't need approval
+        "final_answer_tool": False,
+    }

agent_server/langchain/llm_factory.py

@@ -0,0 +1,166 @@
+"""
+LLM Factory for LangChain agent.
+
+Provides functions to create LangChain LLM instances from configuration.
+"""
+
+import logging
+from typing import Any, Dict
+
+from agent_server.langchain.logging_utils import LLMTraceLogger
+
+logger = logging.getLogger(__name__)
+
+
+def create_llm(llm_config: Dict[str, Any]):
+    """Create LangChain LLM from config.
+
+    Args:
+        llm_config: Configuration dictionary containing:
+            - provider: "gemini", "openai", or "vllm"
+            - gemini: {apiKey, model} for Gemini
+            - openai: {apiKey, model} for OpenAI
+            - vllm: {endpoint, model, apiKey} for vLLM
+
+    Returns:
+        Configured LangChain LLM instance
+
+    Raises:
+        ValueError: If provider is unsupported or API key is missing
+    """
+    provider = llm_config.get("provider", "gemini")
+    callbacks = [LLMTraceLogger()]
+
+    if provider == "gemini":
+        return _create_gemini_llm(llm_config, callbacks)
+    elif provider == "openai":
+        return _create_openai_llm(llm_config, callbacks)
+    elif provider == "vllm":
+        return _create_vllm_llm(llm_config, callbacks)
+    else:
+        raise ValueError(f"Unsupported LLM provider: {provider}")
+
+
+def _create_gemini_llm(llm_config: Dict[str, Any], callbacks):
+    """Create Gemini LLM instance."""
+    from langchain_google_genai import ChatGoogleGenerativeAI
+
+    gemini_config = llm_config.get("gemini", {})
+    api_key = gemini_config.get("apiKey")
+    model = gemini_config.get("model", "gemini-2.5-pro")
+
+    if not api_key:
+        raise ValueError("Gemini API key not configured")
+
+    logger.info(f"Creating Gemini LLM with model: {model}")
+
+    # Gemini 2.5 Flash has issues with tool calling in LangChain
+    # Use convert_system_message_to_human for better compatibility
+    return ChatGoogleGenerativeAI(
+        model=model,
+        google_api_key=api_key,
+        temperature=0.0,
+        max_output_tokens=8192,
+        convert_system_message_to_human=True,  # Better tool calling support
+        callbacks=callbacks,
+    )
+
+
+def _create_openai_llm(llm_config: Dict[str, Any], callbacks):
+    """Create OpenAI LLM instance."""
+    from langchain_openai import ChatOpenAI
+
+    openai_config = llm_config.get("openai", {})
+    api_key = openai_config.get("apiKey")
+    model = openai_config.get("model", "gpt-4")
+
+    if not api_key:
+        raise ValueError("OpenAI API key not configured")
+
+    logger.info(f"Creating OpenAI LLM with model: {model}")
+
+    return ChatOpenAI(
+        model=model,
+        api_key=api_key,
+        temperature=0.0,
+        max_tokens=4096,
+        callbacks=callbacks,
+    )
+
+
+def _create_vllm_llm(llm_config: Dict[str, Any], callbacks):
+    """Create vLLM-compatible LLM instance."""
+    from langchain_openai import ChatOpenAI
+
+    vllm_config = llm_config.get("vllm", {})
+    endpoint = vllm_config.get("endpoint", "http://localhost:8000")
+    model = vllm_config.get("model", "default")
+    api_key = vllm_config.get("apiKey", "dummy")
+
+    logger.info(f"Creating vLLM LLM with model: {model}, endpoint: {endpoint}")
+
+    return ChatOpenAI(
+        model=model,
+        api_key=api_key,
+        base_url=f"{endpoint}/v1",
+        temperature=0.0,
+        max_tokens=4096,
+        callbacks=callbacks,
+    )
+
+
+def create_summarization_llm(llm_config: Dict[str, Any]):
+    """Create LLM for summarization middleware.
+
+    Uses the same provider as the main LLM but with simpler configuration.
+
+    Args:
+        llm_config: Configuration dictionary
+
+    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":
+            from langchain_openai import ChatOpenAI
+
+            vllm_config = llm_config.get("vllm", {})
+            endpoint = vllm_config.get("endpoint", "http://localhost:8000")
+            model = vllm_config.get("model", "default")
+            api_key = vllm_config.get("apiKey", "dummy")
+
+            return ChatOpenAI(
+                model=model,
+                api_key=api_key,
+                base_url=f"{endpoint}/v1",
+                temperature=0.0,
+            )
+    except Exception as e:
+        logger.warning(f"Failed to create summarization LLM: {e}")
+        return None
+
+    return None

agent_server/langchain/logging_utils.py

@@ -0,0 +1,184 @@
+"""
+Logging utilities for LangChain agent.
+
+Provides helper functions for structured logging of LLM interactions,
+messages, and middleware execution.
+"""
+
+import json
+import logging
+from functools import wraps
+from typing import Any, Dict
+
+from langchain_core.callbacks import BaseCallbackHandler
+
+logger = logging.getLogger(__name__)
+
+LOG_SEPARATOR = "=" * 96
+LOG_SUBSECTION = "-" * 96
+
+
+def _format_system_prompt_for_log(messages) -> tuple[int, int, str]:
+    """Extract and format system messages for logging."""
+    from langchain_core.messages import SystemMessage
+
+    system_contents = [
+        str(getattr(msg, "content", ""))
+        for msg in messages
+        if isinstance(msg, SystemMessage)
+    ]
+    combined = "\n\n".join(system_contents)
+    return len(system_contents), len(combined), combined
+
+
+def _pretty_json(value: Any) -> str:
+    """Format value as pretty-printed JSON."""
+    try:
+        return json.dumps(value, indent=2, ensure_ascii=False, sort_keys=True)
+    except TypeError:
+        return json.dumps(str(value), indent=2, ensure_ascii=False)
+
+
+def _serialize_message(message) -> Dict[str, Any]:
+    """Serialize a LangChain message to a dictionary."""
+    data: Dict[str, Any] = {"type": message.__class__.__name__}
+    content = getattr(message, "content", None)
+    if content is not None:
+        data["content"] = content
+    name = getattr(message, "name", None)
+    if name:
+        data["name"] = name
+    tool_call_id = getattr(message, "tool_call_id", None)
+    if tool_call_id:
+        data["tool_call_id"] = tool_call_id
+    tool_calls = getattr(message, "tool_calls", None)
+    if tool_calls:
+        data["tool_calls"] = tool_calls
+    additional_kwargs = getattr(message, "additional_kwargs", None)
+    if additional_kwargs:
+        data["additional_kwargs"] = additional_kwargs
+    response_metadata = getattr(message, "response_metadata", None)
+    if response_metadata:
+        data["response_metadata"] = response_metadata
+    return data
+
+
+def _format_messages_block(title: str, messages) -> str:
+    """Format a list of messages as a log block."""
+    lines = [LOG_SEPARATOR, title, LOG_SEPARATOR]
+    if not messages:
+        lines.append("<empty>")
+        lines.append(LOG_SEPARATOR)
+        return "\n".join(lines)
+
+    for idx, message in enumerate(messages):
+        lines.append(f"[{idx}] {message.__class__.__name__}")
+        lines.append(_pretty_json(_serialize_message(message)))
+        if idx < len(messages) - 1:
+            lines.append(LOG_SUBSECTION)
+    lines.append(LOG_SEPARATOR)
+    return "\n".join(lines)
+
+
+def _format_json_block(title: str, payload: Any) -> str:
+    """Format a JSON payload as a log block."""
+    return "\n".join(
+        [
+            LOG_SEPARATOR,
+            title,
+            LOG_SEPARATOR,
+            _pretty_json(payload),
+            LOG_SEPARATOR,
+        ]
+    )
+
+
+def _format_middleware_marker(name: str, stage: str) -> str:
+    """Format a middleware execution marker."""
+    return "\n".join([LOG_SEPARATOR, f"MIDDLEWARE {stage}: {name}", LOG_SEPARATOR])
+
+
+def _with_middleware_logging(name: str):
+    """Decorator to add logging around middleware execution."""
+
+    def decorator(func):
+        @wraps(func)
+        def wrapped(request, handler):
+            logger.info("%s", _format_middleware_marker(name, "START"))
+            response = func(request, handler)
+            logger.info("%s", _format_middleware_marker(name, "END"))
+            return response
+
+        return wrapped
+
+    return decorator
+
+
+class LLMTraceLogger(BaseCallbackHandler):
+    """Log prompts, responses, tool calls, and tool messages."""
+
+    def _normalize_batches(self, messages):
+        if not messages:
+            return []
+        if isinstance(messages[0], (list, tuple)):
+            return messages
+        return [messages]
+
+    def _log_prompt_batches(self, title: str, messages) -> None:
+        for batch_idx, batch in enumerate(self._normalize_batches(messages)):
+            header = f"{title} (batch={batch_idx}, messages={len(batch)})"
+            logger.info("%s", _format_messages_block(header, batch))
+
+            tool_messages = [
+                msg
+                for msg in batch
+                if getattr(msg, "type", "") == "tool"
+                or msg.__class__.__name__ == "ToolMessage"
+            ]
+            if tool_messages:
+                tool_header = f"{title} TOOL MESSAGES (batch={batch_idx})"
+                logger.info("%s", _format_messages_block(tool_header, tool_messages))
+
+    def on_chat_model_start(self, serialized, messages, **kwargs) -> None:
+        if not messages:
+            logger.info(
+                "%s",
+                _format_messages_block("AGENT -> LLM PROMPT (<none>)", []),
+            )
+            return
+        self._log_prompt_batches("AGENT -> LLM PROMPT", messages)
+
+    def on_chat_model_end(self, response, **kwargs) -> None:
+        generations = getattr(response, "generations", None) or []
+        if generations and isinstance(generations[0], list):
+            batches = generations
+        else:
+            batches = [generations]
+
+        for batch_idx, batch in enumerate(batches):
+            for gen_idx, generation in enumerate(batch):
+                message = getattr(generation, "message", None)
+                if not message:
+                    continue
+
+                title = (
+                    f"LLM -> AGENT RESPONSE (batch={batch_idx}, generation={gen_idx})"
+                )
+                logger.info("%s", _format_messages_block(title, [message]))
+
+                tool_calls = getattr(message, "tool_calls", None)
+                if tool_calls:
+                    tool_title = (
+                        "LLM -> AGENT TOOL CALLS "
+                        f"(batch={batch_idx}, generation={gen_idx})"
+                    )
+                    logger.info("%s", _format_json_block(tool_title, tool_calls))
+
+    def on_llm_start(self, serialized, prompts, **kwargs) -> None:
+        if not prompts:
+            logger.info("%s", _format_json_block("LLM PROMPT (<none>)", ""))
+            return
+
+        for idx, prompt in enumerate(prompts):
+            title = f"LLM PROMPT (batch={idx}, length={len(prompt)})"
+            logger.info("%s", _format_json_block(title, prompt))