[Bug]: McpToolSpec.create_model_from_json_schema drops nested inline object properties

[schelv]

Bug Description

McpToolSpec.create_model_from_json_schema does not handle inline nested objects (objects defined directly under a properties entry with their own properties/required, rather than via a $ref/$defs). Instead of recursively building a nested Pydantic model, the nested object is collapsed into a bare Dict, so its properties and required are lost.

Where

• Package: llama-index-tools-mcp
• File: llama-index-integrations/tools/llama-index-tools-mcp/llama_index/tools/mcp/tool_spec_mixins.py

Version

llama-index-tools-mcp==0.4.8
llama-index-core==0.14.23

Steps to Reproduce

from llama_index.tools.mcp import McpToolSpec, BasicMCPClient

schema = {
    "properties": {
        "nested": {
            "properties": {"value": {"title": "Value", "type": "string"}},
            "required": ["value"],
            "type": "object",
        },
    },
    "required": ["nested"],
    "type": "object",
}

tool_spec = McpToolSpec(BasicMCPClient("python", args=["server.py"]), allowed_tools=[])
model = tool_spec.create_model_from_json_schema(schema)
out = model.model_json_schema()
del out["title"]
print(out)

Expected Behavior

Build a model from the JSON schema using McpToolSpec.create_model_from_json_schema , and then calling model_json_schema() should reproduce the input schema with the nested object structure:

{
    "properties": {
        "nested": {
            "properties": {"value": {"title": "Value", "type": "string"}},
            "required": ["value"],
            "type": "object",
        }
    },
    "required": ["nested"],
    "type": "object",
}

Actual Behavior

The nested field is generated as a bare dict, losing its inner properties:

{
    "properties": {
        "nested": {"additionalProperties": True, "title": "Nested", "type": "object"}
    },
    "required": ["nested"],
    "type": "object",
}

Test Case

I've created a test case that can be added to llama-index-integrations/tools/llama-index-tools-mcp/tests/test_tools_mcp.py.
Only the nested-object test case fails; referenced-nested-object passes and is included as a contrast.

base_test_cases = [
    pytest.param(
        {
            "properties": {
                "nested": {
                    "properties": {
                        "value": {"title": "Value", "type": "string"},
                    },
                    "required": ["value"],
                    "type": "object",
                },
            },
            "required": ["nested"],
            "type": "object",
        },
        id="nested-object",
    ),
    pytest.param(
        {
            "$defs": {
                "Inner": {
                    "properties": {
                        "value": {"title": "Value", "type": "string"},
                    },
                    "required": ["value"],
                    "title": "Inner",
                    "type": "object",
                },
            },
            "properties": {
                "nested": {"$ref": "#/$defs/Inner"},
            },
            "required": ["nested"],
            "type": "object",
        },
        id="referenced-nested-object",
    ),
]


@pytest.mark.parametrize(
    "json_schema",
    [
        *base_test_cases,
    ],
)
def test_create_model_from_json_schema(client: BasicMCPClient, json_schema: dict):
    """Converting a JSON schema into a Pydantic model and back to a JSON schema should yield the original schema."""
    tool_spec = McpToolSpec(client, allowed_tools=[])
    pydantic_model = tool_spec.create_model_from_json_schema(json_schema)
    json_schema_from_pydantic_model = pydantic_model.model_json_schema()

    del json_schema_from_pydantic_model["title"]

    assert json_schema == json_schema_from_pydantic_model

[dosubot]

I can confirm this bug. Looking at the implementation of create_model_from_json_schema in tool_spec_mixins.py, the json_type_mapping simply maps "object" → dict [1], and the method does no recursive traversal when a property has its own properties/required — it just uses that bare dict type directly [2].

A fix would involve checking whether a field with type: "object" also contains properties (or resolves via $ref), and if so, recursively calling create_model_from_json_schema to build a nested Pydantic model. Something along these lines:

for field_name, field_schema in properties.items():
    json_type = field_schema.get("type", "string")
    json_type = json_type[0] if isinstance(json_type, list) else json_type

    if json_type == "object" and "properties" in field_schema:
        # Recursively build a nested model
        field_type = create_model_from_json_schema(field_schema, model_name=field_name.capitalize())
    else:
        field_type = json_type_mapping.get(json_type, str)

    # ... rest of field handling

You'd also want to handle $ref resolution (looking up $defs in the root schema) to cover the referenced-nested-object case in your test. The current implementation doesn't pass the root schema context through, so that would need to be threaded as an additional parameter.

To reply, just mention @dosu.

---

Share context across your team and agents. Try Dosu.

[Aayush-engineer]

Hi, I'd like to work on this fix.

The root cause is clear — create_model_from_json_schema maps "object" directly to dict without checking if the field schema contains nested properties. The fix involves adding a recursive call when a field has type: "object" AND contains properties.

I'll use the test cases provided in this issue and the approach suggested above. Will open a PR shortly.

[anishesg]

Took a look, #22143 should address it.