mbxai 1.4.0__tar.gz → 1.5.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mbxai
-Version: 1.4.0
+Version: 1.5.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.5.0}/pyproject.toml

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

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

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

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

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

{mbxai-1.4.0 → mbxai-1.5.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.5.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.5.0/src/mbxai/tools/types.py

@@ -0,0 +1,220 @@
+"""
+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
+    """
+    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}
+        
+        return current if isinstance(current, dict) else {"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
+    """
+    # Handle $ref resolution
+    if "$ref" in prop:
+        resolved = _resolve_ref(prop, prop["$ref"], root_schema)
+        return _convert_property_to_strict(resolved, root_schema)
+    
+    # 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
+        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:
+            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.5.0/test_schema_conversion.py

@@ -0,0 +1,204 @@
+"""
+Test for schema conversion with Pydantic models containing arrays.
+
+This test demonstrates the fix for the "array schema missing items" error
+when converting Pydantic models to OpenAI function schemas.
+"""
+
+import json
+from typing import Any
+from pydantic import BaseModel, Field
+
+from src.mbxai.tools.types import convert_to_strict_schema
+
+
+class MetadataFilter(BaseModel):
+    """Model for a single metadata filter key-value pair.
+    
+    Each filter represents one condition to apply to the search.
+    Common filter keys include:
+    - category: Content category (e.g., 'api', 'plugins', 'themes')
+    - version: Shopware version (e.g., '6.5', '6.6') 
+    - title: Document title (partial match)
+    - optimized: Whether content was AI-optimized (true/false)
+    - source_url: Source URL (partial match)
+    - optimization_strategy: Strategy used ('enhance_readability', etc.)
+    - ai_generated_metadata: Whether metadata was AI-generated (true/false)
+    """
+    
+    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 to find relevant Shopware knowledge and documentation"
+    )
+    max_results: int = Field(
+        description="Maximum number of search results to return (1-20)",
+        ge=1,
+        le=20
+    )
+    include_metadata: bool = Field(
+        description="Whether to include metadata in the search results"
+    )
+    metadata_filter: list[MetadataFilter] = Field(
+        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'}]"
+    )
+
+
+def test_schema_conversion():
+    """Test that Pydantic models are properly converted to OpenAI-compatible schemas."""
+    
+    print("🧪 Testing Schema Conversion for Shopware Knowledge Search")
+    print("=" * 60)
+    
+    # Generate the JSON schema from the Pydantic model
+    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(
+        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...")
+    
+    function_def = {
+        "type": "function",
+        "function": {
+            "name": "search_shopware_knowledge",
+            "description": "Search Shopware knowledge base for relevant documentation and information",
+            "parameters": strict_schema_no_wrapper,
+            "strict": True
+        }
+    }
+    
+    print("OpenAI Function Definition:")
+    print(json.dumps(function_def, indent=2))
+    
+    # Validation checks
+    print("\n5. Validation Checks...")
+    print("✅ Checking that all arrays have 'items' property...")
+    
+    def check_arrays_have_items(schema, path=""):
+        """Recursively check that all arrays have items property."""
+        issues = []
+        
+        if isinstance(schema, dict):
+            if schema.get("type") == "array":
+                if "items" not in schema:
+                    issues.append(f"Array at {path} missing 'items' property")
+                else:
+                    print(f"   ✓ Array at {path} has items: {schema['items'].get('type', 'unknown')}")
+                    # Recursively check items
+                    issues.extend(check_arrays_have_items(schema["items"], f"{path}.items"))
+            
+            # Check properties
+            if "properties" in schema:
+                for prop_name, prop_schema in schema["properties"].items():
+                    prop_path = f"{path}.{prop_name}" if path else prop_name
+                    issues.extend(check_arrays_have_items(prop_schema, prop_path))
+        
+        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("\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")
+    
+    print("\n✅ Checking that all objects have additionalProperties: false...")
+    def check_additional_properties(schema, path=""):
+        """Recursively check that all objects have additionalProperties: false."""
+        issues = []
+        
+        if isinstance(schema, dict):
+            if schema.get("type") == "object":
+                if schema.get("additionalProperties") is not False:
+                    issues.append(f"Object at {path} missing 'additionalProperties: false'")
+                else:
+                    print(f"   ✓ Object at {path} has additionalProperties: false")
+            
+            # Check nested schemas
+            for key, value in schema.items():
+                if key in ["properties", "items"] and isinstance(value, dict):
+                    if key == "properties":
+                        for prop_name, prop_schema in value.items():
+                            prop_path = f"{path}.{prop_name}" if path else prop_name
+                            issues.extend(check_additional_properties(prop_schema, prop_path))
+                    else:  # items
+                        issues.extend(check_additional_properties(value, f"{path}.items"))
+        
+        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🎉 All tests passed! Schema is OpenAI/OpenRouter compatible!")
+    print("\nKey improvements:")
+    print("- ✅ Arrays have proper 'items' definitions")
+    print("- ✅ No $ref or $defs (fully inlined)")
+    print("- ✅ All objects have additionalProperties: false")
+    print("- ✅ Constraints preserved (ge=1, le=20 for max_results)")
+    print("- ✅ Complex nested structures handled correctly")
+    
+    return function_def
+
+
+if __name__ == "__main__":
+    try:
+        function_def = test_schema_conversion()
+        print(f"\n✅ Test completed successfully!")
+        print(f"Function definition ready for OpenRouter API")
+    except Exception as e:
+        print(f"\n❌ Test failed: {e}")
+        raise 

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

@@ -1,147 +0,0 @@
-"""
-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 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.
-    
-    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
-    """
-    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
-    }
-
-    # 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:
-            ref = inputSchema["$ref"].split("/")[-1]
-            inputSchema = schema.get("$defs", {}).get(ref, {})
-        
-        if keep_input_wrapper:
-            # Create the input property schema
-            input_prop_schema = {
-                "type": "object",
-                "properties": {},
-                "required": [],
-                "additionalProperties": False  # Always enforce additionalProperties: false for OpenRouter
-            }
-            
-            # Copy over input properties
-            if "properties" in inputSchema:
-                for prop_name, prop in inputSchema["properties"].items():
-                    # Create a new property object with only allowed fields
-                    new_prop = {
-                        "type": prop.get("type", "string"),
-                        "description": prop.get("description", f"The {prop_name} parameter")
-                    }
-                    
-                    # If the property is an object, ensure it has additionalProperties: false
-                    if new_prop["type"] == "object":
-                        new_prop["additionalProperties"] = False
-                    
-                    input_prop_schema["properties"][prop_name] = new_prop
-            
-            # 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():
-                    # Create a new property object with only allowed fields
-                    new_prop = {
-                        "type": prop.get("type", "string"),
-                        "description": prop.get("description", f"The {prop_name} parameter")
-                    }
-                    
-                    # If the property is an object, ensure it has additionalProperties: false
-                    if new_prop["type"] == "object":
-                        new_prop["additionalProperties"] = False
-                    
-                    strict_schema["properties"][prop_name] = new_prop
-            
-            # 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():
-                # Create a new property object with only allowed fields
-                new_prop = {
-                    "type": prop.get("type", "string"),
-                    "description": prop.get("description", f"The {prop_name} parameter")
-                }
-                
-                # If the property is an object, ensure it has additionalProperties: false
-                if new_prop["type"] == "object":
-                    new_prop["additionalProperties"] = False
-                
-                strict_schema["properties"][prop_name] = new_prop
-        
-        # 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