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

agent_server/config/__init__.py

@@ -0,0 +1,5 @@
+"""Agent Server Configuration Module"""
+
+from .server_config import ServerConfigManager, get_server_config_manager
+
+__all__ = ["ServerConfigManager", "get_server_config_manager"]

agent_server/config/server_config.py

@@ -0,0 +1,213 @@
+"""
+Server Configuration Manager - Agent Server specific settings
+
+This config manager handles all LLM and server settings.
+Stored in ~/.hdsp_agent/server_config.json
+
+This is separate from the client-side config which only stores agentServerUrl.
+"""
+
+import json
+import os
+import tempfile
+from pathlib import Path
+from typing import Any, Dict
+
+
+class ServerConfigManager:
+    """Manage Agent Server configuration persistence"""
+
+    _instance = None
+    _config_file = None
+
+    def __init__(self):
+        try:
+            # 1순위: 환경변수
+            config_dir = os.environ.get("HDSP_AGENT_CONFIG_DIR")
+
+            # 2순위: 홈 디렉토리 ~/.hdsp_agent
+            if not config_dir:
+                try:
+                    config_dir = os.path.expanduser("~/.hdsp_agent")
+                except Exception:
+                    config_dir = None
+
+            # 경로가 유효한지 체크하고, 없으면 생성 시도
+            if config_dir:
+                config_path = Path(config_dir)
+                try:
+                    config_path.mkdir(parents=True, exist_ok=True)
+                    self._config_file = config_path / "server_config.json"
+                except Exception as e:
+                    print(f"Warning: Cannot write to {config_dir}: {e}")
+                    self._config_file = None
+
+            # 3순위 (비상용): 쓰기 실패했거나 경로가 없으면 /tmp 사용
+            if not self._config_file:
+                tmp_dir = Path(tempfile.gettempdir()) / "hdsp_agent_server"
+                tmp_dir.mkdir(parents=True, exist_ok=True)
+                self._config_file = tmp_dir / "server_config.json"
+                print(f"Using temporary config path: {self._config_file}")
+
+        except Exception as e:
+            print(f"Critical Error in ServerConfigManager init: {e}")
+            self._config_file = Path("/tmp/hdsp_agent_server_config_fallback.json")
+
+        self._config = self._load_config()
+        print(f"ServerConfigManager initialized: {self._config_file}")
+
+    @classmethod
+    def get_instance(cls):
+        """Get singleton instance"""
+        if cls._instance is None:
+            cls._instance = ServerConfigManager()
+        return cls._instance
+
+    @classmethod
+    def reset_instance(cls):
+        """Reset singleton instance (for testing)"""
+        cls._instance = None
+
+    def _load_config(self) -> Dict[str, Any]:
+        """Load configuration from file"""
+        if not self._config_file.exists():
+            return self._default_config()
+
+        try:
+            with open(self._config_file, "r") as f:
+                loaded = json.load(f)
+                # Merge with defaults to ensure all keys exist
+                defaults = self._default_config()
+                defaults.update(loaded)
+                return defaults
+        except (json.JSONDecodeError, IOError) as e:
+            print(f"Error loading server config: {e}")
+            return self._default_config()
+
+    def _default_config(self) -> Dict[str, Any]:
+        """Get default server configuration"""
+        return {
+            # LLM Provider Settings
+            "provider": "gemini",
+            "gemini": {
+                "apiKey": "",
+                "apiKeys": [],
+                "model": "gemini-2.5-flash"
+            },
+            "openai": {
+                "apiKey": "",
+                "model": "gpt-4o"
+            },
+            "vllm": {
+                "endpoint": "https://openrouter.ai/api/v1",
+                "apiKey": "",
+                "model": "openai/gpt-4o",
+                "useResponsesApi": False
+            },
+            # Summarization LLM
+            "summarization": {
+                "enabled": False,
+                "provider": "gemini",
+                "model": None,
+                "endpoint": "",
+                "apiKey": ""
+            },
+            # Embedding
+            "embedding": {
+                "provider": "openai",
+                "model": "text-embedding-3-small",
+                "apiKey": "",
+                "endpoint": ""
+            },
+            # RAG
+            "rag": {
+                "qdrantUrl": "http://localhost:6333",
+                "collectionName": "hdsp_docs"
+            },
+            # Server Settings
+            "agentServerTimeout": 120.0,
+            "idleTimeout": 3600,  # 1 hour default
+            # Prompts (None = use defaults)
+            "prompts": {
+                "planner": None,
+                "python_developer": None,
+                "researcher": None,
+                "athena_query": None
+            },
+            # Feature Toggles
+            "useResponsesApi": False
+        }
+
+    def get_config(self) -> Dict[str, Any]:
+        """Get current configuration"""
+        self._config = self._load_config()
+        return self._config.copy()
+
+    def save_config(self, config: Dict[str, Any]):
+        """Save configuration to file"""
+        self._config.update(config)
+        self._config_file.parent.mkdir(parents=True, exist_ok=True)
+
+        try:
+            with open(self._config_file, "w") as f:
+                json.dump(self._config, f, indent=2)
+        except IOError as e:
+            raise RuntimeError(f"Failed to save server config: {e}")
+
+    def get(self, key: str, default=None):
+        """Get specific config value"""
+        return self._config.get(key, default)
+
+    def set(self, key: str, value: Any):
+        """Set specific config value"""
+        self._config[key] = value
+        self.save_config(self._config)
+
+    def update_config(self, updates: Dict[str, Any]):
+        """Update configuration with partial updates (deep merge for nested dicts)"""
+        for key, value in updates.items():
+            if (
+                key in self._config
+                and isinstance(self._config[key], dict)
+                and isinstance(value, dict)
+            ):
+                self._config[key].update(value)
+            else:
+                self._config[key] = value
+        self.save_config(self._config)
+
+    def get_admin_config(self) -> Dict[str, Any]:
+        """Get all server configuration (for admin API)"""
+        config = self.get_config()
+        # Return everything except internal keys
+        return config.copy()
+
+    def update_admin_config(self, updates: Dict[str, Any]):
+        """Update server configuration"""
+        self.update_config(updates)
+
+    def get_user_config(self) -> Dict[str, Any]:
+        """Get user configuration.
+
+        NOTE: User preferences (workspaceRoot, autoApprove) are now stored
+        in browser localStorage. This method returns defaults for backward
+        compatibility with the API.
+        """
+        return {
+            "workspaceRoot": "",
+            "temperature": 0.7,
+            "autoApprove": False
+        }
+
+    def update_user_config(self, updates: Dict[str, Any]):
+        """Update user configuration.
+
+        NOTE: User preferences are stored in browser localStorage.
+        This is a no-op for backward compatibility.
+        """
+        pass  # No-op: user config is in localStorage
+
+
+def get_server_config_manager() -> ServerConfigManager:
+    """Get the singleton ServerConfigManager instance"""
+    return ServerConfigManager.get_instance()

