mbxai 0.7.2__py3-none-any.whl → 0.8.0__py3-none-any.whl

mbxai/__init__.py

@@ -2,4 +2,4 @@
 MBX AI package.
 """
 
-__version__ = "0.7.2" 
+__version__ = "0.8.0" 

mbxai/examples/openrouter_example.py

@@ -0,0 +1,45 @@
+"""
+Example script demonstrating basic usage of the OpenRouterClient.
+"""
+
+import os
+import logging
+from mbxai.openrouter.client import OpenRouterClient, OpenRouterModel
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+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")
+
+    logger.info("Initializing OpenRouterClient with GPT-4 Turbo")
+    # Initialize the client
+    client = OpenRouterClient(
+        token=token,
+        model=OpenRouterModel.GPT4_TURBO  # Using GPT-4 Turbo as default
+    )
+
+    # Example messages
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "What is the capital of France?"}
+    ]
+
+    logger.info("Sending request to OpenRouter API")
+    # Send the request
+    response = client.create(messages=messages)
+
+    # Log the response
+    logger.info("Received response from OpenRouter API")
+    logger.info(f"Response: {response}")
+
+if __name__ == "__main__":
+    main() 

mbxai/examples/parse_example.py

@@ -0,0 +1,99 @@
+"""
+Example script demonstrating how to use the parse function with OpenRouterClient.
+"""
+
+import os
+import logging
+from typing import Any
+from pydantic import BaseModel, Field
+from mbxai.openrouter.client import OpenRouterClient, OpenRouterModel
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Define a Pydantic model for structured weather data
+class WeatherData(BaseModel):
+    """Weather data for a location."""
+    location: str = Field(..., description="The city name")
+    temperature: float = Field(..., description="Temperature in Celsius")
+    condition: str = Field(..., description="Weather condition (e.g., sunny, cloudy)")
+    humidity: float = Field(..., description="Humidity percentage")
+    wind_speed: float = Field(..., description="Wind speed in km/h")
+    feels_like: float = Field(..., description="Feels like temperature in Celsius")
+    precipitation_chance: float = Field(..., description="Chance of precipitation as a percentage")
+
+async def main():
+    # Get API token from environment variable
+    token = os.getenv("OPENROUTER_API_KEY")
+    if not token:
+        raise ValueError("Please set the OPENROUTER_API_KEY environment variable")
+
+    # Initialize the OpenRouter client
+    logger.info("Initializing OpenRouter client")
+    client = OpenRouterClient(
+        token=token,
+        model=OpenRouterModel.GPT41
+    )
+    
+    # Example 1: Parse weather data for a single location
+    logger.info("Parsing weather data for New York")
+    messages = [
+        {
+            "role": "user", 
+            "content": "What's the current weather in New York? Please provide temperature, condition, humidity, wind speed, feels like temperature, and precipitation chance."
+        }
+    ]
+    
+    response = client.parse(
+        messages=messages,
+        response_format=WeatherData,
+        timeout=30.0,
+    )
+    
+    weather_data = response.choices[0].message.parsed
+    print("\nWeather data for New York:")
+    print(f"Location: {weather_data.location}")
+    print(f"Temperature: {weather_data.temperature}°C")
+    print(f"Condition: {weather_data.condition}")
+    print(f"Humidity: {weather_data.humidity}%")
+    print(f"Wind Speed: {weather_data.wind_speed} km/h")
+    print(f"Feels Like: {weather_data.feels_like}°C")
+    print(f"Precipitation Chance: {weather_data.precipitation_chance}%")
+    
+    # Example 2: Parse weather data for multiple locations
+    logger.info("\nParsing weather data for multiple locations")
+    messages = [
+        {
+            "role": "user", 
+            "content": "Compare the weather in London and Tokyo. For each city, provide temperature, condition, humidity, wind speed, feels like temperature, and precipitation chance."
+        }
+    ]
+    
+    class MultiLocationWeather(BaseModel):
+        """Weather data for multiple locations."""
+        locations: list[WeatherData] = Field(..., description="List of weather data for different locations")
+    
+    response = client.parse(
+        messages=messages,
+        response_format=MultiLocationWeather,
+        timeout=30.0,
+    )
+    
+    multi_weather = response.choices[0].message.parsed
+    print("\nWeather comparison:")
+    for location_data in multi_weather.locations:
+        print(f"\n{location_data.location}:")
+        print(f"Temperature: {location_data.temperature}°C")
+        print(f"Condition: {location_data.condition}")
+        print(f"Humidity: {location_data.humidity}%")
+        print(f"Wind Speed: {location_data.wind_speed} km/h")
+        print(f"Feels Like: {location_data.feels_like}°C")
+        print(f"Precipitation Chance: {location_data.precipitation_chance}%")
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main()) 

mbxai/examples/parse_tool_example.py

@@ -0,0 +1,144 @@
+"""
+Example script demonstrating how to use both parse and tools with OpenRouterClient.
+"""
+
+import os
+import logging
+import random
+from typing import Any
+from pydantic import BaseModel, Field
+from mbxai.openrouter.client import OpenRouterClient, OpenRouterModel
+from mbxai.tools.client import ToolClient
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Define a Pydantic model for structured weather data
+class WeatherData(BaseModel):
+    """Weather data for a location."""
+    location: str = Field(..., description="The city name")
+    temperature: float = Field(..., description="Temperature in Celsius")
+    condition: str = Field(..., description="Weather condition (e.g., sunny, cloudy)")
+    humidity: float = Field(..., description="Humidity percentage")
+    wind_speed: float = Field(..., description="Wind speed in km/h")
+    feels_like: float = Field(..., description="Feels like temperature in Celsius")
+    precipitation_chance: float = Field(..., description="Chance of precipitation as a percentage")
+
+# Mock weather data for demonstration
+WEATHER_DATA = {
+    "new york": {"temperature": 22.5, "condition": "sunny", "humidity": 65, "wind_speed": 12, "feels_like": 23.0, "precipitation_chance": 10},
+    "london": {"temperature": 18.2, "condition": "cloudy", "humidity": 75, "wind_speed": 8, "feels_like": 17.5, "precipitation_chance": 40},
+    "tokyo": {"temperature": 25.7, "condition": "clear", "humidity": 60, "wind_speed": 5, "feels_like": 26.0, "precipitation_chance": 5},
+    "paris": {"temperature": 20.1, "condition": "partly cloudy", "humidity": 70, "wind_speed": 10, "feels_like": 19.5, "precipitation_chance": 20},
+}
+
+def get_weather(location: str) -> dict[str, Any]:
+    """Get weather information for a location.
+    
+    Args:
+        location: The city name to get weather for
+        
+    Returns:
+        Weather information including temperature, condition, humidity, and wind speed
+    """
+    logger.info(f"Getting weather for location: {location}")
+    
+    # Convert location to lowercase for case-insensitive matching
+    location = location.lower()
+    
+    # Get weather data or generate random data for unknown locations
+    if location in WEATHER_DATA:
+        weather = WEATHER_DATA[location]
+    else:
+        logger.warning(f"No weather data for {location}, generating random data")
+        weather = {
+            "temperature": round(random.uniform(15, 30), 1),
+            "condition": random.choice(["sunny", "cloudy", "clear", "partly cloudy"]),
+            "humidity": round(random.uniform(50, 90)),
+            "wind_speed": round(random.uniform(5, 20)),
+            "feels_like": round(random.uniform(15, 30), 1),
+            "precipitation_chance": round(random.uniform(0, 100))
+        }
+    
+    # Create WeatherData instance
+    weather_data = WeatherData(
+        location=location.title(),
+        temperature=weather["temperature"],
+        condition=weather["condition"],
+        humidity=weather["humidity"],
+        wind_speed=weather["wind_speed"],
+        feels_like=weather["feels_like"],
+        precipitation_chance=weather["precipitation_chance"]
+    )
+    
+    logger.info(f"Weather data retrieved: {weather_data}")
+    return weather_data.model_dump()
+
+async def main():
+    # Get API token from environment variable
+    token = os.getenv("OPENROUTER_API_KEY")
+    if not token:
+        raise ValueError("Please set the OPENROUTER_API_KEY environment variable")
+
+    # Initialize the OpenRouter client
+    logger.info("Initializing OpenRouter client")
+    openrouter_client = OpenRouterClient(
+        token=token,
+        model=OpenRouterModel.GPT41
+    )
+    
+    # Initialize the ToolClient
+    logger.info("Initializing ToolClient")
+    tool_client = ToolClient(openrouter_client)
+    
+    # Register the weather tool
+    logger.info("Registering weather tool")
+    tool_client.register_tool(
+        name="get_weather",
+        description="Get the current weather for a location",
+        function=get_weather,
+        schema={
+            "type": "object",
+            "properties": {
+                "location": {
+                    "type": "string",
+                    "description": "The city name to get weather for"
+                }
+            },
+            "required": ["location"]
+        }
+    )
+    
+    # Example 1: Get weather for a single location using tools and parse
+    logger.info("Getting weather for New York using tools and parse")
+    messages = [
+        {
+            "role": "user", 
+            "content": "What's the current weather in New York? Use the get_weather tool and format the response according to the WeatherData model."
+        }
+    ]
+    
+    response = tool_client.parse(
+        messages=messages,
+        response_format=WeatherData,
+        timeout=30.0,
+    )
+    
+    weather_data = response.choices[0].message.parsed
+    print("\nWeather data for New York:")
+    print(f"Location: {weather_data.location}")
+    print(f"Temperature: {weather_data.temperature}°C")
+    print(f"Condition: {weather_data.condition}")
+    print(f"Humidity: {weather_data.humidity}%")
+    print(f"Wind Speed: {weather_data.wind_speed} km/h")
+    print(f"Feels Like: {weather_data.feels_like}°C")
+    print(f"Precipitation Chance: {weather_data.precipitation_chance}%")
+
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main()) 

mbxai/examples/tool_client_example.py

@@ -0,0 +1,126 @@
+"""
+Example script demonstrating how to use the ToolClient with a custom Weather Tool.
+"""
+
+import os
+import logging
+import random
+from typing import Any
+from pydantic import BaseModel
+from mbxai.openrouter.client import OpenRouterClient, OpenRouterModel
+from mbxai.tools.client import ToolClient
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Define the weather data model
+class WeatherData(BaseModel):
+    """Weather data for a location."""
+    location: str
+    temperature: float
+    condition: str
+    humidity: float
+    wind_speed: float
+
+# Mock weather data for demonstration
+WEATHER_DATA = {
+    "new york": {"temperature": 22.5, "condition": "sunny", "humidity": 65, "wind_speed": 12},
+    "london": {"temperature": 18.2, "condition": "cloudy", "humidity": 75, "wind_speed": 8},
+    "tokyo": {"temperature": 25.7, "condition": "clear", "humidity": 60, "wind_speed": 5},
+    "paris": {"temperature": 20.1, "condition": "partly cloudy", "humidity": 70, "wind_speed": 10},
+}
+
+def get_weather(location: str) -> dict[str, Any]:
+    """Get weather information for a location.
+    
+    Args:
+        location: The city name to get weather for
+        
+    Returns:
+        Weather information including temperature, condition, humidity, and wind speed
+    """
+    logger.info(f"Getting weather for location: {location}")
+    
+    # Convert location to lowercase for case-insensitive matching
+    location = location.lower()
+    
+    # Get weather data or generate random data for unknown locations
+    if location in WEATHER_DATA:
+        weather = WEATHER_DATA[location]
+    else:
+        logger.warning(f"No weather data for {location}, generating random data")
+        weather = {
+            "temperature": round(random.uniform(15, 30), 1),
+            "condition": random.choice(["sunny", "cloudy", "clear", "partly cloudy"]),
+            "humidity": round(random.uniform(50, 90)),
+            "wind_speed": round(random.uniform(5, 20))
+        }
+    
+    # Create WeatherData instance
+    weather_data = WeatherData(
+        location=location.title(),
+        temperature=weather["temperature"],
+        condition=weather["condition"],
+        humidity=weather["humidity"],
+        wind_speed=weather["wind_speed"]
+    )
+    
+    logger.info(f"Weather data retrieved: {weather_data}")
+    return weather_data.model_dump()
+
+async def main():
+    # Get API token from environment variable
+    token = os.getenv("OPENROUTER_API_KEY")
+    if not token:
+        raise ValueError("Please set the OPENROUTER_API_KEY environment variable")
+
+    # Initialize the OpenRouter client
+    logger.info("Initializing OpenRouter client")
+    openrouter_client = OpenRouterClient(
+        token=token,
+        model=OpenRouterModel.GPT35_TURBO
+    )
+    
+    # Initialize the ToolClient
+    logger.info("Initializing ToolClient")
+    tool_client = ToolClient(openrouter_client)
+    
+    # Register the weather tool
+    logger.info("Registering weather tool")
+    tool_client.register_tool(
+        name="get_weather",
+        description="Get the current weather for a location",
+        function=get_weather,
+        schema={
+            "type": "object",
+            "properties": {
+                "location": {
+                    "type": "string",
+                    "description": "The city name to get weather for"
+                }
+            },
+            "required": ["location"]
+        }
+    )
+    
+    # Example 1: Simple weather query
+    logger.info("Sending weather query for New York")
+    messages = [
+        {"role": "user", "content": "What's the weather like in New York?"}
+    ]
+    
+    response = tool_client.chat(
+        messages,
+        timeout=30.0,
+    )
+    logger.info("Received response from model")
+    print("\nResponse for New York weather:")
+    print(response)
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main()) 

mbxai/mcp/server.py

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

mbxai/openrouter/client.py

@@ -4,7 +4,6 @@ OpenRouter client implementation.
 
 from typing import Any, Optional, Union
 from openai import OpenAI, OpenAIError
-from pydantic import BaseModel, TypeAdapter, Field
 from .models import OpenRouterModel, OpenRouterModelRegistry
 from .config import OpenRouterConfig
 import logging
@@ -95,7 +94,7 @@ class OpenRouterClient:
     def __init__(
         self,
         token: str,
-        model: Union[str, OpenRouterModel] = OpenRouterModel.GPT4_TURBO,
+        model: Union[str, OpenRouterModel] = OpenRouterModel.GPT35_TURBO,
         base_url: Optional[str] = None,
         default_headers: Optional[dict[str, str]] = None,
         max_retries: int = 3,
@@ -106,7 +105,7 @@ class OpenRouterClient:
 
         Args:
             token: The OpenRouter API token
-            model: The model to use (default: GPT4_TURBO)
+            model: The model to use (default: GPT35_TURBO)
             base_url: Optional custom base URL for the API
             default_headers: Optional default headers for API requests
             max_retries: Maximum number of retry attempts (default: 3)
@@ -187,7 +186,7 @@ class OpenRouterClient:
         self.model = value
 
     @with_retry()
-    def chat_completion(
+    def create(
         self,
         messages: list[dict[str, Any]],
         *,
@@ -205,19 +204,15 @@ class OpenRouterClient:
             total_size = sum(len(str(msg)) for msg in messages)
             logger.info(f"Total message size: {total_size} bytes")
             
-            response = self._client.responses.create(
-                input=messages,
-                model=model or self.model,
-                stream=stream,
+            request = {
+                "model": model or self.model,
+                "messages": messages,
+                "stream": stream,
                 **kwargs,
-            )
+            }
             
-            # Log response details
-            logger.info("Received response from OpenRouter")
-            if hasattr(response, 'output'):
-                logger.info(f"Response output length: {len(response.output) if response.output else 0}")
-            if hasattr(response, 'output_text'):
-                logger.info(f"Response output_text length: {len(response.output_text) if response.output_text else 0}")
+            response = self._client.chat.completions.create(**request)
+            logger.info(f"Received response from OpenRouter: {len(response.choices)} choices")
             
             return response
             
@@ -235,31 +230,15 @@ class OpenRouterClient:
             self._handle_api_error("chat completion", e)
 
     @with_retry()
-    def chat_completion_parse(
+    def parse(
         self,
         messages: list[dict[str, Any]],
-        response_format: type[BaseModel],
+        response_format: object,
         *,
-        model: Optional[Union[str, OpenRouterModel]] = None,
+        model: str | None = None,
         **kwargs: Any,
     ) -> Any:
-        """Create a chat completion and parse the response.
-
-        Args:
-            messages: list of messages
-            response_format: Pydantic model to parse the response into
-            model: Optional model override
-            **kwargs: Additional parameters
-
-        Returns:
-            Parsed completion response with output and output_parsed fields
-
-        Raises:
-            OpenRouterConnectionError: For connection issues
-            OpenRouterAPIError: For API errors
-            OpenRouterError: For other errors
-            ValueError: If response parsing fails
-        """
+        """Get a chat completion from OpenRouter."""
         try:
             # Log the request details
             logger.info(f"Sending chat completion request to OpenRouter with model: {model or self.model}")
@@ -269,26 +248,15 @@ class OpenRouterClient:
             total_size = sum(len(str(msg)) for msg in messages)
             logger.info(f"Total message size: {total_size} bytes")
             
-            # Use responses.parse for structured output
-            response = self._client.responses.parse(
-                model=model or self.model,
-                input=messages,
-                text_format=response_format,
+            request = {
+                "model": model or self.model,
+                "messages": messages,
+                "response_format": response_format,
                 **kwargs,
-            )
-            
-            if not response:
-                logger.error(f"Full response content: {response}")
-                raise OpenRouterAPIError("Invalid response from OpenRouter: empty response")
+            }
             
-            # Log response details
-            logger.info("Received response from OpenRouter")
-            if hasattr(response, 'output'):
-                logger.info(f"Response output length: {len(response.output) if response.output else 0}")
-            if hasattr(response, 'output_parsed'):
-                logger.info("Response includes parsed output")
-            if hasattr(response, 'tool_calls'):
-                logger.info(f"Response includes {len(response.tool_calls)} tool calls")
+            response = self._client.beta.chat.completions.parse(**request)
+            logger.info(f"Received response from OpenRouter: {len(response.choices)} choices")
             
             return response
             
@@ -305,45 +273,6 @@ class OpenRouterClient:
                     logger.error("Could not read response content")
             self._handle_api_error("chat completion", e)
 
-    @with_retry()
-    def embeddings(
-        self,
-        input: Union[str, list[str]],
-        *,
-        model: Optional[Union[str, OpenRouterModel]] = None,
-        **kwargs: Any,
-    ) -> Any:
-        """Create embeddings.
-
-        Args:
-            input: Text to embed
-            model: Optional model override
-            **kwargs: Additional parameters
-
-        Returns:
-            Embeddings response
-
-        Raises:
-            OpenRouterConnectionError: For connection issues
-            OpenRouterAPIError: For API errors
-            OpenRouterError: For other errors
-        """
-        try:
-            # Remove any incompatible parameters
-            kwargs.pop("parse", None)  # Remove parse parameter if present
-            
-            # Use text-embedding-ada-002 for embeddings
-            embeddings_model = "openai/text-embedding-ada-002"
-            
-            return self._client.embeddings.create(
-                model=str(model or embeddings_model),
-                input=input if isinstance(input, list) else [input],
-                encoding_format="float",  # Use float format instead of base64
-                **kwargs,
-            )
-        except Exception as e:
-            self._handle_api_error("embeddings", e)
-
     @classmethod
     def register_model(cls, name: str, value: str) -> None:
         """Register a new model.

