mbxai 2.0.5__tar.gz → 2.1.0__tar.gz

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

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

{mbxai-2.0.5 → mbxai-2.1.0}/pyproject.toml

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

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

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

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

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

{mbxai-2.0.5 → mbxai-2.1.0}/src/mbxai/agent/client.py

@@ -123,9 +123,14 @@ class AgentClient:
                 f"Use MCPClient to register MCP servers."
             )
 
-    def _call_ai_parse(self, messages: list[dict[str, Any]], response_format: Type[BaseModel]) -> Any:
-        """Call the parse method on the AI client."""
-        return self._ai_client.parse(messages, response_format)
+    def _call_ai_parse(self, messages: list[dict[str, Any]], response_format: Type[BaseModel], conversation_history: list[dict[str, Any]] = None) -> Any:
+        """Call the parse method on the AI client with optional conversation history."""
+        # Combine conversation history with new messages
+        if conversation_history:
+            full_messages = conversation_history + messages
+        else:
+            full_messages = messages
+        return self._ai_client.parse(full_messages, response_format)
 
     def _extract_token_usage(self, response: Any) -> TokenUsage:
         """Extract token usage information from an AI response."""
@@ -179,7 +184,8 @@ class AgentClient:
         self,
         prompt: str,
         final_response_structure: Type[BaseModel],
-        ask_questions: bool = True
+        ask_questions: bool = True,
+        agent_id: str = None
     ) -> AgentResponse:
         """
         Process a prompt through the agent's thinking process.
@@ -188,16 +194,25 @@ class AgentClient:
             prompt: The initial prompt from the user
             final_response_structure: Pydantic model defining the expected final response format
             ask_questions: Whether to ask clarifying questions (default: True)
+            agent_id: Optional agent session ID to continue an existing conversation
 
         Returns:
             AgentResponse containing either questions to ask or the final response
         """
-        agent_id = str(__import__("uuid").uuid4())
-        logger.info(f"🚀 Starting agent process (ID: {agent_id}) with prompt: {prompt[:100]}...")
+        # Use provided agent_id or create a new one
+        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]}...")
         
         # 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", [])
+        
         # Step 1: Generate questions (if ask_questions is True)
         if ask_questions:
             logger.info(f"❓ Agent {agent_id}: Analyzing prompt and generating clarifying questions")
@@ -221,7 +236,7 @@ IMPORTANT: For each question, provide a technical key identifier that:
             messages = [{"role": "user", "content": questions_prompt}]
             
             try:
-                response = self._call_ai_parse(messages, QuestionList)
+                response = self._call_ai_parse(messages, QuestionList, conversation_history)
                 question_list = self._extract_parsed_content(response, QuestionList)
                 
                 # Extract token usage for question generation
@@ -248,7 +263,7 @@ IMPORTANT: For each question, provide a technical key identifier that:
         
         # Step 2 & 3: No questions or ask_questions=False - proceed directly
         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)