agent_server/core/__init__.py

@@ -2,7 +2,7 @@
 Core services for HDSP Agent Server
 """
 
-from hdsp_agent_core.managers.config_manager import ConfigManager
+from agent_server.config import ServerConfigManager
 from hdsp_agent_core.managers.session_manager import (
     ChatMessage,
     Session,
@@ -47,7 +47,7 @@ from .state_verifier import (
 from .summary_generator import SummaryGenerator, TaskType, get_summary_generator
 
 __all__ = [
-    "ConfigManager",
+    "ServerConfigManager",
     "LLMClient",
     "LLMService",
     "PromptBuilder",

agent_server/core/llm_service.py

@@ -28,11 +28,10 @@ class LLMService:
             return self._key_manager
         if self.provider == "gemini":
             try:
-                from hdsp_agent_core.managers.config_manager import ConfigManager
-
+                from agent_server.config import ServerConfigManager
                 from agent_server.core.api_key_manager import get_key_manager
 
-                return get_key_manager(ConfigManager.get_instance())
+                return get_key_manager(ServerConfigManager.get_instance())
             except ImportError:
                 # Fallback for standalone usage
                 return None

agent_server/main.py

@@ -95,12 +95,12 @@ async def _legacy_startup():
     logger.info("Using legacy startup (hdsp_agent_core not available)")
 
     try:
-        from hdsp_agent_core.managers.config_manager import ConfigManager
+        from agent_server.config import ServerConfigManager
 
-        ConfigManager.get_instance()
-        logger.info("Configuration loaded successfully")
+        ServerConfigManager.get_instance()
+        logger.info("Server configuration loaded successfully")
     except Exception as e:
-        logger.warning(f"Failed to load configuration: {e}")
+        logger.warning(f"Failed to load server configuration: {e}")
 
     # Initialize RAG system
     try:

agent_server/routers/agent.py

@@ -11,7 +11,7 @@ from typing import Any, Dict, List
 
 from fastapi import APIRouter, HTTPException
 from hdsp_agent_core.knowledge.loader import get_knowledge_base, get_library_detector
-from hdsp_agent_core.managers.config_manager import ConfigManager
+from agent_server.config import ServerConfigManager
 from hdsp_agent_core.models.agent import (
     PlanRequest,
     PlanResponse,
@@ -49,7 +49,7 @@ logger = logging.getLogger(__name__)
 
 def _get_config() -> Dict[str, Any]:
     """Get current configuration (fallback only)"""
-    return ConfigManager.get_instance().get_config()
+    return ServerConfigManager.get_instance().get_config()
 
 
 def _build_llm_config(llm_config) -> Dict[str, Any]:

agent_server/routers/chat.py

@@ -12,7 +12,7 @@ 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 agent_server.config import ServerConfigManager
 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
@@ -105,39 +105,42 @@ logger = logging.getLogger(__name__)
 
 
 def _get_config() -> Dict[str, Any]:
-    """Get current configuration (fallback only)"""
-    return ConfigManager.get_instance().get_config()
+    """Get current configuration from server AdminConfig."""
+    return ServerConfigManager.get_instance().get_admin_config()
 
 
 def _build_llm_config(llm_config) -> Dict[str, Any]:
     """
