mbxai 0.6.19__tar.gz → 0.6.21__tar.gz

{mbxai-0.6.19 → mbxai-0.6.21}/PKG-INFO

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

{mbxai-0.6.19 → mbxai-0.6.21}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mbxai"
-version = "0.6.19"
+version = "0.6.21"
 authors = [
     { name = "MBX AI" }
 ]

{mbxai-0.6.19 → mbxai-0.6.21}/setup.py

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

{mbxai-0.6.19 → mbxai-0.6.21}/src/mbxai/__init__.py

@@ -2,4 +2,4 @@
 MBX AI package.
 """
 
-__version__ = "0.6.19" 
+__version__ = "0.6.21" 

{mbxai-0.6.19 → mbxai-0.6.21}/src/mbxai/mcp/client.py

@@ -16,28 +16,24 @@ T = TypeVar("T", bound=BaseModel)
 
 
 class MCPTool(Tool):
-    """MCP tool definition."""
-    internal_url: str | None = Field(default=None, description="The internal URL to invoke the tool")
-    service: str = Field(description="The service that provides the tool")
-    strict: bool = Field(default=True, description="Whether the tool response is strictly validated")
-    input_schema: dict[str, Any] = Field(description="The input schema for the tool")
-    function: Callable[..., Any] | None = Field(default=None, description="The function that implements the tool")
-    _converted_schema: dict[str, Any] | None = None
+    """A tool from the MCP server."""
+    input_schema: dict[str, Any]
+    internal_url: str
+    strict: bool = True
+    function: Callable[..., Any] | None = None  # Make function optional during initialization
 
     def to_openai_function(self) -> dict[str, Any]:
         """Convert the tool to an OpenAI function definition."""
-        # Use cached schema if available
-        if self._converted_schema is None:
-            # Convert the schema to strict format
-            self._converted_schema = convert_to_strict_schema(self.input_schema, self.strict)
-            logger.debug(f"Converted schema for {self.name}: {json.dumps(self._converted_schema, indent=2)}")
+        # Use the base Tool's schema conversion
+        strict_schema = convert_to_strict_schema(self.input_schema, strict=self.strict)
+        logger.info(f"Converted schema for {self.name}: {json.dumps(strict_schema, indent=2)}")
         
         return {
             "type": "function",
             "function": {
                 "name": self.name,
                 "description": self.description,
-                "parameters": self._converted_schema
+                "parameters": strict_schema
             }
         }
 

{mbxai-0.6.19 → mbxai-0.6.21}/src/mbxai/mcp/server.py

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

{mbxai-0.6.19 → mbxai-0.6.21}/src/mbxai/tools/types.py

@@ -4,6 +4,10 @@ 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) -> dict[str, Any]:
     """Convert a schema to strict format required by OpenAI.
@@ -15,6 +19,9 @@ def convert_to_strict_schema(schema: dict[str, Any], strict: bool = True) -> dic
     Returns:
         A schema in strict format
     """
+    logger.info(f"Converting schema to strict format. Input schema: {json.dumps(schema, indent=2)}")
+    logger.info(f"Strict mode: {strict}")
+
     if not schema:
         return {"type": "object", "properties": {}, "required": []}
 
@@ -32,11 +39,13 @@ def convert_to_strict_schema(schema: dict[str, Any], strict: bool = True) -> dic
     # Handle input wrapper
     if "properties" in schema and "input" in schema["properties"]:
         input_schema = schema["properties"]["input"]
+        logger.info(f"Found input wrapper. Input schema: {json.dumps(input_schema, indent=2)}")
         
         # If input has a $ref, resolve it
         if "$ref" in input_schema:
             ref = input_schema["$ref"].split("/")[-1]
             input_schema = schema.get("$defs", {}).get(ref, {})
+            logger.info(f"Resolved $ref to: {json.dumps(input_schema, indent=2)}")
         
         # Create the input property schema
         input_prop_schema = {
@@ -64,10 +73,12 @@ def convert_to_strict_schema(schema: dict[str, Any], strict: bool = True) -> dic
                         new_prop[key] = value
                 
                 input_prop_schema["properties"][prop_name] = new_prop
+                logger.info(f"Added property {prop_name}: {json.dumps(new_prop, indent=2)}")
         
         # Copy over required fields for input schema
         if "required" in input_schema:
             input_prop_schema["required"] = input_schema["required"]
+            logger.info(f"Added required fields for input schema: {input_prop_schema['required']}")
         
         # Add the input property to the main schema
         strict_schema["properties"]["input"] = input_prop_schema
@@ -75,7 +86,9 @@ def convert_to_strict_schema(schema: dict[str, Any], strict: bool = True) -> dic
         # Copy over required fields for main schema
         if "required" in schema:
             strict_schema["required"] = schema["required"]
+            logger.info(f"Added required fields for main schema: {strict_schema['required']}")
 
+    logger.info(f"Final strict schema: {json.dumps(strict_schema, indent=2)}")
     return strict_schema
 
 class ToolCall(BaseModel):
@@ -88,13 +101,14 @@ class Tool(BaseModel):
     """A tool that can be used by the model."""
     name: str
     description: str
-    function: Callable[..., Any]
+    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)
+        logger.info(f"Converted schema for {self.name}: {json.dumps(strict_schema, indent=2)}")
         
         return {
             "type": "function",

{mbxai-0.6.19 → mbxai-0.6.21}/uv.lock

@@ -446,7 +446,7 @@ wheels = [
 
 [[package]]
 name = "mbxai"
-version = "0.6.19"
+version = "0.6.21"
 source = { editable = "." }
 dependencies = [
     { name = "fastapi" },