bohr-agent-sdk 0.1.101__py3-none-any.whl → 0.1.102__py3-none-any.whl

dp/agent/cli/templates/ui/api/websocket.py

@@ -0,0 +1,184 @@
+# WebSocket endpoint handler
+import os
+from fastapi import WebSocket
+from fastapi.websockets import WebSocketDisconnect
+
+from server.utils import get_ak_info_from_request
+from server.session_manager import SessionManager
+from api.projects import verify_user_project
+from bohrium_open_sdk import OpenSDK
+
+# Global session manager
+manager = SessionManager()
+
+
+async def websocket_endpoint(websocket: WebSocket):
+    # Extract access_key and app_key from headers
+    access_key, app_key = get_ak_info_from_request(websocket.headers)
+    
+    await manager.connect_client(websocket, access_key, app_key)
+    
+    # Get connection context
+    context = manager.active_connections.get(websocket)
+    if not context:
+        await websocket.close()
+        return
+    
+    # Try to get project_id from environment variable (for development)
+    env_project_id = os.environ.get('BOHR_PROJECT_ID')
+    if env_project_id and not context.project_id:
+        try:
+            project_id_int = int(env_project_id)
+            
+            # Verify project_id (but allow usage in development mode)
+            is_valid = await verify_user_project(access_key, project_id_int)
+            
+            context.project_id = project_id_int
+            # Notify frontend that project_id has been set
+            await websocket.send_json({
+                "type": "project_id_set",
+                "project_id": context.project_id,
+                "content": f"Project ID 已从环境变量设置为: {context.project_id} (开发模式)"
+            })
+        except ValueError:
+            pass
+        
+    try:
+        while True:
+            data = await websocket.receive_json()
+            message_type = data.get("type")
+            
+            if message_type == "message":
+                content = data.get("content", "").strip()
+                attachments = data.get("attachments", [])
+                if content or attachments:
+                    await manager.process_message(context, content, attachments)
+                    
+            elif message_type == "create_session":
+                # Create new session
+                session = await manager.create_session(context)
+                await manager.switch_session(context, session.id)
+                await manager.send_sessions_list(context)
+                await manager.send_session_messages(context, session.id)
+                
+            elif message_type == "switch_session":
+                # Switch session
+                session_id = data.get("session_id")
+                if session_id and await manager.switch_session(context, session_id):
+                    # Send updated session list (with new current_session_id)
+                    await manager.send_sessions_list(context)
+                    # Send message history for new session
+                    await manager.send_session_messages(context, session_id)
+                else:
+                    await websocket.send_json({
+                        "type": "error",
+                        "content": "会话不存在"
+                    })
+                    
+            elif message_type == "get_sessions":
+                # Get session list
+                await manager.send_sessions_list(context)
+                
+            elif message_type == "delete_session":
+                # Delete session
+                session_id = data.get("session_id")
+                if session_id:
+                    # Track if deleting current session
+                    is_current_session = (session_id == context.current_session_id)
+                    
+                    success = await manager.delete_session(context, session_id)
+                    if success:
+                        # If deleted current session, switch to another session
+                        if is_current_session:
+                            # Get remaining sessions list
+                            user_identifier = context.get_user_identifier()
+                            session_service = manager.session_services.get(user_identifier)
+                            
+                            if session_service:
+                                response = await session_service.list_sessions(
+                                    app_name=manager.app_name,
+                                    user_id=user_identifier
+                                )
+                                remaining_sessions = response.sessions if hasattr(response, 'sessions') else []
+                                
+                                if remaining_sessions:
+                                    # Switch to first (most recent) session
+                                    # Sort by last update time
+                                    remaining_sessions.sort(
+                                        key=lambda s: manager._get_session_last_update_time(s),
+                                        reverse=True
+                                    )
+                                    new_session_id = remaining_sessions[0].id
+                                    await manager.switch_session(context, new_session_id)
+                                    # Send message history for new session
+                                    await manager.send_session_messages(context, new_session_id)
+                                else:
+                                    # If no sessions left, create new one
+                                    session = await manager.create_session(context)
+                                    await manager.switch_session(context, session.id)
+                                    # New session has no message history, send empty list
+                                    await websocket.send_json({
+                                        "type": "session_messages",
+                                        "session_id": session.id,
+                                        "messages": []
+                                    })
+                        
+                        # Send updated session list (with current session ID)
+                        await manager.send_sessions_list(context)
+                    else:
+                        await websocket.send_json({
+                            "type": "error",
+                            "content": "删除会话失败"
+                        })
+                else:
+                    await websocket.send_json({
+                        "type": "error",
+                        "content": "删除会话失败"
+                    })
+                    
+            elif message_type == "set_project_id":
+                # Set project_id
+                project_id = data.get("project_id")
+                if project_id is not None:
+                    try:
+                        # Ensure project_id is integer
+                        project_id_int = int(project_id)
+                        
+                        # Commented out project_id validation, allow users to set any project_id
+                        # is_valid = await verify_user_project(access_key, project_id_int)
+                        # 
+                        # if not is_valid:
+                        #     await websocket.send_json({
+                        #         "type": "error",
+                        #         "content": f"您没有权限使用项目 ID: {project_id_int}。请从项目列表中选择您有权限的项目。"
+                        #     })
+                        #     return
+                        
+                        # Validation passed, set project_id
+                        context.project_id = project_id_int
+                        
+                        # Only reinitialize runner for current session
+                        if context.current_session_id:
+                            # Reinitialize runner through SessionManager
+                            user_identifier = context.get_user_identifier()
+                            runner_key = f"{user_identifier}_{context.current_session_id}"
+                            if runner_key in manager.runners:
+                                del manager.runners[runner_key]
+                            # Reinitialize
+                            await manager._init_runner(context, context.current_session_id)
+                        
+                        await websocket.send_json({
+                            "type": "project_id_set",
+                            "project_id": context.project_id,
+                            "content": f"Project ID 已设置为: {context.project_id}"
+                        })
+                    except ValueError:
+                        await websocket.send_json({
+                            "type": "error",
+                            "content": f"无效的 Project ID: {project_id}，必须是整数"
+                        })
+                
+    except WebSocketDisconnect:
+        await manager.disconnect_client(websocket)
+    except Exception as e:
+        await manager.disconnect_client(websocket)