-    Build LLM config dict from client-provided LLMConfig.
-    Falls back to server config if not provided.
+    Get LLM config from server AdminConfig.
+
+    NOTE: Client-provided llmConfig is IGNORED for LLM settings.
+    All LLM configuration (provider, API keys, models) comes from
+    the server's AdminConfig managed by administrators.
+
+    Args:
+        llm_config: Ignored (kept for backward compatibility)
+
+    Returns:
+        Dict with provider, gemini, openai, vllm from server config
     """
-    if llm_config is None:
-        return _get_config()
+    # Always use server config - ignore client-provided config
+    admin_config = ServerConfigManager.get_instance().get_admin_config()
 
-    config = {"provider": llm_config.provider}
+    config = {"provider": admin_config.get("provider", "gemini")}
 
-    if llm_config.gemini:
-        config["gemini"] = {
-            "apiKey": llm_config.gemini.apiKey,
-            "model": llm_config.gemini.model,
-        }
+    if admin_config.get("gemini"):
+        config["gemini"] = admin_config["gemini"]
 
-    if llm_config.openai:
-        config["openai"] = {
-            "apiKey": llm_config.openai.apiKey,
-            "model": llm_config.openai.model,
-        }
+    if admin_config.get("openai"):
+        config["openai"] = admin_config["openai"]
 
-    if llm_config.vllm:
-        config["vllm"] = {
-            "endpoint": llm_config.vllm.endpoint,
-            "apiKey": llm_config.vllm.apiKey,
-            "model": llm_config.vllm.model,
-        }
+    if admin_config.get("vllm"):
+        config["vllm"] = admin_config["vllm"]
+
+    if admin_config.get("summarization"):
+        config["summarization"] = admin_config["summarization"]
 
+    logger.info("Using LLM config from server AdminConfig: provider=%s", config.get("provider"))
     return config
 
 
@@ -274,7 +277,7 @@ async def chat_message(request: ChatRequest) -> Dict[str, Any]:
         if not config or not config.get("provider"):
             raise HTTPException(
                 status_code=400,
-                detail="LLM not configured. Please provide llmConfig with API keys.",
+                detail="LLM not configured. Please configure LLM settings in Admin panel.",
             )
 
         # Get or create conversation
@@ -360,7 +363,7 @@ async def chat_stream(request: ChatRequest) -> StreamingResponse:
             config = _build_llm_config(request.llmConfig)
 
             if not config or not config.get("provider"):
-                yield f"data: {json.dumps({'error': 'LLM not configured. Please provide llmConfig with API keys.'})}\n\n"
+                yield f"data: {json.dumps({'error': 'LLM not configured. Please configure LLM settings in Admin panel.'})}\n\n"
                 return
 
             # Get or create conversation
@@ -485,8 +488,8 @@ async def compact_conversation(request: CompactRequest) -> CompactResponse:
             ]
         )
 
-        # Create summarization LLM
-        llm_config = request.llmConfig or _get_config()
+        # Create summarization LLM (always use server config)
+        llm_config = _get_config()
         summarization_llm = create_summarization_llm(llm_config)
 
         if not summarization_llm:

agent_server/routers/config.py

@@ -12,9 +12,10 @@ Provides:
 from typing import Any, Dict, Optional
 
 from fastapi import APIRouter, HTTPException
-from hdsp_agent_core.managers.config_manager import ConfigManager
 from pydantic import BaseModel
 
+from agent_server.config import ServerConfigManager
+
 from agent_server.langchain.agent_prompts.athena_query_prompt import (
     ATHENA_QUERY_SYSTEM_PROMPT,
 )
@@ -67,7 +68,7 @@ async def get_config() -> ConfigResponse:
     Returns the current LLM provider settings (API keys are masked).
     """
     try:
