mbxai 1.5.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

mbxai/examples/auto_schema_example.py

@@ -0,0 +1,228 @@
+"""
+Example demonstrating automatic schema generation from function signatures.
+"""
+
+import os
+from typing import Optional
+from pydantic import BaseModel, Field
+from mbxai import AgentClient, ToolClient, OpenRouterClient
+
+
+class WeatherResponse(BaseModel):
+    """Response for weather queries."""
+    location: str = Field(description="The location")
+    temperature: str = Field(description="Current temperature")
+    conditions: str = Field(description="Weather conditions")
+    recommendations: list[str] = Field(description="Recommendations based on weather")
+
+
+def get_weather(location: str, unit: str = "fahrenheit") -> dict:
+    """Get weather information for a location.
+    
+    Args:
+        location: The city or location name
+        unit: Temperature unit (fahrenheit or celsius)
+    
+    Returns:
+        Weather information dictionary
+    """
+    # Mock weather service
+    temp = "72°F" if unit == "fahrenheit" else "22°C"
+    return {
+        "location": location,
+        "temperature": temp,
+        "conditions": "Sunny"
+    }
+
+
+def calculate_tip(bill_amount: float, tip_percentage: float = 18.0, split_count: int = 1) -> dict:
+    """Calculate tip and split the bill.
+    
+    Args:
+        bill_amount: Total bill amount in dollars
+        tip_percentage: Tip percentage (default 18%)
+        split_count: Number of people to split between (default 1)
+    
+    Returns:
+        Calculation results
+    """
+    tip_amount = bill_amount * (tip_percentage / 100)
+    total_amount = bill_amount + tip_amount
+    per_person = total_amount / split_count
+    
+    return {
+        "bill_amount": bill_amount,
+        "tip_amount": tip_amount,
+        "total_amount": total_amount,
+        "per_person": per_person,
+        "split_count": split_count
+    }
+
+
+def search_knowledge(query: str, category: Optional[str] = None, max_results: int = 5) -> dict:
+    """Search knowledge base for information.
+    
+    Args:
+        query: Search query string
+        category: Optional category filter
+        max_results: Maximum number of results to return
+    
+    Returns:
+        Search results
+    """
+    # Mock search results
+    return {
+        "query": query,
+        "category": category,
+        "results": [f"Result {i+1} for '{query}'" for i in range(min(max_results, 3))],
+        "total_found": max_results
+    }
+
+
+def demo_automatic_schema_generation():
+    """Demonstrate automatic schema generation from function signatures."""
+    
+    print("=== Automatic Schema Generation Example ===\n")
+    
+    # Initialize clients
+    openrouter_client = OpenRouterClient(token=os.getenv("OPENROUTER_API_KEY", "test-token"))
+    tool_client = ToolClient(openrouter_client)
+    agent = AgentClient(tool_client)
+    
+    print("Registering tools with automatic schema generation...\n")
+    
+    # Register tools WITHOUT providing schemas - they'll be auto-generated
+    tools_to_register = [
+        {
+            "name": "get_weather",
+            "description": "Get current weather for a location",
+            "function": get_weather
+        },
+        {
+            "name": "calculate_tip", 
+            "description": "Calculate tip and split bill between people",
+            "function": calculate_tip
+        },
+        {
+            "name": "search_knowledge",
+            "description": "Search knowledge base for information",
+            "function": search_knowledge
+        }
+    ]
+    
+    for tool_info in tools_to_register:
+        try:
+            # Register without schema - will be auto-generated
+            agent.register_tool(
+                name=tool_info["name"],
+                description=tool_info["description"],
+                function=tool_info["function"]
+                # Note: No schema parameter - it will be auto-generated!
+            )
+            print(f"✅ Registered '{tool_info['name']}' with auto-generated schema")
+            
+        except Exception as e:
+            print(f"❌ Failed to register '{tool_info['name']}': {e}")
+    
+    print("\n" + "="*50 + "\n")
+    
+    # Show what schemas were generated
+    print("Generated Tool Schemas:")
+    print("-" * 25)
+    
+    # Access the registered tools to show their schemas
+    if hasattr(tool_client, '_tools'):
+        for tool_name, tool in tool_client._tools.items():
+            print(f"\n🔧 Tool: {tool_name}")
+            print(f"   Description: {tool.description}")
+            print(f"   Schema keys: {list(tool.schema.get('properties', {}).keys())}")
+            print(f"   Required params: {tool.schema.get('required', [])}")
+            
+            # Show a few key properties
+            properties = tool.schema.get('properties', {})
+            for prop_name, prop_schema in list(properties.items())[:3]:  # Show first 3
+                prop_type = prop_schema.get('type', 'unknown')
+                prop_desc = prop_schema.get('description', 'No description')
+                print(f"   - {prop_name}: {prop_type} - {prop_desc}")
+    
+    print("\n" + "="*50 + "\n")
+    
+    # Demonstrate usage examples
+    print("Example usage with auto-generated schemas:")
+    print('agent.agent("What\'s the weather in Tokyo?", WeatherResponse)')
+    print('agent.agent("Calculate tip for a $85 bill split 4 ways", CalculationResponse)')
+    print('agent.agent("Search for Python tutorials", SearchResponse)')
+
+
+def demo_manual_vs_automatic():
+    """Compare manual schema vs automatic generation."""
+    
+    print("\n=== Manual vs Automatic Schema Comparison ===\n")
+    
+    openrouter_client = OpenRouterClient(token="test-token")
+    tool_client = ToolClient(openrouter_client)
+    
+    # Example function
+    def example_function(name: str, age: int, active: bool = True) -> str:
+        """Example function for schema comparison.
+        
+        Args:
+            name: Person's name
+            age: Person's age in years  
+            active: Whether person is active
+        """
+        return f"{name} is {age} years old and {'active' if active else 'inactive'}"
+    
+    print("1. Manual Schema (traditional approach):")
+    manual_schema = {
+        "type": "object",
+        "properties": {
+            "name": {"type": "string", "description": "Person's name"},
+            "age": {"type": "integer", "description": "Person's age in years"},
+            "active": {"type": "boolean", "description": "Whether person is active"}
+        },
+        "required": ["name", "age"],
+        "additionalProperties": False
+    }
+    print(f"   Properties: {list(manual_schema['properties'].keys())}")
+    print(f"   Required: {manual_schema['required']}")
+    
+    print("\n2. Automatic Schema (from function signature):")
+    try:
+        # Register with auto-generation
+        tool_client.register_tool(
+            "example_tool",
+            "Example tool with auto-generated schema", 
+            example_function
+            # No schema provided - will be auto-generated
+        )
+        
+        auto_tool = tool_client._tools.get("example_tool")
+        if auto_tool:
+            auto_schema = auto_tool.schema
+            print(f"   Properties: {list(auto_schema.get('properties', {}).keys())}")
+            print(f"   Required: {auto_schema.get('required', [])}")
+            print(f"   Additional Properties: {auto_schema.get('additionalProperties')}")
+        
+    except Exception as e:
+        print(f"   Error: {e}")
+    
+    print("\n✨ Benefits of automatic generation:")
+    print("   - No manual schema writing required")
+    print("   - Automatically extracts types from function signature")
+    print("   - Handles default values correctly") 
+    print("   - Uses existing convert_to_strict_schema pipeline")
+    print("   - Reduces chance of schema/function mismatch")
+
+
+if __name__ == "__main__":
+    demo_automatic_schema_generation()
+    demo_manual_vs_automatic()
+    
+    print("\n" + "="*60)
+    print("Automatic schema generation demo completed! 🎉")
+    print("\nKey benefits:")
+    print("• Zero-config tool registration")
+    print("• Type-safe schema generation")  
+    print("• Leverages existing Pydantic infrastructure")
+    print("• Compatible with MCPTool.to_openai_function() approach")

