mbxai 2.0.5__tar.gz → 2.1.1__tar.gz

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

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

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

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

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

{mbxai-2.0.5 → mbxai-2.1.1}/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.1"
 
 __all__ = [
     "AgentClient",

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

@@ -123,9 +123,16 @@ 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
+            logger.debug(f"🔗 AI call with {len(conversation_history)} history messages + {len(messages)} new messages = {len(full_messages)} total")
+        else:
+            full_messages = messages
+            logger.debug(f"🔗 AI call with {len(messages)} messages (no history)")
+        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 +186,9 @@ class AgentClient:
         self,
         prompt: str,
         final_response_structure: Type[BaseModel],
-        ask_questions: bool = True
+        ask_questions: bool = True,
+        agent_id: str = None,
+        answers: AnswerList = None
     ) -> AgentResponse:
         """
         Process a prompt through the agent's thinking process.
@@ -188,16 +197,40 @@ 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
+            answers: Optional answers to questions (when continuing a conversation with questions)
 
         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", []).copy()
+        
+        if conversation_history:
+            logger.info(f"📜 Agent {agent_id}: Loaded conversation history with {len(conversation_history)} messages")
+        
+        # Store conversation history for AI calls (don't include current prompt yet)
+        history_for_ai = conversation_history.copy()
+        
+        # Add current prompt to full conversation history for session storage
+        conversation_history.append({"role": "user", "content": prompt})
+        
+        # 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)
+        
         # 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 +254,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, history_for_ai)
                 question_list = self._extract_parsed_content(response, QuestionList)
                 
                 # Extract token usage for question generation
@@ -238,7 +271,8 @@ IMPORTANT: For each question, provide a technical key identifier that:
                         "final_response_structure": final_response_structure,
                         "questions": question_list.questions,
                         "step": "waiting_for_answers",
-                        "token_summary": token_summary
+                        "token_summary": token_summary,
+                        "conversation_history": history_for_ai  # Include history without current prompt
                     }
                     logger.info(f"📋 Agent {agent_id}: Waiting for user answers to {len(question_list.questions)} questions")
                     return agent_response
@@ -248,58 +282,124 @@ 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, history_for_ai)
 
-    def answer_to_agent(self, agent_id: str, answers: AnswerList) -> AgentResponse:
+    def _process_answers_directly(
+        self,
+        agent_id: str,
+        prompt: str,
+        final_response_structure: Type[BaseModel],
+        answers: AnswerList,
+        token_summary: TokenSummary,
+        conversation_history: list[dict[str, Any]]
+    ) -> AgentResponse:
         """
-        Continue an agent session by providing answers to questions.
-
+        Process answers directly without going through question generation.
+        
         Args:
             agent_id: The agent session identifier
-            answers: List of answers to the questions
-
+            prompt: The current prompt
+            final_response_structure: Expected response structure
+            answers: Provided answers
+            token_summary: Current token usage summary
+            conversation_history: Conversation history
+            
         Returns:
             AgentResponse with the final result