mbxai/tools/client.py

@@ -2,14 +2,13 @@
 ToolClient implementation for MBX AI.
 """
 
-from typing import Any, Callable, TypeVar, cast
+from typing import Any, Callable, TypeVar
 import logging
 import inspect
 import json
 from pydantic import BaseModel
 from ..openrouter import OpenRouterClient
-from .types import Tool, ToolCall
-import asyncio
+from .types import Tool
 
 logger = logging.getLogger(__name__)
 
@@ -196,7 +195,7 @@ class ToolClient:
         # Log the messages we're about to send
         self._log_messages(messages, validate_responses=False)
 
-    async def chat(
+    def chat(
         self,
         messages: list[dict[str, Any]],
         *,
@@ -213,7 +212,7 @@ class ToolClient:
         
         while True:
             # Get the model's response
-            response = self._client.chat_completion(
+            response = self._client.create(
                 messages=messages,
                 model=model,
                 stream=stream,
@@ -222,49 +221,43 @@ class ToolClient:
 
             if stream:
                 return response
-
-            # Parse the response output
-            output = response.output if response.output else response.output_text
             
-            # Get all function calls from the output
-            tool_calls = []
-            if isinstance(output, list):
-                tool_calls = [
-                    tc for tc in output 
-                    if isinstance(tc, dict) and tc.get("type") == "function_call"
-                ]
+            if not hasattr(response, 'choices'):
+                raise ValueError("No choices found in response")
             
+            if len(response.choices) == 0:
+                raise ValueError("No choices found in response")
+            
+            messages.append(response.choices[0].message.dict())
+            
+            # Get all function calls from the output
+            tool_calls = response.choices[0].message.tool_calls            
+            logger.info(f"Tool calls: {tool_calls}")
             # Process function calls if any
             if tool_calls:
                 logger.info(f"Processing {len(tool_calls)} function calls")
                 
                 # Process each function call
                 for tool_call in tool_calls:
-                    logger.info(f"Processing tool call: {tool_call['name']}")
+                    logger.info(f"Processing tool call: {tool_call.function.name}")
 
                     # Get the tool
-                    tool = self._tools.get(tool_call["name"])
+                    tool = self._tools.get(tool_call.function.name)
                     if not tool:
-                        raise ValueError(f"Unknown tool: {tool_call['name']}")
+                        raise ValueError(f"Unknown tool: {tool_call.function.name}")
 
                     # Parse arguments
                     try:
-                        arguments = json.loads(tool_call["arguments"])
+                        arguments = json.loads(tool_call.function.arguments)
                     except json.JSONDecodeError as e:
                         logger.error(f"Failed to parse tool arguments: {e}")
-                        raise ValueError(f"Invalid tool arguments format: {tool_call['arguments']}")
+                        raise ValueError(f"Invalid tool arguments format: {tool_call.function.arguments}")
 
                     # Call the tool
                     logger.info(f"Calling tool: {tool.name} with args: {self._truncate_dict(arguments)}")
                     try:
-                        if inspect.iscoroutinefunction(tool.function):
-                            result = await asyncio.wait_for(tool.function(**arguments), timeout=300.0)
-                        else:
-                            result = tool.function(**arguments)
+                        result = tool.function(**arguments)
                         logger.info(f"Tool {tool.name} completed successfully")
-                    except asyncio.TimeoutError:
-                        logger.error(f"Tool {tool.name} timed out after 5 minutes")
-                        result = {"error": "Tool execution timed out after 5 minutes"}
                     except Exception as e:
                         logger.error(f"Error calling tool {tool.name}: {str(e)}")
                         result = {"error": f"Tool execution failed: {str(e)}"}
@@ -274,40 +267,31 @@ class ToolClient:
                         result = json.dumps(result)
 
                     # Append the function call and result to messages
-                    messages.append(tool_call)  # Append the model's function call
                     messages.append({
-                        "type": "function_call_output",
-                        "call_id": tool_call["call_id"],
-                        "output": result
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "name": tool_call.function.name,
+                        "content": result,
                     })
                     
-                    logger.info(f"Added function call and output for {tool_call['name']}")
+                    logger.info(f"Added function call and output for {tool_call.function.name}")
 
                 # Continue the conversation after processing all calls
                 continue
             else:
                 logger.info("Final response")
                 return response
-
-    async def parse(
+            
+            
+    def parse(
         self,
         messages: list[dict[str, Any]],
-        response_format: type[T],
+        response_format: object,
         *,
         model: str | None = None,
         **kwargs: Any,
     ) -> Any:
-        """Chat with the model and parse the response into a Pydantic model.
-
-        Args:
-            messages: The conversation messages
-            response_format: The Pydantic model to parse the response into
-            model: Optional model override
-            **kwargs: Additional parameters for the chat completion
-
-        Returns:
-            The parsed response from the model
-        """
+        """Chat with the model, handling tool calls."""
         tools = [tool.to_openai_function() for tool in self._tools.values()]
         
         if tools:
@@ -316,55 +300,49 @@ class ToolClient:
         
         while True:
             # Get the model's response
-            response = self._client.chat_completion_parse(
+            response = self._client.parse(
                 messages=messages,
                 response_format=response_format,
                 model=model,
                 **kwargs,
             )
-
-            # Parse the response output
-            output = response.output
             
-            # Get all function calls from the output
-            tool_calls = []
-            if isinstance(output, list):
-                tool_calls = [
-                    tc for tc in output 
-                    if isinstance(tc, dict) and tc.get("type") == "function_call"
-                ]
+            if not hasattr(response, 'choices'):
+                raise ValueError("No choices found in response")
             
+            if len(response.choices) == 0:
+                raise ValueError("No choices found in response")
+            
+            messages.append(response.choices[0].message.dict())
+            
+            # Get all function calls from the output
+            tool_calls = response.choices[0].message.tool_calls            
+            logger.info(f"Tool calls: {tool_calls}")
             # Process function calls if any
             if tool_calls:
                 logger.info(f"Processing {len(tool_calls)} function calls")
                 
                 # Process each function call
                 for tool_call in tool_calls:
-                    logger.info(f"Processing tool call: {tool_call['name']}")
+                    logger.info(f"Processing tool call: {tool_call.function.name}")
 
                     # Get the tool
-                    tool = self._tools.get(tool_call["name"])
+                    tool = self._tools.get(tool_call.function.name)
                     if not tool:
-                        raise ValueError(f"Unknown tool: {tool_call['name']}")
+                        raise ValueError(f"Unknown tool: {tool_call.function.name}")
 
                     # Parse arguments
                     try:
-                        arguments = json.loads(tool_call["arguments"])
+                        arguments = json.loads(tool_call.function.arguments)
                     except json.JSONDecodeError as e:
                         logger.error(f"Failed to parse tool arguments: {e}")
-                        raise ValueError(f"Invalid tool arguments format: {tool_call['arguments']}")
+                        raise ValueError(f"Invalid tool arguments format: {tool_call.function.arguments}")
 
                     # Call the tool
                     logger.info(f"Calling tool: {tool.name} with args: {self._truncate_dict(arguments)}")
                     try:
-                        if inspect.iscoroutinefunction(tool.function):
-                            result = await asyncio.wait_for(tool.function(**arguments), timeout=300.0)
-                        else:
-                            result = tool.function(**arguments)
+                        result = tool.function(**arguments)
                         logger.info(f"Tool {tool.name} completed successfully")
-                    except asyncio.TimeoutError:
-                        logger.error(f"Tool {tool.name} timed out after 5 minutes")
-                        result = {"error": "Tool execution timed out after 5 minutes"}
                     except Exception as e:
                         logger.error(f"Error calling tool {tool.name}: {str(e)}")
                         result = {"error": f"Tool execution failed: {str(e)}"}
@@ -374,17 +352,17 @@ class ToolClient:
                         result = json.dumps(result)
 
                     # Append the function call and result to messages
-                    messages.append(tool_call)  # Append the model's function call
                     messages.append({
-                        "type": "function_call_output",
-                        "call_id": tool_call["call_id"],
-                        "output": result
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "name": tool_call.function.name,
+                        "content": result,
                     })
                     
-                    logger.info(f"Added function call and output for {tool_call['name']}")
+                    logger.info(f"Added function call and output for {tool_call.function.name}")
 
                 # Continue the conversation after processing all calls
                 continue
             else:
-                logger.info("Added assistant response with parsed output")
-                return response
+                logger.info("Final response")
+                return response

{mbxai-0.7.2.dist-info → mbxai-0.8.0.dist-info}/METADATA

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

mbxai-0.8.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+mbxai/__init__.py,sha256=3ljCLa8XDn3XjVIZkyCOi5pgS_0Fr2GEkziz7LY6Hrc,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/tool_client_example.py,sha256=9DNaejXLA85dPbExMiv5y76qlFhzOJF9E5EnMOsy_Dc,3993
+mbxai/mcp/__init__.py,sha256=_ek9iYdYqW5saKetj4qDci11jxesQDiHPJRpHMKkxgU,175
+mbxai/mcp/client.py,sha256=m3FBMqewv6b8ZJ7V9TnHqHxJ3acHDQDHvbuYhweI9-g,5283
+mbxai/mcp/example.py,sha256=oaol7AvvZnX86JWNz64KvPjab5gg1VjVN3G8eFSzuaE,2350
+mbxai/mcp/server.py,sha256=ZeN9Q6AMwF0eFg_n8Uu-nz0B7eO7jFomUwiWe8VrxHo,3462
+mbxai/openrouter/__init__.py,sha256=Ito9Qp_B6q-RLGAQcYyTJVWwR2YAZvNqE-HIYXxhtD8,298
+mbxai/openrouter/client.py,sha256=GhjyQ5YPDkUsOqlHF0ufkhDtU6g00hLAA5r7qKFU9co,10971
+mbxai/openrouter/config.py,sha256=Ia93s-auim9Sq71eunVDbn9ET5xX2zusXpV4JBdHAzs,3251
+mbxai/openrouter/models.py,sha256=b3IjjtZAjeGOf2rLsdnCD1HacjTnS8jmv_ZXorc-KJQ,2604
+mbxai/tools/__init__.py,sha256=ogxrHvgJ7OR62Lmd5x9Eh5d2C0jqWyQis7Zy3yKpZ78,218
+mbxai/tools/client.py,sha256=h_1fxVDBq57f_OXNsj-TBp6-r367sv6Z5nk1qLFcLO8,14951
+mbxai/tools/example.py,sha256=1HgKK39zzUuwFbnp3f0ThyWVfA_8P28PZcTwaUw5K78,2232
+mbxai/tools/types.py,sha256=PEJ2AxBqywbJCp689QZhG87rDHWNuKGnmB5CCQsAMlw,5251
+mbxai-0.8.0.dist-info/METADATA,sha256=GEPKzzsNonL8Ynf237ZsaMBzSBNA018rCw8zfOXdCMU,4147
+mbxai-0.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mbxai-0.8.0.dist-info/licenses/LICENSE,sha256=hEyhc4FxwYo3NQ40yNgZ7STqwVk-1_XcTXOnAPbGJAw,1069
+mbxai-0.8.0.dist-info/RECORD,,

mbxai-0.7.2.dist-info/RECORD

@@ -1,18 +0,0 @@
-mbxai/__init__.py,sha256=RXotiHhBVgcPh5XJj8qg6yQv3s_7UODMTOhZ3LVLsKI,47
-mbxai/core.py,sha256=WMvmU9TTa7M_m-qWsUew4xH8Ul6xseCZ2iBCXJTW-Bs,196
-mbxai/mcp/__init__.py,sha256=_ek9iYdYqW5saKetj4qDci11jxesQDiHPJRpHMKkxgU,175
-mbxai/mcp/client.py,sha256=m3FBMqewv6b8ZJ7V9TnHqHxJ3acHDQDHvbuYhweI9-g,5283
-mbxai/mcp/example.py,sha256=oaol7AvvZnX86JWNz64KvPjab5gg1VjVN3G8eFSzuaE,2350
-mbxai/mcp/server.py,sha256=FEmuSOALGSOJsuE8ywjWIaIBbvNwXafw3i5GU5hbukM,3462
-mbxai/openrouter/__init__.py,sha256=Ito9Qp_B6q-RLGAQcYyTJVWwR2YAZvNqE-HIYXxhtD8,298
-mbxai/openrouter/client.py,sha256=K8ytBeAnjHyxoN6DMH4yc1gaPFYmBk08ZLF95YhPXMU,13745
-mbxai/openrouter/config.py,sha256=Ia93s-auim9Sq71eunVDbn9ET5xX2zusXpV4JBdHAzs,3251
-mbxai/openrouter/models.py,sha256=b3IjjtZAjeGOf2rLsdnCD1HacjTnS8jmv_ZXorc-KJQ,2604
-mbxai/tools/__init__.py,sha256=ogxrHvgJ7OR62Lmd5x9Eh5d2C0jqWyQis7Zy3yKpZ78,218
-mbxai/tools/client.py,sha256=KEFs-r97c4YD-DIZnJNUoSnIWQL-cwIZ4YUYqT6OIoo,16041
-mbxai/tools/example.py,sha256=1HgKK39zzUuwFbnp3f0ThyWVfA_8P28PZcTwaUw5K78,2232
-mbxai/tools/types.py,sha256=PEJ2AxBqywbJCp689QZhG87rDHWNuKGnmB5CCQsAMlw,5251
-mbxai-0.7.2.dist-info/METADATA,sha256=KtOisBQNvvBiCf_eB6nYcGe_v5nea5LzIvOMtXBKdNw,4147
-mbxai-0.7.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mbxai-0.7.2.dist-info/licenses/LICENSE,sha256=hEyhc4FxwYo3NQ40yNgZ7STqwVk-1_XcTXOnAPbGJAw,1069
-mbxai-0.7.2.dist-info/RECORD,,