mbxai 2.0.3__tar.gz → 2.0.5__tar.gz

{mbxai-2.0.3 → mbxai-2.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mbxai
-Version: 2.0.3
+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.3 → mbxai-2.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mbxai"
-version = "2.0.3"
+version = "2.0.5"
 authors = [
     { name = "MBX AI" }
 ]
@@ -82,6 +82,7 @@ strict_equality = true
 
 [dependency-groups]
 dev = [
-    "build>=2.0.3.post1",
+    "pytest>=8.3.5",
+    "pytest-asyncio>=0.26.0",
     "twine>=6.1.0",
 ]

{mbxai-2.0.3 → mbxai-2.0.5}/setup.py

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

{mbxai-2.0.3 → mbxai-2.0.5}/src/mbxai/__init__.py

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

{mbxai-2.0.3 → mbxai-2.0.5}/src/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: 
 ==========
@@ -190,6 +210,12 @@ Understand this prompt and what the user wants to achieve by it:
 Think about useful steps and which information are required for it. First ask for required information and details to improve that process, when that is useful for the given case. When it's not useful, return an empty list of questions.
 Use available tools to gather information or perform actions that would improve your response.
 Analyze the prompt carefully and determine if additional information would significantly improve the quality of the response. Only ask questions that are truly necessary and would materially impact the outcome.
+
+IMPORTANT: For each question, provide a technical key identifier that:
+- Uses only alphanumeric characters and underscores
+- Starts with a letter
+- Is descriptive but concise (e.g., "user_name", "email_address", "preferred_genre", "budget_range")
+- Contains no spaces, hyphens, or special characters like ?, !, @, etc.
 """
             
             messages = [{"role": "user", "content": questions_prompt}]
@@ -198,25 +224,31 @@ Analyze the prompt carefully and determine if additional information would signi
                 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:
         """
@@ -242,11 +274,18 @@ Analyze the prompt carefully and determine if additional information would signi
         # 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
@@ -258,7 +297,9 @@ Analyze the prompt carefully and determine if additional information would signi
         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.
@@ -267,28 +308,38 @@ Analyze the prompt carefully and determine if additional information would signi
             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)
         
-        return AgentResponse(final_response=final_response)
+        # 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(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
@@ -319,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.
 
@@ -332,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:
@@ -361,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"""
@@ -388,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.
 
@@ -406,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
@@ -428,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-2.0.5/src/mbxai/agent/models.py

@@ -0,0 +1,131 @@
+"""
+Pydantic models for the agent client.
+"""
+
+from typing import Any, Optional
+from pydantic import BaseModel, Field, field_validator
+import uuid
+import re
+
+
+class Question(BaseModel):
+    """A question for the user to provide more information."""
+    question: str = Field(description="The question to ask the user")
+    key: str = Field(description="A unique and short technical key identifier using only alphanumeric characters and underscores (e.g., user_name, email_address, age)")
+    required: bool = Field(default=True, description="Whether this question is required")
+    
+    @field_validator('key')
+    @classmethod
+    def validate_key(cls, v: str) -> str:
+        """Ensure the key contains only alphanumeric characters and underscores."""
+        if not re.match(r'^[a-zA-Z][a-zA-Z0-9_]*$', v):
+            # Convert invalid key to valid format
+            # Remove special characters and replace spaces with underscores
+            cleaned = re.sub(r'[^a-zA-Z0-9_]', '_', v)
+            # Ensure it starts with a letter
+            if not cleaned or not cleaned[0].isalpha():
+                cleaned = 'key_' + cleaned
+            # Remove consecutive underscores
+            cleaned = re.sub(r'_+', '_', cleaned)
+            # Remove trailing underscores
+            cleaned = cleaned.rstrip('_')
+            # Ensure it's not empty
+            if not cleaned:
+                cleaned = 'key'
+            return cleaned
+        return v
+
+
+class Result(BaseModel):
+    """A simple result wrapper containing just text."""
+    result: str = Field(description="The result text from the AI")
+
+
+class AgentResponse(BaseModel):
+    """Response from the agent that can contain questions or a final result."""
+    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."""
+        return len(self.questions) > 0
+    
+    def is_complete(self) -> bool:
+        """Check if this response contains a final result."""
+        return self.final_response is not None
+
+
+class QuestionList(BaseModel):
+    """A list of questions to ask the user."""
+    questions: list[Question] = Field(description="List of questions to ask the user")
+
+
+class Answer(BaseModel):
+    """An answer to a question."""
+    key: str = Field(description="The key of the question being answered")
+    answer: str = Field(description="The answer to the question")
+
+
+class AnswerList(BaseModel):
+    """A list of answers from the user."""
+    answers: list[Answer] = Field(description="List of answers to questions")
+
+
+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-2.0.5/src/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-2.0.3 → mbxai-2.0.5}/src/mbxai/mcp/server.py

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

mbxai-2.0.3/src/mbxai/agent/models.py

@@ -1,56 +0,0 @@
-"""
-Pydantic models for the agent client.
-"""
-
-from typing import Any, Optional
-from pydantic import BaseModel, Field
-import uuid
-
-
-class Question(BaseModel):
-    """A question for the user to provide more information."""
-    question: str = Field(description="The question to ask the user")
-    key: str = Field(description="A unique and short technical key identifier to identify this question don't use spaces or special characters")
-    required: bool = Field(default=True, description="Whether this question is required")
-
-
-class Result(BaseModel):
-    """A simple result wrapper containing just text."""
-    result: str = Field(description="The result text from the AI")
-
-
-class AgentResponse(BaseModel):
-    """Response from the agent that can contain questions or a final result."""
-    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")
-    
-    def has_questions(self) -> bool:
-        """Check if this response has questions that need to be answered."""
-        return len(self.questions) > 0
-    
-    def is_complete(self) -> bool:
-        """Check if this response contains a final result."""
-        return self.final_response is not None
-
-
-class QuestionList(BaseModel):
-    """A list of questions to ask the user."""
-    questions: list[Question] = Field(description="List of questions to ask the user")
-
-
-class Answer(BaseModel):
-    """An answer to a question."""
-    key: str = Field(description="The key of the question being answered")
-    answer: str = Field(description="The answer to the question")
-
-
-class AnswerList(BaseModel):
-    """A list of answers from the user."""
-    answers: list[Answer] = Field(description="List of answers to questions")
-
-
-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")