PyPI - mbxai - Versions diffs - 1.0.5__tar.gz → 1.0.6__tar.gz - Mend

mbxai 1.0.5tar.gz → 1.0.6tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

{mbxai-1.0.5 → mbxai-1.0.6}/PKG-INFO RENAMED Viewed

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

{mbxai-1.0.5 → mbxai-1.0.6}/pyproject.toml RENAMED Viewed

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

{mbxai-1.0.5 → mbxai-1.0.6}/setup.py RENAMED Viewed

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

{mbxai-1.0.5 → mbxai-1.0.6}/src/mbxai/__init__.py RENAMED Viewed

@@ -2,4 +2,4 @@
 MBX AI package.
 """
-__version__ = "1.0.5"
+__version__ = "1.0.6"

mbxai-1.0.6/src/mbxai/examples/mcp/mcp_server_example.py ADDED Viewed

@@ -0,0 +1,118 @@
+"""Example MCP server implementation."""
+import asyncio
+from typing import Any
+from pydantic import BaseModel
+from mcp.server.fastmcp import FastMCP
+from mbxai.mcp import MCPServer
+from fastapi import Body
+import uvicorn
+# Create a FastMCP instance for this module
+mcp = FastMCP("html-structure-analyser")
+class ScraperInput(BaseModel):
+    url: str
+@mcp.tool()
+async def scrape_html(input: ScraperInput) -> str:
+    """Scrape HTML content from a URL.
+    This function fetches the HTML content from a given URL using httpx.
+    It handles redirects and raises appropriate exceptions for HTTP errors.
+    Args:
+        input: ScraperInput model containing the URL to scrape
+    Returns:
+        str: The HTML content of the page
+    Raises:
+        httpx.HTTPError: If there's an HTTP error while fetching the page
+        Exception: For any other unexpected errors
+    """
+    # This is a mock implementation that returns sample HTML
+    sample_html = f"""
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Sample Page</title>
+    </head>
+    <body>
+        <header>
+            <h1>Welcome to Sample Page</h1>
+            <nav>
+                <ul>
+                    <li><a href="#home">Home</a></li>
+                    <li><a href="#about">About</a></li>
+                    <li><a href="#contact">Contact</a></li>
+                </ul>
+            </nav>
+        </header>
+        <main>
+            <section id="content">
+                <h2>Main Content</h2>
+                <p>This is a sample HTML page that was scraped from {input.url}</p>
+                <article>
+                    <h3>Article Title</h3>
+                    <p>This is a sample article with some content.</p>
+                </article>
+            </section>
+        </main>
+        <footer>
+            <p>&copy; 2024 Sample Website</p>
+        </footer>
+    </body>
+    </html>
+    """
+    return sample_html
+class CustomMCPServer(MCPServer):
+    """Custom MCP server with overridden endpoints."""
+    def _register_endpoints(self) -> None:
+        """Register FastAPI endpoints."""
+        @self.app.get("/tools")
+        async def get_tools():
+            """Return the list of available tools."""
+            tools = []
+            for tool in self._tools.values():
+                tool_dict = tool.model_dump(exclude={'function'})
+                tool_dict['internal_url'] = f"http://localhost:8000/tools/{tool.name}/invoke"
+                tool_dict['service'] = "html-structure-analyser"
+                tools.append(tool_dict)
+            return {"tools": tools}
+        @self.app.post("/tools/{tool_name}/invoke")
+        async def invoke_tool(tool_name: str, arguments: dict[str, Any] = Body(...)):
+            """Invoke a specific MCP tool."""
+            try:
+                result = await self.mcp_server.call_tool(tool_name, arguments=arguments)
+                if isinstance(result, list) and len(result) == 1:
+                    first_item = result[0]
+                    if hasattr(first_item, "type") and first_item.type == "text":
+                        return first_item.text
+                elif isinstance(result, dict) and result.get("type") == "text":
+                    return result["text"]
+                return result
+            except Exception as e:
+                return {"error": f"Error invoking tool {tool_name}: {str(e)}"}
+async def start_server():
+    # Create and start the MCP server
+    server = CustomMCPServer("html-structure-analyser")
+    # Register the tool with the MCP server
+    await server.add_tool(scrape_html)
+    # Create uvicorn config
+    config = uvicorn.Config(server.app, host="0.0.0.0", port=8000)
+    server = uvicorn.Server(config)
+    # Start the server
+    await server.serve()
+if __name__ == "__main__":
+    asyncio.run(start_server())

{mbxai-1.0.5 → mbxai-1.0.6}/src/mbxai/mcp/client.py RENAMED Viewed

@@ -16,7 +16,7 @@ T = TypeVar("T", bound=BaseModel)
 class MCPTool(Tool):
     """A tool from the MCP server."""
-    input_schema: dict[str, Any]
+    inputSchema: dict[str, Any]
     internal_url: str
     strict: bool = True
     function: Callable[..., Any] | None = None  # Make function optional during initialization
@@ -24,7 +24,7 @@ class MCPTool(Tool):
     def to_openai_function(self) -> dict[str, Any]:
         """Convert the tool to an OpenAI function definition."""
         # Convert schema to strict format, keeping input wrapper
-        strict_schema = convert_to_strict_schema(self.input_schema, strict=self.strict, keep_input_wrapper=True)
+        strict_schema = convert_to_strict_schema(self.inputSchema, strict=self.strict, keep_input_wrapper=True)
         function_def = {
             "type": "function",

{mbxai-1.0.5 → mbxai-1.0.6}/src/mbxai/mcp/server.py RENAMED Viewed

@@ -14,7 +14,7 @@ class Tool(BaseModel):
     model_config = ConfigDict(strict=True)
     name: str = Field(description="The name of the tool")
     description: str = Field(description="The description of what the tool does")
-    input_schema: dict[str, Any] = Field(description="The input schema for the tool")
+    inputSchema: dict[str, Any] = Field(description="The input schema for the tool")
     strict: bool = Field(default=True, description="Whether the tool response is strictly validated")
     function: Callable[..., Any] = Field(description="The tool function", exclude=True)
@@ -31,7 +31,7 @@ class MCPServer:
         self.app = FastAPI(
             title=self.name,
             description=self.description,
-            version="1.0.5",
+            version="1.0.6",
         )
         # Initialize MCP server
@@ -75,17 +75,17 @@ class MCPServer:
         tool_metadata = tools[-1]
         # Convert FastMCP schema to our schema format
-        input_schema = tool_metadata.inputSchema
-        if isinstance(input_schema, dict):
-            if "$ref" in input_schema:
-                ref = input_schema["$ref"].split("/")[-1]
-                input_schema = tool_metadata.inputSchema.get("$defs", {}).get(ref, {})
+        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,
             description=tool_metadata.description,
-            input_schema=input_schema,
+            inputSchema=inputSchema,
             strict=True,
             function=tool
         )

{mbxai-1.0.5 → mbxai-1.0.6}/src/mbxai/openrouter/client.py RENAMED Viewed

@@ -9,6 +9,7 @@ from .config import OpenRouterConfig
 import logging
 import time
 import asyncio
+import traceback
 from functools import wraps
 logger = logging.getLogger(__name__)
@@ -150,18 +151,20 @@ class OpenRouterClient:
             OpenRouterError: For other errors
         """
         error_msg = str(error)
