tinyagent-py 0.0.15__py3-none-any.whl → 0.0.16__py3-none-any.whl

tinyagent/tiny_agent.py

@@ -13,11 +13,36 @@ from .storage import Storage    # ← your abstract base
 import traceback
 import time  # Add time import for Unix timestamps
 from pathlib import Path
+import random  # Add random for jitter in retry backoff
 
 # Module-level logger; configuration is handled externally.
 logger = logging.getLogger(__name__)
 #litellm.callbacks = ["arize_phoenix"]
 
+# Set global LiteLLM configuration
+litellm.drop_params = True  # Enable dropping unsupported parameters globally
+
+# Define default retry configuration
+DEFAULT_RETRY_CONFIG = {
+    "max_retries": 5,
+    "min_backoff": 1,  # Start with 1 second
+    "max_backoff": 60,  # Max 60 seconds between retries
+    "jitter": True,    # Add randomness to backoff
+    "backoff_multiplier": 2,  # Exponential backoff factor
+    "retry_status_codes": [429, 500, 502, 503, 504],  # Common server errors
+    "retry_exceptions": [
+        "litellm.InternalServerError",
+        "litellm.APIError",
+        "litellm.APIConnectionError",
+        "litellm.RateLimitError",
+        "litellm.ServiceUnavailableError",
+        "litellm.APITimeoutError"
+    ],
+    # Rate limit specific configuration
+    "rate_limit_backoff_min": 60,  # Minimum wait time for rate limit errors (60 seconds)
+    "rate_limit_backoff_max": 90,  # Maximum wait time for rate limit errors (90 seconds)
+}
+
 def load_template(path: str,key:str="system_prompt") -> str:
     """
     Load the YAML file and extract its 'system_prompt' field.
@@ -330,7 +355,13 @@ DEFAULT_SUMMARY_SYSTEM_PROMPT = (
 class TinyAgent:
     """
     A minimal implementation of an agent powered by MCP and LiteLLM,
-    now with session/state persistence.
+    now with session/state persistence and robust error handling.
+    
+    Features:
+    - Automatic retry mechanism for LLM API calls with exponential backoff
+    - Configurable retry parameters (max retries, backoff times, etc.)
+    - Session persistence
+    - Tool integration via MCP protocol
     """
     session_state: Dict[str, Any] = {}
     user_id: Optional[str] = None
@@ -350,7 +381,9 @@ class TinyAgent:
         metadata: Optional[Dict[str, Any]] = None,
         storage: Optional[Storage] = None,
         persist_tool_configs: bool = False,
-        summary_config: Optional[Dict[str, Any]] = None
+        summary_config: Optional[Dict[str, Any]] = None,
+        retry_config: Optional[Dict[str, Any]] = None,
+        parallel_tool_calls: Optional[bool] = True,
     ):
         """
         Initialize the Tiny Agent.
@@ -359,14 +392,29 @@ class TinyAgent:
             model: The model to use with LiteLLM
             api_key: The API key for the model provider
             system_prompt: Custom system prompt for the agent
+            temperature: Temperature parameter for the model (controls randomness)
             logger: Optional logger to use
+            model_kwargs: Additional keyword arguments to pass to the model
+            user_id: Optional user ID for the session
             session_id: Optional session ID (if provided with storage, will attempt to load existing session)
             metadata: Optional metadata for the session
             storage: Optional storage backend for persistence
             persist_tool_configs: Whether to persist tool configurations
