mbxai 2.1.2__py3-none-any.whl → 2.2.0__py3-none-any.whl

mbxai/__init__.py

@@ -7,7 +7,7 @@ from .openrouter import OpenRouterClient
 from .tools import ToolClient
 from .mcp import MCPClient
 
-__version__ = "2.1.2"
+__version__ = "2.2.0"
 
 __all__ = [
     "AgentClient",

mbxai/agent/client.py

@@ -134,6 +134,35 @@ class AgentClient:
             logger.debug(f"🔗 AI call with {len(messages)} messages (no history)")
         return self._ai_client.parse(full_messages, response_format)
 
+    def _validate_answers(self, answers: Any) -> bool:
+        """
+        Validate that answers parameter is a proper AnswerList with content.
+        
+        Args:
+            answers: The answers parameter to validate
+            
+        Returns:
+            True if answers is valid and has content, False otherwise
+        """
+        # Check if answers is the correct type
+        if not isinstance(answers, AnswerList):
+            logger.warning(f"Invalid answers type: {type(answers)}. Expected AnswerList, treating as no answers.")
+            return False
+        
+        # Check if answers has content
+        if not hasattr(answers, 'answers') or not answers.answers:
+            logger.info(f"Empty answers list provided, proceeding without answers processing.")
+            return False
+        
+        # Check if answers list contains valid Answer objects
+        for answer in answers.answers:
+            if not hasattr(answer, 'key') or not hasattr(answer, 'answer'):
+                logger.warning(f"Invalid answer object in list: {answer}. Treating as no answers.")
+                return False
+        
+        logger.debug(f"Validated {len(answers.answers)} answers")
+        return True
+
     def _extract_token_usage(self, response: Any) -> TokenUsage:
         """Extract token usage information from an AI response."""
         try:
@@ -188,7 +217,7 @@ class AgentClient:
         final_response_structure: Type[BaseModel] = None,
         ask_questions: bool = True,
         agent_id: str = None,
-        answers: AnswerList = None
+        answers: AnswerList | None = None
     ) -> AgentResponse:
         """
         Process a prompt through the agent's thinking process.
@@ -252,8 +281,11 @@ class AgentClient:
         
         # Handle answers provided (skip question generation and process directly)
         if answers is not None:
-            logger.info(f"📝 Agent {agent_id}: Processing with provided answers, skipping question generation")
-            return self._process_answers_directly(agent_id, prompt, final_response_structure, answers, token_summary, history_for_ai)
+            if self._validate_answers(answers):
+                logger.info(f"📝 Agent {agent_id}: Processing with provided answers, skipping question generation")
+                return self._process_answers_directly(agent_id, prompt, final_response_structure, answers, token_summary, history_for_ai)
+            else:
+                logger.info(f"📝 Agent {agent_id}: Invalid or empty answers provided, proceeding with normal flow")
         
         # Step 1: Generate questions (if ask_questions is True)
         if ask_questions:

mbxai/mcp/server.py

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

mbxai/openrouter/client.py

@@ -4,7 +4,7 @@ OpenRouter client implementation.
 
 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
@@ -350,88 +350,6 @@ 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.debug(f"Sending parsed chat completion request to OpenRouter with model: {model or self.model}")
-            logger.debug(f"Message count: {len(messages)}")
-            logger.debug(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.debug(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")
-
-            # 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 response.choices is None:
-                logger.error("Response choices is None")
-                raise OpenRouterAPIError("Invalid response format: choices is None")
-
-            logger.debug(f"Response type: {type(response)}")
-            logger.debug(f"Response attributes: {dir(response)}")
-            logger.debug(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.

mbxai-2.2.0.dist-info/METADATA

@@ -0,0 +1,492 @@
+Metadata-Version: 2.4
+Name: mbxai
+Version: 2.2.0
+Summary: MBX AI SDK
+Project-URL: Homepage, https://www.mibexx.de
+Project-URL: Documentation, https://www.mibexx.de
+Project-URL: Repository, https://github.com/yourusername/mbxai.git
+Author: MBX AI
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Requires-Dist: fastapi>=0.115.12
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp>=1.7.1
+Requires-Dist: openai>=1.77.0
+Requires-Dist: pydantic-settings>=2.9.1
+Requires-Dist: pydantic>=2.9.1
+Requires-Dist: python-multipart>=0.0.20
+Requires-Dist: sse-starlette>=2.3.4
+Requires-Dist: starlette>=0.46.2
+Requires-Dist: typing-inspection<=0.4.0
+Requires-Dist: uvicorn>=0.34.2
+Provides-Extra: dev
+Requires-Dist: black>=24.3.0; extra == 'dev'
+Requires-Dist: isort>=5.13.2; extra == 'dev'
+Requires-Dist: mypy>=1.8.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.26.0; extra == 'dev'
+Requires-Dist: pytest-cov>=6.1.1; extra == 'dev'
+Requires-Dist: pytest>=8.3.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# MBX AI
+
+A comprehensive Python library for building intelligent AI applications with Large Language Models (LLMs), structured responses, tool integration, and agent-based thinking.
+
+## 🚀 Features
+
+- **🔗 Multiple AI Client Types**: OpenRouter integration with tool-enabled and MCP-enabled variants
+- **🤖 Intelligent Agent System**: Dialog-based thinking with question generation, quality iteration, and conversation memory
+- **🛠️ Tool Integration**: Easy function registration with automatic schema generation
+- **🔌 MCP Support**: Full Model Context Protocol (MCP) client and server implementation
+- **📋 Structured Responses**: Type-safe responses using Pydantic models
+- **🔄 Quality Iteration**: Built-in response improvement through AI-powered quality checks
+- **💬 Conversation Memory**: Persistent dialog sessions with history management
+- **⚡ Automatic Retry**: Built-in retry logic with exponential backoff for robust connections
+
+## 📦 Installation
+
+```bash
+pip install mbxai
+```
+
+## 🏗️ Architecture Overview
+
+MBX AI provides four main client types, each building upon the previous:
+
+1. **OpenRouterClient** - Basic LLM interactions with structured responses
+2. **ToolClient** - Adds function calling capabilities
+3. **MCPClient** - Adds Model Context Protocol server integration
+4. **AgentClient** - Adds intelligent dialog-based thinking (wraps any of the above)
+
+| Client | Structured Responses | Function Calling | MCP Integration | Agent Thinking |
+|--------|---------------------|------------------|-----------------|----------------|
+| OpenRouterClient | ✅ | ❌ | ❌ | ❌ |
+| ToolClient | ✅ | ✅ | ❌ | ❌ |
+| MCPClient | ✅ | ✅ | ✅ | ❌ |
+| AgentClient | ✅ | ✅* | ✅* | ✅ |
+
+*AgentClient capabilities depend on the wrapped client
+
+## 🚀 Quick Start
+
+### Basic OpenRouter Client
+
+```python
+import os
+from mbxai import OpenRouterClient
+from pydantic import BaseModel, Field
+
+# Initialize client
+client = OpenRouterClient(token=os.getenv("OPENROUTER_API_KEY"))
+
+# Simple chat
+response = client.create([
+    {"role": "user", "content": "What is the capital of France?"}
+])
+print(response.choices[0].message.content)
+
+# Structured response
+class CityInfo(BaseModel):
+    name: str = Field(description="City name")
+    population: int = Field(description="Population count")
+    country: str = Field(description="Country name")
+
+response = client.parse(
+    messages=[{"role": "user", "content": "Tell me about Paris"}],
+    response_format=CityInfo
+)
+city = response.choices[0].message.parsed
+print(f"{city.name}, {city.country} - Population: {city.population:,}")
+```
+
+### Tool Client with Automatic Schema Generation
+
+```python
+import os
+from mbxai import ToolClient, OpenRouterClient
+
+# Initialize clients
+openrouter_client = OpenRouterClient(token=os.getenv("OPENROUTER_API_KEY"))
+tool_client = ToolClient(openrouter_client)
+
+# Define a function - schema is auto-generated!
+def get_weather(location: str, unit: str = "celsius") -> dict:
+    """Get weather information for a location.
+    
+    Args:
+        location: The city or location name
+        unit: Temperature unit (celsius or fahrenheit)
+    """
+    return {
+        "location": location,
+        "temperature": 22,
+        "unit": unit,
+        "condition": "Sunny"
+    }
+
+# Register tool (schema automatically generated from function signature)
+tool_client.register_tool(
+    name="get_weather",
+    description="Get current weather for a location",
+    function=get_weather
+    # No schema needed - automatically generated!
+)
+
+# Use the tool
+response = tool_client.chat([
+    {"role": "user", "content": "What's the weather like in Tokyo?"}
+])
+print(response.choices[0].message.content)
+```
+
+### MCP Client for Server Integration
+
+```python
+import os
+from mbxai import MCPClient, OpenRouterClient
+
+# Initialize MCP client
+openrouter_client = OpenRouterClient(token=os.getenv("OPENROUTER_API_KEY"))
+mcp_client = MCPClient(openrouter_client)
+
+# Register MCP server (automatically loads all tools)
+mcp_client.register_mcp_server("data-analysis", "http://localhost:8000")
+
+# Chat with MCP tools available
+response = mcp_client.chat([
+    {"role": "user", "content": "Analyze the sales data from the server"}
+])
+print(response.choices[0].message.content)
+```
+
+### Agent Client - Intelligent Dialog System
+
+The AgentClient provides an intelligent thinking process with question generation, quality improvement, and conversation memory.
+
+```python
+import os
+from mbxai import AgentClient, OpenRouterClient
+from pydantic import BaseModel, Field
+
+class TravelPlan(BaseModel):
+    destination: str = Field(description="Travel destination")
+    duration: str = Field(description="Trip duration")
+    activities: list[str] = Field(description="Recommended activities")
+    budget: str = Field(description="Estimated budget")
+
+# Initialize agent
+openrouter_client = OpenRouterClient(token=os.getenv("OPENROUTER_API_KEY"))
+agent = AgentClient(openrouter_client, max_iterations=2)
+
+# Agent with questions (interactive mode)
+response = agent.agent(
+    prompt="Plan a vacation for me",
+    final_response_structure=TravelPlan,
+    ask_questions=True
+)
+
+if response.has_questions():
+    print("Agent Questions:")
+    for q in response.questions:
+        print(f"- {q.question}")
+    
+    # Answer questions
+    from mbxai import AnswerList, Answer
+    answers = AnswerList(answers=[
+        Answer(key="destination_preference", answer="Mountain destination"),
+        Answer(key="budget_range", answer="$2000-3000"),
+        Answer(key="duration", answer="5 days")
+    ])
+    
+    # Continue with answers
+    final_response = agent.agent(
+        prompt="Continue with the travel planning",
+        final_response_structure=TravelPlan,
+        agent_id=response.agent_id,
+        answers=answers
+    )
+    
+    plan = final_response.final_response
+    print(f"Destination: {plan.destination}")
+    print(f"Duration: {plan.duration}")
+else:
+    # Direct response
+    plan = response.final_response
+    print(f"Destination: {plan.destination}")
+```
+
+### Agent with Tool Integration
+
+```python
+from mbxai import AgentClient, ToolClient, OpenRouterClient
+
+# Setup tool-enabled agent
+openrouter_client = OpenRouterClient(token=os.getenv("OPENROUTER_API_KEY"))
+tool_client = ToolClient(openrouter_client)
+agent = AgentClient(tool_client)
+
+# Register tools via agent (proxy method)
+def search_flights(origin: str, destination: str, date: str) -> dict:
+    """Search for flights between cities."""
+    return {
+        "flights": [
+            {"airline": "Example Air", "price": "$450", "duration": "3h 15m"}
+        ]
+    }
+
+agent.register_tool(
+    name="search_flights",
+    description="Search for flights between cities",
+    function=search_flights
+)
+
+# Agent automatically uses tools when needed
+class FlightInfo(BaseModel):
+    flights: list[dict] = Field(description="Available flights")
+    recommendation: str = Field(description="Flight recommendation")
+
+response = agent.agent(
+    prompt="Find flights from New York to Los Angeles for tomorrow",
+    final_response_structure=FlightInfo,
+    ask_questions=False
+)
+
+flight_info = response.final_response
+print(f"Found {len(flight_info.flights)} flights")
+print(f"Recommendation: {flight_info.recommendation}")
+```
+
+## 📚 Detailed Documentation
+
+### OpenRouterClient
+
+The base client for OpenRouter API integration with structured response support.
+
+#### Key Features:
+- **Multiple Models**: Support for GPT-4, Claude, Llama, and other models via OpenRouter
+- **Structured Responses**: Type-safe responses using Pydantic models
+- **Retry Logic**: Automatic retry with exponential backoff
+- **Error Handling**: Comprehensive error handling with detailed logging
+
+#### Methods:
+- `create()` - Basic chat completion
+- `parse()` - Chat completion with structured response
+
+#### Configuration:
+```python
+client = OpenRouterClient(
+    token="your-api-key",
+    model="openai/gpt-4-turbo",  # or use OpenRouterModel enum
+    max_retries=3,
+    retry_initial_delay=1.0,
+    retry_max_delay=10.0
+)
+```
+
+### ToolClient
+
+Extends OpenRouterClient with function calling capabilities.
+
+#### Key Features:
+- **Automatic Schema Generation**: Generate JSON schemas from Python function signatures
+- **Tool Registration**: Simple function registration
+- **Tool Execution**: Automatic tool calling and response handling
+- **Error Recovery**: Graceful handling of tool execution errors
+
+#### Usage:
+```python
+tool_client = ToolClient(openrouter_client)
+
+# Register with automatic schema
+tool_client.register_tool("function_name", "description", function)
+
+# Register with custom schema
+tool_client.register_tool("function_name", "description", function, custom_schema)
+```
+
+### MCPClient
+
+Extends ToolClient with Model Context Protocol (MCP) server integration.
+
+#### Key Features:
+- **MCP Server Integration**: Connect to MCP servers and load their tools
+- **Tool Discovery**: Automatically discover and register tools from MCP servers
+- **HTTP Client Management**: Built-in HTTP client for MCP communication
+- **Schema Conversion**: Convert MCP schemas to OpenAI function format
+
+#### Usage:
+```python
+mcp_client = MCPClient(openrouter_client)
+mcp_client.register_mcp_server("server-name", "http://localhost:8000")
+```
+
+### AgentClient
+
+Wraps any client with intelligent dialog-based thinking capabilities.
+
+#### Key Features:
+- **Question Generation**: Automatically generates clarifying questions
+- **Quality Iteration**: Improves responses through multiple AI review cycles
+- **Conversation Memory**: Maintains conversation history across interactions
+- **Flexible Configuration**: Configurable quality vs speed tradeoffs
+- **Tool Proxy Methods**: Access underlying client's tool capabilities
+
+#### Configuration Options:
+```python
+agent = AgentClient(
+    ai_client=any_supported_client,
+    max_iterations=2  # 0=fastest, 3+=highest quality
+)
+```
+
+#### Dialog Flow:
+1. **Question Generation** (if `ask_questions=True`)
+2. **Answer Processing** (if questions were asked)
+3. **Thinking Process** (analyze prompt and context)
+4. **Quality Iteration** (improve response through AI review)
+5. **Final Response** (generate structured output)
+
+#### Session Management:
+```python
+# List active sessions
+sessions = agent.list_sessions()
+
+# Get session info
+info = agent.get_session_info(agent_id)
+
+# Delete session
+agent.delete_session(agent_id)
+```
+
+## 🏃‍♂️ Advanced Examples
+
+### Custom Model Registration
+
+```python
+from mbxai import OpenRouterClient, OpenRouterModel
+
+# Register custom model
+OpenRouterClient.register_model("CUSTOM_MODEL", "provider/model-name")
+
+# Use custom model
+client = OpenRouterClient(token="your-key", model="CUSTOM_MODEL")
+```
+
+### Conversation History and Context
+
+```python
+# Start a conversation
+response1 = agent.agent("Tell me about quantum computing", ScienceExplanation)
+agent_id = response1.agent_id
+
+# Continue conversation with context
+response2 = agent.agent(
+    "How does it compare to classical computing?",
+    ComparisonExplanation,
+    agent_id=agent_id,
+    ask_questions=False
+)
+
+# The agent remembers the previous conversation context
+```
+
+### Error Handling and Logging
+
+```python
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+
+try:
+    response = client.create(messages)
+except OpenRouterAPIError as e:
+    print(f"API Error: {e}")
+except OpenRouterConnectionError as e:
+    print(f"Connection Error: {e}")
+except Exception as e:
+    print(f"Unexpected Error: {e}")
+```
+
+### Streaming Responses
+
+```python
+# Streaming with OpenRouterClient
+response = client.create(messages, stream=True)
+for chunk in response:
+    if chunk.choices[0].delta.content:
+        print(chunk.choices[0].delta.content, end="")
+
+# Streaming with ToolClient (tools execute before streaming)
+response = tool_client.chat(messages, stream=True)
+for chunk in response:
+    if chunk.choices[0].delta.content:
+        print(chunk.choices[0].delta.content, end="")
+```
+
+## 🧪 Testing
+
+Run the test suite:
+
+```bash
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest tests/
+
+# Run with coverage
+pytest tests/ --cov=mbxai --cov-report=html
+```
+
+## 🔧 Development Setup
+
+1. Clone the repository:
+```bash
+git clone https://github.com/yourusername/mbxai.git
+cd mbxai/packages
+```
+
+2. Create a virtual environment:
+```bash
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+```
+
+3. Install in development mode:
+```bash
+pip install -e ".[dev]"
+```
+
+4. Set up environment variables:
+```bash
+export OPENROUTER_API_KEY="your-api-key"
+```
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 🔗 Links
+
+- **Homepage**: [https://www.mibexx.de](https://www.mibexx.de)
+- **Documentation**: [https://www.mibexx.de](https://www.mibexx.de)
+- **Repository**: [https://github.com/yourusername/mbxai](https://github.com/yourusername/mbxai)
+
+## 📊 Version Information
+
+Current version: **2.1.3**
+
+- Python 3.12+ required
+- Built with modern async/await patterns
+- Type-safe with Pydantic v2
+- Compatible with OpenAI SDK v1.77+

{mbxai-2.1.2.dist-info → mbxai-2.2.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-mbxai/__init__.py,sha256=k465X578GCB1IDy8P5Uwfh-ae2VpoZ2y9B2GN7F7QrE,407
+mbxai/__init__.py,sha256=uPglmoE2kWWVTJn4_zLFhpUZveKcvqpirELVG9NOwI8,407
 mbxai/core.py,sha256=WMvmU9TTa7M_m-qWsUew4xH8Ul6xseCZ2iBCXJTW-Bs,196
 mbxai/agent/__init__.py,sha256=5j3mW2NZtAU1s2w8n833axWBQsxW8U0qKwoQ9JtQZ4k,289
-mbxai/agent/client.py,sha256=S3wWA47bEJkQF69TOA1Ba1t66jVE_CY2f76JbVKlAW0,36455
+mbxai/agent/client.py,sha256=M4n1RKeSi3e59nvJUjDdFR0dgWP-X1pe5j1YzjSV1js,37870
 mbxai/agent/models.py,sha256=sjBtaAENDABHl8IqTON1gxFFSZIaQYUCBFHB5804_Fw,5780
 mbxai/examples/agent_example.py,sha256=7gQHcMVWBu2xdxnVNzz4UfW0lkUnw9a5DN2-YoIRxXE,7420
 mbxai/examples/agent_iterations_example.py,sha256=xMqZhBWS67EkRkArjOAY2fCgLkQ32Qn9E4CSfEKW4MU,7905
@@ -26,9 +26,9 @@ mbxai/examples/mcp/mcp_server_example.py,sha256=nFfg22Jnc6HMW_ezLO3So1xwDdx2_rIt
 mbxai/mcp/__init__.py,sha256=_ek9iYdYqW5saKetj4qDci11jxesQDiHPJRpHMKkxgU,175
 mbxai/mcp/client.py,sha256=QRzId6o4_WRWVv3rtm8cfZZGaoY_UlaOO-oqNjY-tmw,5219
 mbxai/mcp/example.py,sha256=oaol7AvvZnX86JWNz64KvPjab5gg1VjVN3G8eFSzuaE,2350
-mbxai/mcp/server.py,sha256=b3NCIt1AZdsuDm22LY0qXNmmirqVnvrSrA0v921BASc,3332
+mbxai/mcp/server.py,sha256=z-ZyrFbQ-ZD_re4LUP4l9BO17jeJCxEEX3tNFsIoRO0,3332
 mbxai/openrouter/__init__.py,sha256=Ito9Qp_B6q-RLGAQcYyTJVWwR2YAZvNqE-HIYXxhtD8,298
-mbxai/openrouter/client.py,sha256=3LD6WDJ8wjo_nefH5d1NJCsrWPvBc_KBf2NsItUoSt8,18302
+mbxai/openrouter/client.py,sha256=aWgE_-OqfwIcJmotM7diR0HbzA0qnVTdVH3xVIPyWHA,14542
 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
@@ -36,7 +36,7 @@ mbxai/tools/__init__.py,sha256=ogxrHvgJ7OR62Lmd5x9Eh5d2C0jqWyQis7Zy3yKpZ78,218
 mbxai/tools/client.py,sha256=2wFPD-UN3Y2DSyrnqxt2vvFgTYHzUl14_y0r6fhAWmM,17198
 mbxai/tools/example.py,sha256=1HgKK39zzUuwFbnp3f0ThyWVfA_8P28PZcTwaUw5K78,2232
 mbxai/tools/types.py,sha256=OFfM7scDGTm4FOcJA2ecj-fxL1MEBkqPsT3hqCL1Jto,9505
-mbxai-2.1.2.dist-info/METADATA,sha256=gC6y6zxmJ4MrP0ohbqVhZpTCGDvhqI-E_PGcZvgki3s,10018
-mbxai-2.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mbxai-2.1.2.dist-info/licenses/LICENSE,sha256=hEyhc4FxwYo3NQ40yNgZ7STqwVk-1_XcTXOnAPbGJAw,1069
-mbxai-2.1.2.dist-info/RECORD,,
+mbxai-2.2.0.dist-info/METADATA,sha256=ABGw5xmU3g9dh1lYkcruwAzXNdEO_54hEcrVztrMG30,14405
+mbxai-2.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mbxai-2.2.0.dist-info/licenses/LICENSE,sha256=hEyhc4FxwYo3NQ40yNgZ7STqwVk-1_XcTXOnAPbGJAw,1069
+mbxai-2.2.0.dist-info/RECORD,,

mbxai-2.1.2.dist-info/METADATA

@@ -1,346 +0,0 @@
-Metadata-Version: 2.4
-Name: mbxai
-Version: 2.1.2
-Summary: MBX AI SDK
-Project-URL: Homepage, https://www.mibexx.de
-Project-URL: Documentation, https://www.mibexx.de
-Project-URL: Repository, https://github.com/yourusername/mbxai.git
-Author: MBX AI
-License: MIT
-License-File: LICENSE
-Classifier: Development Status :: 4 - Beta
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.12
-Requires-Dist: fastapi>=0.115.12
-Requires-Dist: httpx>=0.27.0
-Requires-Dist: mcp>=1.7.1
-Requires-Dist: openai>=1.77.0
-Requires-Dist: pydantic-settings>=2.9.1
-Requires-Dist: pydantic>=2.9.1
-Requires-Dist: python-multipart>=0.0.20
-Requires-Dist: sse-starlette>=2.3.4
-Requires-Dist: starlette>=0.46.2
-Requires-Dist: typing-inspection<=0.4.0
-Requires-Dist: uvicorn>=0.34.2
-Provides-Extra: dev
-Requires-Dist: black>=24.3.0; extra == 'dev'
-Requires-Dist: isort>=5.13.2; extra == 'dev'
-Requires-Dist: mypy>=1.8.0; extra == 'dev'
-Requires-Dist: pytest-asyncio>=0.26.0; extra == 'dev'
-Requires-Dist: pytest-cov>=6.1.1; extra == 'dev'
-Requires-Dist: pytest>=8.3.5; extra == 'dev'
-Description-Content-Type: text/markdown
-
-# MBX AI
-
-A Python library for building AI applications with LLMs.
-
-## Features
-
-- **OpenRouter Integration**: Connect to various LLM providers through OpenRouter
-- **Intelligent Agent System**: AgentClient with dialog-based thinking, question generation, and quality iteration
-- **Tool Integration**: Easily integrate tools with LLMs using the Model Context Protocol (MCP)
-- **Structured Output**: Get structured, typed responses from LLMs
-- **Chat Interface**: Simple chat interface for interacting with LLMs
-- **FastAPI Server**: Built-in FastAPI server for tool integration
-
-## Installation
-
-```bash
-pip install mbxai
-```
-
-## Quick Start
-
-### Basic Usage
-
-```python
-from mbxai import OpenRouterClient
-
-# Initialize the client
-client = OpenRouterClient(api_key="your-api-key")
-
-# Chat with an LLM
-response = await client.chat([
-    {"role": "user", "content": "Hello, how are you?"}
-])
-print(response.choices[0].message.content)
-```
-
-### Quick Agent Example
-
-```python
-from mbxai import AgentClient, OpenRouterClient
-from pydantic import BaseModel, Field
-
-class TravelPlan(BaseModel):
-    destination: str = Field(description="Travel destination")
-    activities: list[str] = Field(description="Recommended activities")
-    budget: str = Field(description="Estimated budget")
-
-# Initialize agent
-client = OpenRouterClient(token="your-api-key")
-agent = AgentClient(client)
-
-# Get intelligent response with automatic quality improvement
-response = agent.agent(
-    prompt="Plan a weekend trip to a mountain destination",
-    final_response_structure=TravelPlan,
-    ask_questions=False
-)
-
-plan = response.final_response
-print(f"Destination: {plan.destination}")
-print(f"Activities: {', '.join(plan.activities)}")
-```
-
-### Using Tools
-
-```python
-from mbxai import OpenRouterClient, ToolClient
-from pydantic import BaseModel
-
-# Define your tool's input and output models
-class CalculatorInput(BaseModel):
-    a: float
-    b: float
-
-class CalculatorOutput(BaseModel):
-    result: float
-
-# Create a calculator tool
-async def calculator(input: CalculatorInput) -> CalculatorOutput:
-    return CalculatorOutput(result=input.a + input.b)
-
-# Initialize the client with tools
-client = ToolClient(OpenRouterClient(api_key="your-api-key"))
-client.add_tool(calculator)
-
-# Use the tool in a chat
-response = await client.chat([
-    {"role": "user", "content": "What is 2 + 3?"}
-])
-print(response.choices[0].message.content)
-```
-
-### Using MCP (Model Context Protocol)
-
-```python
-from mbxai import OpenRouterClient, MCPClient
-from mbxai.mcp import MCPServer
-from mcp.server.fastmcp import FastMCP
-from pydantic import BaseModel
-
-# Define your tool's input and output models
-class CalculatorInput(BaseModel):
-    a: float
-    b: float
-
-class CalculatorOutput(BaseModel):
-    result: float
-
-# Create a FastMCP instance
-mcp = FastMCP("calculator-service")
-
-# Create a calculator tool
-@mcp.tool()
-async def calculator(argument: CalculatorInput) -> CalculatorOutput:
-    return CalculatorOutput(result=argument.a + argument.b)
-
-# Start the MCP server
-server = MCPServer("calculator-service")
-await server.add_tool(calculator)
-await server.start()
-
-# Initialize the MCP client
-client = MCPClient(OpenRouterClient(api_key="your-api-key"))
-await client.register_mcp_server("calculator-service", "http://localhost:8000")
-
-# Use the tool in a chat
-response = await client.chat([
-    {"role": "user", "content": "What is 2 + 3?"}
-])
-print(response.choices[0].message.content)
-```
-
-### Using AgentClient (Intelligent Dialog System)
-
-The `AgentClient` provides an intelligent dialog-based thinking process that can ask clarifying questions, iterate on responses, and provide structured outputs.
-
-#### Basic Agent Usage
-
-```python
-from mbxai import AgentClient, OpenRouterClient
-from pydantic import BaseModel, Field
-
-# Define your response structure
-class BookRecommendation(BaseModel):
-    title: str = Field(description="The title of the recommended book")
-    author: str = Field(description="The author of the book")
-    genre: str = Field(description="The genre of the book")
-    reason: str = Field(description="Why this book is recommended")
-
-# Initialize the agent
-client = OpenRouterClient(token="your-api-key")
-agent = AgentClient(client)
-
-# Get a recommendation with questions
-response = agent.agent(
-    prompt="I want a book recommendation",
-    final_response_structure=BookRecommendation,
-    ask_questions=True  # Agent will ask clarifying questions
-)
-
-if response.has_questions():
-    # Display questions to user
-    for question in response.questions:
-        print(f"Q: {question.question}")
-    
-    # Collect answers and continue
-    from mbxai import AnswerList, Answer
-    answers = AnswerList(answers=[
-        Answer(key="genre", answer="I love science fiction"),
-        Answer(key="complexity", answer="I prefer complex narratives")
-    ])
-    
-    # Continue the conversation
-    final_response = agent.answer_to_agent(response.agent_id, answers)
-    book_rec = final_response.final_response
-    print(f"Recommended: {book_rec.title} by {book_rec.author}")
-else:
-    # Direct response without questions
-    book_rec = response.final_response
-    print(f"Recommended: {book_rec.title} by {book_rec.author}")
-```
-
-#### Agent with Tool Integration
-
-```python
-from mbxai import AgentClient, ToolClient, OpenRouterClient
-
-# Initialize with tool support
-openrouter_client = OpenRouterClient(token="your-api-key")
-tool_client = ToolClient(openrouter_client)
-agent = AgentClient(tool_client)
-
-# Register tools via the agent (schema auto-generated!)
-def get_weather(location: str, unit: str = "fahrenheit") -> dict:
-    """Get weather information for a location.
-    
-    Args:
-        location: The city or location name
-        unit: Temperature unit (fahrenheit or celsius)
-    """
-    return {"location": location, "temperature": "72°F", "conditions": "Sunny"}
-
-agent.register_tool(
-    name="get_weather",
-    description="Get current weather for a location",
-    function=get_weather
-    # Schema automatically generated from function signature!
-)
-
-# Use agent with tools
-class WeatherResponse(BaseModel):
-    location: str = Field(description="The location")
-    weather: str = Field(description="Weather description")
-    recommendations: list[str] = Field(description="Clothing recommendations")
-
-response = agent.agent(
-    prompt="What's the weather in San Francisco and what should I wear?",
-    final_response_structure=WeatherResponse,
-    ask_questions=False
-)
-
-weather_info = response.final_response
-print(f"Weather: {weather_info.weather}")
-```
-
-#### Agent Configuration
-
-```python
-# Configure quality iterations (default: 2)
-agent = AgentClient(
-    ai_client=openrouter_client,
-    max_iterations=3  # More iterations = higher quality, slower response
-)
-
-# Different configurations for different use cases:
-# max_iterations=0: Fastest, basic quality (chatbots)
-# max_iterations=1: Fast, good quality (content generation)
-# max_iterations=2: Balanced (default, recommended)
-# max_iterations=3+: Highest quality (analysis, reports)
-```
-
-#### Agent with MCP Client
-
-```python
-from mbxai import AgentClient, MCPClient
-
-# Initialize with MCP support
-mcp_client = MCPClient(OpenRouterClient(token="your-api-key"))
-agent = AgentClient(mcp_client)
-
-# Register MCP servers
-agent.register_mcp_server("data-analysis", "http://localhost:8000")
-
-# Register individual tools
-agent.register_tool("analyze_data", "Analyze dataset", analyze_function, schema)
-
-# Use agent with full MCP capabilities
-response = agent.agent(
-    prompt="Analyze the sales data and provide insights",
-    final_response_structure=AnalysisReport,
-    ask_questions=True
-)
-```
-
-#### Agent Features
-
-- **Intelligent Questions**: Automatically generates clarifying questions when needed
-- **Quality Iteration**: Improves responses through multiple AI review cycles  
-- **Tool Integration**: Seamlessly works with ToolClient and MCPClient
-- **Structured Output**: Always returns properly typed Pydantic models
-- **Session Management**: Handles multi-turn conversations with question/answer flow
-- **Configurable**: Adjust quality vs speed with max_iterations parameter
-
-#### Supported AI Clients
-
-| Client | Structured Responses | Tool Registration | MCP Server Registration |
-|--------|---------------------|-------------------|------------------------|
-| OpenRouterClient | ✅ | ❌ | ❌ |
-| ToolClient | ✅ | ✅ | ❌ |
-| MCPClient | ✅ | ✅ | ✅ |
-
-## Development
-
-### Setup
-
-1. Clone the repository:
-```bash
-git clone https://github.com/yourusername/mbxai.git
-cd mbxai
-```
-
-2. Create a virtual environment:
-```bash
-python -m venv .venv
-source .venv/bin/activate  # On Windows: .venv\Scripts\activate
-```
-
-3. Install dependencies:
-```bash
-pip install -e ".[dev]"
-```
-
-### Running Tests
-
-```bash
-pytest tests/
-```
-
-## License
-
-MIT License