Python Executor tool now can create and output files

app.py

@@ -689,16 +689,98 @@ def Search_DuckDuckGo(  # <-- MCP tool #2 (DDG Search)
 # Code Execution: Python (MCP tool #3)
 # ======================================
 
+import tempfile
+import base64
+from pathlib import Path
+
+def _detect_created_files(working_dir: str, before_files: set) -> list[str]:
+    """
+    Detect files created during code execution.
+    Returns list of newly created file paths.
+    """
+    try:
+        current_files = set()
+        for file_path in Path(working_dir).rglob("*"):
+            if file_path.is_file():
+                current_files.add(str(file_path))
+        
+        new_files = current_files - before_files
+        return list(new_files)
+    except Exception:
+        return []
+
+
+def _generate_file_url(file_path: str) -> dict:
+    """
+    Generate a data URL for small files or file info for larger files.
+    Returns dict with file info and download URL.
+    """
+    try:
+        path = Path(file_path)
+        file_size = path.stat().st_size
+        
+        # For files under 1MB, create data URL
+        if file_size < 1024 * 1024:  # 1MB limit
+            with open(file_path, 'rb') as f:
+                file_data = f.read()
+            
+            # Determine MIME type based on extension
+            mime_types = {
+                '.csv': 'text/csv',
+                '.txt': 'text/plain',
+                '.json': 'application/json',
+                '.png': 'image/png',
+                '.jpg': 'image/jpeg',
+                '.jpeg': 'image/jpeg',
+                '.gif': 'image/gif',
+                '.pdf': 'application/pdf',
+                '.html': 'text/html',
+                '.xml': 'text/xml',
+                '.svg': 'image/svg+xml'
+            }
+            
+            mime_type = mime_types.get(path.suffix.lower(), 'application/octet-stream')
+            encoded_data = base64.b64encode(file_data).decode('utf-8')
+            data_url = f"data:{mime_type};base64,{encoded_data}"
+            
+            return {
+                'name': path.name,
+                'size': file_size,
+                'type': mime_type,
+                'url': data_url,
+                'downloadable': True
+            }
+        else:
+            # For larger files, just return file info
+            return {
+                'name': path.name,
+                'size': file_size,
+                'type': 'file',
+                'url': None,
+                'downloadable': False,
+                'note': f'File too large ({file_size} bytes) for data URL'
+            }
+    except Exception as e:
+        return {
+            'name': Path(file_path).name,
+            'error': str(e),
+            'downloadable': False
+        }
+
+
 def Execute_Python(code: Annotated[str, "Python source code to run; stdout is captured and returned."]) -> str:
     """
-    Execute arbitrary Python code and return captured stdout or an error message.
+    Execute arbitrary Python code and return captured stdout plus any created files.
+    
+    Supports creating downloadable artifacts like CSV files, images, etc. Files created
+    during execution will be detected and made available as data URLs for download.
 
     Args:
         code (str): Python source code to run; stdout is captured and returned.
 
     Returns:
-        str: Combined stdout produced by the code, or the exception text if
-        execution failed.
+        str: Combined stdout produced by the code, plus information about any files
+        created during execution with download links for small files.
     """
     _log_call_start("Execute_Python", code=_truncate_for_log(code or "", 300))
     if code is None:
@@ -706,15 +788,63 @@ def Execute_Python(code: Annotated[str, "Python source code to run; stdout is ca
         _log_call_end("Execute_Python", result)
         return result
 
-    old_stdout = sys.stdout
-    redirected_output = sys.stdout = StringIO()
-    try:
-        exec(code)
-        result = redirected_output.getvalue()
-    except Exception as e:
-        result = str(e)
-    finally:
-        sys.stdout = old_stdout
+    # Create a temporary working directory
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # Change to temp directory and capture existing files
+        original_cwd = os.getcwd()
+        os.chdir(temp_dir)
+        
+        try:
+            # Get initial file list
+            before_files = set()
+            for file_path in Path(temp_dir).rglob("*"):
+                if file_path.is_file():
+                    before_files.add(str(file_path))
+            
+            # Execute code with stdout capture
+            old_stdout = sys.stdout
+            redirected_output = sys.stdout = StringIO()
+            
+            try:
+                exec(code)
+                stdout_result = redirected_output.getvalue()
+            except Exception as e:
+                stdout_result = f"Error: {str(e)}"
+            finally:
+                sys.stdout = old_stdout
+            
+            # Detect any files created during execution
+            created_files = _detect_created_files(temp_dir, before_files)
+            
+            # Build result with stdout and file information
+            result_parts = []
+            
+            if stdout_result.strip():
+                result_parts.append("=== Output ===")
+                result_parts.append(stdout_result.strip())
+            
+            if created_files:
+                result_parts.append("\n=== Created Files ===")
+                for file_path in created_files:
+                    file_info = _generate_file_url(file_path)
+                    
+                    if file_info.get('downloadable', False):
+                        result_parts.append(f"📁 {file_info['name']} ({file_info['size']} bytes)")
+                        result_parts.append(f"   Type: {file_info['type']}")
+                        result_parts.append(f"   Download: {file_info['url']}")
+                    elif file_info.get('error'):
+                        result_parts.append(f"❌ {file_info['name']} (error: {file_info['error']})")
+                    else:
+                        result_parts.append(f"📄 {file_info['name']} ({file_info.get('size', 'unknown')} bytes)")
+                        if 'note' in file_info:
+                            result_parts.append(f"   Note: {file_info['note']}")
+            
+            result = "\n".join(result_parts) if result_parts else "No output or files generated."
+            
+        finally:
+            # Restore original working directory
+            os.chdir(original_cwd)
+    
     _log_call_end("Execute_Python", _truncate_for_log(result))
     return result
 
@@ -1245,14 +1375,15 @@ code_interface = gr.Interface(
     outputs=gr.Textbox(label="Output"),
     title="Python Code Executor",
     description=(
-        "<div style=\"text-align:center\">Execute Python code and see the output.</div>"
+        "<div style=\"text-align:center\">Execute Python code and create downloadable files. Supports CSV exports, image generation, and more.</div>"
     ),
     api_description=(
-        "Execute arbitrary Python code and return captured stdout or an error message. "
+        "Execute arbitrary Python code and return captured stdout plus any created files with download URLs. "
         "Supports any valid Python code including imports, variables, functions, loops, and calculations. "
-        "Examples: 'print(2+2)', 'import math; print(math.sqrt(16))', 'for i in range(3): print(i)'. "
+        "Files created during execution (CSV, PNG, TXT, etc.) are automatically detected and made available as data URLs for download. "
+        "Examples: 'print(2+2)', 'import pandas as pd; df.to_csv(\"data.csv\")', 'import matplotlib.pyplot as plt; plt.savefig(\"plot.png\")'. "
         "Parameters: code (str - Python source code to execute). "
-        "Returns: Combined stdout output or exception text if execution fails."
+        "Returns: Combined stdout output and file information with download links for created artifacts."
     ),
     flagging_mode="never",
 )