dp/agent/cli/templates/ui/config/__init__.py

@@ -0,0 +1 @@
+# 配置模块

dp/agent/cli/templates/ui/config/agent_config.py

@@ -0,0 +1,257 @@
+"""
+Agent Configuration Loader
+
+This module provides a centralized configuration system for different agent implementations.
+To switch between different agents, modify the agent-config.json file.
+"""
+
+import json
+import os
+import sys
+import logging
+from pathlib import Path
+from typing import Dict, Any
+import importlib
+import importlib.util
+
+# 配置日志输出到文件
+# 使用相对于项目根目录的路径或环境变量配置
+log_file_path = os.environ.get('WEBSOCKET_LOG_PATH', './websocket.log')
+# 只在没有配置过的情况下配置
+if not logging.getLogger().handlers:
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.FileHandler(log_file_path, encoding='utf-8', mode='a'),
+            logging.StreamHandler()  # 同时输出到控制台
+        ]
+    )
+logger = logging.getLogger(__name__)
+
+class AgentConfig:
+    def __init__(self, config_path: str = None):
+        # 优先使用环境变量中的配置路径
+        if config_path is None:
+            env_path = os.environ.get('AGENT_CONFIG_PATH', 'config/agent-config.json')
+            self.config_path = Path(env_path)
+        else:
+            self.config_path = Path(config_path)
+        
+        self.config = self._load_config()
+        
+    def _load_config(self) -> Dict[str, Any]:
+        """Load configuration from JSON file"""
+        logger.info(f"📦 加载配置文件: {self.config_path}")
+        
+        if not self.config_path.exists():
+            logger.warning(f"⚠️ 配置文件不存在: {self.config_path}")
+            logger.info("🔄 使用默认配置")
+            # Fallback to default config if file doesn't exist
+            return self._get_default_config()
+        
+        try:
+            with open(self.config_path, 'r', encoding='utf-8') as f:
+                config = json.load(f)
+                logger.info("✅ 配置文件加载成功")
+                logger.debug(f"  Agent名称: {config.get('agent', {}).get('name')}")
+                logger.debug(f"  Agent模块: {config.get('agent', {}).get('module')}")
+                logger.debug(f"  Root Agent: {config.get('agent', {}).get('rootAgent')}")
+                return config
+        except json.JSONDecodeError as e:
+            logger.error(f"❌ JSON解析错误: {e}")
+            logger.info("🔄 使用默认配置")
+            return self._get_default_config()
+        except Exception as e:
+            logger.error(f"❌ 读取配置文件失败: {e}")
+            logger.info("🔄 使用默认配置")
+            return self._get_default_config()
+    
+    def _get_default_config(self) -> Dict[str, Any]:
+        """Provide default configuration for Agent"""
+        # 使用环境变量提供的端口，如果没有则使用默认值
+        default_port = int(os.environ.get('AGENT_SERVER_PORT', '50002'))
+        
+        return {
+            "agent": {
+                "name": "My Agent",
+                "description": "Agent",
+                "welcomeMessage": "welcome to chat with me",
+                "module": "agent.subagent",
+                "rootAgent": "rootagent"
+            },
+            "ui": {
+                "title": "Agent",
+                "features": {
+                    "showFileExplorer": True,
+                    "showSessionList": True
+                }
+            },
+            "files": {
+                "watchDirectories": ["./output"]
+            },
+            "server": {
+                "host": ["localhost", "127.0.0.1"],
+                "port": default_port
+            }
+        }
+    
+    def get_agent(self, ak: str = None, app_key: str = None, project_id: int = None):
+        """Dynamically import and return the configured agent
+        
+        Args:
+            ak: Optional access key to pass to the agent
+            app_key: Optional app key to pass to the agent
+            project_id: Optional project ID to pass to the agent
+        """
+        agentconfig = self.config.get("agent", {})
+        module_path = agentconfig.get("module", "agent.subagent")
+        agentname = agentconfig.get("rootAgent", "rootagent")
+        
+        logger.info(f"🤖 加载 Agent")
+        logger.debug(f"  模块路径: {module_path}")
+        logger.debug(f"  Agent名称: {agentname}")
+        logger.debug(f"  AK: {'有' if ak else '无'}")
+        logger.debug(f"  App Key: {'有' if app_key else '无'}")
+        logger.debug(f"  Project ID: {project_id}")
+        
+        try:
+            # 检查是否是文件路径（包含 / 或 \ 或以 .py 结尾）
+            if '/' in module_path or '\\' in module_path or module_path.endswith('.py'):
+                # 作为文件路径处理
+                file_path = Path(module_path)
+                
+                # 如果是相对路径，基于用户工作目录解析
+                if not file_path.is_absolute():
+                    user_working_dir = os.environ.get('USER_WORKING_DIR', os.getcwd())
+                    file_path = Path(user_working_dir) / file_path
+                
+                logger.debug(f"  解析文件路径: {file_path}")
+                
+                # 确保文件存在
+                if not file_path.exists():
+                    logger.error(f"❌ Agent模块文件不存在: {file_path}")
+                    raise ImportError(f"Agent module file not found: {file_path}")
+                
+                logger.info(f"📄 从文件加载: {file_path}")
+                
+                # 从文件路径创建唯一的模块名，包含路径信息避免冲突
+                # 例如: /path/to/agent.py -> path_to_agent
+                module_name = str(file_path).replace('/', '_').replace('\\', '_').replace('.py', '').replace('.', '_')
+                # 确保模块名是有效的 Python 标识符
+                module_name = 'agent_' + module_name.strip('_')
+                
+                # 使用 importlib.util 从文件加载模块
+                spec = importlib.util.spec_from_file_location(module_name, str(file_path))
+                if spec is None or spec.loader is None:
+                    raise ImportError(f"Cannot load module from file: {file_path}")
+                
+                module = importlib.util.module_from_spec(spec)
+                sys.modules[module_name] = module  # 可选：将模块添加到 sys.modules
+                spec.loader.exec_module(module)
+                logger.info(f"✅ 模块加载成功: {module_name}")
+            else:
+                # 作为模块路径处理（原有逻辑）
+                logger.debug(f"  作为 Python模块导入: {module_path}")
+                module = importlib.import_module(module_path)
+                logger.info(f"✅ 模块导入成功: {module_path}")
+            
+            # 检查是否有 create_agent 函数（推荐的方式）
+            if hasattr(module, 'create_agent'):
+                logger.info("🔧 使用 create_agent 函数创建 Agent")
+                # 使用工厂函数创建新的 agent 实例
+                # 检查函数接受哪些参数
+                import inspect
+                sig = inspect.signature(module.create_agent)
+                params = {}
+                
+                # 只传递函数签名中存在的参数
+                if 'ak' in sig.parameters:
+                    params['ak'] = ak
+                if 'app_key' in sig.parameters:
+                    params['app_key'] = app_key
+                if 'project_id' in sig.parameters:
+                    params['project_id'] = project_id
+                
+                agent = module.create_agent(**params)
+                logger.info(f"✅ Agent 创建成功: {type(agent).__name__}")
+                return agent
+            else:
+                # 后向兼容：直接返回模块级别的 agent
+                logger.info(f"🔍 查找模块属性: {agentname}")
+                if hasattr(module, agentname):
+                    agent = getattr(module, agentname)
+                    logger.info(f"✅ 找到 Agent: {type(agent).__name__}")
+                    return agent
+                else:
+                    logger.error(f"❌ 模块 {module_path} 中没有找到 {agentname}")
+                    logger.debug(f"  可用属性: {dir(module)}")
+                    raise AttributeError(f"模块 {module_path} 中没有 {agentname}")
+        except ImportError as e:
+            logger.error(f"❌ 导入错误: {e}")
+            raise ImportError(f"Failed to load agent {agentname} from {module_path}: {e}")
+        except AttributeError as e:
+            logger.error(f"❌ 属性错误: {e}")
+            raise AttributeError(f"Failed to load agent {agentname} from {module_path}: {e}")
+        except Exception as e:
+            logger.error(f"❌ 未知错误: {e}")
+            raise Exception(f"Failed to load agent {agentname} from {module_path}: {e}")
+    
+    def get_ui_config(self) -> Dict[str, Any]:
+        """Get UI-specific configuration"""
+        return self.config.get("ui", {})
+    
+    def get_files_config(self) -> Dict[str, Any]:
+        """Get file handling configuration"""
+        return self.config.get("files", {})
+    
+    def get_websocket_config(self) -> Dict[str, Any]:
+        """Get WebSocket configuration"""
+        return self.config.get("websocket", {})
+    
+    def get_tool_display_name(self, tool_name: str) -> str:
+        """Get display name for a tool"""
+        tools_config = self.config.get("tools", {})
+        display_names = tools_config.get("displayNames", {})
+        return display_names.get(tool_name, tool_name)
+    
+    def is_long_running_tool(self, tool_name: str) -> bool:
+        """Check if a tool is marked as long-running"""
+        tools_config = self.config.get("tools", {})
+        long_running = tools_config.get("longRunningTools", [])
+        return tool_name in long_running
+    
+    def get_server_config(self) -> Dict[str, Any]:
+        """Get server configuration including port and allowed hosts"""
+        # 默认主机始终被允许
+        default_hosts = ["localhost", "127.0.0.1", "0.0.0.0"]
+        
+        server_config = self.config.get("server", {})
+        
+        # 支持 "host" 字段（用户配置）和 "allowedHosts"（向后兼容）
+        user_hosts = server_config.get("host", server_config.get("allowedHosts", []))
+        
+        # 确保 user_hosts 是列表
+        if isinstance(user_hosts, str):
+            user_hosts = [user_hosts]
+        elif not isinstance(user_hosts, list):
+            user_hosts = []
+        
+        # 如果用户配置了 "*"，则允许所有主机
+        if "*" in user_hosts:
+            all_hosts = ["*"]
+        else:
+            # 合并默认主机和用户定义的额外主机
+            all_hosts = list(set(default_hosts + user_hosts))  # 使用 set 去重
+        
+        # 使用环境变量或配置的端口，最后使用默认端口
+        default_port = int(os.environ.get('AGENT_SERVER_PORT', '50002'))
+        port = server_config.get("port", default_port)
+        
+        return {
+            "port": port,
+            "allowedHosts": all_hosts
+        }
+
+# Singleton instance
+agentconfig = AgentConfig()