-
-        Raises:
-            ValueError: If the agent session is not found or in wrong state
         """
-        if agent_id not in self._agent_sessions:
-            raise ValueError(f"Agent session {agent_id} not found")
-        
-        session = self._agent_sessions[agent_id]
-        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
-        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
+        # Check if we have a session with questions to match against
+        session = self._agent_sessions.get(agent_id, {})
+        questions = session.get("questions", [])
+        
+        if not questions:
+            # No previous questions - treat as simple additional context
+            logger.info(f"📝 Agent {agent_id}: No previous questions found, treating answers as additional context")
+            answer_dict = {answer.key: answer.answer for answer in answers.answers}
+            qa_pairs = []
+            for answer in answers.answers:
+                qa_pairs.append({
+                    "question": f"Information about {answer.key}",
+                    "key": answer.key,
+                    "answer": answer.answer,
+                    "required": True
+                })
+        else:
+            # Match answers with previous questions
+            logger.info(f"📝 Agent {agent_id}: Matching {len(answers.answers)} answers with previous questions")
+            answer_dict = {answer.key: answer.answer for answer in answers.answers}
+            
+            # 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
+                })
+        
+        # Process with the provided answers and question context
         result = self._process_with_answers(
-            session["original_prompt"],
-            session["final_response_structure"],
-            answer_dict,
+            prompt,
+            final_response_structure,
+            qa_pairs,
             agent_id,
-            token_summary
+            token_summary,
+            conversation_history
         )
         
-        # Clean up the session
-        del self._agent_sessions[agent_id]
-        
+        # Note: History management is now handled in _process_with_answers
+        # No need to duplicate history management here
         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 +407,49 @@ 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)
+        
+        # Update session with the final response in conversation history
+        if agent_id in self._agent_sessions:
+            # Update conversation history with assistant response
+            updated_history = conversation_history.copy()
+            updated_history.append({"role": "assistant", "content": str(final_response)})
+            
+            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
+            logger.info(f"💾 Agent {agent_id}: Updated session with conversation history ({len(updated_history)} messages)")
+        else:
+            # Create new session if it doesn't exist
+            updated_history = conversation_history.copy()
+            updated_history.append({"role": "assistant", "content": str(final_response)})
+            
+            self._agent_sessions[agent_id] = {
+                "step": "completed",
+                "conversation_history": updated_history,
+                "token_summary": token_summary
+            }
+            logger.info(f"💾 Agent {agent_id}: Created new session with conversation history ({len(updated_history)} messages)")
         
         # Log final token summary
         logger.info(f"📊 Agent {agent_id}: Token usage summary - Total: {token_summary.total_tokens} "
@@ -331,27 +457,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 +508,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 +532,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 +558,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 +575,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 +602,7 @@ The original prompt was:
 ==========
 {prompt}
 ==========
-
+{context_text}
 The current result is:
 ==========
 {current_result}
@@ -452,11 +613,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 +637,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 +647,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 +671,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 +698,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.1}/src/mbxai/examples/agent_example.py

@@ -48,8 +48,8 @@ def example_with_questions():
             Answer(key="recent_books", answer="I recently read and loved Dune and The Name of the Wind")
         ])
         
-        # Continue the agent process with answers
-        final_response = agent.answer_to_agent(response.agent_id, answers)
+        # Continue the agent process with answers using the unified interface
+        final_response = agent.agent("Continue with previous questions", BookRecommendation, ask_questions=False, agent_id=response.agent_id, answers=answers)
         
         if final_response.is_complete():
             book_rec = final_response.final_response
@@ -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.0.5 → mbxai-2.1.1}/src/mbxai/examples/agent_logging_example.py

@@ -74,7 +74,7 @@ def demonstrate_agent_with_questions():
             ])
             
             print(f"\n📝 Providing answers and continuing...")
-            final_response = agent.answer_to_agent(response.agent_id, answers)
+            final_response = agent.agent("Continue with answers", WeatherResponse, ask_questions=False, agent_id=response.agent_id, answers=answers)
             
             if final_response.is_complete():
                 print("\n✅ Final response received!")

mbxai-2.1.1/src/mbxai/examples/conversation_history_test.py

@@ -0,0 +1,169 @@
+"""
+Test example demonstrating conversation history persistence across multiple interactions.
+"""
+
+import os
+from pydantic import BaseModel, Field
+from mbxai import AgentClient, OpenRouterClient, AnswerList, Answer
+
+
+class StoryResponse(BaseModel):
+    """A story response that should reference previous conversation."""
+    story_part: str = Field(description="The current part of the story")
+    references_to_previous: str = Field(description="How this connects to our previous conversation")
+    conversation_context: str = Field(description="Summary of what was discussed before")
+
+
+class ChatResponse(BaseModel):
+    """A general chat response."""
+    response: str = Field(description="The response to the user's message")
+    context_awareness: str = Field(description="What the AI remembers from our conversation")
+
+
+def test_conversation_history_persistence():
+    """Test that conversation history persists and is used across multiple interactions."""
+    print("🧪 TESTING: Conversation History Persistence")
+    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 context
+    print("\n1️⃣ First interaction - setting up story context:")
+    prompt1 = "I want to tell a collaborative story about a space explorer named Luna who discovers an ancient alien artifact on Mars."
+    response1 = agent.agent(prompt1, 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 Part 1: {story1.story_part[:200]}...")
+        print(f"Context awareness: {story1.context_awareness}")
+        
+        # Check session info
+        session_info = agent.get_session_info(agent_id)
+        print(f"📊 Session after first interaction: {session_info['conversation_length']} messages")
+    
+    # Second interaction - continue story, should reference Luna and the artifact
+    print(f"\n2️⃣ Second interaction - continuing story (should remember Luna and artifact):")
+    prompt2 = "Luna touches the artifact and something amazing happens. Continue the story."
+    response2 = agent.agent(prompt2, StoryResponse, ask_questions=False, agent_id=agent_id)
+    
+    if response2.is_complete():
+        story2 = response2.final_response
+        print(f"Story Part 2: {story2.story_part[:200]}...")
+        print(f"References to previous: {story2.references_to_previous}")
+        print(f"Conversation context: {story2.conversation_context}")
+        
+        # Check session info
+        session_info = agent.get_session_info(agent_id)
+        print(f"📊 Session after second interaction: {session_info['conversation_length']} messages")
+    
+    # Third interaction - change topic but should still remember story context
+    print(f"\n3️⃣ Third interaction - changing topic (should still remember our story):")
+    prompt3 = "Actually, let's pause the story. What do you think Luna's personality is like based on our story so far?"
+    response3 = agent.agent(prompt3, ChatResponse, ask_questions=False, agent_id=agent_id)
+    
+    if response3.is_complete():
+        chat3 = response3.final_response
+        print(f"Response: {chat3.response}")
+        print(f"Context awareness: {chat3.context_awareness}")
+        
+        # Check session info
+        session_info = agent.get_session_info(agent_id)
+        print(f"📊 Session after third interaction: {session_info['conversation_length']} messages")
+    
+    # Fourth interaction - return to story, should remember everything
+    print(f"\n4️⃣ Fourth interaction - returning to story (should remember all previous context):")
+    prompt4 = "Great! Now let's continue Luna's story from where we left off. What happens next with the artifact?"
+    response4 = agent.agent(prompt4, StoryResponse, ask_questions=False, agent_id=agent_id)
+    
+    if response4.is_complete():
+        story4 = response4.final_response
+        print(f"Story Part 4: {story4.story_part[:200]}...")
+        print(f"References to previous: {story4.references_to_previous}")
+        print(f"Conversation context: {story4.conversation_context}")
+        
+        # Final session info
+        session_info = agent.get_session_info(agent_id)
+        print(f"📊 Final session state: {session_info['conversation_length']} messages")
+        print(f"Session step: {session_info.get('step', 'unknown')}")
+    
+    # Display full conversation history
+    print(f"\n💬 FULL CONVERSATION HISTORY:")
+    session_info = agent.get_session_info(agent_id)
+    history = session_info.get('conversation_history', [])
+    for i, msg in enumerate(history, 1):
+        role = msg['role'].upper()
+        content = msg['content'][:100] + "..." if len(msg['content']) > 100 else msg['content']
+        print(f"{i:2d}. {role}: {content}")
+    
+    # Cleanup
+    print(f"\n🗑️ Cleaning up session {agent_id}")
+    agent.delete_session(agent_id)
+
+
+def test_with_questions_and_history():
+    """Test conversation history with questions and answers."""
+    print("\n🧪 TESTING: Questions + Answers + History")
+    print("=" * 60)
+    
+    openrouter_client = OpenRouterClient(token=os.getenv("OPENROUTER_API_KEY", "your-token-here"))
+    agent = AgentClient(openrouter_client, max_iterations=1)
+    
+    # Start with questions
+    print("\n1️⃣ Starting conversation with questions:")
+    response1 = agent.agent("I want a personalized workout plan", ChatResponse, ask_questions=True)
+    
+    agent_id = response1.agent_id
+    print(f"Agent ID: {agent_id}")
+    
+    if response1.has_questions():
+        print(f"📋 Generated {len(response1.questions)} questions:")
+        for q in response1.questions:
+            print(f"  - {q.question}")
+        
+        # Answer questions
+        answers = AnswerList(answers=[
+            Answer(key="fitness_level", answer="Beginner"),
+            Answer(key="goals", answer="Weight loss and muscle building"),
+            Answer(key="time_available", answer="30 minutes per day, 4 days a week"),
+            Answer(key="equipment", answer="Home gym with dumbbells and resistance bands")
+        ])
+        
+        print(f"\n2️⃣ Providing answers:")
+        response2 = agent.agent("Here are my answers", ChatResponse, ask_questions=False, agent_id=agent_id, answers=answers)
+        
+        if response2.is_complete():
+            workout_plan = response2.final_response
+            print(f"Workout plan: {workout_plan.response[:200]}...")
+            print(f"Context awareness: {workout_plan.context_awareness}")
+        
+        # Continue conversation
+        print(f"\n3️⃣ Follow-up question (should remember all previous context):")
+        response3 = agent.agent("Can you modify this plan to focus more on cardio?", ChatResponse, ask_questions=False, agent_id=agent_id)
+        
+        if response3.is_complete():
+            modified_plan = response3.final_response
+            print(f"Modified plan: {modified_plan.response[:200]}...")
+            print(f"Context awareness: {modified_plan.context_awareness}")
+        
+        # Show history
+        session_info = agent.get_session_info(agent_id)
+        print(f"\n💬 Conversation had {session_info['conversation_length']} messages")
+        
+        # Cleanup
+        agent.delete_session(agent_id)
+
+
+if __name__ == "__main__":
+    try:
+        test_conversation_history_persistence()
+        print("\n" + "="*80 + "\n")
+        test_with_questions_and_history()
+    except Exception as e:
+        print(f"Error: {e}")
+        import traceback
+        traceback.print_exc()

mbxai-2.1.1/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.agent("Continue with answers", BookRecommendation, ask_questions=False, agent_id=agent_id, answers=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.1.1/src/mbxai/examples/unified_interface_example.py

@@ -0,0 +1,109 @@
+"""
+Example demonstrating the new unified agent interface.
+"""
+
+import os
+from pydantic import BaseModel, Field
+from mbxai import AgentClient, OpenRouterClient, AnswerList, Answer
+
+
+class SimpleResponse(BaseModel):
+    """A simple response."""
+    response: str = Field(description="The response text")
+    context_used: str = Field(description="How context was used in this response")
+
+
+def demonstrate_unified_interface():
+    """Demonstrate the unified agent interface with and without questions."""
+    print("🔧 DEMO: Unified Agent Interface")
+    print("=" * 50)
+    
+    # Initialize the clients
+    openrouter_client = OpenRouterClient(token=os.getenv("OPENROUTER_API_KEY", "your-token-here"))
+    agent = AgentClient(openrouter_client, max_iterations=1)
+    
+    # Example 1: Start conversation with questions
+    print("\n1️⃣ Starting conversation that generates questions:")
+    response1 = agent.agent("I need help planning a trip", SimpleResponse, ask_questions=True)
+    
+    agent_id = response1.agent_id
+    print(f"Agent ID: {agent_id}")
+    
+    if response1.has_questions():
+        print(f"📋 Generated {len(response1.questions)} questions:")
+        for q in response1.questions:
+            print(f"  - {q.question} (key: {q.key})")
+        
+        # Example 2: Provide answers using the unified interface
+        print(f"\n2️⃣ Providing answers using unified interface:")
+        answers = AnswerList(answers=[
+            Answer(key="destination", answer="Japan"),
+            Answer(key="duration", answer="10 days"),
+            Answer(key="budget", answer="$3000"),
+            Answer(key="interests", answer="culture, food, temples")
+        ])
+        
+        response2 = agent.agent(
+            "Now help me plan the trip", 
+            SimpleResponse, 
+            ask_questions=False, 
+            agent_id=agent_id, 
+            answers=answers
+        )
+        
+        if response2.is_complete():
+            trip_plan = response2.final_response
+            print(f"Response: {trip_plan.response}")
+            print(f"Context used: {trip_plan.context_used}")
+    
+    # Example 3: Continue the conversation
+    print(f"\n3️⃣ Continuing conversation without questions:")
+    response3 = agent.agent(
+        "What about transportation within Japan?", 
+        SimpleResponse, 
+        ask_questions=False, 
+        agent_id=agent_id
+    )
+    
+    if response3.is_complete():
+        transport_info = response3.final_response
+        print(f"Response: {transport_info.response}")
+        print(f"Context used: {transport_info.context_used}")
+    
+    # Example 4: Using answers without previous questions (new session)
+    print(f"\n4️⃣ Starting new session with direct answers (no questions):")
+    new_answers = AnswerList(answers=[
+        Answer(key="city", answer="Tokyo"),
+        Answer(key="travel_style", answer="luxury"),
+        Answer(key="group_size", answer="2 people")
+    ])
+    
+    response4 = agent.agent(
+        "Recommend restaurants",
+        SimpleResponse,
+        ask_questions=False,
+        answers=new_answers  # New session, no agent_id provided
+    )
+    
+    if response4.is_complete():
+        restaurant_info = response4.final_response
+        print(f"New Agent ID: {response4.agent_id}")
+        print(f"Response: {restaurant_info.response}")
+        print(f"Context used: {restaurant_info.context_used}")
+    
+    # Show active sessions
+    print(f"\n📊 Active Sessions: {agent.list_sessions()}")
+    
+    # Cleanup
+    print(f"\n🗑️ Cleaning up sessions...")
+    agent.delete_session(agent_id)
+    if response4.agent_id != agent_id:
+        agent.delete_session(response4.agent_id)
+    print(f"Active Sessions after cleanup: {agent.list_sessions()}")
+
+
+if __name__ == "__main__":
+    try:
+        demonstrate_unified_interface()
+    except Exception as e:
+        print(f"Error: {e}")

{mbxai-2.0.5 → mbxai-2.1.1}/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.1",
         )
         
         # Initialize MCP server