mbxai/examples/simple_agent_test.py

@@ -0,0 +1,168 @@
+"""
+Simple test to verify AgentClient functionality.
+"""
+
+from pydantic import BaseModel, Field
+from mbxai.agent import AgentClient, AgentResponse, Question, Result
+from mbxai.openrouter import OpenRouterClient
+
+
+class SimpleResponse(BaseModel):
+    """A simple response structure for testing."""
+    message: str = Field(description="The response message")
+    confidence: float = Field(description="Confidence level from 0.0 to 1.0")
+
+
+def test_agent_validation():
+    """Test AgentClient validation of parse method requirement."""
+    
+    print("=== Testing AgentClient Validation ===")
+    
+    # Test 1: Valid client with parse method (OpenRouterClient-like)
+    class MockOpenRouterClient:
+        def parse(self, messages, response_format):
+            # Mock response based on the format
+            class MockChoice:
+                def __init__(self, content):
+                    self.message = MockMessage(content)
+            
+            class MockMessage:
+                def __init__(self, content):
+                    self.content = content
+                    self.parsed = None
+            
+            class MockResponse:
+                def __init__(self, content):
+                    self.choices = [MockChoice(content)]
+            
+            # Return appropriate mock response based on format
+            if response_format.__name__ == "QuestionList":
+                return MockResponse('{"questions": []}')
+            elif response_format.__name__ == "Result":
+                return MockResponse('{"result": "This is a test result"}')
+            elif response_format.__name__ == "QualityCheck":
+                return MockResponse('{"is_good": true, "feedback": ""}')
+            elif response_format.__name__ == "SimpleResponse":
+                return MockResponse('{"message": "Test completed successfully", "confidence": 0.95}')
+            else:
+                return MockResponse('{"result": "Default response"}')
+    
+    try:
+        mock_client = MockOpenRouterClient()
+        agent = AgentClient(mock_client)
+        print("✅ Valid client accepted - has parse method")
+        
+        # Test max_iterations parameter
+        agent_custom = AgentClient(mock_client, max_iterations=3)
+        print("✅ Custom max_iterations parameter accepted")
+        
+        # Test tool registration (should fail for OpenRouterClient-like)
+        try:
+            agent.register_tool("test", "desc", lambda: None, {})
+            print("❌ Tool registration should have failed for OpenRouterClient-like")
+        except AttributeError:
+            print("✅ Tool registration correctly rejected for OpenRouterClient-like")
+            
+    except ValueError as e:
+        print(f"❌ Valid client rejected: {e}")
+        return False
+    
+    # Test 2: Valid client with parse and register_tool (ToolClient-like)
+    class MockToolClient:
+        def parse(self, messages, response_format):
+            return MockOpenRouterClient().parse(messages, response_format)
+        
+        def register_tool(self, name, description, function, schema):
+            # Mock tool registration
+            pass
+    
+    try:
+        mock_tool_client = MockToolClient()
+        agent = AgentClient(mock_tool_client)
+        print("✅ ToolClient-like client accepted")
+        
+        # Test tool registration (should succeed)
+        agent.register_tool("test", "desc", lambda: None, {})
+        print("✅ Tool registration succeeded for ToolClient-like")
+        
+    except Exception as e:
+        print(f"❌ ToolClient-like test failed: {e}")
+    
+    # Test 3: Invalid client without parse method
+    class MockInvalidClient:
+        def create(self, messages, **kwargs):
+            return "No parse method"
+    
+    try:
+        invalid_client = MockInvalidClient()
+        agent = AgentClient(invalid_client)
+        print("❌ Invalid client accepted - should have been rejected!")
+        return False
+    except ValueError as e:
+        print(f"✅ Invalid client correctly rejected: {e}")
+    
+    return True
+
+
+def test_agent_workflow():
+    """Test the basic agent workflow without actual API calls."""
+    
+    # Mock OpenRouter client for testing
+    class MockOpenRouterClient:
+        def parse(self, messages, response_format):
+            # Mock response based on the format
+            class MockChoice:
+                def __init__(self, content):
+                    self.message = MockMessage(content)
+            
+            class MockMessage:
+                def __init__(self, content):
+                    self.content = content
+                    self.parsed = None
+            
+            class MockResponse:
+                def __init__(self, content):
+                    self.choices = [MockChoice(content)]
+            
+            # Return appropriate mock response based on format
+            if response_format.__name__ == "QuestionList":
+                return MockResponse('{"questions": []}')
+            elif response_format.__name__ == "Result":
+                return MockResponse('{"result": "This is a test result"}')
+            elif response_format.__name__ == "QualityCheck":
+                return MockResponse('{"is_good": true, "feedback": ""}')
+            elif response_format.__name__ == "SimpleResponse":
+                return MockResponse('{"message": "Test completed successfully", "confidence": 0.95}')
+            else:
+                return MockResponse('{"result": "Default response"}')
+    
+    print("\n=== Testing Agent Workflow ===")
+    
+    # Test the agent
+    mock_client = MockOpenRouterClient()
+    agent = AgentClient(mock_client)
+    
+    # Test without questions
+    prompt = "Test prompt"
+    response = agent.agent(prompt, SimpleResponse, ask_questions=False)
+    
+    print("Agent Test Results:")
+    print(f"Has questions: {response.has_questions()}")
+    print(f"Is complete: {response.is_complete()}")
+    
+    if response.is_complete():
+        print(f"Final response type: {type(response.final_response)}")
+        print(f"Final response: {response.final_response}")
+    
+    return response
+
+
+if __name__ == "__main__":
+    # Run validation tests first
+    validation_passed = test_agent_validation()
+    
+    if validation_passed:
+        # Then run workflow test
+        test_agent_workflow()
+    else:
+        print("❌ Validation tests failed, skipping workflow test")