-        config_manager = ConfigManager.get_instance()
+        config_manager = ServerConfigManager.get_instance()
         config = config_manager.get_config()
 
         # Mask API keys for security
@@ -91,7 +92,7 @@ async def update_config(request: ConfigUpdateRequest) -> Dict[str, Any]:
     Updates LLM provider settings.
     """
     try:
-        config_manager = ConfigManager.get_instance()
+        config_manager = ServerConfigManager.get_instance()
 
         # Build update dict from request
         updates = {}
@@ -162,7 +163,7 @@ async def get_admin_config() -> AdminConfigResponse:
     API keys are masked for security.
     """
     try:
-        config_manager = ConfigManager.get_instance()
+        config_manager = ServerConfigManager.get_instance()
         config = config_manager.get_admin_config()
 
         # Mask API keys
@@ -207,7 +208,7 @@ async def update_admin_config(request: AdminConfigUpdateRequest) -> Dict[str, An
     Only updates provided fields.
     """
     try:
-        config_manager = ConfigManager.get_instance()
+        config_manager = ServerConfigManager.get_instance()
 
         # Build update dict from request
         updates = {}
@@ -255,7 +256,7 @@ async def get_user_config() -> UserConfigResponse:
     Get user configuration (preferences).
     """
     try:
-        config_manager = ConfigManager.get_instance()
+        config_manager = ServerConfigManager.get_instance()
         config = config_manager.get_user_config()
 
         return UserConfigResponse(
@@ -275,7 +276,7 @@ async def update_user_config(request: UserConfigUpdateRequest) -> Dict[str, Any]
     Only updates provided fields.
     """
     try:
-        config_manager = ConfigManager.get_instance()
+        config_manager = ServerConfigManager.get_instance()
 
         # Build update dict from request
         updates = {}

agent_server/routers/langchain_agent.py

@@ -34,8 +34,70 @@ from agent_server.langchain.middleware.subagent_events import (
     drain_subagent_events,
     drain_summarization_events,
 )
+from agent_server.config import ServerConfigManager
 
 logger = logging.getLogger(__name__)
+
+
+def _get_llm_config_from_server() -> Dict[str, Any]:
+    """
+    Load LLM configuration from server's AdminConfig.
+
+    This replaces client-provided llmConfig - all LLM settings now come from
+    the server configuration managed by administrators.
+
+    Returns:
+        Dict with provider, gemini, openai, vllm, prompts, etc.
+    """
+    config_manager = ServerConfigManager.get_instance()
+    admin_config = config_manager.get_admin_config()
+
+    config_dict = {
+        "provider": admin_config.get("provider", "gemini"),
+    }
+
+    # Copy LLM provider configs
+    if admin_config.get("gemini"):
+        config_dict["gemini"] = admin_config["gemini"]
+    if admin_config.get("openai"):
+        config_dict["openai"] = admin_config["openai"]
+    if admin_config.get("vllm"):
+        config_dict["vllm"] = admin_config["vllm"]
+    if admin_config.get("summarization"):
+        config_dict["summarization"] = admin_config["summarization"]
+
+    logger.info(
+        "Loaded LLM config from server: provider=%s",
+        config_dict.get("provider")
+    )
+    return config_dict
+
+
+def _get_agent_prompts_from_server() -> Optional[Dict[str, str]]:
+    """
+    Load agent prompts from server's AdminConfig.
+
+    Returns:
+        Dict with planner, python_developer, researcher, athena_query prompts
+        or None if not configured.
+    """
+    config_manager = ServerConfigManager.get_instance()
+    admin_config = config_manager.get_admin_config()
+
+    prompts = admin_config.get("prompts", {})
+    if not prompts:
+        return None
+
+    agent_prompts = {
+        "planner": prompts.get("planner"),
+        "python_developer": prompts.get("python_developer"),
+        "researcher": prompts.get("researcher"),
+        "athena_query": prompts.get("athena_query"),
+    }
+    # Filter out None values
+    agent_prompts = {k: v for k, v in agent_prompts.items() if v}
+
+    return agent_prompts if agent_prompts else None
 router = APIRouter(prefix="/langchain", tags=["langchain-agent"])
 
 # Track cancelled thread IDs to stop ongoing executions
@@ -737,35 +799,24 @@ async def stream_agent(request: AgentRequest):
 
     async def event_generator():
         try:
-            # Use simple agent with HITL
-            provider = request.llmConfig.provider if request.llmConfig else "gemini"
+            # Load LLM config from server (not from client request)
+            config_dict = _get_llm_config_from_server()
+            provider = config_dict.get("provider", "gemini")
             model_name = None
-            if request.llmConfig:
-                if request.llmConfig.gemini:
-                    model_name = request.llmConfig.gemini.get("model")
-                elif request.llmConfig.openai:
-                    model_name = request.llmConfig.openai.get("model")
-                elif request.llmConfig.vllm:
-                    model_name = request.llmConfig.vllm.get("model")
-            logger.info("SimpleAgent LLM provider=%s model=%s", provider, model_name)
-            # Convert LLMConfig to dict
-            config_dict = {
-                "provider": request.llmConfig.provider
-                if request.llmConfig
-                else "gemini",
-            }
-            if request.llmConfig:
-                if request.llmConfig.gemini:
-                    config_dict["gemini"] = request.llmConfig.gemini
-                if request.llmConfig.openai:
-                    config_dict["openai"] = request.llmConfig.openai
-                if request.llmConfig.vllm:
-                    config_dict["vllm"] = request.llmConfig.vllm
-                if request.llmConfig.resource_context:
-                    config_dict["resource_context"] = request.llmConfig.resource_context
-            system_prompt_override = (
-                request.llmConfig.system_prompt if request.llmConfig else None
-            )
+            if config_dict.get("gemini"):
+                model_name = config_dict["gemini"].get("model")
+            elif config_dict.get("openai"):
+                model_name = config_dict["openai"].get("model")
+            elif config_dict.get("vllm"):
+                model_name = config_dict["vllm"].get("model")
+            logger.info("SimpleAgent LLM provider=%s model=%s (from server config)", provider, model_name)
+
+            # resource_context can still come from client if provided
+            if request.llmConfig and request.llmConfig.resource_context:
+                config_dict["resource_context"] = request.llmConfig.resource_context
+
+            # system_prompt_override is no longer used from client
+            system_prompt_override = None
 
             # Get or create checkpointer for this thread
             is_existing_thread = thread_id in _simple_agent_checkpointers
@@ -790,20 +841,11 @@ async def stream_agent(request: AgentRequest):
 
             resolved_workspace_root = _resolve_workspace_root(request.workspaceRoot)
 
-            # Get agent prompts for per-agent customization
-            agent_prompts = None
-            if request.llmConfig and request.llmConfig.agent_prompts:
-                agent_prompts = {
-                    "planner": request.llmConfig.agent_prompts.planner,
-                    "python_developer": (
-                        request.llmConfig.agent_prompts.python_developer
-                    ),
-                    "researcher": request.llmConfig.agent_prompts.researcher,
-                    "athena_query": request.llmConfig.agent_prompts.athena_query,
-                }
-                agent_prompts = {k: v for k, v in agent_prompts.items() if v}
+            # Get agent prompts from server config
+            agent_prompts = _get_agent_prompts_from_server()
+            if agent_prompts:
                 logger.info(
-                    "Using agentPrompts (%s)",
+                    "Using agentPrompts from server config (%s)",
                     list(agent_prompts.keys()),
                 )
             # Don't use systemPrompt as override — use agentPrompts.planner instead
@@ -2110,24 +2152,16 @@ async def resume_agent(request: ResumeRequest):
 
     async def event_generator():
         try:
-            # Convert LLMConfig to dict
-            config_dict = {
-                "provider": request.llmConfig.provider
-                if request.llmConfig
-                else "gemini",
-            }
-            if request.llmConfig:
-                if request.llmConfig.gemini:
-                    config_dict["gemini"] = request.llmConfig.gemini
-                if request.llmConfig.openai:
-                    config_dict["openai"] = request.llmConfig.openai
-                if request.llmConfig.vllm:
-                    config_dict["vllm"] = request.llmConfig.vllm
-                if request.llmConfig.resource_context:
-                    config_dict["resource_context"] = request.llmConfig.resource_context
-            system_prompt_override = (
-                request.llmConfig.system_prompt if request.llmConfig else None
-            )
+            # Load LLM config from server (not from client request)
+            config_dict = _get_llm_config_from_server()
+
+            # resource_context can still come from client if provided
+            if request.llmConfig and request.llmConfig.resource_context:
+                config_dict["resource_context"] = request.llmConfig.resource_context
+
+            # system_prompt_override is no longer used from client
+            system_prompt_override = None
+
             # Get or create cached agent
             resolved_workspace_root = _resolve_workspace_root(request.workspaceRoot)
 
@@ -2153,29 +2187,13 @@ async def resume_agent(request: ResumeRequest):
 
             checkpointer = _simple_agent_checkpointers.get(request.threadId)
 
-            # Get agent prompts for per-agent customization
-            agent_prompts = None
-            if request.llmConfig and request.llmConfig.agent_prompts:
-                agent_prompts = {
-                    "planner": request.llmConfig.agent_prompts.planner,
-                    "python_developer": (
-                        request.llmConfig.agent_prompts.python_developer
-                    ),
-                    "researcher": request.llmConfig.agent_prompts.researcher,
-                    "athena_query": request.llmConfig.agent_prompts.athena_query,
-                }
-                agent_prompts = {k: v for k, v in agent_prompts.items() if v}
+            # Get agent prompts from server config
+            agent_prompts = _get_agent_prompts_from_server()
+            if agent_prompts:
                 logger.info(
-                    "Resume: Using agentPrompts (%s)",
+                    "Resume: Using agentPrompts from server config (%s)",
                     list(agent_prompts.keys()),
                 )
-            # Don't use systemPrompt as override — use agentPrompts.planner instead
-            if system_prompt_override:
-                logger.info(
-                    "Resume: Ignoring systemPrompt (len=%d)",
-                    len(system_prompt_override),
-                )
-                system_prompt_override = None
 
             agent_cache_key = _get_agent_cache_key(
                 llm_config=config_dict,