mbxai 1.4.0__tar.gz → 1.6.0__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mbxai
-Version: 1.4.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.4.0 → mbxai-1.6.0}/pyproject.toml

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

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

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

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

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

{mbxai-1.4.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.4.0",
+            version="1.6.0",
         )
         
         # Initialize MCP server
@@ -74,13 +74,10 @@ class MCPServer:
         tools = await self.mcp_server.list_tools()
         tool_metadata = tools[-1]
         
-        # Convert FastMCP schema to our schema format
+        # Use the raw inputSchema from FastMCP - it will be processed later by convert_to_strict_schema
+        # when the tool is converted to OpenAI function format
         inputSchema = tool_metadata.inputSchema
-        if isinstance(inputSchema, dict):
-            if "$ref" in inputSchema:
-                ref = inputSchema["$ref"].split("/")[-1]
-                inputSchema = tool_metadata.inputSchema.get("$defs", {}).get(ref, {})
-                    
+        
         # Create and store Tool instance
         self._tools[tool_metadata.name] = Tool(
             name=tool_metadata.name,

mbxai-1.6.0/src/mbxai/tools/types.py

@@ -0,0 +1,245 @@
+"""
+Type definitions for the tools package.
+"""
+
+from typing import Any, Callable
+from pydantic import BaseModel, Field
+import logging
+import json
+
+logger = logging.getLogger(__name__)
+
+def _resolve_ref(schema: dict[str, Any], ref: str, root_schema: dict[str, Any]) -> dict[str, Any]:
+    """Resolve a $ref to its actual schema definition.
+    
+    Args:
+        schema: The current schema object
+        ref: The reference string (e.g., "#/$defs/MyType")
+        root_schema: The root schema containing $defs
+        
+    Returns:
+        The resolved schema definition with all nested $refs also resolved
+    """
+    if ref.startswith("#/"):
+        # Remove the "#/" prefix and split the path
+        path_parts = ref[2:].split("/")
+        current = root_schema
+        
+        # Navigate through the path
+        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 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}
+
+def _convert_property_to_strict(prop: dict[str, Any], root_schema: dict[str, Any]) -> dict[str, Any]:
+    """Convert a single property to strict format, recursively handling nested objects and arrays.
+    
+    Args:
+        prop: The property definition to convert
+        root_schema: The root schema containing $defs
+        
+    Returns:
+        A strict format property definition with all $refs resolved
+    """
+    # Handle $ref resolution first - this may return a completely different schema
+    if "$ref" in prop:
+        # 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")
+    
+    # Start with basic property structure
+    new_prop = {
+        "type": prop_type,
+        "description": prop.get("description", f"A {prop_type} parameter")
+    }
+    
+    # Handle specific types
+    if prop_type == "object":
+        # Objects need additionalProperties: false and properties
+        new_prop["additionalProperties"] = False
+        new_prop["properties"] = {}
+        new_prop["required"] = []
+        
+        # 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)
+        
+        # Copy required fields
+        if "required" in prop:
+            new_prop["required"] = prop["required"]
+            
+    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
+            new_prop["items"] = {
+                "type": "string",
+                "description": "Array item"
+            }
+            
+    elif prop_type in ["string", "number", "integer", "boolean"]:
+        # For primitive types, copy additional constraints
+        if "enum" in prop:
+            new_prop["enum"] = prop["enum"]
+        if "minimum" in prop:
+            new_prop["minimum"] = prop["minimum"]
+        if "maximum" in prop:
+            new_prop["maximum"] = prop["maximum"]
+        if "pattern" in prop:
+            new_prop["pattern"] = prop["pattern"]
+        if "format" in prop:
+            new_prop["format"] = prop["format"]
+    
+    return new_prop
+
+def convert_to_strict_schema(schema: dict[str, Any], strict: bool = True, keep_input_wrapper: bool = False) -> dict[str, Any]:
+    """Convert a schema to strict format required by OpenAI.
+    
+    This function handles:
+    - Resolving all $ref and $defs to inline definitions
+    - Adding required 'items' property for arrays
+    - Ensuring all objects have 'additionalProperties: false'
+    - Recursively processing nested schemas
+    
+    Args:
+        schema: The input schema to validate and convert
+        strict: Whether to enforce strict validation with additionalProperties: false
+        keep_input_wrapper: Whether to keep the input wrapper (for MCP tools)
+        
+    Returns:
+        A schema in strict format with all references resolved
+    """
+    if not schema:
+        return {"type": "object", "properties": {}, "required": [], "additionalProperties": False}
+
+    # Create a new schema object to ensure we have all required fields
+    strict_schema = {
+        "type": "object",
+        "properties": {},
+        "required": [],
+        "additionalProperties": False  # Always enforce additionalProperties: false for OpenRouter
+    }
+
+    # Store the root schema for $ref resolution
+    root_schema = schema
+
+    # Handle input wrapper
+    if "properties" in schema and "input" in schema["properties"]:
+        inputSchema = schema["properties"]["input"]
+        
+        # If input has a $ref, resolve it
+        if "$ref" in inputSchema:
+            inputSchema = _resolve_ref(inputSchema, inputSchema["$ref"], root_schema)
+        
+        if keep_input_wrapper:
+            # Create the input property schema
+            input_prop_schema = {
+                "type": "object",
+                "properties": {},
+                "required": [],
+                "additionalProperties": False  # Always enforce additionalProperties: false for OpenRouter
+            }
+            
+            # Process input properties
+            if "properties" in inputSchema:
+                for prop_name, prop in inputSchema["properties"].items():
+                    input_prop_schema["properties"][prop_name] = _convert_property_to_strict(prop, root_schema)
+            
+            # Copy over required fields for input schema
+            if "required" in inputSchema:
+                input_prop_schema["required"] = inputSchema["required"]
+            
+            # Add the input property to the main schema
+            strict_schema["properties"]["input"] = input_prop_schema
+            
+            # Copy over required fields for main schema
+            if "required" in schema:
+                strict_schema["required"] = schema["required"]
+        else:
+            # If not keeping input wrapper, use input schema directly
+            if "properties" in inputSchema:
+                for prop_name, prop in inputSchema["properties"].items():
+                    strict_schema["properties"][prop_name] = _convert_property_to_strict(prop, root_schema)
+            
+            # Copy over required fields
+            if "required" in inputSchema:
+                strict_schema["required"] = inputSchema["required"]
+    else:
+        # If no input wrapper, use the schema as is
+        if "properties" in schema:
+            for prop_name, prop in schema["properties"].items():
+                strict_schema["properties"][prop_name] = _convert_property_to_strict(prop, root_schema)
+        
+        # Copy over required fields
+        if "required" in schema:
+            strict_schema["required"] = schema["required"]
+
+    return strict_schema
+
+class ToolCall(BaseModel):
+    """A tool call from the model."""
+    id: str
+    name: str
+    arguments: dict[str, Any]
+
+class Tool(BaseModel):
+    """A tool that can be used by the model."""
+    name: str
+    description: str
+    function: Callable[..., Any] | None = None  # Make function optional
+    schema: dict[str, Any]
+
+    def to_openai_function(self) -> dict[str, Any]:
+        """Convert the tool to an OpenAI function definition."""
+        # Ensure schema is in strict format
+        strict_schema = convert_to_strict_schema(self.schema)
+        
+        function_def = {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": strict_schema,
+                "strict": True
+            }
+        }
+        
+        logger.debug(f"(types) Created function definition for {self.name}: {json.dumps(function_def, indent=2)}")
+        return function_def 

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()