mbxai 1.0.12__py3-none-any.whl → 1.1.0__py3-none-any.whl

mbxai/__init__.py

@@ -2,4 +2,4 @@
 MBX AI package.
 """
 
-__version__ = "1.0.12" 
+__version__ = "1.1.0" 

mbxai/examples/request.json

@@ -0,0 +1,127 @@
+{
+  "model": "openai/gpt-4.1",
+  "messages": [
+    {
+      "role": "system",
+      "content": ""
+    },
+    {
+      "role": "user",
+      "content": ""
+    }
+  ],
+  "tools": [
+    {
+      "type": "function",
+      "function": {
+        "name": "analyze_html",
+        "description": "Analyze HTML content to understand its structure and extract key information.\n\n    This function performs a comprehensive analysis of HTML content using AI to:\n    - Identify the page structure and layout\n    - Extract key information in a key=value format\n    - Explain the code organization and hierarchy\n    - Identify main content areas and their purposes\n\n    Args:\n        input (AnalyzeHtmlInput): The input containing HTML code to analyze\n\n    Returns:\n        str: A structured analysis containing key information and page structure details\n    ",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "input": {
+              "type": "object",
+              "properties": {
+                "html": {
+                  "type": "string",
+                  "description": "The HTML code to be analyzed"
+                }
+              },
+              "required": ["html"],
+              "additionalProperties": false
+            }
+          },
+          "required": ["input"],
+          "additionalProperties": false
+        },
+        "strict": true
+      }
+    },
+    {
+      "type": "function",
+      "function": {
+        "name": "analyze_variant_handling",
+        "description": "Analyze an e-commerce product detail page to understand variant handling and selection logic.\n\n    This function performs a comprehensive analysis of product variant handling by:\n    - Identifying variant selection UI elements\n    - Understanding variant types and options\n    - Analyzing the variant selection logic\n    - Detecting price updates and availability changes\n    - Identifying variant-related JavaScript functions\n\n    Args:\n        input (AnalyzeVariantHandlingInput): The input containing HTML code of the product detail page\n\n    Returns:\n        str: A structured analysis containing variant handling details\n    ",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "input": {
+              "type": "object",
+              "properties": {
+                "html": {
+                  "type": "string",
+                  "description": "The HTML code to analyze for variant handling"
+                }
+              },
+              "required": ["html"],
+              "additionalProperties": false
+            }
+          },
+          "required": ["input"],
+          "additionalProperties": false
+        },
+        "strict": true
+      }
+    },
+    {
+      "type": "function",
+      "function": {
+        "name": "generate_product_selectors",
+        "description": "Generate clear selectors for extracting product information from an HTML page.\n\n    This function takes the HTML and analysis results from both analysis tools to generate\n    precise selectors that can be used to extract various product information using Python.\n\n    Args:\n        input (GenerateProductSelectorsInput): The input containing HTML and analysis results\n\n    Returns:\n        str: A structured set of selectors for extracting product information\n    ",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "input": {
+              "type": "object",
+              "properties": {
+                "html": {
+                  "type": "string",
+                  "description": "The HTML code to generate selectors for"
+                },
+                "structure_analysis": {
+                  "type": "string",
+                  "description": "The results from analyze_html"
+                },
+                "variant_analysis": {
+                  "type": "string",
+                  "description": "The results from analyze_variant_handling"
+                }
+              },
+              "required": ["html", "structure_analysis", "variant_analysis"],
+              "additionalProperties": false
+            }
+          },
+          "required": ["input"],
+          "additionalProperties": false
+        },
+        "strict": true
+      }
+    },
+    {
+      "type": "function",
+      "function": {
+        "name": "scrape_html",
+        "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    ",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "input": {
+              "type": "object",
+              "properties": {
+                "url": {
+                  "type": "string",
+                  "description": "The URL to scrape HTML from"
+                }
+              },
+              "required": ["url"],
+              "additionalProperties": false
+            }
+          },
+          "required": ["input"],
+          "additionalProperties": false
+        },
+        "strict": true
+      }
+    }
+  ]
+}

mbxai/examples/response.json

@@ -0,0 +1,30 @@
+{
+  "id": "gen-1746645035-Q9k3fnnriVxdePheqbuo",
+  "created": 1746645035,
+  "model": "openai/gpt-4.1",
+  "choices": [
+    {
+      "index": 0,
+      "message": {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          {
+            "id": "call_rMZXIopQAIhToRa5o9nslOnC",
+            "type": "function",
+            "function": {
+              "name": "analyze_variant_handling",
+              "arguments": "{\"input\": {\"html\": \"<!DOCTYPE html>\\n\\n<html lang=\\\"de-DE\\\"\\n      itemscope=\\\"itemscope\\\"\\n      itemtype=\\\"https://schema.org/WebPage\\\">\\n\\n    \\n                            \\n    <head>\\n ...\"}}"
+            }
+          }
+        ]
+      },
+      "finish_reason": "tool_calls"
+    }
+  ],
+  "usage": {
+    "prompt_tokens": 44250,
+    "completion_tokens": 145,
+    "total_tokens": 44395
+  }
+}

mbxai/examples/send_request.py

@@ -0,0 +1,181 @@
+"""
+Script to send a request to AI using OpenRouterClient by reading request.json.
+"""
+
+import os
+import json
+import logging
+from pathlib import Path
+from mbxai.openrouter.client import OpenRouterClient
+from pydantic import BaseModel, Field
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+class PageStructureValidator(BaseModel):
+    """Model representing a validator to check if an HTML page matches a known structure."""
+
+    name: str = Field(description="Name of the validator")
+    xpath_selector: str = Field(
+        description="XPath selector to check if the structure matches"
+    )
+    description: str = Field(
+        description="Description of what this validator checks for"
+    )
+
+
+class ProductSelector(BaseModel):
+    """Model representing a selector for extracting specific product data."""
+
+    field_name: str = Field(description="Name of the product field to extract")
+    xpath_selector: str = Field(description="XPath selector to extract the data")
+    description: str = Field(description="Description of what this selector extracts")
+    is_list: bool = Field(description="Whether this selector should extract a list of values or a single value")
+
+
+class PageStructureAnalysis(BaseModel):
+    """Model representing the analysis of a product page structure."""
+
+    structure_id: str = Field(description="Unique identifier for this page structure")
+    store_name: str = Field(description="Name of the store/website")
+    structure_description: str = Field(description="Description of the page structure")
+    validators: list[PageStructureValidator] = Field(
+        description="Validators to check if HTML matches this structure"
+    )
+    selectors: list[ProductSelector] = Field(
+        description="Selectors to extract product data"
+    )
+
+
+def read_request_json() -> dict:
+    """Read and parse the request.json file.
+    
+    Returns:
+        dict: The parsed JSON data
+    """
+    current_dir = Path(__file__).parent
+    request_file = current_dir / "request.json"
+    
+    try:
+        with open(request_file, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except FileNotFoundError:
+        logger.error(f"request.json not found at {request_file}")
+        raise
+    except json.JSONDecodeError as e:
+        logger.error(f"Error parsing request.json: {e}")
+        raise
+
+def format_response(response) -> dict:
+    """Format the ChatCompletion response into a JSON-serializable dictionary.
+    
+    Args:
+        response: The ChatCompletion response from OpenAI
+        
+    Returns:
+        dict: A JSON-serializable dictionary containing the response data
+    """
+    # Format choices with tool calls if present
+    choices = []
+    for choice in response.choices:
+        choice_data = {
+            'index': choice.index,
+            'message': {
+                'role': choice.message.role,
+                'content': choice.message.content
+            },
+            'finish_reason': choice.finish_reason
+        }
+        
+        # Add tool calls if they exist
+        if hasattr(choice.message, 'tool_calls') and choice.message.tool_calls:
+            choice_data['message']['tool_calls'] = [
+                {
+                    'id': tool_call.id,
+                    'type': tool_call.type,
+                    'function': {
+                        'name': tool_call.function.name,
+                        'arguments': tool_call.function.arguments
+                    }
+                }
+                for tool_call in choice.message.tool_calls
+            ]
+        
+        choices.append(choice_data)
+
+    return {
+        'id': response.id,
+        'created': response.created,
+        'model': response.model,
+        'choices': choices,
+        'usage': {
+            'prompt_tokens': response.usage.prompt_tokens,
+            'completion_tokens': response.usage.completion_tokens,
+            'total_tokens': response.usage.total_tokens
+        }
+    }
+
+def write_response_json(response_data: dict):
+    """Write the response data to response.json file.
+    
+    Args:
+        response_data: The formatted response dictionary to write
+    """
+    current_dir = Path(__file__).parent
+    response_file = current_dir / "response.json"
+    
+    try:
+        with open(response_file, 'w', encoding='utf-8') as f:
+            json.dump(response_data, f, indent=2)
+        logger.info(f"Response written to {response_file}")
+    except IOError as e:
+        logger.error(f"Error writing response.json: {e}")
+        raise
+
+def main():
+    # Get API token from environment variable
+    token = os.getenv("OPENROUTER_API_KEY")
+    if not token:
+        logger.error("OPENROUTER_API_KEY environment variable not set")
+        raise ValueError("Please set the OPENROUTER_API_KEY environment variable")
+
+    # Read request configuration
+    logger.info("Reading request.json")
+    request_data = read_request_json()
+
+    # Initialize the OpenRouter client
+    logger.info("Initializing OpenRouterClient")
+    client = OpenRouterClient(token=token)
+
+    # Extract request parameters
+    model = request_data.get("model")
+    messages = request_data.get("messages", [])
+    tools = request_data.get("tools", [])
+
+    # Send the request
+    logger.info(f"Sending request to model: {model}")
+    response = client.parse(
+        model=model,
+        response_format=PageStructureAnalysis,
+        messages=messages,
+        tools=tools
+    )
+
+    # Format and save the response
+    logger.info("Received response from OpenRouter API")
+    formatted_response = format_response(response)
+    write_response_json(formatted_response)
+    
+    # Print summary
+    print("\nResponse summary:")
+    print(f"- Model: {formatted_response['model']}")
+    print(f"- Total tokens: {formatted_response['usage']['total_tokens']}")
+    print(f"- Response saved to: {Path(__file__).parent / 'response.json'}")
+
+if __name__ == "__main__":
+    main() 

mbxai/mcp/server.py

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

mbxai/openrouter/client.py

@@ -2,10 +2,13 @@
 OpenRouter client implementation.
 """
 