+        stack_trace = traceback.format_exc()
         logger.error(f"API error during {operation}: {error_msg}")
+        logger.error(f"Stack trace:\n{stack_trace}")
         if isinstance(error, OpenAIError):
-            raise OpenRouterAPIError(f"API error during {operation}: {error_msg}")
+            raise OpenRouterAPIError(f"API error during {operation}: {error_msg}\nStack trace:\n{stack_trace}")
         elif "Connection" in error_msg:
-            raise OpenRouterConnectionError(f"Connection error during {operation}: {error_msg}")
+            raise OpenRouterConnectionError(f"Connection error during {operation}: {error_msg}\nStack trace:\n{stack_trace}")
         elif "Expecting value" in error_msg and "line" in error_msg:
             # This is a JSON parsing error, likely due to a truncated or malformed response
             logger.error("JSON parsing error detected. This might be due to a large response or network issues.")
-            raise OpenRouterAPIError(f"Response parsing error during {operation}. The response might be too large or malformed.")
+            raise OpenRouterAPIError(f"Response parsing error during {operation}. The response might be too large or malformed.\nStack trace:\n{stack_trace}")
         else:
-            raise OpenRouterError(f"Error during {operation}: {error_msg}")
+            raise OpenRouterError(f"Error during {operation}: {error_msg}\nStack trace:\n{stack_trace}")
     @property
     def model(self) -> str:
@@ -224,7 +227,9 @@ class OpenRouterClient:
             return response
         except Exception as e:
+            stack_trace = traceback.format_exc()
             logger.error(f"Error in chat completion: {str(e)}")
+            logger.error(f"Stack trace:\n{stack_trace}")
             logger.error(f"Request details: model={model or self.model}, stream={stream}, kwargs={kwargs}")
             logger.error(f"Message structure: {[{'role': msg.get('role'), 'content_length': len(str(msg.get('content', '')))} for msg in messages]}")
@@ -306,16 +311,20 @@ class OpenRouterClient:
                     else:
                         response.choices[0].message.parsed = content
                 except Exception as e:
+                    stack_trace = traceback.format_exc()
                     logger.error(f"Failed to parse message content: {str(e)}")
-                    raise OpenRouterAPIError(f"Failed to parse message content: {str(e)}")
+                    logger.error(f"Stack trace:\n{stack_trace}")
+                    raise OpenRouterAPIError(f"Failed to parse message content: {str(e)}\nStack trace:\n{stack_trace}")
             logger.info(f"Received response from OpenRouter: {len(response.choices)} choices")
             return response
         except Exception as e:
+            stack_trace = traceback.format_exc()
             logger.debug(f"Raising error: {e}")
             logger.error(f"Error in parse completion: {str(e)}")
+            logger.error(f"Stack trace:\n{stack_trace}")
             logger.error(f"Request details: model={model or self.model}, response_format={response_format}, kwargs={kwargs}")
             logger.error(f"Message structure: {[{'role': msg.get('role'), 'content_length': len(str(msg.get('content', '')))} for msg in messages]}")

{mbxai-1.0.5 → mbxai-1.0.6}/src/mbxai/tools/types.py RENAMED Viewed