-            summary_model: Optional model to use for generating conversation summaries
-            summary_system_prompt: Optional system prompt for the summary model
-        """
+            summary_config: Optional model to use for generating conversation summaries
+            retry_config: Optional configuration for LLM API call retries. Supports:
+                - max_retries: Maximum number of retry attempts (default: 5)
+                - min_backoff: Minimum backoff time in seconds (default: 1)
+                - max_backoff: Maximum backoff time in seconds (default: 60)
+                - backoff_multiplier: Exponential backoff multiplier (default: 2)
+                - jitter: Whether to add randomness to backoff (default: True)
+                - retry_status_codes: HTTP status codes to retry on (default: [429, 500, 502, 503, 504])
+                - retry_exceptions: Exception types to retry on (default: includes RateLimitError, etc.)
+                - rate_limit_backoff_min: Minimum wait time for rate limit errors (default: 60 seconds)
+                - rate_limit_backoff_max: Maximum wait time for rate limit errors (default: 90 seconds)
+            parallel_tool_calls: Whether to enable parallel tool calls. If True, the agent will ask the model
+                                to execute multiple tool calls in parallel when possible. Some models like GPT-4
+                                and Claude 3 support this feature. Default is True.
+                    """
         # Set up logger
         self.logger = logger or logging.getLogger(__name__)
         
@@ -378,6 +426,12 @@ class TinyAgent:
         # Simplified hook system - single list of callbacks
         self.callbacks: List[callable] = []
         
+        # Configure LiteLLM to drop unsupported parameters
+        # This is also set globally at the module level, but we set it again here to be sure
+        import litellm
+        litellm.drop_params = True
+        self.logger.info("LiteLLM drop_params feature is enabled")
+        
         # LiteLLM configuration
         self.model = model
         self.api_key = api_key
@@ -388,6 +442,14 @@ class TinyAgent:
         
         self.model_kwargs = model_kwargs
         self.encoder = tiktoken.get_encoding("o200k_base")
+        
+        # Set up retry configuration
+        self.retry_config = DEFAULT_RETRY_CONFIG.copy()
+        if retry_config:
+            self.retry_config.update(retry_config)
+        
+        # Set parallel tool calls preference
+        self.parallel_tool_calls = parallel_tool_calls
             
         # Conversation state
         self.messages = [{
@@ -400,8 +462,11 @@ class TinyAgent:
         # This list now accumulates tools from *all* connected MCP servers:
         self.available_tools: List[Dict[str, Any]] = []
         
-        # Control flow tools
-        self.exit_loop_tools = [
+        # Default built-in tools:
+        # - final_answer: Exit tool that completes the task and returns the final answer
+        # - ask_question: Exit tool that asks the user a question and waits for a response
+        # - notify_user: Non-exit tool that shares progress with the user without stopping the agent loop
+        self.default_tools = [
             {
                 "type": "function",
                 "function": {
@@ -431,6 +496,23 @@ class TinyAgent:
                         "required": ["question"]
                     }
                 }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "notify_user",
+                    "description": "Share progress or status updates with the user without stopping the agent loop. Use this to keep the user informed during long-running tasks. Unlike final_answer and ask_question, this tool allows the agent to continue processing after sending the notification.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "message": {
+                                "type": "string",
+                                "description": "The progress update or status message to share with the user"
+                            }
+                        },
+                        "required": ["message"]
+                    }
+                }
             }
         ]
         
@@ -576,7 +658,8 @@ class TinyAgent:
             session_id=session_id,
             metadata=metadata,
             storage=storage,
-            persist_tool_configs=False   # default off
+            persist_tool_configs=False,   # default off
+            retry_config=None  # Use default retry configuration
         )
 
         # Apply the session data directly instead of loading from storage
@@ -829,21 +912,41 @@ class TinyAgent:
         # The main agent loop
         while True:
             # Get all available tools including exit loop tools
-            all_tools = self.available_tools + self.exit_loop_tools
+            all_tools = self.available_tools + self.default_tools
             
             # Call LLM with messages and tools
             try:
                 self.logger.info(f"Calling LLM with {len(self.messages)} messages and {len(all_tools)} tools")
                 
+                # Verify LiteLLM drop_params setting
+                import litellm
+                self.logger.info(f"LiteLLM drop_params is currently set to: {litellm.drop_params}")
+                
                 # Notify LLM start
                 await self._run_callbacks("llm_start", messages=self.messages, tools=all_tools)
                 
