mbxai 1.5.0__tar.gz → 1.6.0__tar.gz

{mbxai-1.5.0 → mbxai-1.6.0}/.gitignore

@@ -92,4 +92,5 @@ wheels/
 # Project specific
 *.db
 *.sqlite3
-node_modules/ 
+node_modules/
+tmp/ 

{mbxai-1.5.0 → mbxai-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mbxai
-Version: 1.5.0
+Version: 1.6.0
 Summary: MBX AI SDK
 Project-URL: Homepage, https://www.mibexx.de
 Project-URL: Documentation, https://www.mibexx.de

{mbxai-1.5.0 → mbxai-1.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mbxai"
-version = "1.5.0"
+version = "1.6.0"
 authors = [
     { name = "MBX AI" }
 ]
@@ -82,6 +82,6 @@ strict_equality = true
 
 [dependency-groups]
 dev = [
-    "build>=1.5.0.post1",
+    "build>=1.6.0.post1",
     "twine>=6.1.0",
 ]

{mbxai-1.5.0 → mbxai-1.6.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="mbxai",
-    version="1.5.0",
+    version="1.6.0",
     author="MBX AI",
     description="MBX AI SDK",
     long_description=open("README.md").read(),

{mbxai-1.5.0 → mbxai-1.6.0}/src/mbxai/__init__.py

@@ -2,4 +2,4 @@
 MBX AI package.
 """
 
-__version__ = "1.5.0" 
+__version__ = "1.6.0" 

{mbxai-1.5.0 → mbxai-1.6.0}/src/mbxai/mcp/server.py

@@ -31,7 +31,7 @@ class MCPServer:
         self.app = FastAPI(
             title=self.name,
             description=self.description,
-            version="1.5.0",
+            version="1.6.0",
         )
         
         # Initialize MCP server

{mbxai-1.5.0 → mbxai-1.6.0}/src/mbxai/tools/types.py

@@ -18,7 +18,7 @@ def _resolve_ref(schema: dict[str, Any], ref: str, root_schema: dict[str, Any])
         root_schema: The root schema containing $defs
         
     Returns:
-        The resolved schema definition
+        The resolved schema definition with all nested $refs also resolved
     """
     if ref.startswith("#/"):
         # Remove the "#/" prefix and split the path
@@ -33,7 +33,11 @@ def _resolve_ref(schema: dict[str, Any], ref: str, root_schema: dict[str, Any])
                 logger.warning(f"Could not resolve $ref: {ref}")
                 return {"type": "object", "additionalProperties": False}
         
-        return current if isinstance(current, dict) else {"type": "object", "additionalProperties": False}
+        if isinstance(current, dict):
+            # Recursively process the resolved schema to handle nested $refs
+            return _convert_property_to_strict(current, root_schema)
+        else:
+            return {"type": "object", "additionalProperties": False}
     else:
         logger.warning(f"Unsupported $ref format: {ref}")
         return {"type": "object", "additionalProperties": False}
@@ -46,12 +50,32 @@ def _convert_property_to_strict(prop: dict[str, Any], root_schema: dict[str, Any
         root_schema: The root schema containing $defs
         
     Returns:
-        A strict format property definition
+        A strict format property definition with all $refs resolved
     """
-    # Handle $ref resolution
+    # Handle $ref resolution first - this may return a completely different schema
     if "$ref" in prop:
-        resolved = _resolve_ref(prop, prop["$ref"], root_schema)
-        return _convert_property_to_strict(resolved, root_schema)
+        # Get the referenced schema path
+        ref = prop["$ref"]
+        if ref.startswith("#/"):
+            path_parts = ref[2:].split("/")
+            current = root_schema
+            
+            # Navigate through the path to get the referenced schema
+            for part in path_parts:
+                if isinstance(current, dict) and part in current:
+                    current = current[part]
+                else:
+                    logger.warning(f"Could not resolve $ref: {ref}")
+                    return {"type": "object", "additionalProperties": False}
+            
+            if isinstance(current, dict):
+                # Recursively process the resolved schema
+                return _convert_property_to_strict(current, root_schema)
+            else:
+                return {"type": "object", "additionalProperties": False}
+        else:
+            logger.warning(f"Unsupported $ref format: {ref}")
+            return {"type": "object", "additionalProperties": False}
     
     # Get the property type, defaulting to string
     prop_type = prop.get("type", "string")
@@ -69,7 +93,7 @@ def _convert_property_to_strict(prop: dict[str, Any], root_schema: dict[str, Any
         new_prop["properties"] = {}
         new_prop["required"] = []
         
-        # Process nested properties
+        # Process nested properties recursively
         if "properties" in prop:
             for nested_name, nested_prop in prop["properties"].items():
                 new_prop["properties"][nested_name] = _convert_property_to_strict(nested_prop, root_schema)
@@ -81,6 +105,7 @@ def _convert_property_to_strict(prop: dict[str, Any], root_schema: dict[str, Any
     elif prop_type == "array":
         # Arrays must have items definition
         if "items" in prop:
+            # Recursively process items schema (this could also have $refs)
             new_prop["items"] = _convert_property_to_strict(prop["items"], root_schema)
         else:
             # Default items schema if missing

mbxai-1.6.0/tests/test_mcp_tool_registration.py

@@ -0,0 +1,221 @@
+"""
+Test MCP tool registration flow to identify where $ref schemas are still used.
+
+This test simulates the server-client registration process to find the bug.
+"""
+
+import json
+import os
+from typing import Any
+from pydantic import BaseModel, Field
+
+# Add the src directory to the path so we can import from mbxai
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from mbxai.mcp.client import MCPTool
+from mbxai.tools.types import convert_to_strict_schema
+
+
+class MetadataFilter(BaseModel):
+    """Model for a single metadata filter key-value pair."""
+    key: str = Field(description="The metadata field name to filter by")
+    value: Any = Field(description="The value to filter for")
+
+
+class ShopwareKnowledgeSearchInput(BaseModel):
+    """Input model for Shopware knowledge search."""
+    
+    query: str = Field(description="The search query")
+    max_results: int = Field(description="Maximum results (1-20)", ge=1, le=20)
+    include_metadata: bool = Field(description="Whether to include metadata")
+    metadata_filter: list[MetadataFilter] = Field(description="List of metadata filters")
+
+
+def test_mcp_tool_registration_flow():
+    """Test the exact MCP tool registration flow to identify $ref issues."""
+    
+    print("🔍 Testing MCP Tool Registration Flow")
+    print("=" * 50)
+    
+    # Step 1: Simulate what FastMCP generates (like what MCP server gets)
+    print("\n1. Simulating FastMCP schema generation...")
+    fastmcp_schema = ShopwareKnowledgeSearchInput.model_json_schema()
+    
+    print("FastMCP Raw Schema:")
+    print(json.dumps(fastmcp_schema, indent=2))
+    
+    # Create output directory
+    tmp_dir = Path(__file__).parent.parent / "tmp"
+    tmp_dir.mkdir(exist_ok=True)
+    
+    # Save FastMCP schema
+    with open(tmp_dir / "fastmcp_raw_schema.json", 'w') as f:
+        json.dump(fastmcp_schema, f, indent=2)
+    
+    # Step 2: Simulate what MCP server stores (what goes in Tool.inputSchema)
+    print("\n2. What MCP server stores in Tool.inputSchema...")
+    mcp_server_stored_schema = fastmcp_schema  # Server just stores the raw schema
+    
+    with open(tmp_dir / "mcp_server_stored_schema.json", 'w') as f:
+        json.dump(mcp_server_stored_schema, f, indent=2)
+    
+    # Step 3: Simulate what /tools endpoint returns
+    print("\n3. What /tools endpoint returns...")
+    tools_endpoint_response = {
+        "name": "search_shopware_knowledge",
+        "description": "Search Shopware knowledge base",
+        "inputSchema": mcp_server_stored_schema,  # This has $ref!
+        "internal_url": "http://localhost:8000/tools/search_shopware_knowledge/invoke",
+        "service": "shopware-search",
+        "strict": True
+    }
+    
+    print("Tools endpoint response:")
+    print(json.dumps(tools_endpoint_response, indent=2))
+    
+    with open(tmp_dir / "tools_endpoint_response.json", 'w') as f:
+        json.dump(tools_endpoint_response, f, indent=2)
+    
+    # Step 4: Simulate MCPClient creating MCPTool
+    print("\n4. MCPClient creating MCPTool...")
+    try:
+        # This is what MCPClient.register_mcp_server() does
+        mcp_tool = MCPTool(**tools_endpoint_response)
+        
+        print("✅ MCPTool created successfully")
+        print(f"MCPTool.inputSchema: {type(mcp_tool.inputSchema)}")
+        
+        # Check if inputSchema still has $ref
+        schema_str = json.dumps(mcp_tool.inputSchema)
+        has_ref = "$ref" in schema_str or "$defs" in schema_str
+        print(f"❌ MCPTool.inputSchema still has $ref/$defs: {has_ref}")
+        
+        if has_ref:
+            print("   🚨 PROBLEM: Raw schema with $ref is stored in MCPTool!")
+        
+        with open(tmp_dir / "mcp_tool_input_schema.json", 'w') as f:
+            json.dump(mcp_tool.inputSchema, f, indent=2)
+        
+    except Exception as e:
+        print(f"❌ Failed to create MCPTool: {e}")
+        return
+    
+    # Step 5: Test MCPTool.to_openai_function()
+    print("\n5. Testing MCPTool.to_openai_function()...")
+    try:
+        openai_function = mcp_tool.to_openai_function()
+        
+        print("✅ OpenAI function created")
+        
+        # Check if the converted schema still has $ref
+        function_schema_str = json.dumps(openai_function["function"]["parameters"])
+        has_ref_after = "$ref" in function_schema_str or "$defs" in function_schema_str
+        
+        print(f"❌ Final OpenAI schema still has $ref/$defs: {has_ref_after}")
+        
+        if has_ref_after:
+            print("   🚨 CRITICAL PROBLEM: convert_to_strict_schema didn't resolve $ref!")
+        else:
+            print("   ✅ convert_to_strict_schema successfully resolved $ref")
+        
+        # Check if arrays have items
+        def check_arrays_in_schema(schema, path=""):
+            issues = []
+            if isinstance(schema, dict):
+                if schema.get("type") == "array":
+                    if "items" not in schema:
+                        issues.append(f"Array at {path} missing items")
+                    else:
+                        print(f"   ✅ Array at {path} has items")
+                
+                for key, value in schema.items():
+                    if key == "properties" and isinstance(value, dict):
+                        for prop_name, prop_schema in value.items():
+                            issues.extend(check_arrays_in_schema(prop_schema, f"{path}.{prop_name}" if path else prop_name))
+                    elif key == "items" and isinstance(value, dict):
+                        issues.extend(check_arrays_in_schema(value, f"{path}.items"))
+            return issues
+        
+        array_issues = check_arrays_in_schema(openai_function["function"]["parameters"])
+        if array_issues:
+            for issue in array_issues:
+                print(f"   ❌ {issue}")
+        
+        with open(tmp_dir / "final_openai_function.json", 'w') as f:
+            json.dump(openai_function, f, indent=2)
+        
+        print(f"\n📁 Files created in {tmp_dir}:")
+        print("   - fastmcp_raw_schema.json")
+        print("   - mcp_server_stored_schema.json")
+        print("   - tools_endpoint_response.json")
+        print("   - mcp_tool_input_schema.json")
+        print("   - final_openai_function.json")
+        
+        return openai_function
+        
+    except Exception as e:
+        print(f"❌ Failed to create OpenAI function: {e}")
+        import traceback
+        traceback.print_exc()
+        return None
+
+def test_direct_schema_conversion():
+    """Test direct schema conversion to compare with MCP flow."""
+    
+    print("\n\n🔧 Testing Direct Schema Conversion (for comparison)")
+    print("=" * 55)
+    
+    # Generate the schema
+    schema = ShopwareKnowledgeSearchInput.model_json_schema()
+    
+    print("\n1. Direct conversion without input wrapper...")
+    strict_schema = convert_to_strict_schema(schema, strict=True, keep_input_wrapper=False)
+    
+    schema_str = json.dumps(strict_schema)
+    has_ref = "$ref" in schema_str or "$defs" in schema_str
+    print(f"   Direct conversion has $ref/$defs: {has_ref}")
+    
+    print("\n2. Direct conversion with input wrapper...")
+    # Simulate MCP-style wrapper
+    wrapped_schema = {
+        "type": "object",
+        "properties": {
+            "input": schema
+        },
+        "required": ["input"]
+    }
+    
+    strict_wrapped = convert_to_strict_schema(wrapped_schema, strict=True, keep_input_wrapper=True)
+    
+    wrapped_str = json.dumps(strict_wrapped)
+    has_ref_wrapped = "$ref" in wrapped_str or "$defs" in wrapped_str
+    print(f"   Wrapped conversion has $ref/$defs: {has_ref_wrapped}")
+    
+    # Save for comparison
+    tmp_dir = Path(__file__).parent.parent / "tmp"
+    with open(tmp_dir / "direct_conversion_no_wrapper.json", 'w') as f:
+        json.dump(strict_schema, f, indent=2)
+    
+    with open(tmp_dir / "direct_conversion_with_wrapper.json", 'w') as f:
+        json.dump(strict_wrapped, f, indent=2)
+
+
+if __name__ == "__main__":
+    try:
+        # Test the MCP registration flow
+        result = test_mcp_tool_registration_flow()
+        
+        # Test direct conversion for comparison
+        test_direct_schema_conversion()
+        
+        if result:
+            print("\n✅ MCP flow test completed - check the JSON files for details")
+        else:
+            print("\n❌ MCP flow test failed")
+            
+    except Exception as e:
+        print(f"\n💥 Test failed with error: {e}")
+        import traceback
+        traceback.print_exc() 

mbxai-1.6.0/tests/test_real_mcp_schema.py

@@ -0,0 +1,308 @@
+"""
+Test with the real MCP schema structure from production logs.
+
+This test uses the exact schema structure that was causing the error
+to verify the nested $ref resolution fix works correctly.
+"""
+
+import json
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from mbxai.mcp.client import MCPTool
+from mbxai.tools.types import convert_to_strict_schema
+
+
+def test_real_production_schema():
+    """Test with the exact schema structure from production logs."""
+    
+    print("🔍 Testing Real Production MCP Schema")
+    print("=" * 45)
+    
+    # This is the exact schema structure from your production logs
+    real_mcp_tool_data = {
+        "description": "Search the Shopware knowledge base for relevant information.\n    \n    This tool performs semantic search through the Shopware knowledge collection\n    to find documentation, guides, and other relevant information based on the query.\n    \n    Args:\n        input: ShopwareKnowledgeSearchInput containing search parameters\n        \n    Returns:\n        ShopwareKnowledgeSearchResponse with search results and metadata\n        \n    Raises:\n        RuntimeError: If the search operation fails\n    ",
+        "inputSchema": {
+            "$defs": {
+                "MetadataFilter": {
+                    "description": "Model for a single metadata filter key-value pair.\n\nEach filter represents one condition to apply to the search.\nCommon filter keys include:\n- category: Content category (e.g., 'api', 'plugins', 'themes')\n- version: Shopware version (e.g., '6.5', '6.6') \n- title: Document title (partial match)\n- optimized: Whether content was AI-optimized (true/false)\n- source_url: Source URL (partial match)\n- optimization_strategy: Strategy used ('enhance_readability', etc.)\n- ai_generated_metadata: Whether metadata was AI-generated (true/false)",
+                    "properties": {
+                        "key": {
+                            "description": "The metadata field name to filter by",
+                            "title": "Key",
+                            "type": "string"
+                        },
+                        "value": {
+                            "description": "The value to filter for",
+                            "title": "Value"
+                        }
+                    },
+                    "required": [
+                        "key",
+                        "value"
+                    ],
+                    "title": "MetadataFilter",
+                    "type": "object"
+                },
+                "ShopwareKnowledgeSearchInput": {
+                    "description": "Input model for Shopware knowledge search.",
+                    "properties": {
+                        "include_metadata": {
+                            "description": "Whether to include metadata in the search results",
+                            "title": "Include Metadata",
+                            "type": "boolean"
+                        },
+                        "max_results": {
+                            "description": "Maximum number of search results to return (1-20)",
+                            "maximum": 20,
+                            "minimum": 1,
+                            "title": "Max Results",
+                            "type": "integer"
+                        },
+                        "metadata_filter": {
+                            "description": "List of metadata filters to apply to the search. Use empty list [] for no filtering, or specify key-value pairs like [{'key': 'category', 'value': 'api'}, {'key': 'version', 'value': '6.5'}]",
+                            "items": {
+                                "$ref": "#/$defs/MetadataFilter"  # This is the problematic nested $ref
+                            },
+                            "title": "Metadata Filter",
+                            "type": "array"
+                        },
+                        "query": {
+                            "description": "The search query to find relevant Shopware knowledge and documentation",
+                            "title": "Query",
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "query",
+                        "max_results",
+                        "include_metadata",
+                        "metadata_filter"
+                    ],
+                    "title": "ShopwareKnowledgeSearchInput",
+                    "type": "object"
+                }
+            },
+            "properties": {
+                "input": {
+                    "$ref": "#/$defs/ShopwareKnowledgeSearchInput"  # This references the above
+                }
+            },
+            "required": [
+                "input"
+            ],
+            "title": "search_shopware_knowledgeArguments",
+            "type": "object"
+        },
+        "internal_url": "http://shopware-knowledge.mbxai-mcp.svc.cluster.local:5000/tools/search_shopware_knowledge/invoke",
+        "name": "search_shopware_knowledge",
+        "service": "shopware-knowledge",
+        "strict": True
+    }
+    
+    print("\n1. Creating MCPTool with real production schema...")
+    
+    try:
+        # Create MCPTool (this should work)
+        mcp_tool = MCPTool(**real_mcp_tool_data)
+        print("✅ MCPTool created successfully")
+        
+        # Verify the raw schema still has $refs
+        schema_str = json.dumps(mcp_tool.inputSchema)
+        has_refs = "$ref" in schema_str and "$defs" in schema_str
+        print(f"   Raw inputSchema has $ref/$defs: {has_refs}")
+        
+        if not has_refs:
+            print("   ⚠️  Warning: Expected raw schema to have $refs")
+        
+    except Exception as e:
+        print(f"❌ Failed to create MCPTool: {e}")
+        return False
+    
+    print("\n2. Converting to OpenAI function with nested $ref resolution...")
+    
+    try:
+        # This is where the magic happens - convert to OpenAI function
+        openai_function = mcp_tool.to_openai_function()
+        print("✅ OpenAI function created successfully")
+        
+        # Check if all $refs are resolved
+        function_params = openai_function["function"]["parameters"]
+        params_str = json.dumps(function_params)
+        
+        has_refs_after = "$ref" in params_str or "$defs" in params_str
+        print(f"   Final schema has $ref/$defs: {has_refs_after}")
+        
+        if has_refs_after:
+            print("   ❌ FAIL: Schema conversion didn't resolve all $refs!")
+            return False
+        else:
+            print("   ✅ SUCCESS: All $refs resolved!")
+        
+        # Check the specific structure we care about
+        print("\n3. Validating specific schema structure...")
+        
+        # Should have input property
+        if "input" not in function_params["properties"]:
+            print("   ❌ Missing 'input' property")
+            return False
+        
+        input_schema = function_params["properties"]["input"]
+        print("   ✅ Found 'input' property")
+        
+        # Should have metadata_filter array
+        if "metadata_filter" not in input_schema["properties"]:
+            print("   ❌ Missing 'metadata_filter' in input schema")
+            return False
+        
+        metadata_filter = input_schema["properties"]["metadata_filter"]
+        print("   ✅ Found 'metadata_filter' property")
+        
+        # Should be array type
+        if metadata_filter["type"] != "array":
+            print(f"   ❌ metadata_filter type is {metadata_filter['type']}, expected 'array'")
+            return False
+        print("   ✅ metadata_filter is array type")
+        
+        # Should have items property
+        if "items" not in metadata_filter:
+            print("   ❌ metadata_filter missing 'items' property")
+            return False
+        print("   ✅ metadata_filter has 'items' property")
+        
+        # Items should be object with key/value properties (no $ref)
+        items_schema = metadata_filter["items"]
+        if items_schema["type"] != "object":
+            print(f"   ❌ metadata_filter items type is {items_schema['type']}, expected 'object'")
+            return False
+        print("   ✅ metadata_filter items is object type")
+        
+        if "key" not in items_schema["properties"] or "value" not in items_schema["properties"]:
+            print("   ❌ metadata_filter items missing 'key' or 'value' properties")
+            return False
+        print("   ✅ metadata_filter items has 'key' and 'value' properties")
+        
+        # Check that items schema has no $ref
+        items_str = json.dumps(items_schema)
+        if "$ref" in items_str:
+            print("   ❌ metadata_filter items still contains $ref")
+            return False
+        print("   ✅ metadata_filter items has no $ref")
+        
+        # Save the results
+        tmp_dir = Path(__file__).parent.parent / "tmp"
+        tmp_dir.mkdir(exist_ok=True)
+        
+        with open(tmp_dir / "real_production_schema_raw.json", 'w') as f:
+            json.dump(mcp_tool.inputSchema, f, indent=2)
+        
+        with open(tmp_dir / "real_production_schema_converted.json", 'w') as f:
+            json.dump(openai_function, f, indent=2)
+        
+        print(f"\n📁 Files saved to {tmp_dir}:")
+        print("   - real_production_schema_raw.json")
+        print("   - real_production_schema_converted.json")
+        
+        print("\n🎉 ALL TESTS PASSED! Nested $ref resolution works correctly!")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Failed to convert to OpenAI function: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def test_direct_conversion_with_nested_refs():
+    """Test direct schema conversion with the nested refs structure."""
+    
+    print("\n\n🔧 Testing Direct Conversion with Nested $refs")
+    print("=" * 50)
+    
+    # The problematic schema structure
+    nested_ref_schema = {
+        "$defs": {
+            "MetadataFilter": {
+                "type": "object",
+                "properties": {
+                    "key": {"type": "string", "description": "Filter key"},
+                    "value": {"type": "string", "description": "Filter value"}
+                },
+                "required": ["key", "value"]
+            },
+            "ShopwareInput": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "Search query"},
+                    "metadata_filter": {
+                        "type": "array",
+                        "description": "Metadata filters",
+                        "items": {
+                            "$ref": "#/$defs/MetadataFilter"  # Nested $ref
+                        }
+                    }
+                },
+                "required": ["query", "metadata_filter"]
+            }
+        },
+        "type": "object",
+        "properties": {
+            "input": {
+                "$ref": "#/$defs/ShopwareInput"  # Top-level $ref
+            }
+        },
+        "required": ["input"]
+    }
+    
+    print("Testing direct conversion with keep_input_wrapper=True...")
+    
+    try:
+        result = convert_to_strict_schema(nested_ref_schema, strict=True, keep_input_wrapper=True)
+        
+        # Check no $refs remain
+        result_str = json.dumps(result)
+        has_refs = "$ref" in result_str or "$defs" in result_str
+        
+        print(f"   Result has $ref/$defs: {has_refs}")
+        
+        if has_refs:
+            print("   ❌ Direct conversion still has $refs")
+            return False
+        else:
+            print("   ✅ Direct conversion resolved all $refs")
+        
+        # Save result
+        tmp_dir = Path(__file__).parent.parent / "tmp"
+        with open(tmp_dir / "direct_nested_ref_conversion.json", 'w') as f:
+            json.dump(result, f, indent=2)
+        
+        return True
+        
+    except Exception as e:
+        print(f"   ❌ Direct conversion failed: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    try:
+        print("🧪 Testing Nested $ref Resolution Fix")
+        print("=" * 40)
+        
+        # Test with real production schema
+        test1_passed = test_real_production_schema()
+        
+        # Test direct conversion
+        test2_passed = test_direct_conversion_with_nested_refs()
+        
+        if test1_passed and test2_passed:
+            print("\n🎉 ALL TESTS PASSED!")
+            print("The nested $ref resolution fix is working correctly!")
+        else:
+            print("\n❌ SOME TESTS FAILED")
+            print("The fix needs more work.")
+            
+    except Exception as e:
+        print(f"\n💥 Test suite failed: {e}")
+        import traceback
+        traceback.print_exc() 

{mbxai-1.5.0 → mbxai-1.6.0/tests}/test_schema_conversion.py

@@ -6,10 +6,16 @@ when converting Pydantic models to OpenAI function schemas.
 """
 
 import json
+import os
 from typing import Any
 from pydantic import BaseModel, Field
 
-from src.mbxai.tools.types import convert_to_strict_schema
+# Add the src directory to the path so we can import from mbxai
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from mbxai.tools.types import convert_to_strict_schema
 
 
 class MetadataFilter(BaseModel):
@@ -49,8 +55,8 @@ class ShopwareKnowledgeSearchInput(BaseModel):
     )
 
 
-def test_schema_conversion():
-    """Test that Pydantic models are properly converted to OpenAI-compatible schemas."""
+def test_shopware_schema_conversion():
+    """Test that Shopware knowledge search Pydantic models are properly converted to OpenAI-compatible schemas."""
     
     print("🧪 Testing Schema Conversion for Shopware Knowledge Search")
     print("=" * 60)
@@ -59,62 +65,53 @@ def test_schema_conversion():
     print("\n1. Generating Pydantic JSON Schema...")
     pydantic_schema = ShopwareKnowledgeSearchInput.model_json_schema()
     
-    print("Original Pydantic Schema:")
-    print(json.dumps(pydantic_schema, indent=2))
-    
-    # Test 1: Convert without input wrapper
-    print("\n2. Converting to OpenAI strict schema (no input wrapper)...")
-    strict_schema_no_wrapper = convert_to_strict_schema(
+    # Convert to OpenAI strict schema
+    print("2. Converting to OpenAI strict schema...")
+    strict_schema = convert_to_strict_schema(
         pydantic_schema, 
         strict=True, 
         keep_input_wrapper=False
     )
     
-    print("Strict Schema (no wrapper):")
-    print(json.dumps(strict_schema_no_wrapper, indent=2))
-    
-    # Test 2: Convert with input wrapper (MCP style)
-    print("\n3. Converting to OpenAI strict schema (with input wrapper)...")
-    
-    # Create MCP-style schema with input wrapper
-    mcp_style_schema = {
-        "type": "object",
-        "properties": {
-            "input": pydantic_schema
-        },
-        "required": ["input"],
-        "additionalProperties": False
-    }
-    
-    strict_schema_with_wrapper = convert_to_strict_schema(
-        mcp_style_schema,
-        strict=True,
-        keep_input_wrapper=True
-    )
-    
-    print("Strict Schema (with input wrapper):")
-    print(json.dumps(strict_schema_with_wrapper, indent=2))
-    
-    # Test 3: Create OpenAI function definition
-    print("\n4. Creating OpenAI Function Definition...")
-    
+    # Create OpenAI function definition
+    print("3. Creating OpenAI Function Definition...")
     function_def = {
         "type": "function",
         "function": {
             "name": "search_shopware_knowledge",
             "description": "Search Shopware knowledge base for relevant documentation and information",
-            "parameters": strict_schema_no_wrapper,
+            "parameters": strict_schema,
             "strict": True
         }
     }
     
-    print("OpenAI Function Definition:")
-    print(json.dumps(function_def, indent=2))
+    # Create local tmp directory for output files
+    tmp_dir = Path(__file__).parent.parent / "tmp"
+    tmp_dir.mkdir(exist_ok=True)
+    
+    # Create output files in local tmp directory
+    original_schema_file = tmp_dir / "shopware_original_schema.json"
+    strict_schema_file = tmp_dir / "shopware_strict_schema.json"
+    function_def_file = tmp_dir / "shopware_openai_function.json"
+    
+    with open(original_schema_file, 'w') as f:
+        json.dump(pydantic_schema, f, indent=2)
+    
+    with open(strict_schema_file, 'w') as f:
+        json.dump(strict_schema, f, indent=2)
+    
+    with open(function_def_file, 'w') as f:
+        json.dump(function_def, f, indent=2)
+    
+    print(f"\n📄 Generated files:")
+    print(f"   Original Pydantic Schema: {original_schema_file}")
+    print(f"   OpenAI Strict Schema: {strict_schema_file}")
+    print(f"   OpenAI Function Definition: {function_def_file}")
     
     # Validation checks
-    print("\n5. Validation Checks...")
-    print("✅ Checking that all arrays have 'items' property...")
+    print("\n4. Validation Checks...")
     
+    # Check that all arrays have 'items' property
     def check_arrays_have_items(schema, path=""):
         """Recursively check that all arrays have items property."""
         issues = []
@@ -136,22 +133,18 @@ def test_schema_conversion():
         
         return issues
     
-    issues = check_arrays_have_items(strict_schema_no_wrapper)
-    if issues:
-        for issue in issues:
-            print(f"   ❌ {issue}")
-        raise AssertionError(f"Schema validation failed: {issues}")
-    else:
-        print("   ✓ All arrays have proper 'items' definitions")
+    print("✅ Checking that all arrays have 'items' property...")
+    issues = check_arrays_have_items(strict_schema)
+    assert not issues, f"Schema validation failed: {issues}"
+    print("   ✓ All arrays have proper 'items' definitions")
     
+    # Check that no $ref or $defs exist
     print("\n✅ Checking that no $ref or $defs exist...")
-    schema_str = json.dumps(strict_schema_no_wrapper)
-    if "$ref" in schema_str or "$defs" in schema_str:
-        raise AssertionError("Schema still contains $ref or $defs")
-    else:
-        print("   ✓ No $ref or $defs found - schema is fully inlined")
+    schema_str = json.dumps(strict_schema)
+    assert "$ref" not in schema_str and "$defs" not in schema_str, "Schema still contains $ref or $defs"
+    print("   ✓ No $ref or $defs found - schema is fully inlined")
     
-    print("\n✅ Checking that all objects have additionalProperties: false...")
+    # Check that all objects have additionalProperties: false
     def check_additional_properties(schema, path=""):
         """Recursively check that all objects have additionalProperties: false."""
         issues = []
@@ -175,13 +168,30 @@ def test_schema_conversion():
         
         return issues
     
-    issues = check_additional_properties(strict_schema_no_wrapper)
-    if issues:
-        for issue in issues:
-            print(f"   ❌ {issue}")
-        raise AssertionError(f"additionalProperties validation failed: {issues}")
-    else:
-        print("   ✓ All objects have additionalProperties: false")
+    print("\n✅ Checking that all objects have additionalProperties: false...")
+    issues = check_additional_properties(strict_schema)
+    assert not issues, f"additionalProperties validation failed: {issues}"
+    print("   ✓ All objects have additionalProperties: false")
+    
+    # Check that constraints are preserved
+    print("\n✅ Checking that constraints are preserved...")
+    max_results_prop = strict_schema["properties"]["max_results"]
+    assert max_results_prop["minimum"] == 1, "minimum constraint not preserved"
+    assert max_results_prop["maximum"] == 20, "maximum constraint not preserved"
+    print("   ✓ Constraints preserved (ge=1, le=20 for max_results)")
+    
+    # Check that metadata_filter array has proper MetadataFilter items
+    print("\n✅ Checking metadata_filter array structure...")
+    metadata_filter_prop = strict_schema["properties"]["metadata_filter"]
+    assert metadata_filter_prop["type"] == "array", "metadata_filter should be array"
+    assert "items" in metadata_filter_prop, "metadata_filter array missing items"
+    
+    items_schema = metadata_filter_prop["items"]
+    assert items_schema["type"] == "object", "metadata_filter items should be object"
+    assert "key" in items_schema["properties"], "metadata_filter items missing 'key' property"
+    assert "value" in items_schema["properties"], "metadata_filter items missing 'value' property"
+    assert items_schema["required"] == ["key", "value"], "metadata_filter items missing required fields"
+    print("   ✓ metadata_filter array has proper MetadataFilter object items")
     
     print("\n🎉 All tests passed! Schema is OpenAI/OpenRouter compatible!")
     print("\nKey improvements:")
@@ -190,15 +200,78 @@ def test_schema_conversion():
     print("- ✅ All objects have additionalProperties: false")
     print("- ✅ Constraints preserved (ge=1, le=20 for max_results)")
     print("- ✅ Complex nested structures handled correctly")
+    print("- ✅ metadata_filter array properly defines MetadataFilter items")
     
-    return function_def
+    # Return file paths for further inspection
+    return {
+        "original_schema_file": str(original_schema_file),
+        "strict_schema_file": str(strict_schema_file),
+        "function_def_file": str(function_def_file),
+        "function_definition": function_def
+    }
+
+
+def test_mcp_style_schema_conversion():
+    """Test schema conversion with MCP-style input wrapper."""
+    
+    print("\n🧪 Testing MCP-Style Schema Conversion")
+    print("=" * 50)
+    
+    # Generate the JSON schema from the Pydantic model
+    pydantic_schema = ShopwareKnowledgeSearchInput.model_json_schema()
+    
+    # Create MCP-style schema with input wrapper
+    mcp_style_schema = {
+        "type": "object",
+        "properties": {
+            "input": pydantic_schema
+        },
+        "required": ["input"],
+        "additionalProperties": False
+    }
+    
+    # Convert with input wrapper
+    strict_schema_with_wrapper = convert_to_strict_schema(
+        mcp_style_schema,
+        strict=True,
+        keep_input_wrapper=True
+    )
+    
+    # Create output file in local tmp directory
+    tmp_dir = Path(__file__).parent.parent / "tmp"
+    tmp_dir.mkdir(exist_ok=True)
+    
+    mcp_schema_file = tmp_dir / "shopware_mcp_style_schema.json"
+    with open(mcp_schema_file, 'w') as f:
+        json.dump(strict_schema_with_wrapper, f, indent=2)
+    
+    print(f"📄 MCP-Style Schema: {mcp_schema_file}")
+    
+    # Validate MCP-style structure
+    assert "input" in strict_schema_with_wrapper["properties"], "MCP wrapper missing input property"
+    input_schema = strict_schema_with_wrapper["properties"]["input"]
+    assert "metadata_filter" in input_schema["properties"], "Input schema missing metadata_filter"
+    
+    print("✅ MCP-style schema conversion successful!")
+    
+    return str(mcp_schema_file)
 
 
 if __name__ == "__main__":
     try:
-        function_def = test_schema_conversion()
-        print(f"\n✅ Test completed successfully!")
-        print(f"Function definition ready for OpenRouter API")
+        # Run the main test
+        result = test_shopware_schema_conversion()
+        
+        # Run the MCP-style test
+        mcp_file = test_mcp_style_schema_conversion()
+        
+        print(f"\n✅ All tests completed successfully!")
+        print(f"\n📁 Check these files to inspect the generated schemas:")
+        print(f"   - Original: {result['original_schema_file']}")
+        print(f"   - Strict: {result['strict_schema_file']}")
+        print(f"   - Function: {result['function_def_file']}")
+        print(f"   - MCP Style: {mcp_file}")
+        
     except Exception as e:
         print(f"\n❌ Test failed: {e}")
         raise