-from typing import Any, Optional, Union
+from typing import Any, Optional, Union, Type
 from openai import OpenAI, OpenAIError, RateLimitError, APITimeoutError, APIConnectionError, BadRequestError, AuthenticationError
+from openai.lib._parsing import type_to_response_format_param
 from .models import OpenRouterModel, OpenRouterModelRegistry
 from .config import OpenRouterConfig
+from .schema import format_response
+from pydantic import BaseModel
 import logging
 import time
 import asyncio
@@ -90,6 +93,16 @@ def with_retry(max_retries: int = 3, initial_delay: float = 1.0, max_delay: floa
     return decorator
 
 
+class CustomJSONEncoder(json.JSONEncoder):
+    """Custom JSON encoder to handle special types."""
+    def default(self, obj):
+        if hasattr(obj, '__name__'):
+            return obj.__name__
+        if hasattr(obj, '__dict__'):
+            return obj.__dict__
+        return str(obj)
+
+
 class OpenRouterClient:
     """Client for interacting with the OpenRouter API."""
 
@@ -130,7 +143,7 @@ class OpenRouterClient:
                 retry_initial_delay=retry_initial_delay,
                 retry_max_delay=retry_max_delay,
             )
-            
+
             self._client = OpenAI(
                 api_key=token,
                 base_url=self.config.base_url,
@@ -155,7 +168,7 @@ class OpenRouterClient:
         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}\nStack trace:\n{stack_trace}")
         elif "Connection" in error_msg:
@@ -203,37 +216,37 @@ class OpenRouterClient:
             # Log the request details
             logger.info(f"Sending chat completion request to OpenRouter with model: {model or self.model}")
             logger.info(f"Message count: {len(messages)}")
-            
+
             # Calculate total message size for logging
             total_size = sum(len(str(msg)) for msg in messages)
             logger.info(f"Total message size: {total_size} bytes")
-            
+
             request = {
                 "model": model or self.model,
                 "messages": messages,
                 "stream": stream,
                 **kwargs,
             }
-            
+
             response = self._client.chat.completions.create(**request)
-            
+
             if response is None:
                 logger.error("Received None response from OpenRouter API")
                 raise OpenRouterAPIError("Received None response from OpenRouter API")
-            
+
             logger.info(f"Response type: {type(response)}")
             logger.info(f"Response attributes: {dir(response)}")
             logger.info(f"Received response from OpenRouter: {len(response.choices)} choices")
-            
+
             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]}")
-            
+
             if hasattr(e, 'response') and e.response is not None:
                 logger.error(f"Response status: {e.response.status_code}")
                 logger.error(f"Response headers: {e.response.headers}")
@@ -255,27 +268,27 @@ class OpenRouterClient:
         **kwargs: Any,
     ) -> Any:
         """Get a chat completion from OpenRouter."""