+        return self._process_with_answers(prompt, final_response_structure, [], agent_id, token_summary, conversation_history)
 
     def answer_to_agent(self, agent_id: str, answers: AnswerList) -> AgentResponse:
         """
@@ -271,35 +286,97 @@ IMPORTANT: For each question, provide a technical key identifier that:
         if session["step"] != "waiting_for_answers":
             raise ValueError(f"Agent session {agent_id} is not waiting for answers")
         
-        # Convert answers to a more usable format
+        # Convert answers to a more usable format and create question-answer pairs
         answer_dict = {answer.key: answer.answer for answer in answers.answers}
+        questions = session.get("questions", [])
+        
+        # Create question-answer pairs for better context
+        qa_pairs = []
+        for question in questions:
+            answer_text = answer_dict.get(question.key, "No answer provided")
+            qa_pairs.append({
+                "question": question.question,
+                "key": question.key,
+                "answer": answer_text,
+                "required": question.required
+            })
         
         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())
+        conversation_history = session.get("conversation_history", [])
         
-        # Process with the provided answers
+        # Process with the provided answers and question context
         result = self._process_with_answers(
             session["original_prompt"],
             session["final_response_structure"],
-            answer_dict,
+            qa_pairs,
             agent_id,
-            token_summary
+            token_summary,
+            conversation_history
         )
         
-        # Clean up the session
-        del self._agent_sessions[agent_id]
+        # Update session with conversation history but don't delete it
+        if agent_id in self._agent_sessions:
+            self._agent_sessions[agent_id]["step"] = "completed"
+            self._agent_sessions[agent_id]["conversation_history"] = self._agent_sessions[agent_id].get("conversation_history", [])
+            
+            # Add this interaction to history
+            self._agent_sessions[agent_id]["conversation_history"].extend([
+                {"role": "user", "content": session["original_prompt"]},
+                {"role": "assistant", "content": str(result.final_response) if result.final_response else "No response generated"}
+            ])
         
         return result
 
+    def _format_qa_context_for_quality_check(self, answers: Union[list, dict[str, str]]) -> str:
+        """
+        Format question-answer context for quality check and improvement prompts.
+        
+        Args:
+            answers: Question-answer pairs or simple answers
+            
+        Returns:
+            Formatted context text
+        """
+        if not answers:
+            return ""
+            
+        if isinstance(answers, list) and answers:
+            # Check if it's a list of question-answer pairs (enhanced format)
+            if isinstance(answers[0], dict) and "question" in answers[0]:
+                context_text = "\nContext Information (Questions & Answers):\n"
+                context_text += "The response was generated with the following additional context:\n\n"
+                for i, qa_pair in enumerate(answers, 1):
+                    question = qa_pair.get("question", "Unknown question")
+                    answer = qa_pair.get("answer", "No answer provided")
+                    required = qa_pair.get("required", True)
+                    
+                    status_marker = "🔴 REQUIRED" if required else "🟡 OPTIONAL"
+                    context_text += f"{i}. {status_marker} Q: {question}\n"
+                    context_text += f"   A: {answer}\n\n"
+                return context_text
+            else:
+                # Legacy format - simple list
+                return f"\nAdditional context: {', '.join(str(a) for a in answers)}\n\n"
+        elif isinstance(answers, dict) and answers:
+            # Legacy format - simple dict
+            context_text = "\nAdditional context provided:\n"
+            for key, answer in answers.items():
+                context_text += f"- {key}: {answer}\n"
+            return context_text + "\n"
+        
+        return ""
+
     def _process_with_answers(
         self,
         prompt: str,
         final_response_structure: Type[BaseModel],
         answers: Union[list, dict[str, str]],
         agent_id: str,
-        token_summary: TokenSummary
+        token_summary: TokenSummary,
+        conversation_history: list[dict[str, Any]] = None
     ) -> AgentResponse:
         """
         Process the prompt with answers through the thinking pipeline.
@@ -307,23 +384,27 @@ IMPORTANT: For each question, provide a technical key identifier that:
         Args:
             prompt: The original prompt
             final_response_structure: Expected final response structure
-            answers: Answers to questions (empty if no questions were asked)
+            answers: Question-answer pairs or simple answers (empty if no questions were asked)
             agent_id: The agent session identifier
             token_summary: Current token usage summary
+            conversation_history: Optional conversation history for dialog context
 
         Returns:
             AgentResponse with the final result
         """
+        if conversation_history is None:
+            conversation_history = []
+            
         # Step 3: Process the prompt with thinking
         logger.info(f"🧠 Agent {agent_id}: Processing prompt and generating initial response")
-        result = self._think_and_process(prompt, answers, agent_id, token_summary)
+        result = self._think_and_process(prompt, answers, agent_id, token_summary, conversation_history)
         
         # Step 4: Quality check and iteration
-        final_result = self._quality_check_and_iterate(prompt, result, answers, agent_id, token_summary)
+        final_result = self._quality_check_and_iterate(prompt, result, answers, agent_id, token_summary, conversation_history)
         
         # Step 5: Generate final answer in requested format
         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)
+        final_response = self._generate_final_response(prompt, final_result, final_response_structure, agent_id, token_summary, conversation_history)
         
         # Log final token summary
         logger.info(f"📊 Agent {agent_id}: Token usage summary - Total: {token_summary.total_tokens} "
@@ -331,27 +412,49 @@ IMPORTANT: For each question, provide a technical key identifier that:
         
         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]], agent_id: str, token_summary: TokenSummary) -> str:
+    def _think_and_process(self, prompt: str, answers: Union[list, dict[str, str]], agent_id: str, token_summary: TokenSummary, conversation_history: list[dict[str, Any]] = None) -> str:
         """
         Process the prompt with thinking.
 
         Args:
             prompt: The original prompt
