优化

Author: CJackHwang

README.md

@@ -71,7 +71,7 @@ graph TD
 
     subgraph "核心应用 (Core Application)"
         FastAPI_App["api_utils/app.py (FastAPI 应用)"]
-        Routes["api_utils/routes.py (路由处理)"]
+        Routes["api_utils/routers/* (路由处理)"]
         RequestProcessor["api_utils/request_processor.py (请求处理)"]
         AuthUtils["api_utils/auth_utils.py (认证管理)"]
         PageController["browser_utils/page_controller.py (页面控制)"]

api_utils/__init__.py

@@ -8,19 +8,19 @@
     create_app
 )
 
-# 路由处理器
-from .routes import (
-    read_index,
-    get_css,
-    get_js,
-    get_api_info,
-    health_check,
-    list_models,
-    chat_completions,
-    cancel_request,
-    get_queue_status,
-    websocket_log_endpoint
-)
+# 路由处理器（改为从 routers 聚合导入）
+from .routers import (
+    read_index,
+    get_css,
+    get_js,
+    get_api_info,
+    health_check,
+    list_models,
+    chat_completions,
+    cancel_request,
+    get_queue_status,
+    websocket_log_endpoint
+)
 
 # 工具函数
 from .utils import (
@@ -75,4 +75,4 @@
     '_process_request_refactored',
     # 队列工作器
     'queue_worker'
-] 
+] 

api_utils/app.py

@@ -18,7 +18,7 @@
 from playwright.async_api import Browser as AsyncBrowser, Playwright as AsyncPlaywright
 
 # --- FIX: Replaced star import with explicit imports ---
-from config import NO_PROXY_ENV, EXCLUDED_MODELS_FILENAME
+from config import NO_PROXY_ENV, EXCLUDED_MODELS_FILENAME, get_environment_variable
 
 # --- models模块导入 ---
 from models import WebSocketConnectionManager
@@ -70,10 +70,10 @@
 STREAM_PROCESS = None
 
 # --- Lifespan Context Manager ---
