mbxai 2.0.4__py3-none-any.whl → 2.0.5__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.0.4"
+__version__ = "2.0.5"
 
 __all__ = [
     "AgentClient",

mbxai/agent/client.py

@@ -10,7 +10,7 @@ from pydantic import BaseModel
 from ..openrouter import OpenRouterClient
 from ..tools import ToolClient
 from ..mcp import MCPClient
-from .models import AgentResponse, Question, QuestionList, AnswerList, Result, QualityCheck
+from .models import AgentResponse, Question, QuestionList, AnswerList, Result, QualityCheck, TokenUsage, TokenSummary
 
 logger = logging.getLogger(__name__)
 
@@ -127,6 +127,21 @@ class AgentClient:
         """Call the parse method on the AI client."""
         return self._ai_client.parse(messages, response_format)
 
+    def _extract_token_usage(self, response: Any) -> TokenUsage:
+        """Extract token usage information from an AI response."""
+        try:
+            if hasattr(response, 'usage') and response.usage:
+                usage = response.usage
+                return TokenUsage(
+                    prompt_tokens=getattr(usage, 'prompt_tokens', 0),
+                    completion_tokens=getattr(usage, 'completion_tokens', 0),
+                    total_tokens=getattr(usage, 'total_tokens', 0)
+                )
+        except (AttributeError, TypeError) as e:
+            logger.debug(f"Could not extract token usage: {e}")
+        
+        return TokenUsage()  # Return empty usage if extraction fails
+
     def _extract_parsed_content(self, response: Any, response_format: Type[BaseModel]) -> BaseModel:
         """Extract the parsed content from the AI response."""
         if hasattr(response, 'choices') and len(response.choices) > 0:
@@ -177,10 +192,15 @@ class AgentClient:
         Returns:
             AgentResponse containing either questions to ask or the final response
         """
-        logger.debug(f"Starting agent process with prompt: {prompt[:100]}...")
+        agent_id = str(__import__("uuid").uuid4())
+        logger.info(f"🚀 Starting agent process (ID: {agent_id}) with prompt: {prompt[:100]}...")
+        
+        # Initialize token summary
+        token_summary = TokenSummary()
         
         # Step 1: Generate questions (if ask_questions is True)
         if ask_questions:
+            logger.info(f"❓ Agent {agent_id}: Analyzing prompt and generating clarifying questions")
             questions_prompt = f"""
 Understand this prompt and what the user wants to achieve by it: 
 ==========
@@ -204,25 +224,31 @@ IMPORTANT: For each question, provide a technical key identifier that:
                 response = self._call_ai_parse(messages, QuestionList)
                 question_list = self._extract_parsed_content(response, QuestionList)
                 
-                logger.debug(f"Generated {len(question_list.questions)} questions")
+                # Extract token usage for question generation
+                token_summary.question_generation = self._extract_token_usage(response)
+                
+                logger.info(f"❓ Agent {agent_id}: Generated {len(question_list.questions)} questions (tokens: {token_summary.question_generation.total_tokens})")
                 
                 # If we have questions, return them to the user
                 if question_list.questions:
-                    agent_response = AgentResponse(questions=question_list.questions)
+                    agent_response = AgentResponse(agent_id=agent_id, questions=question_list.questions, token_summary=token_summary)
                     # Store the session for continuation
                     self._agent_sessions[agent_response.agent_id] = {
                         "original_prompt": prompt,
                         "final_response_structure": final_response_structure,
                         "questions": question_list.questions,
-                        "step": "waiting_for_answers"
+                        "step": "waiting_for_answers",
+                        "token_summary": token_summary
                     }
+                    logger.info(f"📋 Agent {agent_id}: Waiting for user answers to {len(question_list.questions)} questions")
                     return agent_response
                     
             except Exception as e:
                 logger.warning(f"Failed to generate questions: {e}. Proceeding without questions.")
         
         # Step 2 & 3: No questions or ask_questions=False - proceed directly
-        return self._process_with_answers(prompt, final_response_structure, [])
+        logger.info(f"⚡ Agent {agent_id}: No questions needed, proceeding directly to processing")
+        return self._process_with_answers(prompt, final_response_structure, [], agent_id, token_summary)
 
     def answer_to_agent(self, agent_id: str, answers: AnswerList) -> AgentResponse:
         """
@@ -248,11 +274,18 @@ IMPORTANT: For each question, provide a technical key identifier that:
         # Convert answers to a more usable format
         answer_dict = {answer.key: answer.answer for answer in answers.answers}
         
+        logger.info(f"📝 Agent {agent_id}: Received {len(answers.answers)} answers, continuing processing")
+        
+        # Get token summary from session
+        token_summary = session.get("token_summary", TokenSummary())
+        
         # Process with the provided answers
         result = self._process_with_answers(
             session["original_prompt"],
             session["final_response_structure"],
-            answer_dict
+            answer_dict,
+            agent_id,
+            token_summary
         )
         
         # Clean up the session
@@ -264,7 +297,9 @@ IMPORTANT: For each question, provide a technical key identifier that:
         self,
         prompt: str,
         final_response_structure: Type[BaseModel],
-        answers: Union[list, dict[str, str]]
+        answers: Union[list, dict[str, str]],
+        agent_id: str,
+        token_summary: TokenSummary
     ) -> AgentResponse:
         """
         Process the prompt with answers through the thinking pipeline.
@@ -273,28 +308,38 @@ IMPORTANT: For each question, provide a technical key identifier that:
             prompt: The original prompt
             final_response_structure: Expected final response structure
             answers: Answers to questions (empty if no questions were asked)
+            agent_id: The agent session identifier
+            token_summary: Current token usage summary
 
         Returns:
             AgentResponse with the final result
         """
         # Step 3: Process the prompt with thinking
-        result = self._think_and_process(prompt, answers)
+        logger.info(f"🧠 Agent {agent_id}: Processing prompt and generating initial response")
+        result = self._think_and_process(prompt, answers, agent_id, token_summary)
         
         # Step 4: Quality check and iteration
-        final_result = self._quality_check_and_iterate(prompt, result, answers)
+        final_result = self._quality_check_and_iterate(prompt, result, answers, agent_id, token_summary)
         
         # Step 5: Generate final answer in requested format
-        final_response = self._generate_final_response(prompt, final_result, final_response_structure)
+        logger.info(f"📝 Agent {agent_id}: Generating final structured response")
+        final_response = self._generate_final_response(prompt, final_result, final_response_structure, agent_id, token_summary)
+        
+        # Log final token summary
+        logger.info(f"📊 Agent {agent_id}: Token usage summary - Total: {token_summary.total_tokens} "
+                   f"(Prompt: {token_summary.total_prompt_tokens}, Completion: {token_summary.total_completion_tokens})")
         
-        return AgentResponse(final_response=final_response)
+        return AgentResponse(agent_id=agent_id, final_response=final_response, token_summary=token_summary)
 
-    def _think_and_process(self, prompt: str, answers: Union[list, dict[str, str]]) -> str:
+    def _think_and_process(self, prompt: str, answers: Union[list, dict[str, str]], agent_id: str, token_summary: TokenSummary) -> str:
         """
         Process the prompt with thinking.
 
         Args:
             prompt: The original prompt
             answers: Answers to questions
+            agent_id: The agent session identifier
+            token_summary: Current token usage summary
 
         Returns:
             The AI's result
@@ -325,12 +370,17 @@ Provide your best result for the given prompt.
         try:
             response = self._call_ai_parse(messages, Result)
             result_obj = self._extract_parsed_content(response, Result)
+            
+            # Track token usage for thinking process
+            token_summary.thinking_process = self._extract_token_usage(response)
+            logger.info(f"🧠 Agent {agent_id}: Thinking completed (tokens: {token_summary.thinking_process.total_tokens})")
+            
             return result_obj.result
         except Exception as e:
             logger.error(f"Error in thinking process: {e}")
             raise RuntimeError(f"Failed to process prompt with AI client: {e}") from e
 
-    def _quality_check_and_iterate(self, prompt: str, result: str, answers: Union[list, dict[str, str]]) -> str:
+    def _quality_check_and_iterate(self, prompt: str, result: str, answers: Union[list, dict[str, str]], agent_id: str, token_summary: TokenSummary) -> str:
         """
         Check the quality of the result and iterate if needed.
 
@@ -338,12 +388,20 @@ Provide your best result for the given prompt.
             prompt: The original prompt
             result: The current result
             answers: The answers provided
+            agent_id: The agent session identifier
+            token_summary: Current token usage summary
 
         Returns:
             The final improved result
         """
         current_result = result
         
+        if self._max_iterations == 0:
+            logger.info(f"✅ Agent {agent_id}: Skipping quality check (max_iterations=0)")
+            return current_result
+        
+        logger.info(f"🔍 Agent {agent_id}: Starting quality check and improvement process (max iterations: {self._max_iterations})")
+        
         for iteration in range(self._max_iterations):
             quality_prompt = f"""
 Given this original prompt:
@@ -367,11 +425,15 @@ Evaluate the quality and provide feedback if improvements are needed.
                 response = self._call_ai_parse(messages, QualityCheck)
                 quality_check = self._extract_parsed_content(response, QualityCheck)
                 
+                # Track token usage for quality check
+                quality_check_tokens = self._extract_token_usage(response)
+                token_summary.quality_checks.append(quality_check_tokens)
+                
                 if quality_check.is_good:
-                    logger.debug(f"Quality check passed on iteration {iteration}")
+                    logger.info(f"✅ Agent {agent_id}: Quality check passed on iteration {iteration + 1} (tokens: {quality_check_tokens.total_tokens})")
                     break
                     
-                logger.debug(f"Quality check failed on iteration {iteration}: {quality_check.feedback}")
+                logger.info(f"🔄 Agent {agent_id}: Quality check iteration {iteration + 1} - Improvements needed: {quality_check.feedback[:100]}... (tokens: {quality_check_tokens.total_tokens})")
                 
                 # Improve the result
                 improvement_prompt = f"""
@@ -394,17 +456,27 @@ Please provide an improved version that addresses the feedback while maintaining
 """
                 
                 messages = [{"role": "user", "content": improvement_prompt}]
-                response = self._call_ai_parse(messages, Result)
-                result_obj = self._extract_parsed_content(response, Result)
+                improvement_response = self._call_ai_parse(messages, Result)
+                result_obj = self._extract_parsed_content(improvement_response, Result)
                 current_result = result_obj.result
                 
+                # Track token usage for improvement
+                improvement_tokens = self._extract_token_usage(improvement_response)
+                token_summary.improvements.append(improvement_tokens)
+                
+                logger.info(f"⚡ Agent {agent_id}: Improvement iteration {iteration + 1} completed (tokens: {improvement_tokens.total_tokens})")
+                
             except Exception as e:
                 logger.warning(f"Error in quality check iteration {iteration}: {e}")
                 break
         
+        total_quality_tokens = sum(usage.total_tokens for usage in token_summary.quality_checks)
+        total_improvement_tokens = sum(usage.total_tokens for usage in token_summary.improvements)
+        logger.info(f"🏁 Agent {agent_id}: Quality check completed - {len(token_summary.quality_checks)} checks, {len(token_summary.improvements)} improvements (Quality tokens: {total_quality_tokens}, Improvement tokens: {total_improvement_tokens})")
+        
         return current_result
 
-    def _generate_final_response(self, prompt: str, result: str, final_response_structure: Type[BaseModel]) -> BaseModel:
+    def _generate_final_response(self, prompt: str, result: str, final_response_structure: Type[BaseModel], agent_id: str, token_summary: TokenSummary) -> BaseModel:
         """
         Generate the final response in the requested format.
 
@@ -412,6 +484,8 @@ Please provide an improved version that addresses the feedback while maintaining
             prompt: The original prompt
             result: The processed result
             final_response_structure: The expected response structure
+            agent_id: The agent session identifier
+            token_summary: Current token usage summary
 
         Returns:
             The final response in the requested format
@@ -434,7 +508,13 @@ Generate the final answer in the exact format requested. Make sure the response
         
         try:
             response = self._call_ai_parse(messages, final_response_structure)
-            return self._extract_parsed_content(response, final_response_structure)
+            final_response = self._extract_parsed_content(response, final_response_structure)
+            
+            # Track token usage for final response generation
+            token_summary.final_response = self._extract_token_usage(response)
+            logger.info(f"📝 Agent {agent_id}: Final structured response generated (tokens: {token_summary.final_response.total_tokens})")
+            
+            return final_response
         except Exception as e:
             logger.error(f"Error generating final response: {e}")
             # Fallback - try to create a basic response

mbxai/agent/models.py

@@ -46,6 +46,7 @@ class AgentResponse(BaseModel):
     agent_id: str = Field(default_factory=lambda: str(uuid.uuid4()), description="Unique identifier for this agent session")
     questions: list[Question] = Field(default_factory=list, description="List of questions for the user")
     final_response: Optional[Any] = Field(default=None, description="The final response if processing is complete")
+    token_summary: Optional["TokenSummary"] = Field(default=None, description="Summary of token usage for this agent process")
     
     def has_questions(self) -> bool:
         """Check if this response has questions that need to be answered."""
@@ -76,3 +77,55 @@ class QualityCheck(BaseModel):
     """Result of quality checking the AI response."""
     is_good: bool = Field(description="Whether the result is good enough")
     feedback: str = Field(description="Feedback on what could be improved if not good")
+
+
+class TokenUsage(BaseModel):
+    """Token usage information for a single API call."""
+    prompt_tokens: int = Field(default=0, description="Number of tokens in the prompt")
+    completion_tokens: int = Field(default=0, description="Number of tokens in the completion")
+    total_tokens: int = Field(default=0, description="Total number of tokens used")
+
+
+class TokenSummary(BaseModel):
+    """Summary of token usage across all API calls in an agent process."""
+    question_generation: TokenUsage = Field(default_factory=TokenUsage, description="Tokens used for question generation")
+    thinking_process: TokenUsage = Field(default_factory=TokenUsage, description="Tokens used for thinking/processing")
+    quality_checks: list[TokenUsage] = Field(default_factory=list, description="Tokens used for each quality check iteration")
+    improvements: list[TokenUsage] = Field(default_factory=list, description="Tokens used for each improvement iteration")
+    final_response: TokenUsage = Field(default_factory=TokenUsage, description="Tokens used for final response generation")
+    
+    @property
+    def total_tokens(self) -> int:
+        """Calculate total tokens used across all operations."""
+        total = (
+            self.question_generation.total_tokens +
+            self.thinking_process.total_tokens +
+            sum(usage.total_tokens for usage in self.quality_checks) +
+            sum(usage.total_tokens for usage in self.improvements) +
+            self.final_response.total_tokens
+        )
+        return total
+    
+    @property
+    def total_prompt_tokens(self) -> int:
+        """Calculate total prompt tokens used across all operations."""
+        total = (
+            self.question_generation.prompt_tokens +
+            self.thinking_process.prompt_tokens +
+            sum(usage.prompt_tokens for usage in self.quality_checks) +
+            sum(usage.prompt_tokens for usage in self.improvements) +
+            self.final_response.prompt_tokens
+        )
+        return total
+    
+    @property
+    def total_completion_tokens(self) -> int:
+        """Calculate total completion tokens used across all operations."""
+        total = (
+            self.question_generation.completion_tokens +
+            self.thinking_process.completion_tokens +
+            sum(usage.completion_tokens for usage in self.quality_checks) +
+            sum(usage.completion_tokens for usage in self.improvements) +
+            self.final_response.completion_tokens
+        )
+        return total

mbxai/examples/agent_logging_example.py

@@ -0,0 +1,212 @@
+"""
+Example demonstrating the enhanced logging and token tracking features of the AgentClient.
+"""
+
+import os
+import logging
+from pydantic import BaseModel, Field
+
+from mbxai.openrouter import OpenRouterClient
+from mbxai.agent import AgentClient
+
+# Configure logging to see all the agent information
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+
+class WeatherResponse(BaseModel):
+    """Response format for weather information."""
+    location: str = Field(description="The location requested")
+    current_conditions: str = Field(description="Current weather conditions")
+    temperature: str = Field(description="Current temperature")
+    forecast: str = Field(description="Weather forecast")
+    recommendation: str = Field(description="Clothing or activity recommendation based on weather")
+
+class AnalysisResponse(BaseModel):
+    """Response format for complex analysis."""
+    summary: str = Field(description="Executive summary of the analysis")
+    key_findings: list[str] = Field(description="List of key findings")
+    methodology: str = Field(description="How the analysis was conducted")
+    recommendations: list[str] = Field(description="Actionable recommendations")
+    confidence_level: str = Field(description="Confidence level in the analysis")
+
+def demonstrate_agent_with_questions():
+    """Demonstrate agent process with question generation."""
+    print("\n" + "="*60)
+    print("🔍 DEMO: Agent with Question Generation")
+    print("="*60)
+    
+    try:
+        # Note: This requires a real OpenRouter API key
+        api_key = os.getenv("OPENROUTER_API_KEY")
+        if not api_key:
+            print("❌ OPENROUTER_API_KEY not found. Using mock example.")
+            print("Set OPENROUTER_API_KEY environment variable to run with real API calls.")
+            return
+        
+        openrouter_client = OpenRouterClient(token=api_key)
+        agent = AgentClient(openrouter_client, max_iterations=2)
+        
+        prompt = "I need weather information for planning my outdoor activities this weekend."
+        
+        print(f"📤 Sending prompt: {prompt}")
+        response = agent.agent(prompt, WeatherResponse, ask_questions=True)
+        
+        if response.has_questions():
+            print(f"\n📋 Agent generated {len(response.questions)} questions:")
+            for i, question in enumerate(response.questions, 1):
+                print(f"  {i}. {question.question} (key: {question.key})")
+            
+            if response.token_summary:
+                print(f"\n📊 Token usage for question generation:")
+                print(f"   - Prompt tokens: {response.token_summary.question_generation.prompt_tokens}")
+                print(f"   - Completion tokens: {response.token_summary.question_generation.completion_tokens}")
+                print(f"   - Total tokens: {response.token_summary.question_generation.total_tokens}")
+            
+            # Simulate user providing answers
+            from mbxai.agent.models import AnswerList, Answer
+            
+            answers = AnswerList(answers=[
+                Answer(key="location", answer="San Francisco, CA"),
+                Answer(key="activity_type", answer="hiking and outdoor photography"),
+                Answer(key="time_frame", answer="Saturday and Sunday morning")
+            ])
+            
+            print(f"\n📝 Providing answers and continuing...")
+            final_response = agent.answer_to_agent(response.agent_id, answers)
+            
+            if final_response.is_complete():
+                print("\n✅ Final response received!")
+                print(f"📊 Complete token summary:")
+                if final_response.token_summary:
+                    ts = final_response.token_summary
+                    print(f"   - Question generation: {ts.question_generation.total_tokens} tokens")
+                    print(f"   - Thinking process: {ts.thinking_process.total_tokens} tokens")
+                    print(f"   - Quality checks: {sum(q.total_tokens for q in ts.quality_checks)} tokens ({len(ts.quality_checks)} checks)")
+                    print(f"   - Improvements: {sum(i.total_tokens for i in ts.improvements)} tokens ({len(ts.improvements)} iterations)")
+                    print(f"   - Final response: {ts.final_response.total_tokens} tokens")
+                    print(f"   - TOTAL: {ts.total_tokens} tokens")
+                
+                # Access the structured response
+                weather_data = final_response.final_response
+                print(f"\n🌤️  Weather for {weather_data.location}:")
+                print(f"   Current: {weather_data.current_conditions}")
+                print(f"   Temperature: {weather_data.temperature}")
+                print(f"   Recommendation: {weather_data.recommendation}")
+        
+    except Exception as e:
+        print(f"❌ Error: {e}")
+
+def demonstrate_agent_without_questions():
+    """Demonstrate agent process without question generation."""
+    print("\n" + "="*60)
+    print("⚡ DEMO: Agent without Question Generation (Direct Processing)")
+    print("="*60)
+    
+    try:
+        # Note: This requires a real OpenRouter API key
+        api_key = os.getenv("OPENROUTER_API_KEY")
+        if not api_key:
+            print("❌ OPENROUTER_API_KEY not found. Using mock example.")
+            print("Set OPENROUTER_API_KEY environment variable to run with real API calls.")
+            return
+        
+        openrouter_client = OpenRouterClient(token=api_key)
+        agent = AgentClient(openrouter_client, max_iterations=1)
+        
+        prompt = """
+        Analyze the current state of renewable energy adoption in Europe. 
+        Focus on solar and wind power, include recent statistics, challenges, 
+        and future outlook for the next 5 years.
+        """
+        
+        print(f"📤 Sending prompt: {prompt[:100]}...")
+        response = agent.agent(prompt, AnalysisResponse, ask_questions=False)
+        
+        if response.is_complete():
+            print("\n✅ Analysis completed!")
+            
+            if response.token_summary:
+                ts = response.token_summary
+                print(f"\n📊 Token usage breakdown:")
+                print(f"   - Thinking process: {ts.thinking_process.total_tokens} tokens")
+                print(f"   - Quality checks: {sum(q.total_tokens for q in ts.quality_checks)} tokens ({len(ts.quality_checks)} checks)")
+                print(f"   - Improvements: {sum(i.total_tokens for i in ts.improvements)} tokens ({len(ts.improvements)} iterations)")
+                print(f"   - Final response: {ts.final_response.total_tokens} tokens")
+                print(f"   - TOTAL: {ts.total_tokens} tokens")
+            
+            # Access the structured response
+            analysis = response.final_response
+            print(f"\n📊 Analysis Results:")
+            print(f"   Summary: {analysis.summary[:150]}...")
+            print(f"   Key Findings: {len(analysis.key_findings)} items")
+            print(f"   Recommendations: {len(analysis.recommendations)} items")
+            print(f"   Confidence: {analysis.confidence_level}")
+        
+    except Exception as e:
+        print(f"❌ Error: {e}")
+
+def demonstrate_different_iteration_settings():
+    """Demonstrate different max_iterations settings and their effect on token usage."""
+    print("\n" + "="*60)
+    print("🔄 DEMO: Different Iteration Settings")
+    print("="*60)
+    
+    iteration_configs = [
+        {"iterations": 0, "description": "No quality checks"},
+        {"iterations": 1, "description": "Basic quality check"},
+        {"iterations": 3, "description": "Thorough quality improvement"}
+    ]
+    
+    prompt = "Explain quantum computing in simple terms for a business audience."
+    
+    for config in iteration_configs:
+        print(f"\n📋 Testing with {config['iterations']} max iterations ({config['description']})")
+        print("-" * 40)
+        
+        try:
+            api_key = os.getenv("OPENROUTER_API_KEY")
+            if not api_key:
+                print(f"   ❌ Skipping - OPENROUTER_API_KEY not found")
+                continue
+            
+            openrouter_client = OpenRouterClient(token=api_key)
+            agent = AgentClient(openrouter_client, max_iterations=config["iterations"])
+            
+            print(f"   🚀 Processing with max_iterations={config['iterations']}")
+            print(f"   - Description: {config['description']}")
+            print(f"   - Expected processing time: {'Low' if config['iterations'] <= 1 else 'Medium' if config['iterations'] <= 2 else 'High'}")
+            print(f"   - Expected response quality: {'Basic' if config['iterations'] == 0 else 'Good' if config['iterations'] <= 2 else 'Excellent'}")
+            
+            # In real usage, you would call:
+            # response = agent.agent(prompt, AnalysisResponse, ask_questions=False)
+            
+        except Exception as e:
+            print(f"   ❌ Error: {e}")
+
+if __name__ == "__main__":
+    print("🤖 Agent Client Logging and Token Tracking Demo")
+    print("This example demonstrates the enhanced logging and token usage tracking features.")
+    
+    # Check for API key
+    api_key = os.getenv("OPENROUTER_API_KEY")
+    if not api_key:
+        print("\n⚠️  Note: To run with real API calls, set the OPENROUTER_API_KEY environment variable.")
+        print("The examples will show the logging structure but won't make actual API calls.")
+    
+    # Run demonstrations
+    demonstrate_agent_with_questions()
+    demonstrate_agent_without_questions() 
+    demonstrate_different_iteration_settings()
+    
+    print("\n✅ Demo completed!")
+    print("\nTo see the logging in action, run this script with a valid OPENROUTER_API_KEY.")
+    print("You'll see detailed logs showing:")
+    print("   - 🚀 Agent process start")
+    print("   - ❓ Question generation")
+    print("   - 🧠 Thinking process")
+    print("   - 🔍 Quality checks")
+    print("   - ⚡ Improvements")
+    print("   - 📝 Final response generation")
+    print("   - 📊 Complete token usage summary")

mbxai/mcp/server.py

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

{mbxai-2.0.4.dist-info → mbxai-2.0.5.dist-info}/METADATA

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

{mbxai-2.0.4.dist-info → mbxai-2.0.5.dist-info}/RECORD

@@ -1,10 +1,11 @@
-mbxai/__init__.py,sha256=tQvBc7DtUU3Y8uBqWgt8a89YWskLrhWMzhuEpFHbtEs,407
+mbxai/__init__.py,sha256=LBQ9uRdY1u9DERFu9g7Q-EN6BbL2Q0jQmovQBZN2E6U,407
 mbxai/core.py,sha256=WMvmU9TTa7M_m-qWsUew4xH8Ul6xseCZ2iBCXJTW-Bs,196
 mbxai/agent/__init__.py,sha256=5j3mW2NZtAU1s2w8n833axWBQsxW8U0qKwoQ9JtQZ4k,289
-mbxai/agent/client.py,sha256=Gpu3B8NeBSuZeSx-pjvhvCv-yntzvbwFaYpVVwHASFc,18367
-mbxai/agent/models.py,sha256=0IYhO2jO40ydpFwuZewZa11Pbd5NXqdofCKmMKGmKc8,3144
+mbxai/agent/client.py,sha256=Rt8S2a7WYa674xgK7T_ZralxCZ-WqppeOlcLCljUClk,23648
+mbxai/agent/models.py,sha256=sjBtaAENDABHl8IqTON1gxFFSZIaQYUCBFHB5804_Fw,5780
 mbxai/examples/agent_example.py,sha256=uECWy8QX1IhJMVcdw6EJy6sLcvO8vKgEF_YHJOhZO6Y,5947
 mbxai/examples/agent_iterations_example.py,sha256=xMqZhBWS67EkRkArjOAY2fCgLkQ32Qn9E4CSfEKW4MU,7905
+mbxai/examples/agent_logging_example.py,sha256=su2Ccdfp8aYGCQkZhnNRGbaBd6DZEsYpPoxm7dI2g_o,10162
 mbxai/examples/agent_tool_registration_example.py,sha256=oWm0-d4mdba-VQ3HobiCIR0IHtEDCtJenb8Lnm9QqCw,9108
 mbxai/examples/agent_validation_example.py,sha256=xlEf5Mwq5_Iu8bNU4cuHGZVYvAyZNhO2GMFmOom-CLo,4185
 mbxai/examples/auto_schema_example.py,sha256=ymuJJqqDxYznZT2VN6zVFEM7m_lDuccZ1AKSx-xzLTM,8174
@@ -21,7 +22,7 @@ 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=dDU425A2ufXsjMbYuOH-KZVjCRUyNR716DRREGRfGwc,3332
+mbxai/mcp/server.py,sha256=vJeVQpC616KNAwPzZP8FVfHmYnfIYbGq-L8h1MRVIC0,3332
 mbxai/openrouter/__init__.py,sha256=Ito9Qp_B6q-RLGAQcYyTJVWwR2YAZvNqE-HIYXxhtD8,298
 mbxai/openrouter/client.py,sha256=3LD6WDJ8wjo_nefH5d1NJCsrWPvBc_KBf2NsItUoSt8,18302
 mbxai/openrouter/config.py,sha256=Ia93s-auim9Sq71eunVDbn9ET5xX2zusXpV4JBdHAzs,3251
@@ -31,7 +32,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.0.4.dist-info/METADATA,sha256=0EqHKwLFaFtmBBXTZRWFEsxQJJmu2TS_32UpSVQm7J8,10018
-mbxai-2.0.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mbxai-2.0.4.dist-info/licenses/LICENSE,sha256=hEyhc4FxwYo3NQ40yNgZ7STqwVk-1_XcTXOnAPbGJAw,1069
-mbxai-2.0.4.dist-info/RECORD,,
+mbxai-2.0.5.dist-info/METADATA,sha256=Wa_VavJcCfmnybtF5oRyECfrYVnjr-5Hjw81Uq-LOZc,10018
+mbxai-2.0.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mbxai-2.0.5.dist-info/licenses/LICENSE,sha256=hEyhc4FxwYo3NQ40yNgZ7STqwVk-1_XcTXOnAPbGJAw,1069
+mbxai-2.0.5.dist-info/RECORD,,