-            answers: Answers to questions
+            answers: Question-answer pairs or simple answers
             agent_id: The agent session identifier
             token_summary: Current token usage summary
+            conversation_history: Optional conversation history for dialog context
 
         Returns:
             The AI's result
         """
-        # Format answers for the prompt
+        if conversation_history is None:
+            conversation_history = []
+        # Format answers for the prompt with enhanced context
         answers_text = ""
-        if isinstance(answers, dict) and answers:
+        if isinstance(answers, list) and answers:
+            # Check if it's a list of question-answer pairs (enhanced format)
+            if answers and isinstance(answers[0], dict) and "question" in answers[0]:
+                answers_text = "\n\nQuestion-Answer Context:\n"
+                answers_text += "The following questions were asked to gather more information, along with the answers provided:\n\n"
+                for i, qa_pair in enumerate(answers, 1):
+                    question = qa_pair.get("question", "Unknown question")
+                    answer = qa_pair.get("answer", "No answer provided")
+                    key = qa_pair.get("key", "")
+                    required = qa_pair.get("required", True)
+                    
+                    status_marker = "🔴 REQUIRED" if required else "🟡 OPTIONAL"
+                    answers_text += f"{i}. {status_marker} Question: {question}\n"
+                    answers_text += f"   Answer: {answer}\n"
+                    if key:
+                        answers_text += f"   (Key: {key})\n"
+                    answers_text += "\n"
+            else:
+                # Legacy format - simple list
+                answers_text = f"\n\nAdditional information: {', '.join(str(a) for a in answers)}\n"
+        elif isinstance(answers, dict) and answers:
+            # Legacy format - simple dict
             answers_text = "\n\nAdditional information provided:\n"
             for key, answer in answers.items():
                 answers_text += f"- {key}: {answer}\n"
-        elif isinstance(answers, list) and answers:
-            answers_text = f"\n\nAdditional information: {', '.join(answers)}\n"
         
         thinking_prompt = f"""
 Think about this prompt, the goal and the steps required to fulfill it: 
@@ -360,15 +463,19 @@ Think about this prompt, the goal and the steps required to fulfill it:
 ==========
 {answers_text}
 
-Consider the prompt carefully, analyze what the user wants to achieve, and think through the best approach to provide a comprehensive and helpful response. Use any available tools to gather information or perform actions that would improve your response.
+Consider the prompt carefully, analyze what the user wants to achieve, and think through the best approach to provide a comprehensive and helpful response. 
+
+IMPORTANT: When formulating your response, take into account both the original prompt AND the specific questions that were asked along with their answers. The questions reveal what additional information was deemed necessary, and the answers provide crucial context that should inform your response.
+
+Use any available tools to gather information or perform actions that would improve your response.
 
-Provide your best result for the given prompt.
+Provide your best result for the given prompt, incorporating all the context from the question-answer pairs.
 """
         
         messages = [{"role": "user", "content": thinking_prompt}]
         
         try:
-            response = self._call_ai_parse(messages, Result)
+            response = self._call_ai_parse(messages, Result, conversation_history)
             result_obj = self._extract_parsed_content(response, Result)
             
             # Track token usage for thinking process
@@ -380,20 +487,24 @@ Provide your best result for the given prompt.
             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]], agent_id: str, token_summary: TokenSummary) -> str:
+    def _quality_check_and_iterate(self, prompt: str, result: str, answers: Union[list, dict[str, str]], agent_id: str, token_summary: TokenSummary, conversation_history: list[dict[str, Any]] = None) -> str:
         """
         Check the quality of the result and iterate if needed.
 
         Args:
             prompt: The original prompt
             result: The current result
-            answers: The answers provided
+            answers: Question-answer pairs or simple answers
             agent_id: The agent session identifier
             token_summary: Current token usage summary
+            conversation_history: Optional conversation history for dialog context
 
         Returns:
             The final improved result
         """
+        if conversation_history is None:
+            conversation_history = []
+            
         current_result = result
         
         if self._max_iterations == 0:
@@ -402,13 +513,16 @@ Provide your best result for the given prompt.
         
         logger.info(f"🔍 Agent {agent_id}: Starting quality check and improvement process (max iterations: {self._max_iterations})")
         
+        # Format context information for quality checks
+        context_text = self._format_qa_context_for_quality_check(answers)
+        
         for iteration in range(self._max_iterations):
             quality_prompt = f"""
 Given this original prompt:
 ==========
 {prompt}
 ==========