-def _setup_logging():
-    import server
-    log_level_env = os.environ.get('SERVER_LOG_LEVEL', 'INFO')
-    redirect_print_env = os.environ.get('SERVER_REDIRECT_PRINT', 'false')
+def _setup_logging():
+    import server
+    log_level_env = get_environment_variable('SERVER_LOG_LEVEL', 'INFO')
+    redirect_print_env = get_environment_variable('SERVER_REDIRECT_PRINT', 'false')
     server.log_ws_manager = WebSocketConnectionManager()
     return setup_server_logging(
         logger_instance=server.logger,
@@ -91,11 +91,11 @@ def _initialize_globals():
     auth_utils.initialize_keys()
     server.logger.info("API keys and global locks initialized.")
 
-def _initialize_proxy_settings():
-    import server
-    STREAM_PORT = os.environ.get('STREAM_PORT')
+def _initialize_proxy_settings():
+    import server
+    STREAM_PORT = get_environment_variable('STREAM_PORT')
     if STREAM_PORT == '0':
-        PROXY_SERVER_ENV = os.environ.get('HTTPS_PROXY') or os.environ.get('HTTP_PROXY')
+        PROXY_SERVER_ENV = get_environment_variable('HTTPS_PROXY') or get_environment_variable('HTTP_PROXY')
     else:
         PROXY_SERVER_ENV = f"http://127.0.0.1:{STREAM_PORT or 3120}/"
 
@@ -109,10 +109,14 @@ def _initialize_proxy_settings():
 
 async def _start_stream_proxy():
     import server
-    STREAM_PORT = os.environ.get('STREAM_PORT')
+    STREAM_PORT = get_environment_variable('STREAM_PORT')
     if STREAM_PORT != '0':
         port = int(STREAM_PORT or 3120)
-        STREAM_PROXY_SERVER_ENV = os.environ.get('UNIFIED_PROXY_CONFIG') or os.environ.get('HTTPS_PROXY') or os.environ.get('HTTP_PROXY')
+        STREAM_PROXY_SERVER_ENV = (
+            get_environment_variable('UNIFIED_PROXY_CONFIG')
+            or get_environment_variable('HTTPS_PROXY')
+            or get_environment_variable('HTTP_PROXY')
+        )
         server.logger.info(f"Starting STREAM proxy on port {port} with upstream proxy: {STREAM_PROXY_SERVER_ENV}")
         server.STREAM_QUEUE = multiprocessing.Queue()
         server.STREAM_PROCESS = multiprocessing.Process(target=stream.start, args=(server.STREAM_QUEUE, port, STREAM_PROXY_SERVER_ENV))
@@ -141,8 +145,8 @@ async def _initialize_browser_and_page():
     server.is_playwright_ready = True
     server.logger.info("Playwright started.")
 
-    ws_endpoint = os.environ.get('CAMOUFOX_WS_ENDPOINT')
-    launch_mode = os.environ.get('LAUNCH_MODE', 'unknown')
+    ws_endpoint = get_environment_variable('CAMOUFOX_WS_ENDPOINT')
+    launch_mode = get_environment_variable('LAUNCH_MODE', 'unknown')
 
     if not ws_endpoint and launch_mode != "direct_debug_no_browser":
         raise ValueError("CAMOUFOX_WS_ENDPOINT environment variable is missing.")
@@ -213,7 +217,7 @@ async def lifespan(app: FastAPI):
         await _start_stream_proxy()
         await _initialize_browser_and_page()
 
-        launch_mode = os.environ.get('LAUNCH_MODE', 'unknown')
+        launch_mode = get_environment_variable('LAUNCH_MODE', 'unknown')
         if server.is_page_ready or launch_mode == "direct_debug_no_browser":
             server.worker_task = asyncio.create_task(queue_worker())
             logger.info("Request processing worker started.")
@@ -300,12 +304,13 @@ def create_app() -> FastAPI:
     app.add_middleware(APIKeyAuthMiddleware)
 
     # 注册路由
-    from .routes import (
-        read_index, get_css, get_js, get_api_info,
-        health_check, list_models, chat_completions,
-        cancel_request, get_queue_status, websocket_log_endpoint,
-        get_api_keys, add_api_key, test_api_key, delete_api_key
-    )
+    # Import aggregated modular routers
+    from .routers import (
+        read_index, get_css, get_js, get_api_info,
+        health_check, list_models, chat_completions,
+        cancel_request, get_queue_status, websocket_log_endpoint,
+        get_api_keys, add_api_key, test_api_key, delete_api_key
+    )
     from fastapi.responses import FileResponse
 
     app.get("/", response_class=FileResponse)(read_index)
@@ -325,4 +330,4 @@ def create_app() -> FastAPI:
     app.post("/api/keys/test")(test_api_key)
     app.delete("/api/keys")(delete_api_key)
 
-    return app
+    return app

api_utils/error_utils.py

@@ -0,0 +1,37 @@
+from fastapi import HTTPException
+from typing import Optional, Dict
+
+
+def http_error(status_code: int, detail: str, headers: Optional[Dict[str, str]] = None) -> HTTPException:
+    return HTTPException(status_code=status_code, detail=detail, headers=headers or None)
+
+
+def client_cancelled(req_id: str, message: str = "Request cancelled.") -> HTTPException:
+    return http_error(499, f"[{req_id}] {message}")
+
+
+def client_disconnected(req_id: str, stage: str = "") -> HTTPException:
+    suffix = f" during {stage}" if stage else ""
+    return http_error(499, f"[{req_id}] Client disconnected{suffix}.")
+
+
+def processing_timeout(req_id: str, message: str = "Processing timed out.") -> HTTPException:
+    return http_error(504, f"[{req_id}] {message}")
+
+
+def bad_request(req_id: str, message: str) -> HTTPException:
+    return http_error(400, f"[{req_id}] {message}")
+
+
+def server_error(req_id: str, message: str) -> HTTPException:
+    return http_error(500, f"[{req_id}] {message}")
+
+
+def upstream_error(req_id: str, message: str) -> HTTPException:
+    # 502 Bad Gateway for upstream/playwright failures
+    return http_error(502, f"[{req_id}] {message}")
+
+
+def service_unavailable(req_id: str, retry_after_seconds: int = 30) -> HTTPException:
+    return http_error(503, f"[{req_id}] 服务当前不可用。请稍后重试。", headers={"Retry-After": str(retry_after_seconds)})
+

api_utils/mcp_adapter.py

@@ -0,0 +1,85 @@
+import json
+import os
+from typing import Dict, Any
+import asyncio
+
+import httpx
+
+
+def _normalize_endpoint(ep: str) -> str:
+    if not ep:
+        raise RuntimeError('MCP HTTP endpoint not provided')
+    return ep.rstrip('/')
+
+
+async def execute_mcp_tool(name: str, params: Dict[str, Any]) -> str:
+    """
+    Minimal MCP-over-HTTP adapter:
+    - POST {MCP_HTTP_ENDPOINT}/tools/execute with {name, arguments}
+    - Returns JSON string.
+    Compatible with servers exposing MCP-like HTTP interface.
+    """
+    ep = os.environ.get('MCP_HTTP_ENDPOINT')
+    if not ep:
+        raise RuntimeError('MCP_HTTP_ENDPOINT not configured')
+    url = f"{_normalize_endpoint(ep)}/tools/execute"
+    payload = {"name": name, "arguments": params}
+    headers = {"Content-Type": "application/json"}
+    timeout = float(os.environ.get('MCP_HTTP_TIMEOUT', '15'))
+    async with httpx.AsyncClient(timeout=timeout) as client:
+        resp = await client.post(url, json=payload, headers=headers)
+        resp.raise_for_status()
+        try:
+            data = resp.json()
+        except Exception:
+            data = {"raw": resp.text}
+    return json.dumps(data, ensure_ascii=False)
+
+
+async def execute_mcp_tool_with_endpoint(endpoint: str, name: str, params: Dict[str, Any]) -> str:
+    url = f"{_normalize_endpoint(endpoint)}/tools/execute"
+    payload = {"name": name, "arguments": params}
+    headers = {"Content-Type": "application/json"}
+    timeout = float(os.environ.get('MCP_HTTP_TIMEOUT', '15'))
+    async with httpx.AsyncClient(timeout=timeout) as client:
+        resp = await client.post(url, json=payload, headers=headers)
+        resp.raise_for_status()
+        try:
+            data = resp.json()
+        except Exception:
+            data = {"raw": resp.text}
+    return json.dumps(data, ensure_ascii=False)
+
+
+# Synchronous helpers for use inside threads
+def execute_mcp_tool_sync(name: str, params: Dict[str, Any]) -> str:
+    ep = os.environ.get('MCP_HTTP_ENDPOINT')
+    if not ep:
+        raise RuntimeError('MCP_HTTP_ENDPOINT not configured')
+    url = f"{_normalize_endpoint(ep)}/tools/execute"
+    payload = {"name": name, "arguments": params}
+    headers = {"Content-Type": "application/json"}
+    timeout = float(os.environ.get('MCP_HTTP_TIMEOUT', '15'))
+    with httpx.Client(timeout=timeout) as client:
+        resp = client.post(url, json=payload, headers=headers)
+        resp.raise_for_status()
+        try:
+            data = resp.json()
+        except Exception:
+            data = {"raw": resp.text}
+    return json.dumps(data, ensure_ascii=False)
+
+
+def execute_mcp_tool_with_endpoint_sync(endpoint: str, name: str, params: Dict[str, Any]) -> str:
+    url = f"{_normalize_endpoint(endpoint)}/tools/execute"
+    payload = {"name": name, "arguments": params}
+    headers = {"Content-Type": "application/json"}
+    timeout = float(os.environ.get('MCP_HTTP_TIMEOUT', '15'))
+    with httpx.Client(timeout=timeout) as client:
+        resp = client.post(url, json=payload, headers=headers)
+        resp.raise_for_status()
+        try:
+            data = resp.json()
+        except Exception:
+            data = {"raw": resp.text}
+    return json.dumps(data, ensure_ascii=False)

api_utils/model_switching.py

@@ -17,10 +17,8 @@ async def analyze_model_requirements(req_id: str, context: RequestContext, reque
         if parsed_model_list:
             valid_model_ids = [m.get("id") for m in parsed_model_list]
             if requested_model_id not in valid_model_ids:
-                raise HTTPException(
-                    status_code=400,
-                    detail=f"[{req_id}] Invalid model '{requested_model_id}'. Available models: {', '.join(valid_model_ids)}",
-                )
+                from .error_utils import bad_request
+                raise bad_request(req_id, f"Invalid model '{requested_model_id}'. Available models: {', '.join(valid_model_ids)}")
 
         context['model_id_to_use'] = requested_model_id
         if current_ai_studio_model_id != requested_model_id:
@@ -60,7 +58,8 @@ async def _handle_model_switch_failure(req_id: str, page: AsyncPage, model_id_to
     import server
     logger.warning(f"[{req_id}] ❌ 模型切换至 {model_id_to_use} 失败。")
     server.current_ai_studio_model_id = model_before_switch
-    raise HTTPException(status_code=422, detail=f"[{req_id}] 未能切换到模型 '{model_id_to_use}'。请确保模型可用。")
+    from .error_utils import http_error
+    raise http_error(422, f"[{req_id}] 未能切换到模型 '{model_id_to_use}'。请确保模型可用。")
 
 
 async def handle_parameter_cache(req_id: str, context: RequestContext) -> None:
@@ -76,4 +75,3 @@ async def handle_parameter_cache(req_id: str, context: RequestContext) -> None:
             logger.info(f"[{req_id}] 模型已更改，参数缓存失效。")
             page_params_cache.clear()
             page_params_cache["last_known_model_id_for_params"] = current_ai_studio_model_id
-

api_utils/page_response.py

@@ -18,7 +18,8 @@ async def locate_response_elements(page: AsyncPage, req_id: str, logger, check_c
         await expect_async(response_element).to_be_attached(timeout=90000)
         logger.info(f"[{req_id}] 响应元素已定位。")
     except (PlaywrightAsyncError, asyncio.TimeoutError) as locate_err:
-        raise HTTPException(status_code=502, detail=f"[{req_id}] 定位AI Studio响应元素失败: {locate_err}")
+        from .error_utils import upstream_error
+        raise upstream_error(req_id, f"定位AI Studio响应元素失败: {locate_err}")
     except Exception as locate_exc:
-        raise HTTPException(status_code=500, detail=f"[{req_id}] 定位响应元素时意外错误: {locate_exc}")
-
+        from .error_utils import server_error
+        raise server_error(req_id, f"定位响应元素时意外错误: {locate_exc}")