mbxai/mcp/server.py

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

mbxai/tools/client.py

@@ -6,14 +6,57 @@ from typing import Any, Callable, TypeVar
 import logging
 import inspect
 import json
-from pydantic import BaseModel
+from pydantic import BaseModel, create_model
 from ..openrouter import OpenRouterClient
-from .types import Tool
+from .types import Tool, convert_to_strict_schema
 
 logger = logging.getLogger(__name__)
 
 T = TypeVar("T", bound=BaseModel)
 
+
+def _generate_schema_from_function(func: Callable[..., Any]) -> dict[str, Any]:
+    """Generate JSON schema from function signature using Pydantic's model_json_schema."""
+    try:
+        sig = inspect.signature(func)
+        
+        # Extract fields for the Pydantic model
+        fields = {}
+        
+        for param_name, param in sig.parameters.items():
+            # Skip self parameter
+            if param_name == 'self':
+                continue
+            
+            # Get the parameter type annotation
+            param_type = param.annotation if param.annotation != inspect.Parameter.empty else str
+            
+            # Handle default values
+            if param.default != inspect.Parameter.empty:
+                fields[param_name] = (param_type, param.default)
+            else:
+                fields[param_name] = (param_type, ...)  # Required field
+        
+        # Create a temporary Pydantic model
+        temp_model = create_model('TempToolModel', **fields)
+        
+        # Generate schema using Pydantic's built-in method
+        schema = temp_model.model_json_schema()
+        
+        logger.debug(f"Generated schema for function {func.__name__}: {json.dumps(schema, indent=2)}")
+        return schema
+        
+    except Exception as e:
+        logger.warning(f"Failed to generate schema for function {func.__name__}: {e}")
+        # Return a basic schema as fallback
+        return {
+            "type": "object",
+            "properties": {},
+            "required": [],
+            "additionalProperties": False
+        }
+
+
 class ToolClient:
     """Client for handling tool calls with OpenRouter."""
 