-
+{context_text}
 And this result:
 ==========
 {current_result}
@@ -416,13 +530,15 @@ And this result:
 
 Is this result good and comprehensive, or does it need to be improved? Consider if the response fully addresses the prompt, provides sufficient detail, and would be helpful to the user.
 
+IMPORTANT: Also evaluate whether the result properly incorporates and addresses the information provided through the question-answer pairs above. The response should demonstrate that it has taken this additional context into account.
+
 Evaluate the quality and provide feedback if improvements are needed.
 """
             
             messages = [{"role": "user", "content": quality_prompt}]
             
             try:
-                response = self._call_ai_parse(messages, QualityCheck)
+                response = self._call_ai_parse(messages, QualityCheck, conversation_history)
                 quality_check = self._extract_parsed_content(response, QualityCheck)
                 
                 # Track token usage for quality check
@@ -441,7 +557,7 @@ The original prompt was:
 ==========
 {prompt}
 ==========
-
+{context_text}
 The current result is:
 ==========
 {current_result}
@@ -452,11 +568,11 @@ Feedback for improvement:
 {quality_check.feedback}
 ==========
 
-Please provide an improved version that addresses the feedback while maintaining the strengths of the current result.
+Please provide an improved version that addresses the feedback while maintaining the strengths of the current result. Make sure to incorporate all the context from the question-answer pairs above.
 """
                 
                 messages = [{"role": "user", "content": improvement_prompt}]
-                improvement_response = self._call_ai_parse(messages, Result)
+                improvement_response = self._call_ai_parse(messages, Result, conversation_history)
                 result_obj = self._extract_parsed_content(improvement_response, Result)
                 current_result = result_obj.result
                 
@@ -476,7 +592,7 @@ Please provide an improved version that addresses the feedback while maintaining
         
         return current_result
 
-    def _generate_final_response(self, prompt: str, result: str, final_response_structure: Type[BaseModel], agent_id: str, token_summary: TokenSummary) -> BaseModel:
+    def _generate_final_response(self, prompt: str, result: str, final_response_structure: Type[BaseModel], agent_id: str, token_summary: TokenSummary, conversation_history: list[dict[str, Any]] = None) -> BaseModel:
         """
         Generate the final response in the requested format.
 
@@ -486,10 +602,13 @@ Please provide an improved version that addresses the feedback while maintaining
             final_response_structure: The expected response structure
             agent_id: The agent session identifier
             token_summary: Current token usage summary
+            conversation_history: Optional conversation history for dialog context
 
         Returns:
             The final response in the requested format
         """
