fix: Add support for list-type JSON Schema fields in modeling.py (#37)

* fix: Add support for list-type JSON Schema fields in modeling.py

Problem:
- JSON Schema allows specifying multiple types using array notation: {"type": ["string", "number"]}
- This is valid per JSON Schema specification, and common in real-world schemas
- The mcpadapt modeling.py module failed with "unhashable type: 'list'" when processing such schemas
- Error occurs in get_field_type() when attempting to use a list as a dictionary key

Solution:
- Enhanced get_field_type() to properly handle list-type JSON Schema types
- Added special case to detect when json_type is a list
- Implemented conversion of list-type to Python Union types
- For single-item lists, extract and use the single type
- For multi-item lists, create a Union of all mapped types
- Preserves original behavior for all other schema types

This fix ensures compatibility with JSON Schema that use the array notation for
specifying multiple allowed types for a field, which is a common pattern in the
JSON Schema ecosystem. The fix is backwards compatible and follows the expected
behavior of properly converting JSON Schema types to their Python equivalents.

* test: Add dedicated test for JSON Schema list-type handling

This commit adds a comprehensive test suite for validating the fix for JSON Schema
array notation in type fields (e.g., "type": ["string", "number"]).

Key additions:
- New test file tests/test_modeling.py with multiple test scenarios:
  - Direct test against modeling.py to verify handling of list-type JSON Schema fields
  - Tests for array-type fields with multiple primitive types
  - Specific tests for handling of null types in array notation
  - Inspection utility to examine actual schema structure in MCP tools

The tests are designed to:
1. Verify the fix works correctly for all edge cases
2. Provide clear diagnostics when the bug is present
3. Demonstrate proper handling of various JSON Schema type patterns
4. Ensure consistent behavior with the existing anyOf implementation

The test handles both the "happy path" (with fix) and failure path (without fix),
making it valuable for preventing regressions. It also improves null type handling
to be consistent with how the codebase already handles nulls in anyOf constructs.

This testing approach validates that our implementation correctly supports the
JSON Schema specification, which allows multiple types to be specified either
via array notation or anyOf constructs.

* fix: Address PR #37 review feedback on JSON Schema list-type handling

- Extended JSON Schema array notation fix to langchain_adapter.py
- Added support for both array notation ("type": ["string", "number"])
  and anyOf structures in LangChain adapter
- Reorganized tests per reviewer feedback:
  * Moved simplified direct test to tests/utils/test_modeling.py
  * Added E2E test to test_langchain_adapter.py
  * Removed redundant test file

This commit ensures consistent handling of JSON Schema list-type fields
across all adapters and addresses all feedback from the PR review.

---------

Co-authored-by: Sakthi Kannan <saktr@amazon.com>

Author: sakthikannan25

src/mcpadapt/langchain_adapter.py

@@ -84,7 +84,38 @@ def _generate_tool_class(
     # TODO: this could be better and handle nested objects...
     tool_params = []
     for k, v in properties.items():
-        tool_params.append(f"{k}: {JSON_SCHEMA_TO_PYTHON_TYPES[v['type']]}")
+        # Handle case where 'type' is missing but 'anyOf' is present (for multiple types)
+        if "type" in v:
+            if isinstance(v["type"], list):
+                # Handle list-type (multiple allowed types in JSON Schema)
+                types = []
+                for t in v["type"]:
+                    if t != "null":  # Exclude null types
+                        types.append(JSON_SCHEMA_TO_PYTHON_TYPES[t])
+
+                if len(types) > 1:
+                    python_type = " | ".join(types)
+                else:
+                    python_type = types[0] if types else "str"  # Default to str
+            else:
+                python_type = JSON_SCHEMA_TO_PYTHON_TYPES[v["type"]]
+        elif "anyOf" in v:
+            # Extract types from anyOf
+            types = []
+            for option in v["anyOf"]:
+                if "type" in option and option["type"] != "null":
+                    types.append(JSON_SCHEMA_TO_PYTHON_TYPES[option["type"]])
+
+            if len(types) > 1:
+                python_type = " | ".join(types)
+            else:
+                python_type = types[0] if types else "str"  # Default to str
+        else:
+            # Default to str if no type information is available
+            python_type = "str"
+
+        tool_params.append(f"{k}: {python_type}")
+
     tool_params = ", ".join(tool_params)
 
     argument = "{" + ", ".join(f"'{k}': {k}" for k in properties.keys()) + "}"

src/mcpadapt/utils/modeling.py

@@ -157,7 +157,23 @@ def get_field_type(field_name: str, field_schema: Dict[str, Any], required: set)
         else:
             # Simple types
             json_type = field_schema.get("type", "string")
-            field_type = json_type_mapping.get(json_type, Any)  # type: ignore
+
+            # Handle list-type (multiple allowed types in JSON Schema)
+            if isinstance(json_type, list):
+                # Convert to Union type (consistent with anyOf handling)
+                types = []
+                for t in json_type:
+                    if t != "null":  # Exclude null types as in anyOf handling
+                        mapped_type = json_type_mapping.get(t, Any)
+                        types.append(mapped_type)
+
+                if len(types) > 1:
+                    field_type = Union[tuple(types)]  # type: ignore
+                else:
+                    field_type = types[0] if types else Any
+            else:
+                # Original code for simple types
+                field_type = json_type_mapping.get(json_type, Any)  # type: ignore
 
         # Handle optionality and default values
         default = field_schema.get("default")

tests/test_langchain_adapter.py

@@ -7,6 +7,32 @@
 from mcpadapt.langchain_adapter import LangChainAdapter
 
 
+@pytest.fixture
+def json_schema_array_type_server_script():
+    """
+    Create a server with a tool that uses array notation for type fields.
+    This tests handling of JSON Schema 'type': ['string', 'number'] syntax.
+    """
+    return dedent(
+        '''
+        from mcp.server.fastmcp import FastMCP
+
+        mcp = FastMCP("JSON Schema Array Type Test Server")
+
+        @mcp.tool()
+        def multi_type_tool(
+            id: str | int,  # This becomes {"type": ["string", "number"]} in JSON Schema
+            name: str | None = None,  # Tests nullable with array type
+        ) -> str:
+            """Test tool with a parameter that accepts multiple types using array notation"""
+            id_type = type(id).__name__
+            return f"Received ID: {id} (type: {id_type}), Name: {name}"
+        
+        mcp.run()
+        '''
+    )
+
+
 @pytest.fixture
 def echo_server_script():
     return dedent(
@@ -112,6 +138,31 @@ def test_basic_sync_sse(echo_sse_server):
         assert len(tools) == 1
 
 
+def test_json_schema_array_type_handling(json_schema_array_type_server_script):
+    """
+    Test that MCPAdapt correctly handles JSON Schema with array notation for types.
+    This ensures our fix for 'unhashable type: list' error is working.
+    """
+    with MCPAdapt(
+        StdioServerParameters(
+            command="uv",
+            args=["run", "python", "-c", json_schema_array_type_server_script],
+        ),
+        LangChainAdapter(),
+    ) as tools:
+        # Verify the tool was successfully loaded
+        assert len(tools) == 1
+        assert tools[0].name == "multi_type_tool"
+
+        # Test with string type
+        result_string = tools[0].invoke({"id": "abc123", "name": "test"})
+        assert "Received ID: abc123 (type: str)" in result_string
+
+        # Test with integer type
+        result_int = tools[0].invoke({"id": 42, "name": "test"})
+        assert "Received ID: 42 (type: int)" in result_int
+
+
 def test_tool_name_with_dashes():
     mcp_server_script = dedent(
         '''

tests/utils/test_modeling.py

@@ -0,0 +1,37 @@
+"""
+Tests for the modeling module, specifically focused on JSON Schema handling.
+"""
+
+from mcpadapt.utils.modeling import create_model_from_json_schema
+
+
+def test_direct_modeling_with_list_type():
+    """
+    Test the modeling module directly with a schema using list-type notation.
+    This test is specifically designed to verify handling of list-type JSON Schema fields.
+    """
+    # Create a schema with list-type field
+    schema = {
+        "type": "object",
+        "properties": {
+            "multi_type_field": {
+                "type": ["string", "number"],
+                "description": "Field that accepts multiple types",
+            },
+            "nullable_field": {
+                "type": ["string", "null"],
+                "description": "Field that is nullable",
+            },
+        },
+    }
+
+    # Create model from schema - should not raise TypeError
+    model = create_model_from_json_schema(schema)
+
+    # Verify the model works as expected with string
+    instance = model(multi_type_field="test")
+    assert instance.multi_type_field == "test"
+
+    # Verify the model works as expected with number
+    instance = model(multi_type_field=42)
+    assert instance.multi_type_field == 42