tinyagent-py 0.0.17rc1__tar.gz → 0.0.19__tar.gz

{tinyagent_py-0.0.17rc1 → tinyagent_py-0.0.19}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: tinyagent-py
-Version: 0.0.17rc1
-Summary: TinyAgent with MCP Client, Code Agent (Thinking, Planning, and Executing in Python), and Extendable Hooks, Tiny but powerful
+Version: 0.0.19
+Summary: TinyAgent with MCP Client, CodeAgent (Thinking, Planning, Interactive Python and Shell with high variaety of sandboxing(seatbelt, Modal, E2B, docker, etc) ), and Extendable Hooks, Tiny but powerful
 Author-email: Mahdi Golchin <golchin@askdev.ai>
 Project-URL: Homepage, https://github.com/askbudi/tinyagent
 Project-URL: Bug Tracker, https://github.com/askbudi/tinyagent/issues

{tinyagent_py-0.0.17rc1 → tinyagent_py-0.0.19}/pyproject.toml

@@ -12,8 +12,8 @@ tinyagent = ["prompts/*.yaml"]
 
 [project]
 name = "tinyagent-py"
-version = "0.0.17rc1"
-description = "TinyAgent with MCP Client, Code Agent (Thinking, Planning, and Executing in Python), and Extendable Hooks, Tiny but powerful"
+version = "0.0.19"
+description = "TinyAgent with MCP Client, CodeAgent (Thinking, Planning, Interactive Python and Shell with high variaety of sandboxing(seatbelt, Modal, E2B, docker, etc) ), and Extendable Hooks, Tiny but powerful"
 readme = "README.md"
 authors = [
   {name="Mahdi Golchin", email="golchin@askdev.ai"}

{tinyagent_py-0.0.17rc1 → tinyagent_py-0.0.19}/tinyagent/code_agent/tiny_code_agent.py

@@ -31,7 +31,7 @@ DEFAULT_SUMMARY_SYSTEM_PROMPT = (
     
 )
 
-class TinyCodeAgent:
+class TinyCodeAgent(TinyAgent):
     """
     A TinyAgent specialized for code execution tasks.
     
@@ -69,6 +69,8 @@ class TinyCodeAgent:
         ui: Optional[str] = None,
         truncation_config: Optional[Dict[str, Any]] = None,
         auto_git_checkpoint: bool = False,
+        enable_python_tool: bool = True,
+        enable_shell_tool: bool = True,
         **agent_kwargs
     ):
         """
@@ -95,6 +97,8 @@ class TinyCodeAgent:
             ui: The user interface callback to use ('rich', 'jupyter', or None).
             truncation_config: Configuration for output truncation (max_tokens, max_lines)
             auto_git_checkpoint: If True, automatically create git checkpoints after each successful shell command
+            enable_python_tool: If True (default), enable the run_python tool for Python code execution
+            enable_shell_tool: If True (default), enable the bash tool for shell command execution
             **agent_kwargs: Additional arguments passed to TinyAgent
             
         Provider Config Options:
@@ -136,6 +140,10 @@ class TinyCodeAgent:
         self.default_workdir = default_workdir or os.getcwd()  # Default to current working directory if not specified
         self.auto_git_checkpoint = auto_git_checkpoint  # Enable/disable automatic git checkpoints
         
+        # Store tool enablement flags
+        self._python_tool_enabled = enable_python_tool
+        self._shell_tool_enabled = enable_shell_tool
+        
         # Set up truncation configuration with defaults
         default_truncation = {
             "max_tokens": 3000,
@@ -158,8 +166,8 @@ class TinyCodeAgent:
         
         self.summary_config = summary_config or {}
 
-        # Create the underlying TinyAgent with summary configuration
-        self.agent = TinyAgent(
+        # Initialize the parent TinyAgent with the built system prompt
+        super().__init__(
             model=model,
             api_key=api_key,
             system_prompt=self.system_prompt,
@@ -173,7 +181,7 @@ class TinyCodeAgent:
         
         # Add LLM tools (not code tools - those go to the provider)
         if self.tools:
-            self.agent.add_tools(self.tools)
+            self.add_tools(self.tools)
 
         # Add the selected UI callback
         if ui:
@@ -394,221 +402,237 @@ class TinyCodeAgent:
     
     def _setup_code_execution_tools(self):
         """Set up the code execution tools using the code provider."""
-        @tool(name="run_python", description=dedent("""
-        This tool receives Python code and executes it in a sandboxed environment.
-        During each intermediate step, you can use 'print()' to save important information.
-        These print outputs will appear in the 'Observation:' field for the next step.
+        # Clear existing default tools to avoid duplicates
+        # Remove existing default tools by name if they exist
+        if hasattr(self, 'available_tools'):
+            tools_to_remove = []
+            for tool_dict in self.available_tools:
+                if 'function' in tool_dict and 'name' in tool_dict['function']:
+                    if tool_dict['function']['name'] in ['run_python', 'bash']:
+                        tools_to_remove.append(tool_dict)
+            
+            # Remove the tools from available_tools
+            for tool_dict in tools_to_remove:
+                self.available_tools.remove(tool_dict)
+        
+        if self._python_tool_enabled:
+            @tool(name="run_python", description=dedent("""
+            This tool receives Python code and executes it in a sandboxed environment.
+            During each intermediate step, you can use 'print()' to save important information.
+            These print outputs will appear in the 'Observation:' field for the next step.
 
-        Args:
-            code_lines: list[str]: The Python code to execute as a list of strings.
-                Your code should include all necessary steps for successful execution,
-                cover edge cases, and include error handling.
-                Each line should be an independent line of code.
+            Args:
+                code_lines: list[str]: The Python code to execute as a list of strings.
+                    Your code should include all necessary steps for successful execution,
+                    cover edge cases, and include error handling.
+                    Each line should be an independent line of code.
 
-        Returns:
-            Status of code execution or error message.
-        """))
-        async def run_python(code_lines: List[str], timeout: int = 120) -> str:
-            """Execute Python code using the configured provider."""
-            try:
-                # Before execution, ensure provider has the latest user variables
-                if self.user_variables:
-                    self.code_provider.set_user_variables(self.user_variables)
+            Returns:
+                Status of code execution or error message.
+            """))
+            async def run_python(code_lines: List[str], timeout: int = 120) -> str:
+                """Execute Python code using the configured provider."""
+                try:
+                    # Before execution, ensure provider has the latest user variables
+                    if self.user_variables:
+                        self.code_provider.set_user_variables(self.user_variables)
+                        
+                    result = await self.code_provider.execute_python(code_lines, timeout)
                     
-                result = await self.code_provider.execute_python(code_lines, timeout)
-                
-                # After execution, update TinyCodeAgent's user_variables from the provider
-                # This ensures they stay in sync
-                self.user_variables = self.code_provider.get_user_variables()
-                
-                # Apply truncation if enabled
-                if self.truncation_config["enabled"] and "printed_output" in result:
-                    truncated_output, is_truncated, original_tokens, original_lines = truncate_output(
-                        result["printed_output"],
-                        max_tokens=self.truncation_config["max_tokens"],
-                        max_lines=self.truncation_config["max_lines"]
-                    )
+                    # After execution, update TinyCodeAgent's user_variables from the provider
+                    # This ensures they stay in sync
+                    self.user_variables = self.code_provider.get_user_variables()
                     
-                    if is_truncated:
-                        result["printed_output"] = format_truncation_message(
-                            truncated_output,
-                            is_truncated,
-                            original_tokens,
-                            original_lines,
-                            self.truncation_config["max_lines"],
-                            "python_output"
+                    # Apply truncation if enabled
+                    if self.truncation_config["enabled"] and "printed_output" in result:
+                        truncated_output, is_truncated, original_tokens, original_lines = truncate_output(
+                            result["printed_output"],
+                            max_tokens=self.truncation_config["max_tokens"],
+                            max_lines=self.truncation_config["max_lines"]
                         )
+                        
+                        if is_truncated:
+                            result["printed_output"] = format_truncation_message(
+                                truncated_output,
+                                is_truncated,
+                                original_tokens,
+                                original_lines,
+                                self.truncation_config["max_lines"],
+                                "python_output"
+                            )
+                    
+                    return json.dumps(result)
+                except Exception as e:
+                    print("!"*100)
+                    COLOR = {
+                            "RED": "\033[91m",
+                            "ENDC": "\033[0m",
+                        }
+                    print(f"{COLOR['RED']}{str(e)}{COLOR['ENDC']}")
+                    print(f"{COLOR['RED']}{traceback.format_exc()}{COLOR['ENDC']}")
+                    print("!"*100)
+                    
+                    # Even after an exception, update user_variables from the provider
+                    # This ensures any variables that were successfully created/modified are preserved
+                    self.user_variables = self.code_provider.get_user_variables()
+                    
+                    return json.dumps({"error": f"Error executing code: {str(e)}"})
+            
+            self.add_tool(run_python)
+        
+        if self._shell_tool_enabled:
+            @tool(name="bash", description=dedent("""
+            This tool executes shell commands securely in a sandboxed environment.
+            Only a limited set of safe commands are allowed for security reasons.
+            Before executing the command, please follow these steps:
+              
+              1. Directory Verification:
+                 - If the command will create new directories or files, first use ls to verify the parent directory exists and is the correct location
+                 - For example, before running "mkdir foo/bar", first use ls to check that "foo" exists and is the intended parent directory
+              
+              2. Command Execution:
+                 - Always quote file paths that contain spaces with double quotes (e.g., cd "path with spaces/file.txt")
+                 - Examples of proper quoting:
+                   - cd "/Users/name/My Documents" (correct)
+                   - cd /Users/name/My Documents (incorrect - will fail)
+                   - python "/path/with spaces/script.py" (correct)
+                   - python /path/with spaces/script.py (incorrect - will fail)
+                 - After ensuring proper quoting, execute the command.
+                 - Capture the output of the command.
+              
+              Usage notes:
+                - The command argument is required.
+                - You have the capability to call multiple tools in a single response. When multiple independent pieces of information are requested, batch your tool calls together for optimal performance.
+                - You can specify an optional timeout in milliseconds (up to 600000ms / 10 minutes). If not specified, commands will timeout after 120000ms (2 minutes).
+                - It is very helpful if you write a clear, concise description of what this command does in 5-10 words.
+                - If the output is too large, it will be truncated before being returned to you.
                 
-                return json.dumps(result)
-            except Exception as e:
-                print("!"*100)
-                COLOR = {
-                        "RED": "\033[91m",
-                        "ENDC": "\033[0m",
-                    }
-                print(f"{COLOR['RED']}{str(e)}{COLOR['ENDC']}")
-                print(f"{COLOR['RED']}{traceback.format_exc()}{COLOR['ENDC']}")
-                print("!"*100)
-                
-                # Even after an exception, update user_variables from the provider
-                # This ensures any variables that were successfully created/modified are preserved
-                self.user_variables = self.code_provider.get_user_variables()
-                
-                return json.dumps({"error": f"Error executing code: {str(e)}"})
-        
-        @tool(name="bash", description=dedent("""
-        This tool executes shell commands securely in a sandboxed environment.
-        Only a limited set of safe commands are allowed for security reasons.
-        Before executing the command, please follow these steps:
-          
-          1. Directory Verification:
-             - If the command will create new directories or files, first use ls to verify the parent directory exists and is the correct location
-             - For example, before running "mkdir foo/bar", first use ls to check that "foo" exists and is the intended parent directory
-          
-          2. Command Execution:
-             - Always quote file paths that contain spaces with double quotes (e.g., cd "path with spaces/file.txt")
-             - Examples of proper quoting:
-               - cd "/Users/name/My Documents" (correct)
-               - cd /Users/name/My Documents (incorrect - will fail)
-               - python "/path/with spaces/script.py" (correct)
-               - python /path/with spaces/script.py (incorrect - will fail)
-             - After ensuring proper quoting, execute the command.
-             - Capture the output of the command.
-          
-          Usage notes:
-            - The command argument is required.
-            - You have the capability to call multiple tools in a single response. When multiple independent pieces of information are requested, batch your tool calls together for optimal performance.
-            - You can specify an optional timeout in milliseconds (up to 600000ms / 10 minutes). If not specified, commands will timeout after 120000ms (2 minutes).
-            - It is very helpful if you write a clear, concise description of what this command does in 5-10 words.
-            - If the output is too large, it will be truncated before being returned to you.
+               - If you _still_ need to run `grep`, STOP. ALWAYS USE ripgrep at `rg` first, which all ${PRODUCT_NAME} users have pre-installed.
+              "  - When issuing multiple commands, use the ; or && operator to separate them. DO NOT use newlines (newlines are ok in quoted strings).\n" +
+                - Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of `cd`. You may use `cd` if the User explicitly requests it.
+                  <good-example>
+                  pytest /foo/bar/tests
+                  </good-example>
+                  <bad-example>
+                  cd /foo/bar && pytest tests
+                  </bad-example>
             
-           - If you _still_ need to run `grep`, STOP. ALWAYS USE ripgrep at `rg` first, which all ${PRODUCT_NAME} users have pre-installed.
-          "  - When issuing multiple commands, use the ; or && operator to separate them. DO NOT use newlines (newlines are ok in quoted strings).\n" +
-            - Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of `cd`. You may use `cd` if the User explicitly requests it.
-              <good-example>
-              pytest /foo/bar/tests
-              </good-example>
-              <bad-example>
-              cd /foo/bar && pytest tests
-              </bad-example>
-        
-        ## IMPORTANT: Bash Tool Usage
-        
-        When using the bash tool, you MUST provide all required parameters:
-        
-        **Correct Usage:**
-        ```
-        bash(
-            command=["ls", "-la"],
-            absolute_workdir="/path/to/directory", 
-            description="List files in directory"
-        )
-        ```
-        
-        **For creating files with content, use these safe patterns:**
-        
-        1. **Simple file creation:**
-        ```
-        bash(
-            command=["touch", "filename.txt"],
-            absolute_workdir="/working/directory",
-            description="Create empty file"
-        )
-        ```
-        
-        2. **Write content using cat and heredoc:**
-        ```
-        bash(
-            command=["sh", "-c", "cat > filename.txt << 'EOF'\nYour content here\nEOF"],
-            absolute_workdir="/working/directory", 
-            description="Create file with content"
-        )
-        ```
-        
-        3. **Write content using echo:**
-        ```
-        bash(
-            command=["sh", "-c", "echo 'Your content' > filename.txt"],
-            absolute_workdir="/working/directory",
-            description="Write content to file"
-        )
-        ```
-        
-        **Never:**
-        - Call bash() without all required parameters
-        - Use complex nested quotes without testing
-        - Try to create large files in a single command (break into parts)
+            ## IMPORTANT: Bash Tool Usage
+            
+            When using the bash tool, you MUST provide all required parameters:
+            
+            **Correct Usage:**
+            ```
+            bash(
+                command=["ls", "-la"],
+                absolute_workdir="/path/to/directory", 
+                description="List files in directory"
+            )
+            ```
+            
+            **For creating files with content, use these safe patterns:**
+            
+            1. **Simple file creation:**
+            ```
+            bash(
+                command=["touch", "filename.txt"],
+                absolute_workdir="/working/directory",
+                description="Create empty file"
+            )
+            ```
+            
+            2. **Write content using cat and heredoc:**
+            ```
+            bash(
+                command=["sh", "-c", "cat > filename.txt << 'EOF'\nYour content here\nEOF"],
+                absolute_workdir="/working/directory", 
+                description="Create file with content"
+            )
+            ```
+            
+            3. **Write content using echo:**
+            ```
+            bash(
+                command=["sh", "-c", "echo 'Your content' > filename.txt"],
+                absolute_workdir="/working/directory",
+                description="Write content to file"
+            )
+            ```
+            
+            **Never:**
+            - Call bash() without all required parameters
+            - Use complex nested quotes without testing
+            - Try to create large files in a single command (break into parts)
 
-        Args:
-            command: list[str]: The shell command to execute as a list of strings.  Example: ["ls", "-la"] or ["cat", "file.txt"]
-                
-            absolute_workdir: str: could be presented workdir in the system prompt or one of the subdirectories of the workdir. This is the only allowed path, and accessing else will result in an error.
-            description: str: A clear, concise description of what this command does in 5-10 words.
-            timeout: int: Maximum execution time in seconds (default: 60).
-        Returns:
-            Dictionary with stdout, stderr, and exit_code from the command execution.
-            If the command is rejected for security reasons, stderr will contain the reason.
-            The stdout will include information about which working directory was used.
-        """))
-        async def run_shell(command: List[str], absolute_workdir: str,  description: str, timeout: int = 60) -> str:
-            """Execute shell commands securely using the configured provider."""
-            try:
-                # Use the default working directory if none is specified
-                effective_workdir = absolute_workdir or self.default_workdir
-                print(f" {command} to {description}")
-                # Verify that the working directory exists
-                if effective_workdir and not os.path.exists(effective_workdir):
-                    return json.dumps({
-                        "stdout": "",
-                        "stderr": f"Working directory does not exist: {effective_workdir}",
-                        "exit_code": 1
-                    })
-                
-                if effective_workdir and not os.path.isdir(effective_workdir):
-                    return json.dumps({
-                        "stdout": "",
-                        "stderr": f"Path is not a directory: {effective_workdir}",
-                        "exit_code": 1
-                    })
-                
-                result = await self.code_provider.execute_shell(command, timeout, effective_workdir)
-                
-                # Apply truncation if enabled
-                if self.truncation_config["enabled"] and "stdout" in result and result["stdout"]:
-                    truncated_output, is_truncated, original_tokens, original_lines = truncate_output(
-                        result["stdout"],
-                        max_tokens=self.truncation_config["max_tokens"],
-                        max_lines=self.truncation_config["max_lines"]
-                    )
+            Args:
+                command: list[str]: The shell command to execute as a list of strings.  Example: ["ls", "-la"] or ["cat", "file.txt"]
                     
-                    if is_truncated:
-                        result["stdout"] = format_truncation_message(
-                            truncated_output,
-                            is_truncated,
-                            original_tokens,
-                            original_lines,
-                            self.truncation_config["max_lines"],
-                            "bash_output"
+                absolute_workdir: str: could be presented workdir in the system prompt or one of the subdirectories of the workdir. This is the only allowed path, and accessing else will result in an error.
+                description: str: A clear, concise description of what this command does in 5-10 words.
+                timeout: int: Maximum execution time in seconds (default: 60).
+            Returns:
+                Dictionary with stdout, stderr, and exit_code from the command execution.
+                If the command is rejected for security reasons, stderr will contain the reason.
+                The stdout will include information about which working directory was used.
+            """))
+            async def run_shell(command: List[str], absolute_workdir: str,  description: str, timeout: int = 60) -> str:
+                """Execute shell commands securely using the configured provider."""
+                try:
+                    # Use the default working directory if none is specified
+                    effective_workdir = absolute_workdir or self.default_workdir
+                    print(f" {command} to {description}")
+                    # Verify that the working directory exists
+                    if effective_workdir and not os.path.exists(effective_workdir):
+                        return json.dumps({
+                            "stdout": "",
+                            "stderr": f"Working directory does not exist: {effective_workdir}",
+                            "exit_code": 1
+                        })
+                    
+                    if effective_workdir and not os.path.isdir(effective_workdir):
+                        return json.dumps({
+                            "stdout": "",
+                            "stderr": f"Path is not a directory: {effective_workdir}",
+                            "exit_code": 1
+                        })
+                    
+                    result = await self.code_provider.execute_shell(command, timeout, effective_workdir)
+                    
+                    # Apply truncation if enabled
+                    if self.truncation_config["enabled"] and "stdout" in result and result["stdout"]:
+                        truncated_output, is_truncated, original_tokens, original_lines = truncate_output(
+                            result["stdout"],
+                            max_tokens=self.truncation_config["max_tokens"],
+                            max_lines=self.truncation_config["max_lines"]
                         )
-                
-                # Create a git checkpoint if auto_git_checkpoint is enabled
-                if self.auto_git_checkpoint and result.get("exit_code", 1) == 0:
-                    checkpoint_result = await self._create_git_checkpoint(command, description, effective_workdir)
-                    self.log_manager.get_logger(__name__).info(f"Git checkpoint {effective_workdir} result: {checkpoint_result}")
-                
-                return json.dumps(result)
-            except Exception as e:
-                COLOR = {
-                    "RED": "\033[91m",
-                    "ENDC": "\033[0m",
-                }
-                print(f"{COLOR['RED']}{str(e)}{COLOR['ENDC']}")
-                print(f"{COLOR['RED']}{traceback.format_exc()}{COLOR['ENDC']}")
-                
-                return json.dumps({"error": f"Error executing shell command: {str(e)}"})
-        
-        self.agent.add_tool(run_python)
-        self.agent.add_tool(run_shell)
+                        
+                        if is_truncated:
+                            result["stdout"] = format_truncation_message(
+                                truncated_output,
+                                is_truncated,
+                                original_tokens,
+                                original_lines,
+                                self.truncation_config["max_lines"],
+                                "bash_output"
+                            )
+                    
+                    # Create a git checkpoint if auto_git_checkpoint is enabled
+                    if self.auto_git_checkpoint and result.get("exit_code", 1) == 0:
+                        checkpoint_result = await self._create_git_checkpoint(command, description, effective_workdir)
+                        self.log_manager.get_logger(__name__).info(f"Git checkpoint {effective_workdir} result: {checkpoint_result}")
+                    
+                    return json.dumps(result)
+                except Exception as e:
+                    COLOR = {
+                        "RED": "\033[91m",
+                        "ENDC": "\033[0m",
+                    }
+                    print(f"{COLOR['RED']}{str(e)}{COLOR['ENDC']}")
+                    print(f"{COLOR['RED']}{traceback.format_exc()}{COLOR['ENDC']}")
+                    
+                    return json.dumps({"error": f"Error executing shell command: {str(e)}"})
+            
+            self.add_tool(run_shell)
     
     async def _create_git_checkpoint(self, command: List[str], description: str, workdir: str) -> Dict[str, Any]:
         """
@@ -706,50 +730,17 @@ class TinyCodeAgent:
         """
         return self.default_workdir
     
-    async def run(self, user_input: str, max_turns: int = 10) -> str:
-        """
-        Run the code agent with the given input.
-        
-        Args:
-            user_input: The user's request or question
-            max_turns: Maximum number of conversation turns
-            
-        Returns:
-            The agent's response
-        """
-        return await self.agent.run(user_input, max_turns)
+
     
-    async def resume(self, max_turns: int = 10) -> str:
-        """
-        Resume the conversation without adding a new user message.
-        
-        This method continues the conversation from the current state,
-        allowing the agent to process the existing conversation history
-        and potentially take additional actions.
-        
-        Args:
-            max_turns: Maximum number of conversation turns
-            
-        Returns:
-            The agent's response
-        """
-        return await self.agent.resume(max_turns)
+
     
-    async def connect_to_server(self, command: str, args: List[str], **kwargs):
-        """Connect to an MCP server."""
-        return await self.agent.connect_to_server(command, args, **kwargs)
+
     
-    def add_callback(self, callback):
-        """Add a callback to the agent."""
-        self.agent.add_callback(callback)
+
     
-    def add_tool(self, tool):
-        """Add a tool to the agent (LLM tool)."""
-        self.agent.add_tool(tool)
+
     
-    def add_tools(self, tools: List[Any]):
-        """Add multiple tools to the agent (LLM tools)."""
-        self.agent.add_tools(tools)
+
     
     def add_code_tool(self, tool):
         """
@@ -763,8 +754,8 @@ class TinyCodeAgent:
         self.code_provider.set_code_tools(self.code_tools)
         # Rebuild system prompt to include new code tools info
         self.system_prompt = self._build_system_prompt()
-        # Update the agent's system prompt
-        self.agent.system_prompt = self.system_prompt
+        # Update the system prompt in messages
+        self._update_system_prompt()
     
     def add_code_tools(self, tools: List[Any]):
         """
@@ -778,8 +769,8 @@ class TinyCodeAgent:
         self.code_provider.set_code_tools(self.code_tools)
         # Rebuild system prompt to include new code tools info
         self.system_prompt = self._build_system_prompt()
-        # Update the agent's system prompt
-        self.agent.system_prompt = self.system_prompt
+        # Update the system prompt in messages
+        self._update_system_prompt()
     
     def remove_code_tool(self, tool_name: str):
         """
@@ -795,8 +786,8 @@ class TinyCodeAgent:
         self.code_provider.set_code_tools(self.code_tools)
         # Rebuild system prompt
         self.system_prompt = self._build_system_prompt()
-        # Update the agent's system prompt
-        self.agent.system_prompt = self.system_prompt
+        # Update the system prompt in messages
+        self._update_system_prompt()
     
     def get_code_tools(self) -> List[Any]:
         """
@@ -827,8 +818,8 @@ class TinyCodeAgent:
         self.code_provider.set_user_variables(self.user_variables)
         # Rebuild system prompt to include new variables info
         self.system_prompt = self._build_system_prompt()
-        # Update the agent's system prompt
-        self.agent.system_prompt = self.system_prompt
+        # Update the system prompt in messages
+        self._update_system_prompt()
     
     def add_user_variable(self, name: str, value: Any):
         """
@@ -843,7 +834,7 @@ class TinyCodeAgent:
         # Rebuild system prompt to include new variables info
         self.system_prompt = self._build_system_prompt()
         # Update the agent's system prompt
-        self.agent.system_prompt = self.system_prompt
+        self._update_system_prompt()
     
     def remove_user_variable(self, name: str):
         """
@@ -858,7 +849,7 @@ class TinyCodeAgent:
             # Rebuild system prompt
             self.system_prompt = self._build_system_prompt()
             # Update the agent's system prompt
-            self.agent.system_prompt = self.system_prompt
+            self._update_system_prompt()
     
     def get_user_variables(self) -> Dict[str, Any]:
         """
@@ -926,7 +917,7 @@ class TinyCodeAgent:
         # Rebuild system prompt to include new authorized imports
         self.system_prompt = self._build_system_prompt()
         # Update the agent's system prompt
-        self.agent.system_prompt = self.system_prompt
+        self._update_system_prompt()
     
     def get_authorized_imports(self) -> List[str]:
         """
@@ -973,27 +964,22 @@ class TinyCodeAgent:
             # Rebuild system prompt to reflect updated authorized imports
             self.system_prompt = self._build_system_prompt()
             # Update the agent's system prompt
-            self.agent.system_prompt = self.system_prompt
+            self._update_system_prompt()
     
     async def close(self):
         """Clean up resources."""
         await self.code_provider.cleanup()
-        await self.agent.close()
+        await super().close()
     
-    def clear_conversation(self):
-        """Clear the conversation history."""
-        self.agent.clear_conversation()
-    
-    @property
-    def messages(self):
-        """Get the conversation messages."""
-        return self.agent.messages
+
     
-    @property
-    def session_id(self):
-        """Get the session ID."""
-        return self.agent.session_id 
+ 
 
+    def _update_system_prompt(self):
+        """Update the system prompt in the messages array."""
+        if self.messages and len(self.messages) > 0:
+            self.messages[0]["content"] = self.system_prompt
+    
     def set_check_string_obfuscation(self, enabled: bool):
         """
         Enable or disable string obfuscation detection.
@@ -1008,32 +994,9 @@ class TinyCodeAgent:
         if hasattr(self.code_provider, 'check_string_obfuscation'):
             self.code_provider.check_string_obfuscation = enabled
 
-    async def summarize(self) -> str:
-        """
-        Generate a summary of the current conversation history.
-        
-        Args:
-        Returns:
-            A string containing the conversation summary
-        """
-        # Use the underlying TinyAgent's summarize_conversation method
-        return await self.agent.summarize()
-        
-    async def compact(self) -> bool:
-        """
-        Compact the conversation history by replacing it with a summary.
-        
-        This method delegates to the underlying TinyAgent's compact method,
-        which:
-        1. Generates a summary of the current conversation
-        2. If successful, replaces the conversation with just [system, user] messages
-           where the user message contains the summary
-        3. Returns True if compaction was successful, False otherwise
+
         
-        Returns:
-            Boolean indicating whether the compaction was successful
-        """
-        return await self.agent.compact()
+
 
     def add_ui_callback(self, ui_type: str, optimized: bool = True):
         """
@@ -1122,6 +1085,48 @@ class TinyCodeAgent:
         """
         return self.auto_git_checkpoint
     
+    def enable_python_tool(self, enabled: bool = True):
+        """
+        Enable or disable the Python code execution tool.
+        
+        Args:
+            enabled: If True, enable the run_python tool. If False, disable it.
+        """
+        if enabled != self._python_tool_enabled:
+            self._python_tool_enabled = enabled
+            # Re-setup tools to reflect the change
+            self._setup_code_execution_tools()
+    
+    def enable_shell_tool(self, enabled: bool = True):
+        """
+        Enable or disable the shell command execution tool.
+        
+        Args:
+            enabled: If True, enable the bash tool. If False, disable it.
+        """
+        if enabled != self._shell_tool_enabled:
+            self._shell_tool_enabled = enabled
+            # Re-setup tools to reflect the change
+            self._setup_code_execution_tools()
+    
+    def get_python_tool_status(self) -> bool:
+        """
+        Get the current status of the Python tool.
+        
+        Returns:
+            True if the run_python tool is enabled, False otherwise.
+        """
+        return self._python_tool_enabled
+    
+    def get_shell_tool_status(self) -> bool:
+        """
+        Get the current status of the shell tool.
+        
+        Returns:
+            True if the bash tool is enabled, False otherwise.
+        """
+        return self._shell_tool_enabled
+    
     def set_environment_variables(self, env_vars: Dict[str, str]):
         """
         Set environment variables for the code execution provider.
@@ -1534,6 +1539,35 @@ async def run_example():
         await agent_seatbelt.connect_to_server("npx", ["-y", "@openbnb/mcp-server-airbnb", "--ignore-robots-txt"])
         await agent_seatbelt.connect_to_server("npx", ["-y", "@modelcontextprotocol/server-sequential-thinking"])
         
+        # Example: connecting with environment variables
+        env_vars = {
+            "MCP_DEBUG": "true",
+            "RATE_LIMIT": "100",
+            "CUSTOM_CONFIG": "seatbelt_mode"
+        }
+        
+        # Create a simple Modal agent to demonstrate environment variable usage
+        agent_modal = TinyCodeAgent(
+            model="gpt-4.1-mini",
+            tools=[search_web],
+            code_tools=[data_processor],
+            provider="modal",
+            local_execution=False,
+            api_key=api_key
+        )
+        
+        try:
+            await agent_modal.connect_to_server(
+                "npx", 
+                ["-y", "@openbnb/mcp-server-airbnb", "--ignore-robots-txt"],
+                env=env_vars
+            )
+            logger.info("Successfully connected Modal agent with environment variables")
+        except Exception as e:
+            logger.warning(f"Environment variable example failed: {e}")
+        finally:
+            await agent_modal.close()
+        
         # Test the seatbelt agent
         response_seatbelt = await agent_seatbelt.run("""
         I have some sample data. Please use the data_processor tool in Python to analyze my sample_data
@@ -1645,6 +1679,148 @@ async def run_example():
         print("\n" + "="*80)
         print("⚠️  Seatbelt provider is not supported on this system. Skipping seatbelt tests.")
     
+    # Test optional tool functionality
+    print("\n" + "="*80)
+    print("🔧 Testing optional tool functionality")
+    
+    # Create an agent with only Python tool enabled (no shell tool)
+    print("Creating agent with only Python tool enabled...")
+    agent_python_only = TinyCodeAgent(
+        model="gpt-4.1-mini",
+        tools=[search_web],
+        code_tools=[data_processor],
+        user_variables={"test_data": [1, 2, 3, 4, 5]},
+        enable_python_tool=True,
+        enable_shell_tool=False,  # Disable shell tool
+        local_execution=True
+    )
+    
+    # Connect to MCP servers
+    await agent_python_only.connect_to_server("npx", ["-y", "@openbnb/mcp-server-airbnb", "--ignore-robots-txt"])
+    await agent_python_only.connect_to_server("npx", ["-y", "@modelcontextprotocol/server-sequential-thinking"])
+    
+    # Check tool status
+    print(f"Python tool enabled: {agent_python_only.get_python_tool_status()}")
+    print(f"Shell tool enabled: {agent_python_only.get_shell_tool_status()}")
+    
+    # Test Python execution (should work)
+    python_response = await agent_python_only.run("""
+    Use the data_processor tool to analyze the test_data and show me the results.
+    """)
+    print("Python Tool Test (should work):")
+    print(python_response)
+    
+    # Test shell execution (should not work - tool disabled)
+    shell_response = await agent_python_only.run("""
+    Run 'ls -la' to list files in the current directory.
+    """)
+    print("Shell Tool Test (should not work - tool disabled):")
+    print(shell_response)
+    
+    # Now enable the shell tool dynamically
+    print("\nEnabling shell tool dynamically...")
+    agent_python_only.enable_shell_tool(True)
+    print(f"Shell tool enabled: {agent_python_only.get_shell_tool_status()}")
+    
+    # Test shell execution again (should work now)
+    shell_response2 = await agent_python_only.run("""
+    Run 'ls -la' to list files in the current directory.
+    """)
+    print("Shell Tool Test (should work now - tool enabled):")
+    print(shell_response2)
+    
+    # Create an agent with only shell tool enabled (no Python tool)
+    print("\nCreating agent with only shell tool enabled...")
+    agent_shell_only = TinyCodeAgent(
+        model="gpt-4.1-mini",
+        tools=[search_web],
+        code_tools=[data_processor],
+        user_variables={"test_data": [1, 2, 3, 4, 5]},
+        enable_python_tool=False,  # Disable Python tool
+        enable_shell_tool=True,
+        local_execution=True
+    )
+    
+    # Connect to MCP servers
+    await agent_shell_only.connect_to_server("npx", ["-y", "@openbnb/mcp-server-airbnb", "--ignore-robots-txt"])
+    await agent_shell_only.connect_to_server("npx", ["-y", "@modelcontextprotocol/server-sequential-thinking"])
+    
+    # Check tool status
+    print(f"Python tool enabled: {agent_shell_only.get_python_tool_status()}")
+    print(f"Shell tool enabled: {agent_shell_only.get_shell_tool_status()}")
+    
+    # Test shell execution (should work)
+    shell_response3 = await agent_shell_only.run("""
+    Run 'pwd' to show the current working directory.
+    """)
+    print("Shell Tool Test (should work):")
+    print(shell_response3)
+    
+    # Test Python execution (should not work - tool disabled)
+    python_response2 = await agent_shell_only.run("""
+    Use the data_processor tool to analyze the test_data and show me the results.
+    """)
+    print("Python Tool Test (should not work - tool disabled):")
+    print(python_response2)
+    
+    # Now enable the Python tool dynamically
+    print("\nEnabling Python tool dynamically...")
+    agent_shell_only.enable_python_tool(True)
+    print(f"Python tool enabled: {agent_shell_only.get_python_tool_status()}")
+    
+    # Test Python execution again (should work now)
+    python_response3 = await agent_shell_only.run("""
+    Use the data_processor tool to analyze the test_data and show me the results.
+    """)
+    print("Python Tool Test (should work now - tool enabled):")
+    print(python_response3)
+    
+    # Create an agent with both tools disabled
+    print("\nCreating agent with both tools disabled...")
+    agent_no_tools = TinyCodeAgent(
+        model="gpt-4.1-mini",
+        tools=[search_web],
+        code_tools=[data_processor],
+        user_variables={"test_data": [1, 2, 3, 4, 5]},
+        enable_python_tool=False,  # Disable Python tool
+        enable_shell_tool=False,   # Disable shell tool
+        local_execution=True
+    )
+    
+    # Connect to MCP servers
+    await agent_no_tools.connect_to_server("npx", ["-y", "@openbnb/mcp-server-airbnb", "--ignore-robots-txt"])
+    await agent_no_tools.connect_to_server("npx", ["-y", "@modelcontextprotocol/server-sequential-thinking"])
+    
+    # Check tool status
+    print(f"Python tool enabled: {agent_no_tools.get_python_tool_status()}")
+    print(f"Shell tool enabled: {agent_no_tools.get_shell_tool_status()}")
+    
+    # Test both tools (should not work - both disabled)
+    no_tools_response = await agent_no_tools.run("""
+    Try to use both Python and shell tools to analyze the test_data and list files.
+    """)
+    print("Both Tools Test (should not work - both disabled):")
+    print(no_tools_response)
+    
+    # Enable both tools dynamically
+    print("\nEnabling both tools dynamically...")
+    agent_no_tools.enable_python_tool(True)
+    agent_no_tools.enable_shell_tool(True)
+    print(f"Python tool enabled: {agent_no_tools.get_python_tool_status()}")
+    print(f"Shell tool enabled: {agent_no_tools.get_shell_tool_status()}")
+    
+    # Test both tools again (should work now)
+    both_tools_response = await agent_no_tools.run("""
+    Use both Python and shell tools: first analyze the test_data with data_processor, then list files with ls.
+    """)
+    print("Both Tools Test (should work now - both enabled):")
+    print(both_tools_response)
+    
+    # Clean up
+    await agent_python_only.close()
+    await agent_shell_only.close()
+    await agent_no_tools.close()
+    
     await agent_remote.close()
     await agent_local.close()
 

{tinyagent_py-0.0.17rc1 → tinyagent_py-0.0.19}/tinyagent/mcp_client.py

@@ -1,6 +1,7 @@
 import asyncio
 import json
 import logging
+import traceback
 from typing import Dict, List, Optional, Any, Tuple, Callable
 
 # Keep your MCPClient implementation unchanged
@@ -57,16 +58,17 @@ class MCPClient:
                         logger.debug(f"Callback is a regular function")
                         callback(event_name, self, **kwargs)
             except Exception as e:
-                logger.error(f"Error in callback for {event_name}: {str(e)}")
+                logger.error(f"Error in callback for {event_name}: {str(e)} {traceback.format_exc()}")
 
-    async def connect(self, command: str, args: list[str]):
+    async def connect(self, command: str, args: list[str], env: dict[str, str] = None):
         """
         Launches the MCP server subprocess and initializes the client session.
         :param command: e.g. "python" or "node"
         :param args: list of args to pass, e.g. ["my_server.py"] or ["build/index.js"]
+        :param env: dictionary of environment variables to pass to the subprocess
         """
         # Prepare stdio transport parameters
-        params = StdioServerParameters(command=command, args=args)
+        params = StdioServerParameters(command=command, args=args, env=env)
         # Open the stdio client transport
         self.stdio, self.sock_write = await self.exit_stack.enter_async_context(
             stdio_client(params)
@@ -156,6 +158,28 @@ async def run_example():
         result = await client.call_tool("echo", {"message": "Hello, MCP!"})
         mcp_logger.info(f"Echo result: {result}")
         
+        # Example with environment variables
+        mcp_logger.info("Testing with environment variables...")
+        client_with_env = MCPClient(logger=mcp_logger)
+        
+        # Example: connecting with environment variables
+        env_vars = {
+            "DEBUG": "true",
+            "LOG_LEVEL": "info",
+            "CUSTOM_VAR": "example_value"
+        }
+        
+        try:
+            await client_with_env.connect(
+                "python", 
+                ["-m", "mcp.examples.echo_server"], 
+                env=env_vars
+            )
+            mcp_logger.info("Successfully connected with environment variables")
+            await client_with_env.close()
+        except Exception as e:
+            mcp_logger.warning(f"Environment variable example failed (expected): {e}")
+        
     finally:
         # Clean up
         await client.close()

{tinyagent_py-0.0.17rc1 → tinyagent_py-0.0.19}/tinyagent/tiny_agent.py

@@ -705,11 +705,12 @@ class TinyAgent:
                         self.logger.debug(f"Callback is a regular function")
                         callback(event_name, self, **kwargs)
             except Exception as e:
-                self.logger.error(f"Error in callback for {event_name}: {str(e)}")
+                self.logger.error(f"Error in callback for {event_name}: {str(e)} {traceback.format_exc()}")
     
     async def connect_to_server(self, command: str, args: List[str], 
                                include_tools: Optional[List[str]] = None, 
-                               exclude_tools: Optional[List[str]] = None) -> None:
+                               exclude_tools: Optional[List[str]] = None,
+                               env: Optional[Dict[str, str]] = None) -> None:
         """
         Connect to an MCP server and fetch available tools.
         
@@ -718,6 +719,7 @@ class TinyAgent:
             args: List of arguments for the server
             include_tools: Optional list of tool name patterns to include (if provided, only matching tools will be added)
             exclude_tools: Optional list of tool name patterns to exclude (matching tools will be skipped)
+            env: Optional dictionary of environment variables to pass to the subprocess
         """
         # 1) Create and connect a brand-new client
         client = MCPClient()
@@ -726,7 +728,7 @@ class TinyAgent:
         for callback in self.callbacks:
             client.add_callback(callback)
         
-        await client.connect(command, args)
+        await client.connect(command, args, env)
         self.mcp_clients.append(client)
         
         # 2) List tools on *this* server
@@ -1717,7 +1719,21 @@ async def run_example():
     
     # Connect to MCP servers for additional tools
     try:
+        # Example: connecting without environment variables (existing behavior)
         await agent1.connect_to_server("npx", ["-y", "@openbnb/mcp-server-airbnb", "--ignore-robots-txt"])
+        
+        # Example: connecting with environment variables
+        env_vars = {
+            "DEBUG": "true",
+            "LOG_LEVEL": "info",
+            "API_TIMEOUT": "30"
+        }
+        await agent1.connect_to_server(
+            "npx", 
+            ["-y", "@modelcontextprotocol/server-sequential-thinking"],
+            env=env_vars
+        )
+        agent_logger.info("Successfully connected to MCP servers with environment variables")
     except Exception as e:
         agent_logger.error(f"Failed to connect to MCP servers: {e}")
     
@@ -1747,7 +1763,17 @@ async def run_example():
     
     # Connect to the same MCP server
     try:
-        await agent2.connect_to_server("npx", ["-y", "@openbnb/mcp-server-airbnb", "--ignore-robots-txt"])
+        # Example with environment variables for o4-mini model
+        env_vars = {
+            "NODE_ENV": "production",
+            "CACHE_ENABLED": "false"
+        }
+        await agent2.connect_to_server(
+            "npx", 
+            ["-y", "@openbnb/mcp-server-airbnb", "--ignore-robots-txt"],
+            env=env_vars
+        )
+        agent_logger.info("Successfully connected o4-mini agent with environment variables")
     except Exception as e:
         agent_logger.error(f"Failed to connect to MCP servers: {e}")
     

{tinyagent_py-0.0.17rc1 → tinyagent_py-0.0.19}/tinyagent_py.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: tinyagent-py
-Version: 0.0.17rc1
-Summary: TinyAgent with MCP Client, Code Agent (Thinking, Planning, and Executing in Python), and Extendable Hooks, Tiny but powerful
+Version: 0.0.19
+Summary: TinyAgent with MCP Client, CodeAgent (Thinking, Planning, Interactive Python and Shell with high variaety of sandboxing(seatbelt, Modal, E2B, docker, etc) ), and Extendable Hooks, Tiny but powerful
 Author-email: Mahdi Golchin <golchin@askdev.ai>
 Project-URL: Homepage, https://github.com/askbudi/tinyagent
 Project-URL: Bug Tracker, https://github.com/askbudi/tinyagent/issues