@@ -33,12 +33,12 @@ def convert_to_strict_schema(schema: dict[str, Any], strict: bool = True, keep_i
     # Handle input wrapper
     if "properties" in schema and "input" in schema["properties"]:
-        input_schema = schema["properties"]["input"]
+        inputSchema = schema["properties"]["input"]
         # 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, {})
+        if "$ref" in inputSchema:
+            ref = inputSchema["$ref"].split("/")[-1]
+            inputSchema = schema.get("$defs", {}).get(ref, {})
         if keep_input_wrapper:
             # Create the input property schema
@@ -50,8 +50,8 @@ def convert_to_strict_schema(schema: dict[str, Any], strict: bool = True, keep_i
             }
             # Copy over input properties
-            if "properties" in input_schema:
-                for prop_name, prop in input_schema["properties"].items():
+            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"),
@@ -65,8 +65,8 @@ def convert_to_strict_schema(schema: dict[str, Any], strict: bool = True, keep_i
                     input_prop_schema["properties"][prop_name] = new_prop
             # Copy over required fields for input schema
-            if "required" in input_schema:
-                input_prop_schema["required"] = input_schema["required"]
+            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
@@ -76,8 +76,8 @@ def convert_to_strict_schema(schema: dict[str, Any], strict: bool = True, keep_i
                 strict_schema["required"] = schema["required"]
         else:
             # If not keeping input wrapper, use input schema directly
-            if "properties" in input_schema:
-                for prop_name, prop in input_schema["properties"].items():
+            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"),
@@ -91,8 +91,8 @@ def convert_to_strict_schema(schema: dict[str, Any], strict: bool = True, keep_i
                     strict_schema["properties"][prop_name] = new_prop
             # Copy over required fields
-            if "required" in input_schema:
-                strict_schema["required"] = input_schema["required"]
+            if "required" in inputSchema:
+                strict_schema["required"] = inputSchema["required"]
     else:
         # If no input wrapper, use the schema as is
         if "properties" in schema:

mbxai-1.0.5/src/mbxai/examples/mcp/mcp_server_example.py DELETED Viewed

@@ -1,94 +0,0 @@
-"""Example MCP server implementation."""
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
-import uvicorn
-from typing import Any
-app = FastAPI()
-class ScraperInput(BaseModel):
-    url: str
-class ScrapeHtmlArguments(BaseModel):
-    input: ScraperInput
-@app.get("/tools")
-async def get_tools():
-    """Return the list of available tools."""
-    return {
-        "tools": [
-            {
-                "description": "Scrape HTML content from a URL.\n\n    This function fetches the HTML content from a given URL using httpx.\n    It handles redirects and raises appropriate exceptions for HTTP errors.\n\n    Args:\n        input (ScrapeHtmlInput): The input containing the URL to scrape\n\n    Returns:\n        ScrapeHtmlOutput: The HTML content of the page\n\n    Raises:\n        httpx.HTTPError: If there's an HTTP error while fetching the page\n        Exception: For any other unexpected errors\n    ",
-                "input_schema": {
-                    "$defs": {
-                        "ScrapeHtmlInput": {
-                            "properties": {
-                                "url": {
-                                    "description": "The URL to scrape HTML from",
-                                    "minLength": 1,
-                                    "title": "Url",
-                                    "type": "string",
-                                }
-                            },
-                            "required": ["url"],
-                            "title": "ScrapeHtmlInput",
-                            "type": "object",
-                        }
-                    },
-                    "properties": {"input": {"$ref": "#/$defs/ScrapeHtmlInput"}},
-                    "required": ["input"],
-                    "title": "scrape_htmlArguments",
-                    "type": "object",
-                },
-                "internal_url": "http://localhost:8000/tools/scrape_html/invoke",
-                "name": "scrape_html",
-                "service": "html-structure-analyser",
-                "strict": True,
-            }
-        ]
-    }
-@app.post("/tools/scrape_html/invoke")
-async def scrape_html(arguments: ScrapeHtmlArguments):
-    sample_html = """
-    <!DOCTYPE html>
-    <html lang="en">
-    <head>
-        <meta charset="UTF-8">
-        <meta name="viewport" content="width=device-width, initial-scale=1.0">
-        <title>Sample Page</title>
-    </head>
-    <body>
-        <header>
-            <h1>Welcome to Sample Page</h1>
-            <nav>
-                <ul>
-                    <li><a href="#home">Home</a></li>
-                    <li><a href="#about">About</a></li>
-                    <li><a href="#contact">Contact</a></li>
-                </ul>
-            </nav>
-        </header>
-        <main>
-            <section id="content">
-                <h2>Main Content</h2>
-                <p>This is a sample HTML page that was scraped from {arguments.input.url}</p>
-                <article>
-                    <h3>Article Title</h3>
-                    <p>This is a sample article with some content.</p>
-                </article>
-            </section>
-        </main>
-        <footer>
-            <p>&copy; 2024 Sample Website</p>
-        </footer>
-    </body>
-    </html>
-    """
-    return sample_html
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=8000)