-        
+
         request = {
             "model": model or self.model,
             "messages": messages,
             "response_format": response_format,
             **kwargs,
         }
-        
+
         # Log the full request for debugging
         logger.debug(f"Full request: {request}")
-        
+
         try:
             # Log the request details
             logger.info(f"Sending parse request to OpenRouter with model: {model or self.model}")
             logger.info(f"Message count: {len(messages)}")
             logger.info(f"Response format: {response_format}")
-            
+
             # Calculate total message size for logging
             total_size = sum(len(str(msg)) for msg in messages)
             logger.info(f"Total message size: {total_size} bytes")
-            
+
             try:
                 response = self._client.beta.chat.completions.parse(**request)
             except RateLimitError as e:
@@ -296,17 +309,17 @@ class OpenRouterClient:
             except OpenAIError as e:
                 logger.error(f"OpenAI error: {str(e)}")
                 raise OpenRouterAPIError(f"OpenAI error: {str(e)}")
-            
+
             # Log raw response for debugging
             logger.debug(f"Raw response: {response}")
             if hasattr(response, '__dict__'):
                 logger.debug(f"Response attributes: {dir(response)}")
                 logger.debug(f"Response dict: {response.__dict__}")
-            
+
             if response is None:
                 logger.error("Received None response from OpenRouter API")
                 raise OpenRouterAPIError("Received None response from OpenRouter API")
-            
+
             # Try to get the raw response content if available
             if hasattr(response, '_response'):
                 try:
@@ -314,25 +327,25 @@ class OpenRouterClient:
                     logger.debug(f"Raw response content: {raw_content[:1000]}...")
                 except Exception as e:
                     logger.debug(f"Could not get raw response content: {e}")
-            
+
             # Validate response structure
             if not hasattr(response, 'choices'):
                 logger.error(f"Response missing 'choices' attribute. Available attributes: {dir(response)}")
                 raise OpenRouterAPIError("Invalid response format: missing 'choices' attribute")
-            
+
             if not response.choices:
                 logger.error("Response has empty choices list")
                 raise OpenRouterAPIError("Invalid response format: empty choices list")
-            
+
             if not hasattr(response.choices[0], 'message'):
                 logger.error(f"First choice missing 'message' attribute. Available attributes: {dir(response.choices[0])}")
                 raise OpenRouterAPIError("Invalid response format: missing 'message' attribute in first choice")
-            
+
             # Check if the message has a parsed attribute or content
             if not hasattr(response.choices[0].message, 'parsed') and not hasattr(response.choices[0].message, 'content'):
                 logger.error(f"Message missing both 'parsed' and 'content' attributes. Available attributes: {dir(response.choices[0].message)}")
                 raise OpenRouterAPIError("Invalid response format: message must have either 'parsed' or 'content' attribute")
-            
+
             # If there's no parsed attribute but there is content, try to parse it
             if not hasattr(response.choices[0].message, 'parsed') and hasattr(response.choices[0].message, 'content'):
                 try:
@@ -347,18 +360,17 @@ class OpenRouterClient:
                     logger.error(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.error(f"Raising error: {e}")
-            logger.error(f"Full request from ERROR:\n{json.dumps(request, indent=2)}")
             logger.error(f"Error in parse completion: {str(e)}")
             logger.error(f"Stack trace:\n{stack_trace}")
-            
+
             if hasattr(e, 'response') and e.response is not None:
                 logger.error(f"Response status: {e.response.status_code}")
                 logger.error(f"Response headers: {e.response.headers}")
@@ -370,6 +382,79 @@ class OpenRouterClient:
                     logger.error("Could not read response content")
             self._handle_api_error("parse completion", e)
 
+    @with_retry()
+    def create_parsed(
+        self,
+        messages: list[dict[str, Any]],
+        response_format: Type[BaseModel],
+        *,
+        model: str | None = None,
+        stream: bool = False,
+        **kwargs: Any,
+    ) -> Any:
+        """Get a chat completion from OpenRouter with structured output.
+        
+        Args:
+            messages: The messages to send to the model
+            response_format: A Pydantic model defining the expected response format
+            model: Optional model override
+            stream: Whether to stream the response
+            **kwargs: Additional arguments to pass to the API
+            
+        Returns:
+            The parsed response from the model
+        """
+        try:
+            # Convert Pydantic model to OpenAI response format
+            response_format_param = type_to_response_format_param(response_format)
+
+            # Log the request details
+            logger.info(f"Sending parsed chat completion request to OpenRouter with model: {model or self.model}")
+            logger.info(f"Message count: {len(messages)}")
+            logger.info(f"Response format: {json.dumps(response_format_param, indent=2)}")
+
+            # Calculate total message size for logging
+            total_size = sum(len(str(msg)) for msg in messages)
+            logger.info(f"Total message size: {total_size} bytes")
+
+            request = {
+                "model": model or self.model,
+                "messages": messages,
+                "stream": stream,
+                "response_format": response_format_param,
+                **kwargs,
+            }
+
+            response = self._client.chat.completions.create(**request)
+
+            if response is None:
+                logger.error("Received None response from OpenRouter API")
+                raise OpenRouterAPIError("Received None response from OpenRouter API")
+
+            logger.info(f"Response type: {type(response)}")
+            logger.info(f"Response attributes: {dir(response)}")
+            logger.info(f"Received response from OpenRouter: {len(response.choices)} choices")
+
+            return response
+
+        except Exception as e:
+            stack_trace = traceback.format_exc()
+            logger.error(f"Error in parsed 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]}")
+
+            if hasattr(e, 'response') and e.response is not None:
+                logger.error(f"Response status: {e.response.status_code}")
+                logger.error(f"Response headers: {e.response.headers}")
+                try:
+                    content = e.response.text
+                    logger.error(f"Response content length: {len(content)} bytes")
+                    logger.error(f"Response content preview: {content[:1000]}...")
+                except:
+                    logger.error("Could not read response content")
+            self._handle_api_error("parsed chat completion", e)
+
     @classmethod
     def register_model(cls, name: str, value: str) -> None:
         """Register a new model.
@@ -390,4 +475,4 @@ class OpenRouterClient:
         Returns:
             A dictionary mapping model names to their identifiers.
         """
-        return OpenRouterModelRegistry.list_models() 
+        return OpenRouterModelRegistry.list_models() 

mbxai/openrouter/schema.py

@@ -0,0 +1,21 @@
+"""
+Response formatting utilities for OpenRouter.
+"""
+
+from typing import Any
+import json
+
+def format_response(response: Any) -> dict[str, Any]:
+    """Format the response into a JSON-serializable dictionary.
+    
+    Args:
+        response: The response from OpenAI
+        
+    Returns:
+        A JSON-serializable dictionary containing the response data
+    """
+    if hasattr(response, 'model_dump'):
+        return response.model_dump()
+    elif hasattr(response, '__dict__'):
+        return response.__dict__
+    return str(response) 

mbxai/tools/client.py

@@ -282,7 +282,6 @@ class ToolClient:
                 logger.info("Final response")
                 return response
             
-            
     def parse(
         self,
         messages: list[dict[str, Any]],
@@ -300,7 +299,7 @@ class ToolClient:
         
         while True:
             # Get the model's response
-            response = self._client.parse(
+            response = self._client.create_parsed(
                 messages=messages,
                 response_format=response_format,
                 model=model,

{mbxai-1.0.12.dist-info → mbxai-1.1.0.dist-info}/METADATA

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

{mbxai-1.0.12.dist-info → mbxai-1.1.0.dist-info}/RECORD

@@ -1,24 +1,28 @@
-mbxai/__init__.py,sha256=Tt4H1XboHHlIeLHSX5mcSCD1CmE4PLQ8L2jidznrytg,48
+mbxai/__init__.py,sha256=_2qGr1Yic6rhVzF_j8_SfajJN6gzgVi6j6QA2iK59wQ,47
 mbxai/core.py,sha256=WMvmU9TTa7M_m-qWsUew4xH8Ul6xseCZ2iBCXJTW-Bs,196
 mbxai/examples/openrouter_example.py,sha256=-grXHKMmFLoh-yUIEMc31n8Gg1S7uSazBWCIOWxgbyQ,1317
 mbxai/examples/parse_example.py,sha256=eCKMJoOl6qwo8sDP6Trc6ncgjPlgTqi5tPE2kB5_P0k,3821
 mbxai/examples/parse_tool_example.py,sha256=duHN8scI9ZK6XZ5hdiz1Adzyc-_7tH9Ls9qP4S0bf5s,5477
+mbxai/examples/request.json,sha256=fjVMses305wVUXgcmjESCvPgP81Js8Kk6zHjZ8EDyEg,5434
+mbxai/examples/response.json,sha256=4SGJJyQjWWeN__Mrxm6ZtHIo1NUtLEheldd5KaA2mHw,856
+mbxai/examples/send_request.py,sha256=O5gCHUHy7RvkEFo9IQATgnSOfOdu8OqKHfjAlLDwWPg,6023
 mbxai/examples/tool_client_example.py,sha256=9DNaejXLA85dPbExMiv5y76qlFhzOJF9E5EnMOsy_Dc,3993
 mbxai/examples/mcp/mcp_client_example.py,sha256=R4H-OU5FvGL41cCkTdLa3bocsmVJYQYOcOHRf61nbZc,2822
 mbxai/examples/mcp/mcp_server_example.py,sha256=nFfg22Jnc6HMW_ezLO3So1xwDdx2_rItj5CR-y_Nevs,3966
 mbxai/mcp/__init__.py,sha256=_ek9iYdYqW5saKetj4qDci11jxesQDiHPJRpHMKkxgU,175
 mbxai/mcp/client.py,sha256=eXIN2ebprNF5UgM1jb-4JkXmc-5toUhtlBNFKVU7FgY,5204
 mbxai/mcp/example.py,sha256=oaol7AvvZnX86JWNz64KvPjab5gg1VjVN3G8eFSzuaE,2350
-mbxai/mcp/server.py,sha256=-umh9KNn0dep-C4Rk4qicrQxawBn3H5Op0Vf7m04ZK4,3455
+mbxai/mcp/server.py,sha256=V8yGrpOzLJgNzK9YhwhLN_ETAyP0SUpZvxENlcxlHiU,3454
 mbxai/openrouter/__init__.py,sha256=Ito9Qp_B6q-RLGAQcYyTJVWwR2YAZvNqE-HIYXxhtD8,298
-mbxai/openrouter/client.py,sha256=5M0a7lL2XKdBdbNN7gIpA2Uch28AQ4mKr1DkGBi1aBs,16634
+mbxai/openrouter/client.py,sha256=zVibH-BoHsv92RAuwqmTeLUIlAPjEqu3mMNzsRzfCFU,19875
 mbxai/openrouter/config.py,sha256=Ia93s-auim9Sq71eunVDbn9ET5xX2zusXpV4JBdHAzs,3251
 mbxai/openrouter/models.py,sha256=b3IjjtZAjeGOf2rLsdnCD1HacjTnS8jmv_ZXorc-KJQ,2604
+mbxai/openrouter/schema.py,sha256=H_77ZrA9zmbX155bWpCJj1jehUyJPS0QybEW1IVAoe0,540
 mbxai/tools/__init__.py,sha256=ogxrHvgJ7OR62Lmd5x9Eh5d2C0jqWyQis7Zy3yKpZ78,218
-mbxai/tools/client.py,sha256=h_1fxVDBq57f_OXNsj-TBp6-r367sv6Z5nk1qLFcLO8,14951
+mbxai/tools/client.py,sha256=TS2ZYYbJPDmGQ1-1ikuDY0_LiwLPhOQ1cy4pIS2UeEA,14946
 mbxai/tools/example.py,sha256=1HgKK39zzUuwFbnp3f0ThyWVfA_8P28PZcTwaUw5K78,2232
 mbxai/tools/types.py,sha256=pAoVuL7nKhvL3Iek0JheGfll4clsABFLl1CNjmiG3No,5866
-mbxai-1.0.12.dist-info/METADATA,sha256=1WO8gDKfVAQsdYxVlJtE_wBBzKjkroUtE_E4Yx4byMg,4148
-mbxai-1.0.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mbxai-1.0.12.dist-info/licenses/LICENSE,sha256=hEyhc4FxwYo3NQ40yNgZ7STqwVk-1_XcTXOnAPbGJAw,1069
-mbxai-1.0.12.dist-info/RECORD,,
+mbxai-1.1.0.dist-info/METADATA,sha256=cKWnzgZ223Q-xqZbw3Ra_outHqDwOWmr6B5K9C0ntK8,4147
+mbxai-1.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mbxai-1.1.0.dist-info/licenses/LICENSE,sha256=hEyhc4FxwYo3NQ40yNgZ7STqwVk-1_XcTXOnAPbGJAw,1069
+mbxai-1.1.0.dist-info/RECORD,,