mbxai 2.1.1__tar.gz → 2.1.3__tar.gz

{mbxai-2.1.1 → mbxai-2.1.3}/PKG-INFO

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

{mbxai-2.1.1 → mbxai-2.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mbxai"
-version = "2.1.1"
+version = "2.1.3"
 authors = [
     { name = "MBX AI" }
 ]

{mbxai-2.1.1 → mbxai-2.1.3}/setup.py

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

{mbxai-2.1.1 → mbxai-2.1.3}/src/mbxai/__init__.py

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

{mbxai-2.1.1 → mbxai-2.1.3}/src/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:
@@ -184,39 +213,63 @@ class AgentClient:
 
     def agent(
         self,
-        prompt: str,
-        final_response_structure: Type[BaseModel],
+        prompt: str = None,
+        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.
 
         Args:
-            prompt: The initial prompt from the user
-            final_response_structure: Pydantic model defining the expected final response format
+            prompt: The prompt from the user (optional if agent_id exists with history)
+            final_response_structure: Pydantic model defining the expected final response format (required for new sessions)
             ask_questions: Whether to ask clarifying questions (default: True)
             agent_id: Optional agent session ID to continue an existing conversation
             answers: Optional answers to questions (when continuing a conversation with questions)
 
         Returns:
             AgentResponse containing either questions to ask or the final response
+            
+        Raises:
+            ValueError: If neither prompt nor agent_id with history is provided, or if final_response_structure is missing for new sessions
         """
-        # Use provided agent_id or create a new one
-        if agent_id is None:
-            agent_id = str(__import__("uuid").uuid4())
+        # Validate inputs and determine session type
+        is_existing_session = agent_id is not None and agent_id in self._agent_sessions
+        existing_session = self._agent_sessions.get(agent_id, {}) if agent_id else {}
+        conversation_history = existing_session.get("conversation_history", []).copy()
+        
+        # Validation logic
+        if not is_existing_session:
+            # New session - both prompt and final_response_structure are required
+            if not prompt:
+                raise ValueError("Prompt is required when starting a new agent session")
+            if not final_response_structure:
+                raise ValueError("final_response_structure is required when starting a new agent session")
+            
+            # Create new agent_id if not provided
+            if agent_id is None:
+                agent_id = str(__import__("uuid").uuid4())
             logger.info(f"🚀 Starting new agent process (ID: {agent_id}) with prompt: {prompt[:100]}...")
         else:
-            logger.info(f"🔄 Continuing agent process (ID: {agent_id}) with prompt: {prompt[:100]}...")
+            # Existing session - use previous final_response_structure if not provided
+            if not final_response_structure:
+                final_response_structure = existing_session.get("final_response_structure")
+                if not final_response_structure:
+                    raise ValueError("final_response_structure not found in existing session and not provided")
+            
+            # Handle optional prompt for existing sessions
+            if not prompt:
+                # Use conversation history to continue without explicit prompt
+                prompt = "[Continue conversation based on history]"
+                logger.info(f"🔄 Continuing agent process (ID: {agent_id}) without explicit prompt (using history)")
+            else:
+                logger.info(f"🔄 Continuing agent process (ID: {agent_id}) with prompt: {prompt[:100]}...")
         
         # Initialize token summary
         token_summary = TokenSummary()
         
-        # Check if this is a continuing conversation
-        existing_session = self._agent_sessions.get(agent_id, {})
-        conversation_history = existing_session.get("conversation_history", []).copy()
-        
         if conversation_history:
             logger.info(f"📜 Agent {agent_id}: Loaded conversation history with {len(conversation_history)} messages")
         
@@ -228,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:
@@ -438,6 +494,7 @@ IMPORTANT: For each question, provide a technical key identifier that:
             self._agent_sessions[agent_id]["conversation_history"] = updated_history
             self._agent_sessions[agent_id]["step"] = "completed"
             self._agent_sessions[agent_id]["token_summary"] = token_summary
+            self._agent_sessions[agent_id]["final_response_structure"] = final_response_structure
             logger.info(f"💾 Agent {agent_id}: Updated session with conversation history ({len(updated_history)} messages)")
         else:
             # Create new session if it doesn't exist
@@ -447,7 +504,8 @@ IMPORTANT: For each question, provide a technical key identifier that:
             self._agent_sessions[agent_id] = {
                 "step": "completed",
                 "conversation_history": updated_history,
-                "token_summary": token_summary
+                "token_summary": token_summary,
+                "final_response_structure": final_response_structure
             }
             logger.info(f"💾 Agent {agent_id}: Created new session with conversation history ({len(updated_history)} messages)")
         

{mbxai-2.1.1 → mbxai-2.1.3}/src/mbxai/examples/dialog_agent_example.py

@@ -135,6 +135,21 @@ def demonstrate_dialog_with_questions():
                 print(f"Genre: {book_rec2.genre}")
                 print(f"Reason: {book_rec2.reason}")
                 print(f"Connection to previous: {book_rec2.connection_to_previous}")
+            
+            # Continue WITHOUT explicit prompt - using only conversation history
+            print(f"\n3️⃣ Continuing conversation WITHOUT explicit prompt (history-based):")
+            try:
+                response3 = agent.agent(agent_id=agent_id, ask_questions=False)  # No prompt provided
+                
+                if response3.is_complete():
+                    book_rec3 = response3.final_response
+                    print(f"History-based recommendation:")
+                    print(f"Book: {book_rec3.title} by {book_rec3.author}")
+                    print(f"Genre: {book_rec3.genre}")
+                    print(f"Reason: {book_rec3.reason}")
+                    print(f"Connection to previous: {book_rec3.connection_to_previous}")
+            except Exception as e:
+                print(f"Error with history-based continuation: {e}")
         
         # Session cleanup
         print(f"\n🗑️ Session cleanup...")

mbxai-2.1.3/src/mbxai/examples/optional_prompt_example.py

@@ -0,0 +1,164 @@
+"""
+Example demonstrating optional prompt functionality with existing agent sessions.
+"""
+
+import os
+from pydantic import BaseModel, Field
+from mbxai import AgentClient, OpenRouterClient, AnswerList, Answer
+
+
+class ConversationResponse(BaseModel):
+    """A general conversation response."""
+    response: str = Field(description="The response to the conversation")
+    context_used: str = Field(description="How previous conversation history was used")
+    continuation_type: str = Field(description="Type of continuation (new topic, follow-up, etc.)")
+
+
+class StoryResponse(BaseModel):
+    """A story response."""
+    story_continuation: str = Field(description="The next part of the story")
+    character_development: str = Field(description="How characters developed in this part")
+    plot_advancement: str = Field(description="How the plot advanced")
+
+
+def demonstrate_optional_prompt():
+    """Demonstrate using agent with optional prompts for existing sessions."""
+    print("🎭 DEMO: Optional Prompt with Existing Agent Sessions")
+    print("=" * 60)
+    
+    # Initialize the clients
+    openrouter_client = OpenRouterClient(token=os.getenv("OPENROUTER_API_KEY", "your-token-here"))
+    agent = AgentClient(openrouter_client, max_iterations=1)
+    
+    # First interaction - establish a story context
+    print("\n1️⃣ First interaction - establishing story context:")
+    response1 = agent.agent(
+        prompt="Let's create a story about a detective solving a mystery in a small town",
+        final_response_structure=StoryResponse,
+        ask_questions=False
+    )
+    
+    agent_id = response1.agent_id
+    print(f"Agent ID: {agent_id}")
+    
+    if response1.is_complete():
+        story1 = response1.final_response
+        print(f"Story start: {story1.story_continuation[:150]}...")
+        print(f"Characters: {story1.character_development}")
+    
+    # Second interaction - continue with explicit prompt
+    print(f"\n2️⃣ Second interaction - continue with explicit prompt:")
+    response2 = agent.agent(
+        prompt="The detective finds a mysterious letter. What does it say?",
+        agent_id=agent_id,
+        ask_questions=False
+    )
+    
+    if response2.is_complete():
+        story2 = response2.final_response
+        print(f"Story continuation: {story2.story_continuation[:150]}...")
+        print(f"Plot advancement: {story2.plot_advancement}")
+    
+    # Third interaction - continue WITHOUT explicit prompt (using only history)
+    print(f"\n3️⃣ Third interaction - continue WITHOUT explicit prompt (history-based):")
+    try:
+        response3 = agent.agent(
+            agent_id=agent_id,  # Only provide agent_id, no prompt
+            ask_questions=False
+        )
+        
+        if response3.is_complete():
+            story3 = response3.final_response
+            print(f"History-based continuation: {story3.story_continuation[:150]}...")
+            print(f"Character development: {story3.character_development}")
+            print(f"Plot advancement: {story3.plot_advancement}")
+        
+    except Exception as e:
+        print(f"Error with history-based continuation: {e}")
+    
+    # Fourth interaction - switch response format but use same session
+    print(f"\n4️⃣ Fourth interaction - switch to conversation format:")
+    response4 = agent.agent(
+        prompt="What do you think about this story so far?",
+        final_response_structure=ConversationResponse,
+        agent_id=agent_id,
+        ask_questions=False
+    )
+    
+    if response4.is_complete():
+        conv4 = response4.final_response
+        print(f"Analysis: {conv4.response[:150]}...")
+        print(f"Context used: {conv4.context_used}")
+        print(f"Continuation type: {conv4.continuation_type}")
+    
+    # Fifth interaction - continue conversation without prompt
+    print(f"\n5️⃣ Fifth interaction - continue conversation analysis without prompt:")
+    try:
+        response5 = agent.agent(
+            agent_id=agent_id,
+            ask_questions=False
+        )
+        
+        if response5.is_complete():
+            conv5 = response5.final_response
+            print(f"Continued analysis: {conv5.response[:150]}...")
+            print(f"Context used: {conv5.context_used}")
+            print(f"Continuation type: {conv5.continuation_type}")
+        
+    except Exception as e:
+        print(f"Error with continued conversation: {e}")
+    
+    # Show final session state
+    session_info = agent.get_session_info(agent_id)
+    print(f"\n📊 Final session state:")
+    print(f"   - Total messages: {session_info['conversation_length']}")
+    print(f"   - Session step: {session_info.get('step', 'unknown')}")
+    print(f"   - Has final_response_structure: {'final_response_structure' in session_info}")
+    
+    # Cleanup
+    agent.delete_session(agent_id)
+
+
+def demonstrate_error_cases():
+    """Demonstrate error cases with optional prompt."""
+    print("\n🚨 DEMO: Error Cases with Optional Prompt")
+    print("=" * 50)
+    
+    openrouter_client = OpenRouterClient(token=os.getenv("OPENROUTER_API_KEY", "your-token-here"))
+    agent = AgentClient(openrouter_client, max_iterations=1)
+    
+    # Error case 1: No prompt and no existing session
+    print("\n❌ Error case 1: No prompt, no existing session")
+    try:
+        response = agent.agent(ask_questions=False)
+        print("This should have failed!")
+    except ValueError as e:
+        print(f"Expected error: {e}")
+    
+    # Error case 2: No prompt and no final_response_structure for new session
+    print("\n❌ Error case 2: No final_response_structure for new session")
+    try:
+        response = agent.agent(prompt="Test", ask_questions=False)
+        print("This should have failed!")
+    except ValueError as e:
+        print(f"Expected error: {e}")
+    
+    # Error case 3: Unknown agent_id without prompt
+    print("\n❌ Error case 3: Unknown agent_id without prompt")
+    try:
+        response = agent.agent(agent_id="unknown-id", ask_questions=False)
+        print("This should have failed!")
+    except ValueError as e:
+        print(f"Expected error: {e}")
+    
+    print("\n✅ All error cases handled correctly!")
+
+
+if __name__ == "__main__":
+    try:
+        demonstrate_optional_prompt()
+        demonstrate_error_cases()
+    except Exception as e:
+        print(f"Unexpected error: {e}")
+        import traceback
+        traceback.print_exc()

{mbxai-2.1.1 → mbxai-2.1.3}/src/mbxai/mcp/server.py

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