dp/agent/cli/templates/ui/frontend/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/nexus-icon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Agent UI</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

dp/agent/cli/templates/ui/frontend/package.json

@@ -0,0 +1,46 @@
+{
+    "name": "bohr-agent-ui",
+    "version": "1.0.0",
+    "description": "Beautiful UI for Bohr Agent SDK",
+    "private": true,
+    "dependencies": {
+      "@tailwindcss/typography": "^0.5.10",
+      "axios": "^1.6.2",
+      "classnames": "^2.3.2",
+      "clsx": "^2.1.1",
+      "date-fns": "^2.30.0",
+      "framer-motion": "^10.16.0",
+      "html-react-parser": "^4.2.10",
+      "lucide-react": "^0.292.0",
+      "react": "^18.2.0",
+      "react-dom": "^18.2.0",
+      "react-markdown": "^9.0.1",
+      "react-router-dom": "^6.20.0",
+      "react-syntax-highlighter": "^15.5.0",
+      "remark-gfm": "^4.0.0",
+      "socket.io-client": "^4.5.4",
+      "zustand": "^5.0.6"
+    },
+    "devDependencies": {
+      "@types/dompurify": "^3.0.5",
+      "@types/node": "^24.1.0",
+      "@types/react": "^18.2.0",
+      "@types/react-dom": "^18.2.0",
+      "@types/react-syntax-highlighter": "^15.5.11",
+      "@vitejs/plugin-react": "^4.2.0",
+      "autoprefixer": "^10.4.16",
+      "less": "^4.4.0",
+      "postcss": "^8.4.32",
+      "tailwindcss": "^3.3.6",
+      "typescript": "^5.3.0",
+      "vite": "^5.0.0"
+    },
+    "scripts": {
+      "dev": "vite",
+      "build": "tsc && vite build",
+      "preview": "vite preview",
+      "type-check": "tsc --noEmit"
+    }
+  }
+
+  

dp/agent/cli/templates/ui/frontend/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

dp/agent/cli/templates/ui/frontend/tsconfig.node.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["vite.config.ts"]
+}