+        if conversation_history is None:
+            conversation_history = []
         final_prompt = f"""
 Given this original prompt:
 ==========
@@ -507,7 +626,7 @@ Generate the final answer in the exact format requested. Make sure the response
         messages = [{"role": "user", "content": final_prompt}]
         
         try:
-            response = self._call_ai_parse(messages, final_response_structure)
+            response = self._call_ai_parse(messages, final_response_structure, conversation_history)
             final_response = self._extract_parsed_content(response, final_response_structure)
             
             # Track token usage for final response generation
@@ -534,3 +653,49 @@ Generate the final answer in the exact format requested. Make sure the response
                 logger.error(f"Fallback response creation failed: {fallback_error}")
                 # Last resort - return the structure with default values
                 return final_response_structure()
+
+    def get_session_info(self, agent_id: str) -> dict[str, Any]:
+        """
+        Get information about an agent session.
+        
+        Args:
+            agent_id: The agent session identifier
+            
+        Returns:
+            Session information dictionary
+            
+        Raises:
+            ValueError: If the agent session is not found
+        """
+        if agent_id not in self._agent_sessions:
+            raise ValueError(f"Agent session {agent_id} not found")
+        
+        session = self._agent_sessions[agent_id].copy()
+        # Remove sensitive information and add summary
+        session["conversation_length"] = len(session.get("conversation_history", []))
+        return session
+
+    def delete_session(self, agent_id: str) -> bool:
+        """
+        Delete an agent session.
+        
+        Args:
+            agent_id: The agent session identifier
+            
+        Returns:
+            True if session was deleted, False if it didn't exist
+        """
+        if agent_id in self._agent_sessions:
+            del self._agent_sessions[agent_id]
+            logger.info(f"🗑️ Deleted agent session {agent_id}")
+            return True
+        return False
+
+    def list_sessions(self) -> list[str]:
+        """
+        List all active agent session IDs.
+        
+        Returns:
+            List of agent session IDs
+        """
+        return list(self._agent_sessions.keys())

{mbxai-2.0.5 → mbxai-2.1.0}/src/mbxai/examples/agent_example.py

@@ -126,6 +126,33 @@ def example_with_tool_client():
             print(f"- {rec}")
 
 
+def example_dialog_conversation():
+    """Example demonstrating persistent dialog functionality."""
+    print("Example of persistent dialog conversation:")
+    
+    openrouter_client = OpenRouterClient(token=os.getenv("OPENROUTER_API_KEY", "your-token-here"))
+    agent = AgentClient(openrouter_client, max_iterations=1)
+    
+    # Start conversation
+    response1 = agent.agent("I want a book recommendation for science fiction", BookRecommendation, ask_questions=False)
+    agent_id = response1.agent_id
+    
+    if response1.is_complete():
+        book1 = response1.final_response
+        print(f"First recommendation: {book1.title} by {book1.author}")
+        
+        # Continue conversation with same agent_id
+        response2 = agent.agent("Can you recommend something by a different author in the same genre?", BookRecommendation, ask_questions=False, agent_id=agent_id)
+        
+        if response2.is_complete():
+            book2 = response2.final_response
+            print(f"Second recommendation: {book2.title} by {book2.author}")
+            print(f"Context: {book2.reason}")
+    
+    # Clean up session when done
+    agent.delete_session(agent_id)
+
+
 if __name__ == "__main__":
     print("=== Agent Client Examples ===\n")
     
@@ -150,3 +177,11 @@ if __name__ == "__main__":
         example_with_tool_client()
     except Exception as e:
         print(f"Error: {e}")
+    
+    print("\n" + "="*50 + "\n")
+    
+    print("4. Example with persistent dialog:")
+    try:
+        example_dialog_conversation()
+    except Exception as e:
+        print(f"Error: {e}")

mbxai-2.1.0/src/mbxai/examples/dialog_agent_example.py

@@ -0,0 +1,157 @@
+"""
+Example usage of the AgentClient with persistent dialog sessions.
+"""
+
+import os
+from pydantic import BaseModel, Field
+from mbxai import AgentClient, OpenRouterClient, AnswerList, Answer
+
+
+class ChatResponse(BaseModel):
+    """A general chat response."""
+    response: str = Field(description="The response to the user's message")
+    context_awareness: str = Field(description="How this response relates to previous conversation")
+
+
+class BookRecommendation(BaseModel):
+    """A book recommendation response."""
+    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 based on conversation")
+    connection_to_previous: str = Field(description="How this recommendation connects to our previous conversation")
+
+
+def demonstrate_dialog_conversation():
+    """Demonstrate persistent dialog functionality."""
+    print("🔄 DEMO: Persistent Dialog Agent")
+    print("=" * 50)
+    
+    # Initialize the clients
+    openrouter_client = OpenRouterClient(token=os.getenv("OPENROUTER_API_KEY", "your-token-here"))
+    agent = AgentClient(openrouter_client, max_iterations=1)
+    
+    # First conversation - start new session
+    print("\n1️⃣ Starting new conversation:")
+    prompt1 = "Hi, I'm looking for a good book to read. I love science fiction."
+    response1 = agent.agent(prompt1, ChatResponse, ask_questions=False)
+    
+    if response1.is_complete():
+        agent_id = response1.agent_id
+        chat_resp = response1.final_response
+        print(f"Agent ID: {agent_id}")
+        print(f"Response: {chat_resp.response}")
+        print(f"Context awareness: {chat_resp.context_awareness}")
+        
+        # Second conversation - continue same session
+        print(f"\n2️⃣ Continuing conversation with agent {agent_id}:")
+        prompt2 = "Actually, I also enjoy fantasy novels. What would you recommend that combines both genres?"
+        response2 = agent.agent(prompt2, BookRecommendation, ask_questions=False, agent_id=agent_id)
+        
+        if response2.is_complete():
+            book_rec = response2.final_response
+            print(f"Book: {book_rec.title} by {book_rec.author}")
+            print(f"Genre: {book_rec.genre}")
+            print(f"Reason: {book_rec.reason}")
+            print(f"Connection to previous: {book_rec.connection_to_previous}")
+            
+            # Third conversation - continue same session
+            print(f"\n3️⃣ Continuing conversation with agent {agent_id}:")
+            prompt3 = "That sounds great! Can you recommend something similar but from a different author?"
+            response3 = agent.agent(prompt3, BookRecommendation, ask_questions=False, agent_id=agent_id)
+            
+            if response3.is_complete():
+                book_rec2 = response3.final_response
+                print(f"Book: {book_rec2.title} by {book_rec2.author}")
+                print(f"Genre: {book_rec2.genre}")
+                print(f"Reason: {book_rec2.reason}")
+                print(f"Connection to previous: {book_rec2.connection_to_previous}")
+        
+        # Show session info
+        print(f"\n📊 Session Information:")
+        try:
+            session_info = agent.get_session_info(agent_id)
+            print(f"Conversation length: {session_info['conversation_length']} messages")
+            print(f"Session step: {session_info.get('step', 'unknown')}")
+        except Exception as e:
+            print(f"Error getting session info: {e}")
+        
+        # List all sessions
+        print(f"\n📝 Active sessions: {agent.list_sessions()}")
+        
+        # Cleanup - optional
+        print(f"\n🗑️ Cleaning up session...")
+        deleted = agent.delete_session(agent_id)
+        print(f"Session deleted: {deleted}")
+        print(f"Active sessions after cleanup: {agent.list_sessions()}")
+
+
+def demonstrate_dialog_with_questions():
+    """Demonstrate dialog with question-answer flow."""
+    print("\n🔄 DEMO: Dialog Agent with Questions")
+    print("=" * 50)
+    
+    # Initialize the clients
+    openrouter_client = OpenRouterClient(token=os.getenv("OPENROUTER_API_KEY", "your-token-here"))
+    agent = AgentClient(openrouter_client, max_iterations=1)
+    
+    # First conversation with questions
+    print("\n1️⃣ Starting conversation with questions:")
+    prompt1 = "I want a personalized book recommendation"
+    response1 = agent.agent(prompt1, BookRecommendation, ask_questions=True)
+    
+    agent_id = response1.agent_id
+    print(f"Agent ID: {agent_id}")
+    
+    if response1.has_questions():
+        print(f"\n📋 Agent generated {len(response1.questions)} questions:")
+        for i, question in enumerate(response1.questions, 1):
+            print(f"  {i}. {question.question} (key: {question.key})")
+        
+        # Simulate answering questions
+        answers = AnswerList(answers=[
+            Answer(key="genre_preference", answer="I love science fiction and fantasy"),
+            Answer(key="reading_level", answer="I prefer complex, adult novels"),
+            Answer(key="recent_books", answer="I recently read and loved Dune and The Name of the Wind")
+        ])
+        
+        print(f"\n📝 Providing answers...")
+        final_response = agent.answer_to_agent(agent_id, answers)
+        
+        if final_response.is_complete():
+            book_rec = final_response.final_response
+            print(f"Book: {book_rec.title} by {book_rec.author}")
+            print(f"Genre: {book_rec.genre}")
+            print(f"Reason: {book_rec.reason}")
+            
+            # Continue conversation - this should remember the previous interaction
+            print(f"\n2️⃣ Continuing conversation with agent {agent_id}:")
+            prompt2 = "Thank you! Can you also recommend something by a female author in the same genres?"
+            response2 = agent.agent(prompt2, BookRecommendation, ask_questions=False, agent_id=agent_id)
+            
+            if response2.is_complete():
+                book_rec2 = response2.final_response
+                print(f"Book: {book_rec2.title} by {book_rec2.author}")
+                print(f"Genre: {book_rec2.genre}")
+                print(f"Reason: {book_rec2.reason}")
+                print(f"Connection to previous: {book_rec2.connection_to_previous}")
+        
+        # Session cleanup
+        print(f"\n🗑️ Session cleanup...")
+        agent.delete_session(agent_id)
+
+
+if __name__ == "__main__":
+    print("=== Dialog Agent Examples ===\n")
+    
+    try:
+        demonstrate_dialog_conversation()
+    except Exception as e:
+        print(f"Error in dialog conversation demo: {e}")
+    
+    print("\n" + "="*80 + "\n")
+    
+    try:
+        demonstrate_dialog_with_questions()
+    except Exception as e:
+        print(f"Error in dialog with questions demo: {e}")

{mbxai-2.0.5 → mbxai-2.1.0}/src/mbxai/mcp/server.py

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