-                response = await litellm.acompletion(
+                # Use parallel_tool_calls based on user preference, default to False if not specified
+                use_parallel_tool_calls = self.parallel_tool_calls if self.parallel_tool_calls is not None else False
+                
+                # Disable parallel_tool_calls for models known not to support it
+                unsupported_models = ["o1-mini", "o1-preview", "o3", "o4-mini"]
+                for unsupported_model in unsupported_models:
+                    if unsupported_model in self.model:
+                        old_value = use_parallel_tool_calls
+                        use_parallel_tool_calls = False
+                        if old_value:
+                            self.logger.warning(f"Disabling parallel_tool_calls for model {self.model} as it's known not to support it")
+                
+                self.logger.info(f"Using parallel tool calls: {use_parallel_tool_calls}")
+                
+                # Use our retry wrapper instead of direct litellm call
+                response = await self._litellm_with_retry(
                     model=self.model,
                     api_key=self.api_key,
                     messages=self.messages,
                     tools=all_tools,
                     tool_choice="auto",
+                    parallel_tool_calls=use_parallel_tool_calls,
                     temperature=self.temperature,
                     **self.model_kwargs
                 )
@@ -881,8 +984,11 @@ class TinyAgent:
                 if has_tool_calls:
                     self.logger.info(f"Tool calls detected: {len(tool_calls)}")
                     
-                    # Process each tool call one by one
-                    for tool_call in tool_calls:
+                    # Create a list to hold all the tool execution tasks
+                    tool_tasks = []
+                    
+                    # Create a function to process a single tool call
+                    async def process_tool_call(tool_call):
                         tool_call_id = tool_call.id
                         function_info = tool_call.function
                         tool_name = function_info.name
@@ -912,22 +1018,15 @@ class TinyAgent:
                             if tool_name == "final_answer":
                                 # Add a response for this tool call before returning
                                 tool_result_content = tool_args.get("content", "Task completed without final answer.!!!")
-                                tool_message["content"] = tool_result_content
-                                self.messages.append(tool_message)
-                                await self._run_callbacks("message_add", message=tool_message)
-                                await self._run_callbacks("agent_end", result="Task completed.")
-                                await self._run_callbacks("tool_end", tool_call=tool_call, result=tool_result_content)
-                                return tool_message["content"] 
                             elif tool_name == "ask_question":
                                 question = tool_args.get("question", "Could you provide more details?")
                                 # Add a response for this tool call before returning
                                 tool_result_content = f"Question asked: {question}"
-                                tool_message["content"] = tool_result_content
-                                self.messages.append(tool_message)
-                                await self._run_callbacks("message_add", message=tool_message)
-                                await self._run_callbacks("agent_end", result=f"I need more information: {question}")
-                                await self._run_callbacks("tool_end", tool_call=tool_call, result=tool_result_content)
-                                return f"I need more information: {question}"
+                            elif tool_name == "notify_user":
+                                message = tool_args.get("message", "No message provided.")
+                                self.logger.info(f"Received notify_user tool call with message: {message}")
+                                # Set the tool result content
+                                tool_result_content = "OK"
                             else:
                                 # Check if it's a custom tool first
                                 if tool_name in self.custom_tool_handlers:
@@ -965,9 +1064,32 @@ class TinyAgent:
                             # Always add the tool message to ensure each tool call has a response
                             tool_message["content"] = tool_result_content
                             await self._run_callbacks("tool_end", tool_call=tool_call, result=tool_result_content)
-
+                            return tool_message
+                    
+                    # Create tasks for all tool calls
+                    for tool_call in tool_calls:
+                        tool_tasks.append(process_tool_call(tool_call))
+                    
+                    # Execute all tool calls concurrently
+                    tool_messages = await asyncio.gather(*tool_tasks)
+                    
+                    # Process results of tool calls
+                    for tool_message in tool_messages:
                         self.messages.append(tool_message)
                         await self._run_callbacks("message_add", message=tool_message)
+                        
+                        # Handle special exit tools
+                        if tool_message["name"] == "final_answer":
+                            await self._run_callbacks("agent_end", result="Task completed.")
+                            return tool_message["content"]
+                        elif tool_message["name"] == "ask_question":
+                            # Extract the question from the original tool call
+                            for tc in tool_calls:
+                                if tc.id == tool_message["tool_call_id"]:
+                                    args = json.loads(tc.function.arguments)
+                                    question = args.get("question", "")
+                                    await self._run_callbacks("agent_end", result=f"I need more information: {question}")
+                                    return f"I need more information: {question}"
                     
                     next_turn_should_call_tools = False
                 else:
@@ -1113,6 +1235,154 @@ class TinyAgent:
             self._needs_session_load = False
 
         return self
+    
+    def _is_rate_limit_error(self, exception: Exception) -> bool:
+        """
+        Check if an exception is a rate limit error that should be handled with longer backoff.
+        
+        Args:
+            exception: The exception to check
+            
+        Returns:
+            True if this is a rate limit error, False otherwise
+        """
+        if not exception:
+            return False
+        
+        # Check for LiteLLM RateLimitError
+        error_name = exception.__class__.__name__
+        if "RateLimitError" in error_name:
+            return True
+        
+        # Check for rate limit in the error message
+        error_message = str(exception).lower()
+        rate_limit_indicators = [
+            "rate limit",
+            "rate_limit_error",
+            "rate-limit",
+            "too many requests",
+            "quota exceeded",
+            "requests per minute",
+            "requests per hour",
+            "requests per day",
+            "rate limiting",
+            "throttled"
+        ]
+        
+        for indicator in rate_limit_indicators:
+            if indicator in error_message:
+                return True
+        
+        # Check for specific HTTP status codes (429 = Too Many Requests)
+        status_code = getattr(exception, "status_code", None)
+        if status_code == 429:
+            return True
+            
+        return False
+
+    async def _litellm_with_retry(self, **kwargs) -> Any:
+        """
+        Execute litellm.acompletion with retry logic for handling transient errors.
+        
+        Args:
+            **kwargs: Arguments to pass to litellm.acompletion
+            
+        Returns:
+            The response from litellm.acompletion
+            
+        Raises:
+            Exception: If all retries fail
+        """
+        max_retries = self.retry_config["max_retries"]
+        min_backoff = self.retry_config["min_backoff"]
+        max_backoff = self.retry_config["max_backoff"]
+        backoff_multiplier = self.retry_config["backoff_multiplier"]
+        jitter = self.retry_config["jitter"]
+        retry_status_codes = self.retry_config["retry_status_codes"]
+        retry_exceptions = self.retry_config["retry_exceptions"]
+        
+        # Rate limit specific configuration
+        rate_limit_backoff_min = self.retry_config.get("rate_limit_backoff_min", 60)  # 60 seconds
+        rate_limit_backoff_max = self.retry_config.get("rate_limit_backoff_max", 90)  # 90 seconds
+        
+        attempt = 0
+        last_exception = None
+        
+        # Log the model and key parameters being used
+        model_name = kwargs.get('model', 'unknown')
+        self.logger.debug(f"Calling LiteLLM with model: {model_name}")
+        if 'parallel_tool_calls' in kwargs:
+            self.logger.debug(f"Using parallel_tool_calls={kwargs['parallel_tool_calls']}")
+        
+        while attempt <= max_retries:
+            try:
+                # First attempt or retry
+                if attempt > 0:
+                    # Check if this is a rate limit error and handle it specially
+                    is_rate_limit_error = self._is_rate_limit_error(last_exception)
+                    
+                    if is_rate_limit_error:
+                        # Use longer backoff for rate limit errors (60-90 seconds)
+                        backoff = rate_limit_backoff_min + (rate_limit_backoff_max - rate_limit_backoff_min) * random.random()
+                        self.logger.warning(
+                            f"Rate limit error detected. Retry attempt {attempt}/{max_retries} for LLM call after {backoff:.2f}s delay. "
+                            f"Previous error: {str(last_exception)}"
+                        )
+                    else:
+                        # Use normal exponential backoff for other errors
+                        backoff = min(max_backoff, min_backoff * (backoff_multiplier ** (attempt - 1)))
+                        
+                        # Add jitter if enabled (±20% randomness)
+                        if jitter:
+                            backoff = backoff * (0.8 + 0.4 * random.random())
+                        
+                        self.logger.warning(
+                            f"Retry attempt {attempt}/{max_retries} for LLM call after {backoff:.2f}s delay. "
+                            f"Previous error: {str(last_exception)}"
+                        )
+                    
+                    # Wait before retry
+                    await asyncio.sleep(backoff)
+                
+                # Make the actual API call
+                return await litellm.acompletion(**kwargs)
+                
+            except Exception as e:
+                last_exception = e
+                error_name = e.__class__.__name__
+                full_error_path = f"{e.__class__.__module__}.{error_name}" if hasattr(e, "__module__") else error_name
+                
+                # Check if this exception should trigger a retry
+                should_retry = False
+                
+                # Check for status code in exception (if available)
+                status_code = getattr(e, "status_code", None)
+                if status_code and status_code in retry_status_codes:
+                    should_retry = True
+                
+                # Check exception type against retry list
+                for exception_path in retry_exceptions:
+                    if exception_path in full_error_path:
+                        should_retry = True
+                        break
+                
+                if not should_retry or attempt >= max_retries:
+                    # Either not a retryable error or we've exhausted retries
+                    self.logger.error(
+                        f"LLM call failed after {attempt} attempt(s). Error: {str(e)}"
+                    )
+                    raise
+                
+                # Log the error and continue to next retry attempt
+                error_type = "rate limit" if self._is_rate_limit_error(e) else "general"
+                self.logger.warning(
+                    f"LLM call failed (attempt {attempt+1}/{max_retries+1}) - {error_type} error: {str(e)}. Will retry."
+                )
+                
+            attempt += 1
+        
+        # This should not be reached due to the raise in the loop, but just in case:
+        raise last_exception
 
     @classmethod
     async def create(
@@ -1128,11 +1398,39 @@ class TinyAgent:
         session_id: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
         storage: Optional[Storage] = None,
-        persist_tool_configs: bool = False
+        persist_tool_configs: bool = False,
+        retry_config: Optional[Dict[str, Any]] = None,
+        parallel_tool_calls: Optional[bool] = True,
     ) -> "TinyAgent":
         """
         Async factory: constructs the agent, then loads an existing session
         if (storage and session_id) were provided.
+        
+        Args:
+            model: The model to use with LiteLLM
+            api_key: The API key for the model provider
+            system_prompt: Custom system prompt for the agent
+            temperature: Temperature parameter for the model (controls randomness)
+            logger: Optional logger to use
+            model_kwargs: Additional keyword arguments to pass to the model
+            user_id: Optional user ID for the session
+            session_id: Optional session ID (if provided with storage, will attempt to load existing session)
+            metadata: Optional metadata for the session
+            storage: Optional storage backend for persistence
+            persist_tool_configs: Whether to persist tool configurations
+            retry_config: Optional configuration for LLM API call retries. Supports:
+                - max_retries: Maximum number of retry attempts (default: 5)
+                - min_backoff: Minimum backoff time in seconds (default: 1)
+                - max_backoff: Maximum backoff time in seconds (default: 60)
+                - backoff_multiplier: Exponential backoff multiplier (default: 2)
+                - jitter: Whether to add randomness to backoff (default: True)
+                - retry_status_codes: HTTP status codes to retry on (default: [429, 500, 502, 503, 504])
+                - retry_exceptions: Exception types to retry on (default: includes RateLimitError, etc.)
+                - rate_limit_backoff_min: Minimum wait time for rate limit errors (default: 60 seconds)
+                - rate_limit_backoff_max: Maximum wait time for rate limit errors (default: 90 seconds)
+            parallel_tool_calls: Whether to enable parallel tool calls. If True, the agent will ask the model
+                                to execute multiple tool calls in parallel when possible. Some models like GPT-4
+                                and Claude 3 support this feature. Default is None (disabled).
         """
         agent = cls(
             model=model,
@@ -1145,7 +1443,9 @@ class TinyAgent:
             session_id=session_id,
             metadata=metadata,
             storage=storage,
-            persist_tool_configs=persist_tool_configs
+            persist_tool_configs=persist_tool_configs,
+            retry_config=retry_config,
+            parallel_tool_calls=parallel_tool_calls
         )
         if agent._needs_session_load:
             await agent.init_async()
@@ -1225,13 +1525,13 @@ class TinyAgent:
             # Log that we're generating a summary
             self.logger.info(f"Generating conversation summary using model {self.summary_config.get('model',self.model)}")
             
-            # Call the LLM to generate the summary
-            response = await litellm.acompletion(
+            # Call the LLM to generate the summary using our retry wrapper
+            response = await self._litellm_with_retry(
                 model=self.summary_config.get("model",self.model),
                 api_key=self.summary_config.get("api_key",self.api_key),
                 messages=summary_messages,
-                temperature=self.summary_config.get("temperature",self.temperature),  # Use low temperature for consistent summaries
-                max_tokens=self.summary_config.get("max_tokens",8000)   # Reasonable limit for summary length
+                temperature=self.summary_config.get("temperature",self.temperature),
+                max_tokens=self.summary_config.get("max_tokens",8000)
             )
             
             # Extract the summary from the response
@@ -1373,16 +1673,39 @@ async def run_example():
         agent_logger.error("Please set the OPENAI_API_KEY environment variable")
         return
     
-    # Initialize the agent with our logger
-    agent = await TinyAgent.create(
-        model="gpt-4.1-mini",
+    # Custom retry configuration - more aggressive than default
+    custom_retry_config = {
+        "max_retries": 3,  # Fewer retries for the example
+        "min_backoff": 2,  # Start with 2 seconds
+        "max_backoff": 30,  # Max 30 seconds between retries
+        "retry_exceptions": [
+            "litellm.InternalServerError",
+            "litellm.APIError",
+            "litellm.APIConnectionError",
+            "litellm.RateLimitError",
+            "litellm.ServiceUnavailableError",
+            "litellm.APITimeoutError",
+            "TimeoutError",  # Add any additional exceptions
+            "ConnectionError"
+        ],
+        # Rate limit specific configuration
+        "rate_limit_backoff_min": 60,  # Wait 60-90 seconds for rate limit errors
+        "rate_limit_backoff_max": 90,  # This is the recommended range for most APIs
+    }
+    
+    # Example 1: Using a model that supports parallel function calling (GPT-4)
+    agent_logger.info("Example 1: Using a model that supports parallel function calling (GPT-4)")
+    agent1 = await TinyAgent.create(
+        model="gpt-4",  # A model that supports parallel function calling
         api_key=api_key,
         logger=agent_logger,
-        session_id="my-session-123",
-        storage=None
+        session_id="parallel-example",
+        retry_config=custom_retry_config,
+        parallel_tool_calls=True,  # Explicitly enable parallel function calling
+        drop_unsupported_params=True  # Enable dropping unsupported parameters
     )
     
-    # Add the Rich UI callback with our logger
+    # Add the Rich UI callback
     rich_ui = RichUICallback(
         markdown=True,
         show_message=True,
@@ -1390,21 +1713,51 @@ async def run_example():
         show_tool_calls=True,
         logger=ui_logger
     )
-    agent.add_callback(rich_ui)
+    agent1.add_callback(rich_ui)
     
-    # Run the agent with a user query
-    user_input = "What is the capital of France?"
-    agent_logger.info(f"Running agent with input: {user_input}")
-    result = await agent.run(user_input)
+    # Connect to MCP servers for additional tools
+    try:
+        await agent1.connect_to_server("npx", ["-y", "@openbnb/mcp-server-airbnb", "--ignore-robots-txt"])
+    except Exception as e:
+        agent_logger.error(f"Failed to connect to MCP servers: {e}")
     
-    agent_logger.info(f"Initial result: {result}")
+    # Run the agent with a task that would benefit from parallel function calling
+    user_input1 = "Compare the weather in Tokyo, New York, and Paris for planning a trip next week."
+    agent_logger.info(f"Running agent with input: {user_input1}")
+    result1 = await agent1.run(user_input1, max_turns=10)
+    agent_logger.info(f"Final result from example 1: {result1}")
     
-    # Now demonstrate the resume functionality
-    agent_logger.info("Resuming the conversation without new user input")
-    resume_result = await agent.resume(max_turns=3)
+    # Clean up
+    await agent1.close()
     
-    agent_logger.info(f"Resume result: {resume_result}")
+    # Example 2: Using a model that doesn't support parallel function calling (o4-mini)
+    agent_logger.info("\nExample 2: Using a model that doesn't support parallel function calling (o4-mini)")
+    agent2 = await TinyAgent.create(
+        model="o4-mini",  # A model that doesn't support parallel function calling
+        api_key=api_key,
+        logger=agent_logger,
+        session_id="o4-mini-example",
+        retry_config=custom_retry_config,
+        parallel_tool_calls=True,  # We still set this to True, but it will be automatically disabled
+        drop_unsupported_params=True  # Enable dropping unsupported parameters
+    )
+    
+    # Add the Rich UI callback
+    agent2.add_callback(rich_ui)
+    
+    # Connect to the same MCP server
+    try:
+        await agent2.connect_to_server("npx", ["-y", "@openbnb/mcp-server-airbnb", "--ignore-robots-txt"])
+    except Exception as e:
+        agent_logger.error(f"Failed to connect to MCP servers: {e}")
+    
+    # Run the agent with the same task
+    user_input2 = "Compare the weather in Tokyo, New York, and Paris for planning a trip next week."
+    agent_logger.info(f"Running agent with input: {user_input2}")
+    result2 = await agent2.run(user_input2, max_turns=10)
+    agent_logger.info(f"Final result from example 2: {result2}")
     
     # Clean up
-    await agent.close()
-    agent_logger.debug("Example completed")
+    await agent2.close()
+    
+    agent_logger.debug("Examples completed")

{tinyagent_py-0.0.15.dist-info → tinyagent_py-0.0.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinyagent-py
-Version: 0.0.15
+Version: 0.0.16
 Summary: TinyAgent with MCP Client, Code Agent (Thinking, Planning, and Executing in Python), and Extendable Hooks, Tiny but powerful
 Author-email: Mahdi Golchin <golchin@askdev.ai>
 Project-URL: Homepage, https://github.com/askbudi/tinyagent
@@ -274,6 +274,30 @@ agent = TinyCodeAgent(
 )
 ```
 
+### Automatic Git Checkpoints
+
+TinyCodeAgent can automatically create Git checkpoints after each successful shell command execution. This helps track changes made by the agent and provides a safety net for reverting changes if needed.
+
+```python
+# Enable automatic Git checkpoints during initialization
+agent = TinyCodeAgent(
+    model="gpt-4.1-mini",
+    auto_git_checkpoint=True  # Enable automatic Git checkpoints
+)
+
+# Or enable/disable it later
+agent.enable_auto_git_checkpoint(True)  # Enable
+agent.enable_auto_git_checkpoint(False)  # Disable
+
+# Check current status
+is_enabled = agent.get_auto_git_checkpoint_status()
+```
+
+Each checkpoint includes:
+- Descriptive commit message with the command description
+- Timestamp of when the command was executed
+- The actual command that was run
+
 For detailed documentation, see the [TinyCodeAgent README](tinyagent/code_agent/README.md).
 
 ## How the TinyAgent Hook System Works