@@ -31,7 +74,7 @@ class ToolClient:
         name: str,
         description: str,
         function: Callable[..., Any],
-        schema: dict[str, Any],
+        schema: dict[str, Any] | None = None,
     ) -> None:
         """Register a new tool.
 
@@ -39,8 +82,17 @@ class ToolClient:
             name: The name of the tool
             description: A description of what the tool does
             function: The function to call when the tool is used
-            schema: The JSON schema for the tool's parameters
+            schema: The JSON schema for the tool's parameters. If None or empty, 
+                   will be automatically generated from the function signature.
         """
+        # Generate schema automatically if not provided or empty
+        if not schema:
+            logger.debug(f"No schema provided for tool '{name}', generating from function signature")
+            raw_schema = _generate_schema_from_function(function)
+            # Use the existing convert_to_strict_schema like MCPTool does
+            schema = convert_to_strict_schema(raw_schema, strict=True, keep_input_wrapper=False)
+            logger.debug(f"Auto-generated and converted schema for '{name}': {json.dumps(schema, indent=2)}")
+        
         tool = Tool(
             name=name,
             description=description,
@@ -336,7 +388,7 @@ class ToolClient:
                         raise ValueError(f"Invalid tool arguments format: {tool_call.function.arguments}")
 
                     # Call the tool
-                    logger.debug(f"Calling tool: {tool.name} with args: {self._truncate_dict(arguments)}")
+                    logger.info(f"Calling tool: {tool.name} with args: {self._truncate_dict(arguments)}")
                     try:
                         result = tool.function(**arguments)
                         logger.debug(f"Tool {tool.name} completed successfully")

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