fix nested MCP schema conversion

Author: 黑曜

agentrun/integration/utils/tool.py

@@ -1731,11 +1731,24 @@ def _sanitize_python_identifier(name: str) -> str:
 def _json_schema_to_pydantic(
     name: str,
     schema: Optional[Dict[str, Any]],
+    root_schema: Optional[Dict[str, Any]] = None,
 ) -> Optional[Type[BaseModel]]:
-    """将 JSON Schema 转换为 Pydantic 模型"""
+    """将 JSON Schema 转换为 Pydantic 模型
+
+    Args:
+        name: 模型名称
+        schema: 待转换的 JSON Schema 片段
+        root_schema: 顶层 schema, 用于解析深层 ``$ref`` 指向的 ``$defs``。
+            首次调用时若为空, 默认取 ``schema`` 自身, 便于二次转换时
+            (get_parameters_schema 输出携带 ``$defs``) 正确解引用。
+    """
     if not schema or not isinstance(schema, dict):
         return None
 
+    # 记录顶层 schema, 供嵌套字段解析 $ref/$defs 使用
+    if root_schema is None:
+        root_schema = schema
+
     properties = schema.get("properties", {})
     if not properties:
         return None
@@ -1768,7 +1781,7 @@ def _json_schema_to_pydantic(
             needs_populate_by_name = True
 
         # 映射类型
-        field_type = _json_type_to_python(field_schema)
+        field_type = _json_type_to_python(field_schema, root_schema)
         description = field_schema.get("description", "")
         default = field_schema.get("default")
         aliases = field_schema.get("x-aliases")
@@ -1812,25 +1825,53 @@ def _json_schema_to_pydantic(
     )
 
 
-def _json_type_to_python(field_schema: Dict[str, Any]) -> type:
-    """映射 JSON Schema 类型到 Python 类型"""
-    schema_type = field_schema.get("type", "string")
+def _json_type_to_python(
+    field_schema: Dict[str, Any],
+    root_schema: Optional[Dict[str, Any]] = None,
+) -> type:
+    """映射 JSON Schema 类型到 Python 类型
+
+    Args:
+        field_schema: 字段 schema, 可能是裸类型, 也可能是 anyOf/oneOf/$ref 包装
+        root_schema: 顶层 schema, 用于解析 ``$ref`` (二次转换时携带 ``$defs``)
+    """
+    # 若字段被 anyOf/oneOf/allOf/$ref 包装 (常见于二次转换的 schema),
+    # 先展开出核心 schema, 否则无顶层 type 时会误判为 string, 丢失嵌套 object。
+    if root_schema is not None and (
+        "anyOf" in field_schema
+        or "oneOf" in field_schema
+        or "allOf" in field_schema
+        or "$ref" in field_schema
+    ):
+        core_schema, _ = _extract_core_schema(field_schema, root_schema)
+        if core_schema:
+            field_schema = core_schema
+
+    schema_type = field_schema.get("type")
+    if not schema_type:
+        # 无显式 type 时, 依据结构推断, 避免默认降级为 string
+        if "properties" in field_schema:
+            schema_type = "object"
+        elif "items" in field_schema:
+            schema_type = "array"
+        else:
+            schema_type = "string"
 
     # 处理嵌套对象和数组
     if schema_type == "object":
         # 如果有 properties,递归创建嵌套模型
         properties = field_schema.get("properties")
         if properties:
             nested_model = _json_schema_to_pydantic(
-                "NestedObject", field_schema
+                "NestedObject", field_schema, root_schema
             )
             return nested_model if nested_model else dict
         return dict
 
     if schema_type == "array":
         items_schema = field_schema.get("items", {})
         if isinstance(items_schema, dict):
-            item_type = _json_type_to_python(items_schema)
+            item_type = _json_type_to_python(items_schema, root_schema)
             from typing import List as TypingList
 
             return TypingList[item_type]  # type: ignore

tests/unittests/integration/test_tool_utils.py

@@ -838,6 +838,103 @@ class _Args(_BM):
         assert merged_map.get("x-alias") == "query"
 
 
+class TestNestedObjectRoundTrip:
+    """覆盖嵌套 object 参数经二次转换后仍保持 object 类型
+
+    回归西瓜创客问题: MCP inputSchema 中 attrs.risk / attrs.refund 为嵌套
+    object, 经 get_parameters_schema -> LangChainToolAdapter.from_canonical ->
+    convert_to_openai_tool 二次转换后, 深层 anyOf/$ref 未被解析,
+    _json_type_to_python 无顶层 type 时默认为 string, 导致 object 被降级。
+    """
+
+    @staticmethod
+    def _unwrap_anyof(node: Dict[str, Any]) -> Dict[str, Any]:
+        """从 anyOf/oneOf 中挑出非 null 的核心 schema, 便于断言真实类型"""
+        for key in ("anyOf", "oneOf"):
+            options = node.get(key)
+            if isinstance(options, list):
+                for option in options:
+                    if isinstance(option, dict) and option.get("type") != "null":
+                        return option
+        return node
+
+    def test_nested_optional_object_survives_second_conversion(self):
+        """attrs.risk / attrs.refund 经二次转换后仍应是 object"""
+        from agentrun.integration.utils.tool import _build_tool_from_meta
+
+        toolset = MagicMock()
+
+        meta = {
+            "name": "create_order",
+            "description": "demo",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "attrs": {
+                        "type": "object",
+                        "description": "attributes",
+                        "properties": {
+                            "risk": {
+                                "type": "object",
+                                "description": "risk info",
+                                "properties": {
+                                    "level": {"type": "string"},
+                                },
+                            },
+                            "refund": {
+                                "type": "object",
+                                "description": "refund info",
+                                "properties": {
+                                    "amount": {"type": "number"},
+                                },
+                            },
+                        },
+                    },
+                },
+                "required": [],
+            },
+        }
+
+        tool_obj = _build_tool_from_meta(toolset, meta, None)
+        assert tool_obj is not None
+
+        # 第一次转换: 生成 canonical parameters (含 $defs / anyOf / $ref)
+        params = tool_obj.get_parameters_schema()
+
+        # 第二次转换: canonical -> LangChain -> OpenAI tool
+        from langchain_core.utils.function_calling import (
+            convert_to_openai_tool,
+        )
+
+        from agentrun.integration.langchain.tool_adapter import (
+            LangChainToolAdapter,
+        )
+        from agentrun.integration.utils.canonical import CanonicalTool
+
+        canonical = CanonicalTool(
+            name=tool_obj.name,
+            description=tool_obj.description,
+            parameters=params,
+            func=tool_obj.func,
+        )
+        lc_tool = LangChainToolAdapter().from_canonical([canonical])[0]
+        openai_tool = convert_to_openai_tool(lc_tool)
+
+        props = openai_tool["function"]["parameters"]["properties"]
+        attrs = self._unwrap_anyof(props["attrs"])
+        assert attrs.get("type") == "object"
+        assert "properties" in attrs
+
+        risk = self._unwrap_anyof(attrs["properties"]["risk"])
+        refund = self._unwrap_anyof(attrs["properties"]["refund"])
+
+        # 核心断言: 深层嵌套 object 不应被降级为 string
+        assert risk.get("type") == "object", risk
+        assert "level" in risk.get("properties", {})
+        assert refund.get("type") == "object", refund
+        assert "amount" in refund.get("properties", {})
+
+
 class TestBuildToolFromMetaInvalidFieldNames:
     """覆盖 _build_tool_from_meta 完整链路 (回归 'x-access-id' 加载失败)"""