yapi-mcp 0.1.2__tar.gz → 0.1.4__tar.gz

{yapi_mcp-0.1.2 → yapi_mcp-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yapi-mcp
-Version: 0.1.2
+Version: 0.1.4
 Summary: Model Context Protocol server for YApi 1.12.0 API management platform
 Project-URL: Homepage, https://github.com/geq1fan/yapi-mcp
 Project-URL: Repository, https://github.com/geq1fan/yapi-mcp
@@ -20,6 +20,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
 Requires-Dist: fastmcp>=2.0.0
 Requires-Dist: httpx>=0.27.0
+Requires-Dist: markdown>=3.5.0
 Requires-Dist: pydantic-settings>=2.0.0
 Provides-Extra: dev
 Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'

{yapi_mcp-0.1.2 → yapi_mcp-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yapi-mcp"
-version = "0.1.2"
+version = "0.1.4"
 description = "Model Context Protocol server for YApi 1.12.0 API management platform"
 authors = [{ name = "YApi MCP Team" }]
 readme = "README.md"
@@ -21,6 +21,7 @@ dependencies = [
     "fastmcp>=2.0.0",
     "httpx>=0.27.0",
     "pydantic-settings>=2.0.0",
+    "markdown>=3.5.0",
 ]
 
 [project.urls]

{yapi_mcp-0.1.2 → yapi_mcp-0.1.4}/src/yapi_mcp/server.py

@@ -2,14 +2,19 @@
 
 import json
 from functools import cache
-from typing import Annotated
+from typing import Annotated, Any
 
 import httpx
 from fastmcp import FastMCP
 
 from yapi_mcp.config import ServerConfig
 from yapi_mcp.yapi.client import YApiClient
-from yapi_mcp.yapi.errors import map_http_error_to_mcp
+from yapi_mcp.yapi.errors import (
+    ERROR_TYPE_NETWORK_ERROR,
+    ERROR_TYPE_VALIDATION_FAILED,
+    format_tool_error,
+    map_http_error_to_mcp,
+)
 
 
 class MCPToolError(RuntimeError):
@@ -31,9 +36,39 @@ class InvalidInterfacePathError(ValueError):
         super().__init__("接口路径必须以 / 开头")
 
 
-def _http_error_to_tool_error(error: httpx.HTTPStatusError) -> MCPHTTPError:
+def _http_error_to_tool_error(
+    error: httpx.HTTPStatusError,
+    operation: str,
+    params: dict[str, Any],
+) -> MCPHTTPError:
     mcp_error = map_http_error_to_mcp(error)
-    return MCPHTTPError(mcp_error.message)
+    yapi_error_data = mcp_error.data.get("yapi_error") if mcp_error.data else None
+    error_json = format_tool_error(
+        error_type=mcp_error.error_type,
+        message=mcp_error.message,
+        operation=operation,
+        params=params,
+        error_code=mcp_error.code,
+        retryable=mcp_error.retryable,
+        yapi_error=yapi_error_data if isinstance(yapi_error_data, dict) else None,
+    )
+    return MCPHTTPError(error_json)
+
+
+def _network_error_to_tool_error(
+    error: Exception,
+    operation: str,
+    params: dict[str, Any],
+) -> MCPToolError:
+    error_json = format_tool_error(
+        error_type=ERROR_TYPE_NETWORK_ERROR,
+        message=f"网络错误: {error!s}",
+        operation=operation,
+        params=params,
+        error_code=-32000,
+        retryable=True,
+    )
+    return MCPToolError(error_json)
 
 
 def _wrap_validation_error(error: ValueError) -> MCPValidationError:
@@ -79,10 +114,12 @@ async def yapi_search_interfaces(
 ) -> str:
     """在指定 YApi 项目中搜索接口,支持按标题、路径、描述模糊匹配."""
     config = get_config()
+    operation = "yapi_search_interfaces"
+    params = {"project_id": project_id, "keyword": keyword}
+
     try:
         async with YApiClient(str(config.yapi_server_url), config.cookies) as client:
             results = await client.search_interfaces(project_id, keyword)
-            # Return JSON string with search results
             return json.dumps(
                 [result.model_dump(by_alias=True) for result in results],
                 ensure_ascii=False,
@@ -91,7 +128,9 @@ async def yapi_search_interfaces(
     except MCPToolError:
         raise
     except httpx.HTTPStatusError as exc:
-        raise _http_error_to_tool_error(exc) from exc
+        raise _http_error_to_tool_error(exc, operation, params) from exc
+    except (httpx.TimeoutException, httpx.ConnectError) as exc:
+        raise _network_error_to_tool_error(exc, operation, params) from exc
     except Exception as exc:
         prefix = SEARCH_INTERFACES_ERROR
         raise _wrap_tool_error(prefix, exc) from exc
@@ -103,6 +142,9 @@ async def yapi_get_interface(
 ) -> str:
     """获取 YApi 接口的完整定义(包括请求参数、响应结构、描述等)."""
     config = get_config()
+    operation = "yapi_get_interface"
+    params = {"interface_id": interface_id}
+
     try:
         async with YApiClient(str(config.yapi_server_url), config.cookies) as client:
             interface = await client.get_interface(interface_id)
@@ -114,7 +156,9 @@ async def yapi_get_interface(
     except MCPToolError:
         raise
     except httpx.HTTPStatusError as exc:
-        raise _http_error_to_tool_error(exc) from exc
+        raise _http_error_to_tool_error(exc, operation, params) from exc
+    except (httpx.TimeoutException, httpx.ConnectError) as exc:
+        raise _network_error_to_tool_error(exc, operation, params) from exc
     except Exception as exc:
         prefix = GET_INTERFACE_ERROR
         raise _wrap_tool_error(prefix, exc) from exc
@@ -130,14 +174,25 @@ async def yapi_save_interface(
     method: Annotated[str, "HTTP方法 (创建时必需)"] = "",
     req_body: Annotated[str, "请求参数(JSON字符串)"] = "",
     res_body: Annotated[str, "响应结构(JSON字符串)"] = "",
-    desc: Annotated[str, "接口描述"] = "",
-    req_body_type: Annotated[str, "请求体类型(form/json/raw/file)"] = "",
-    req_body_is_json_schema: Annotated[bool, "请求体是否为JSON Schema"] = True,
-    res_body_type: Annotated[str, "响应体类型(json/raw)"] = "",
-    res_body_is_json_schema: Annotated[bool, "响应体是否为JSON Schema"] = True,
+    markdown: Annotated[str, "接口描述(Markdown格式)"] = "",
+    req_query: Annotated[str, "Query参数(JSON数组,每项含name/required/desc)"] = "",
+    req_body_type: Annotated[str | None, "请求体类型(form/json/raw/file)"] = None,
+    req_body_is_json_schema: Annotated[bool | None, "请求体是否为JSON Schema"] = None,
+    res_body_type: Annotated[str | None, "响应体类型(json/raw)"] = None,
+    res_body_is_json_schema: Annotated[bool | None, "响应体是否为JSON Schema"] = None,
 ) -> str:
     """保存 YApi 接口定义。interface_id 有值则更新,无值则创建新接口。"""
     config = get_config()
+    operation = "yapi_save_interface"
+    params = {
+        "catid": catid,
+        "project_id": project_id,
+        "interface_id": interface_id,
+        "title": title,
+        "path": path,
+        "method": method,
+    }
+
     try:
         if path and not path.startswith("/"):
             raise InvalidInterfacePathError
@@ -152,8 +207,9 @@ async def yapi_save_interface(
                 method=method if method else None,
                 req_body=req_body,
                 res_body=res_body,
-                desc=desc,
-                req_body_type=req_body_type if req_body_type else None,
+                markdown=markdown,
+                req_query=req_query,
+                req_body_type=req_body_type,
                 req_body_is_json_schema=req_body_is_json_schema,
                 res_body_type=res_body_type if res_body_type else None,
                 res_body_is_json_schema=res_body_is_json_schema,
@@ -168,7 +224,9 @@ async def yapi_save_interface(
     except MCPToolError:
         raise
     except httpx.HTTPStatusError as exc:
-        raise _http_error_to_tool_error(exc) from exc
+        raise _http_error_to_tool_error(exc, operation, params) from exc
+    except (httpx.TimeoutException, httpx.ConnectError) as exc:
+        raise _network_error_to_tool_error(exc, operation, params) from exc
     except ValueError as exc:
         raise _wrap_validation_error(exc) from exc
     except Exception as exc:

{yapi_mcp-0.1.2 → yapi_mcp-0.1.4}/src/yapi_mcp/yapi/client.py

@@ -1,11 +1,29 @@
 """YApi API HTTP client implementation."""
 
+import json
 from typing import Any, NoReturn
 
 import httpx
+import markdown as md_lib
 
 from .models import YApiErrorResponse, YApiInterface, YApiInterfaceSummary
 
+# Markdown 转 HTML 转换器（单例）
+_md_converter = md_lib.Markdown(extensions=["extra", "codehilite", "nl2br"])
+
+
+def _markdown_to_html(text: str) -> str:
+    """将 Markdown 文本转换为 HTML。
+
+    Args:
+        text: Markdown 格式文本
+
+    Returns:
+        HTML 格式文本
+    """
+    _md_converter.reset()
+    return _md_converter.convert(text)
+
 
 def _raise_yapi_api_error(response: httpx.Response, error: YApiErrorResponse) -> NoReturn:
     message = f"YApi API error: {error.errmsg} (code: {error.errcode})"
@@ -108,7 +126,7 @@ class YApiClient:
                 iface["_cat_name"] = cat_name
                 interfaces.append(iface)
 
-        # 客户端关键词过滤（支持分类名搜索）
+        # 客户端关键词过滤（支持分类名搜索，同时匹配 desc 和 markdown）
         if keyword:
             keyword_lower = keyword.lower()
             interfaces = [
@@ -117,6 +135,7 @@ class YApiClient:
                 if keyword_lower in iface.get("title", "").lower()
                 or keyword_lower in iface.get("path", "").lower()
                 or keyword_lower in iface.get("desc", "").lower()
+                or keyword_lower in iface.get("markdown", "").lower()
                 or keyword_lower in iface.get("_cat_name", "").lower()
             ]
 
@@ -150,7 +169,8 @@ class YApiClient:
         method: str | None = None,
         req_body: str = "",
         res_body: str = "",
-        desc: str = "",
+        markdown: str = "",
+        req_query: str = "",
         req_body_type: str | None = None,
         req_body_is_json_schema: bool | None = None,
         res_body_type: str | None = None,
@@ -170,7 +190,7 @@ class YApiClient:
             method: HTTP method (required for create)
             req_body: Request body definition (JSON string, optional)
             res_body: Response body definition (JSON string, optional)
-            desc: Interface description (optional)
+            markdown: Interface description in Markdown format (optional)
             req_body_type: Request body type (form, json, raw, file)
             req_body_is_json_schema: Whether req_body is JSON Schema format
             res_body_type: Response body type (json, raw)
@@ -219,8 +239,11 @@ class YApiClient:
                 payload["res_body_is_json_schema"] = (
                     res_body_is_json_schema if res_body_is_json_schema is not None else True
                 )
-            if desc:
-                payload["desc"] = desc
+            if markdown:
+                payload["markdown"] = markdown
+                payload["desc"] = _markdown_to_html(markdown)
+            if req_query:
+                payload["req_query"] = json.loads(req_query)
 
             response = await self.client.post("/interface/add", json=payload)
             self._check_response(response)
@@ -241,8 +264,9 @@ class YApiClient:
             payload["req_body_other"] = req_body
         if res_body:
             payload["res_body"] = res_body
-        if desc is not None:
-            payload["desc"] = desc
+        if markdown is not None:
+            payload["markdown"] = markdown
+            payload["desc"] = _markdown_to_html(markdown) if markdown else ""
         # 类型标记参数独立设置（不依赖内容参数）
         if req_body_type is not None:
             payload["req_body_type"] = req_body_type
@@ -252,6 +276,8 @@ class YApiClient:
             payload["res_body_type"] = res_body_type
         if res_body_is_json_schema is not None:
             payload["res_body_is_json_schema"] = res_body_is_json_schema
+        if req_query:
+            payload["req_query"] = json.loads(req_query)
 
         response = await self.client.post("/interface/up", json=payload)
         self._check_response(response)

yapi_mcp-0.1.4/src/yapi_mcp/yapi/errors.py

@@ -0,0 +1,274 @@
+"""Error mapping from YApi/HTTP errors to MCP errors."""
+
+import json
+from collections.abc import Mapping
+from typing import Any, Literal, NotRequired, TypedDict
+
+import httpx
+
+ErrorData = dict[str, object]
+
+ERROR_TYPE_AUTH_FAILED = "AUTH_FAILED"
+ERROR_TYPE_RESOURCE_NOT_FOUND = "RESOURCE_NOT_FOUND"
+ERROR_TYPE_PERMISSION_DENIED = "PERMISSION_DENIED"
+ERROR_TYPE_INVALID_PARAMS = "INVALID_PARAMS"
+ERROR_TYPE_VALIDATION_FAILED = "VALIDATION_FAILED"
+ERROR_TYPE_SERVER_ERROR = "SERVER_ERROR"
+ERROR_TYPE_NETWORK_ERROR = "NETWORK_ERROR"
+ERROR_TYPE_CONFIG_ERROR = "CONFIG_ERROR"
+
+
+class ToolErrorDetails(TypedDict, total=False):
+    operation: str
+    params: dict[str, Any]
+    error_code: int
+    yapi_error: NotRequired[dict[str, Any] | None]
+
+
+class ToolErrorResponse(TypedDict):
+    error: Literal[True]
+    error_type: str
+    message: str
+    retryable: bool
+    suggestions: list[str]
+    details: ToolErrorDetails
+
+
+HTTP_STATUS_OK = 200
+HTTP_STATUS_UNAUTHORIZED = 401
+HTTP_STATUS_NOT_FOUND = 404
+HTTP_STATUS_FORBIDDEN = 403
+HTTP_STATUS_SERVER_ERROR = 500
+HTTP_STATUS_BAD_REQUEST = 400
+
+MCP_CODE_AUTH_FAILED = -32001
+MCP_CODE_NOT_FOUND = -32002
+MCP_CODE_FORBIDDEN = -32003
+MCP_CODE_SERVER_ERROR = -32000
+MCP_CODE_INVALID_PARAMS = -32602
+
+
+ERROR_SUGGESTIONS: dict[str, list[str]] = {
+    ERROR_TYPE_AUTH_FAILED: [
+        "检查环境变量中的 Cookie 是否正确配置",
+        "确认 _yapi_token 和 _yapi_uid 未过期",
+        "尝试重新登录 YApi 获取新的 Cookie",
+    ],
+    ERROR_TYPE_RESOURCE_NOT_FOUND: [
+        "检查 project_id、interface_id 或 catid 是否正确",
+        "确认资源未被删除或移动",
+        "尝试通过搜索功能查找正确的资源 ID",
+    ],
+    ERROR_TYPE_PERMISSION_DENIED: [
+        "确认当前账号有访问该项目的权限",
+        "联系项目管理员添加权限",
+        "检查是否使用了正确的 Cookie",
+    ],
+    ERROR_TYPE_INVALID_PARAMS: [
+        "检查传入参数的格式和类型是否正确",
+        "确认必填参数（如 project_id、title、path、method）已提供",
+        "参考接口文档确认参数要求",
+    ],
+    ERROR_TYPE_VALIDATION_FAILED: [
+        "检查接口路径是否以 / 开头",
+        "确认 HTTP method 是否为有效值（GET/POST/PUT/DELETE 等）",
+        "检查 JSON 字符串格式是否正确",
+    ],
+    ERROR_TYPE_SERVER_ERROR: [
+        "YApi 服务器可能暂时不可用，稍后重试",
+        "检查 YApi 服务器状态和日志",
+        "联系 YApi 管理员排查服务端问题",
+    ],
+    ERROR_TYPE_NETWORK_ERROR: [
+        "检查网络连接是否正常",
+        "确认 YAPI_SERVER_URL 配置正确",
+        "检查防火墙或代理设置",
+        "稍后重试",
+    ],
+    ERROR_TYPE_CONFIG_ERROR: [
+        "检查环境变量配置是否完整",
+        "确认 YAPI_SERVER_URL、YAPI_TOKEN、YAPI_UID 已设置",
+        "参考项目 README 中的配置说明",
+    ],
+}
+
+
+def get_error_suggestions(error_type: str) -> list[str]:
+    return ERROR_SUGGESTIONS.get(error_type, ["请检查错误信息并重试"])
+
+
+def format_tool_error(
+    error_type: str,
+    message: str,
+    operation: str,
+    params: dict[str, Any],
+    error_code: int = -32000,
+    retryable: bool = False,
+    yapi_error: dict[str, Any] | None = None,
+    suggestions: list[str] | None = None,
+) -> str:
+    response: ToolErrorResponse = {
+        "error": True,
+        "error_type": error_type,
+        "message": message,
+        "retryable": retryable,
+        "suggestions": suggestions or get_error_suggestions(error_type),
+        "details": {
+            "operation": operation,
+            "params": params,
+            "error_code": error_code,
+        },
+    }
+
+    if yapi_error is not None:
+        response["details"]["yapi_error"] = yapi_error
+
+    return json.dumps(response, ensure_ascii=False, indent=2)
+
+
+class MCPError(Exception):
+    """MCP protocol error with error code and optional data."""
+
+    def __init__(
+        self,
+        code: int,
+        message: str,
+        data: ErrorData | None = None,
+        error_type: str = ERROR_TYPE_SERVER_ERROR,
+        retryable: bool = False,
+    ) -> None:
+        """Initialize MCP error.
+
+        Args:
+            code: MCP error code (negative integer)
+            message: Human-readable error message
+            data: Optional additional error data
+            error_type: Error type constant for structured responses
+            retryable: Whether this error is retryable
+        """
+        super().__init__(message)
+        self.code = code
+        self.message = message
+        self.data = data
+        self.error_type = error_type
+        self.retryable = retryable
+
+    def to_dict(self) -> dict[str, object]:
+        """Convert to MCP error response dict."""
+        result: dict[str, object] = {
+            "code": self.code,
+            "message": self.message,
+            "error_type": self.error_type,
+            "retryable": self.retryable,
+        }
+        if self.data is not None:
+            result["data"] = self.data
+        return result
+
+
+def map_http_error_to_mcp(error: httpx.HTTPStatusError) -> MCPError:
+    """Map HTTP status errors to MCP error codes.
+
+    Error code mapping:
+    - 200 with errcode != 0 → -32602 (YApi business error)
+    - 401 Unauthorized → -32001 (Authentication failed)
+    - 404 Not Found → -32002 (Resource not found)
+    - 403 Forbidden → -32003 (Permission denied)
+    - 500+ Server Error → -32000 (Server error)
+    - 400 Bad Request → -32602 (Invalid params)
+    - Other 4xx → -32602 (Invalid params)
+
+    Args:
+        error: httpx HTTPStatusError exception
+
+    Returns:
+        MCPError with appropriate code, message, error_type and retryable flag
+    """
+    status_code = error.response.status_code
+
+    error_data: ErrorData = {"http_status": status_code}
+    yapi_error: dict | None = None
+    try:
+        raw_error = error.response.json()
+        if isinstance(raw_error, Mapping):
+            yapi_error = dict(raw_error)
+            error_data["yapi_error"] = yapi_error
+    except Exception:
+        error_data["response_text"] = error.response.text[:200]
+
+    if status_code == HTTP_STATUS_OK and yapi_error and yapi_error.get("errcode", 0) != 0:
+        errmsg = yapi_error.get("errmsg", "未知错误")
+        message = (
+            f"YApi 业务错误: {errmsg}。请检查传入的参数是否正确（如 catid、project_id、path 等）"
+        )
+        return MCPError(
+            code=MCP_CODE_INVALID_PARAMS,
+            message=message,
+            data=error_data,
+            error_type=ERROR_TYPE_INVALID_PARAMS,
+            retryable=False,
+        )
+
+    if status_code == HTTP_STATUS_UNAUTHORIZED:
+        return MCPError(
+            code=MCP_CODE_AUTH_FAILED,
+            message="认证失败: Cookie 无效或过期",
+            data=error_data,
+            error_type=ERROR_TYPE_AUTH_FAILED,
+            retryable=False,
+        )
+    if status_code == HTTP_STATUS_NOT_FOUND:
+        yapi_err = error_data.get("yapi_error")
+        errmsg = (
+            yapi_err.get("errmsg", "Resource not found")
+            if isinstance(yapi_err, dict)
+            else "Resource not found"
+        )
+        return MCPError(
+            code=MCP_CODE_NOT_FOUND,
+            message=f"资源不存在: {errmsg}",
+            data=error_data,
+            error_type=ERROR_TYPE_RESOURCE_NOT_FOUND,
+            retryable=False,
+        )
+    if status_code == HTTP_STATUS_FORBIDDEN:
+        return MCPError(
+            code=MCP_CODE_FORBIDDEN,
+            message="权限不足: 无法操作该项目/接口",
+            data=error_data,
+            error_type=ERROR_TYPE_PERMISSION_DENIED,
+            retryable=False,
+        )
+    if status_code >= HTTP_STATUS_SERVER_ERROR:
+        yapi_err = error_data.get("yapi_error")
+        errmsg = (
+            yapi_err.get("errmsg", "Internal server error")
+            if isinstance(yapi_err, dict)
+            else "Internal server error"
+        )
+        return MCPError(
+            code=MCP_CODE_SERVER_ERROR,
+            message=f"YApi 服务器错误: {errmsg}",
+            data=error_data,
+            error_type=ERROR_TYPE_SERVER_ERROR,
+            retryable=True,
+        )
+    if status_code == HTTP_STATUS_BAD_REQUEST:
+        yapi_err = error_data.get("yapi_error")
+        errmsg = (
+            yapi_err.get("errmsg", "Bad request") if isinstance(yapi_err, dict) else "Bad request"
+        )
+        return MCPError(
+            code=MCP_CODE_INVALID_PARAMS,
+            message=f"Invalid params: {errmsg}",
+            data=error_data,
+            error_type=ERROR_TYPE_INVALID_PARAMS,
+            retryable=False,
+        )
+    return MCPError(
+        code=MCP_CODE_INVALID_PARAMS,
+        message=f"Invalid params: HTTP {status_code}",
+        data=error_data,
+        error_type=ERROR_TYPE_INVALID_PARAMS,
+        retryable=False,
+    )

yapi_mcp-0.1.2/src/yapi_mcp/yapi/errors.py

@@ -1,119 +0,0 @@
-"""Error mapping from YApi/HTTP errors to MCP errors."""
-
-from collections.abc import Mapping, MutableMapping
-
-import httpx
-
-ErrorData = MutableMapping[str, object]
-
-HTTP_STATUS_UNAUTHORIZED = 401
-HTTP_STATUS_NOT_FOUND = 404
-HTTP_STATUS_FORBIDDEN = 403
-HTTP_STATUS_SERVER_ERROR = 500
-HTTP_STATUS_BAD_REQUEST = 400
-
-MCP_CODE_AUTH_FAILED = -32001
-MCP_CODE_NOT_FOUND = -32002
-MCP_CODE_FORBIDDEN = -32003
-MCP_CODE_SERVER_ERROR = -32000
-MCP_CODE_INVALID_PARAMS = -32602
-
-
-class MCPError(Exception):
-    """MCP protocol error with error code and optional data."""
-
-    def __init__(
-        self,
-        code: int,
-        message: str,
-        data: ErrorData | None = None,
-    ) -> None:
-        """Initialize MCP error.
-
-        Args:
-            code: MCP error code (negative integer)
-            message: Human-readable error message
-            data: Optional additional error data
-        """
-        super().__init__(message)
-        self.code = code
-        self.message = message
-        self.data = data
-
-    def to_dict(self) -> dict[str, object]:
-        """Convert to MCP error response dict."""
-        result: dict[str, object] = {"code": self.code, "message": self.message}
-        if self.data is not None:
-            result["data"] = self.data
-        return result
-
-
-def map_http_error_to_mcp(error: httpx.HTTPStatusError) -> MCPError:
-    """Map HTTP status errors to MCP error codes.
-
-    Error code mapping:
-    - 401 Unauthorized → -32001 (Authentication failed)
-    - 404 Not Found → -32002 (Resource not found)
-    - 403 Forbidden → -32003 (Permission denied)
-    - 500+ Server Error → -32000 (Server error)
-    - 400 Bad Request → -32602 (Invalid params)
-    - Other 4xx → -32602 (Invalid params)
-
-    Args:
-        error: httpx HTTPStatusError exception
-
-    Returns:
-        MCPError with appropriate code and message
-    """
-    status_code = error.response.status_code
-
-    # Try to extract YApi error details from response
-    error_data: ErrorData = {"http_status": status_code}
-    try:
-        yapi_error = error.response.json()
-        if isinstance(yapi_error, Mapping):
-            error_data["yapi_error"] = dict(yapi_error)
-    except Exception:
-        # If response is not JSON, include response text
-        error_data["response_text"] = error.response.text[:200]
-
-    # Map HTTP status codes to MCP error codes
-    if status_code == HTTP_STATUS_UNAUTHORIZED:
-        return MCPError(
-            code=MCP_CODE_AUTH_FAILED,
-            message="认证失败: Cookie 无效或过期",
-            data=error_data,
-        )
-    if status_code == HTTP_STATUS_NOT_FOUND:
-        errmsg = error_data.get("yapi_error", {}).get("errmsg", "Resource not found")
-        return MCPError(
-            code=MCP_CODE_NOT_FOUND,
-            message=f"资源不存在: {errmsg}",
-            data=error_data,
-        )
-    if status_code == HTTP_STATUS_FORBIDDEN:
-        return MCPError(
-            code=MCP_CODE_FORBIDDEN,
-            message="权限不足: 无法操作该项目/接口",
-            data=error_data,
-        )
-    if status_code >= HTTP_STATUS_SERVER_ERROR:
-        errmsg = error_data.get("yapi_error", {}).get("errmsg", "Internal server error")
-        return MCPError(
-            code=MCP_CODE_SERVER_ERROR,
-            message=f"YApi 服务器错误: {errmsg}",
-            data=error_data,
-        )
-    if status_code == HTTP_STATUS_BAD_REQUEST:
-        errmsg = error_data.get("yapi_error", {}).get("errmsg", "Bad request")
-        return MCPError(
-            code=MCP_CODE_INVALID_PARAMS,
-            message=f"Invalid params: {errmsg}",
-            data=error_data,
-        )
-    # Other 4xx errors
-    return MCPError(
-        code=MCP_CODE_INVALID_PARAMS,
-        message=f"Invalid params: HTTP {status_code}",
-        data=error_data,
-    )