Update app.py

app.py

@@ -11,6 +11,8 @@ from contextlib import redirect_stdout
 import textwrap
 import shutil
 import traceback
+import json
+from typing import List, Tuple, Optional, Dict
 
 # Clean up any existing temp files on startup to save space
 try:
@@ -44,6 +46,89 @@ client = openai.OpenAI(
 
 MODEL_NAME = "x-ai/grok-4-fast:free"
 
+class ErrorAnalyzer:
+    """Analyze errors and suggest fixes"""
+    
+    @staticmethod
+    def analyze_error(error_message: str, code: str) -> Dict:
+        """Analyze error and return fix strategy"""
+        error_type = "unknown"
+        suggestions = []
+        packages_to_install = []
+        
+        # Import errors
+        if "No module named" in error_message or "ModuleNotFoundError" in error_message:
+            error_type = "import_error"
+            module_match = re.search(r"No module named ['\"]([^'\"]+)['\"]", error_message)
+            if module_match:
+                module = module_match.group(1)
+                packages_to_install.append(module)
+                suggestions.append(f"Install missing module: {module}")
+        
+        # Permission errors
+        elif "Permission denied" in error_message or "PermissionError" in error_message:
+            error_type = "permission_error"
+            suggestions.append("Use temp directory for file operations")
+            suggestions.append("Avoid system directories")
+        
+        # Memory errors
+        elif "MemoryError" in error_message or "killed" in error_message.lower():
+            error_type = "memory_error"
+            suggestions.append("Reduce data size or use chunks")
+            suggestions.append("Process data in smaller batches")
+        
+        # File not found
+        elif "FileNotFoundError" in error_message or "No such file" in error_message:
+            error_type = "file_error"
+            suggestions.append("Check file paths")
+            suggestions.append("Create directory if needed")
+        
+        # Syntax errors
+        elif "SyntaxError" in error_message:
+            error_type = "syntax_error"
+            suggestions.append("Fix syntax issues")
+            suggestions.append("Check indentation")
+        
+        # Attribute errors
+        elif "AttributeError" in error_message:
+            error_type = "attribute_error"
+            suggestions.append("Check method/attribute names")
+            suggestions.append("Verify object types")
+        
+        # Type errors
+        elif "TypeError" in error_message:
+            error_type = "type_error"
+            suggestions.append("Check data types")
+            suggestions.append("Add type conversions")
+        
+        # Value errors
+        elif "ValueError" in error_message:
+            error_type = "value_error"
+            suggestions.append("Validate input data")
+            suggestions.append("Add error handling")
+        
+        # Network errors
+        elif "URLError" in error_message or "ConnectionError" in error_message:
+            error_type = "network_error"
+            suggestions.append("Check internet connection")
+            suggestions.append("Add retry logic")
+        
+        # Package specific errors
+        if "openpyxl" in error_message or "xlrd" in error_message:
+            packages_to_install.append("openpyxl")
+            suggestions.append("Install Excel support: openpyxl")
+        
+        if "PIL" in error_message or "Pillow" in error_message:
+            packages_to_install.append("Pillow")
+            suggestions.append("Install image processing: Pillow")
+        
+        return {
+            "error_type": error_type,
+            "suggestions": suggestions,
+            "packages": packages_to_install,
+            "original_error": error_message
+        }
+
 def indent_code(code, spaces=4):
     """Indent the code by the specified number of spaces."""
     indented_lines = []
@@ -78,20 +163,20 @@ def detect_required_packages(code):
     
     # Usage patterns that require additional packages
     usage_patterns = {
-        r'\.to_excel': 'openpyxl',  # pandas.to_excel needs openpyxl
-        r'\.read_excel': 'openpyxl',  # pandas.read_excel needs openpyxl
-        r'\.ExcelWriter': 'openpyxl',  # pandas ExcelWriter
-        r'\.to_parquet': 'pyarrow',  # pandas parquet support
+        r'\.to_excel': 'openpyxl',
+        r'\.read_excel': 'openpyxl',
+        r'\.ExcelWriter': 'openpyxl',
+        r'\.to_parquet': 'pyarrow',
         r'\.read_parquet': 'pyarrow',
-        r'\.to_sql': 'sqlalchemy',  # pandas SQL support
+        r'\.to_sql': 'sqlalchemy',
         r'\.read_sql': 'sqlalchemy',
-        r'\.to_feather': 'pyarrow',  # pandas feather format
+        r'\.to_feather': 'pyarrow',
         r'\.read_feather': 'pyarrow',
-        r'\.to_stata': 'statsmodels',  # pandas stata support
+        r'\.to_stata': 'statsmodels',
         r'\.read_stata': 'statsmodels',
-        r'\.to_clipboard': 'pyperclip',  # pandas clipboard
-        r'xlsxwriter': 'xlsxwriter',  # Excel writer engine
-        r'openpyxl': 'openpyxl',  # Excel engine
+        r'\.to_clipboard': 'pyperclip',
+        r'xlsxwriter': 'xlsxwriter',
+        r'openpyxl': 'openpyxl',
     }
     
     # Check for pip install comments
@@ -164,13 +249,11 @@ def detect_required_packages(code):
     for pattern, package in usage_patterns.items():
         if re.search(pattern, code, re.IGNORECASE) and package not in pre_installed:
             required_packages.add(package)
-            print(f"Detected usage pattern '{pattern}' requiring {package}")
     
     # Special case: if pandas is imported and Excel operations detected
     if 'pandas' in code and any(pattern in code for pattern in ['.to_excel', '.read_excel', 'ExcelWriter']):
         if 'openpyxl' not in pre_installed:
             required_packages.add('openpyxl')
-            print("Detected pandas Excel operations, adding openpyxl")
     
     # Remove pre-installed packages
     required_packages = required_packages - pre_installed
@@ -198,7 +281,6 @@ def install_package(package_name):
         spec = importlib.util.find_spec(import_name)
         if spec is None:
             print(f"Installing package: {package_name}")
-            # Remove --no-deps to ensure dependencies are installed
             result = subprocess.run([
                 sys.executable, "-m", "pip", "install", "--quiet", "--no-cache-dir", package_name
             ], capture_output=True, text=True)
@@ -239,67 +321,82 @@ def install_packages_if_needed(packages):
     
     return len(failed_packages) == 0
 
-def generate_code_with_openrouter(instruction, file_paths):
-    """Generate Python code using OpenRouter API."""
+def generate_code_with_openrouter(instruction, file_paths, previous_errors=None, attempt=1):
+    """Generate Python code using OpenRouter API with error awareness."""
+    
+    error_context = ""
+    if previous_errors:
+        error_context = "\n\nPREVIOUS ERRORS TO AVOID:\n"
+        for err in previous_errors:
+            error_context += f"- Error type: {err.get('error_type', 'unknown')}\n"
+            error_context += f"  Details: {err.get('original_error', '')[:200]}\n"
+            error_context += f"  Suggestions: {', '.join(err.get('suggestions', []))}\n"
+    
+    alternative_approaches = ""
+    if attempt > 1:
+        alternative_approaches = f"\n\nThis is attempt {attempt}. Please use a different approach:"
+        if attempt == 2:
+            alternative_approaches += "\n- Use simpler libraries if possible"
+            alternative_approaches += "\n- Add more error handling"
+            alternative_approaches += "\n- Check file paths carefully"
+        elif attempt >= 3:
+            alternative_approaches += "\n- Use only standard library if possible"
+            alternative_approaches += "\n- Implement fallback solutions"
+            alternative_approaches += "\n- Generate mock data if files are problematic"
+    
     prompt_template = textwrap.dedent("""
 You are a Python expert. Instruction: "{instruction}"
 Input files: {file_paths_str} (use file_paths[0] for first file, iterate for multiple; if empty, generate based on instruction alone).
+{error_context}
+{alternative_approaches}
 
 Write a complete Python script that:
 1. Import all necessary libraries at the top.
-2. Add "# pip install package_name" comments after imports for all needed libraries with version.
+2. Add "# pip install package_name" comments after imports for all needed libraries.
 3. Define file_paths = {file_paths_list}
-4. Perform the requested operation.
-5. Save output to a temp directory using tempfile.mkdtemp()
-6. Print "OUTPUT_FILE_PATH: /full/path/to/output" at the end using os.path.abspath()
+4. Add comprehensive error handling with try-except blocks
+5. Create output directory if needed using os.makedirs(exist_ok=True)
+6. Save output to a temp directory using tempfile.mkdtemp()
+7. Print "OUTPUT_FILE_PATH: /full/path/to/output" at the end using os.path.abspath()
+8. If file operations fail, try alternative approaches
 
 Important rules:
 - For pandas Excel operations, always add: # pip install openpyxl
-- For image operations, add relevant pip install comments
-- For ML/AI operations, ensure proper imports with pip comments
-- If no files provided, generate data as per instruction
-- Always use try-except for error handling
+- Always use absolute paths with os.path.abspath()
+- Create directories before saving files
+- Handle common errors (FileNotFoundError, PermissionError, etc.)
+- If a library fails, try alternatives (e.g., csv instead of pandas)
 - No __name__ == '__main__', no functions, just direct code
+- Add detailed error messages
 
-Examples:
-
-For Excel generation:
-import os
-import tempfile
-import pandas as pd
-# pip install openpyxl
-import random
-
-file_paths = {file_paths_list}
-temp_dir = tempfile.mkdtemp()
-output_path = os.path.join(temp_dir, 'data.xlsx')
-
-# Generate data
-data = []
-for i in range(1000):
-    data.append({{'Name': f'Person {{i}}', 'Age': random.randint(20, 60)}})
-
-df = pd.DataFrame(data)
-df.to_excel(output_path, index=False, engine='openpyxl')
-
-print(f"OUTPUT_FILE_PATH: {{os.path.abspath(output_path)}}")
-
-For image processing:
+Example with error handling:
 import os
 import tempfile
-from PIL import Image
-# pip install Pillow
+try:
+    import pandas as pd
+    # pip install pandas openpyxl
+except ImportError:
+    print("Pandas not available, using csv module")
+    import csv
 
 file_paths = {file_paths_list}
-input_path = file_paths[0]
-temp_dir = tempfile.mkdtemp()
-output_path = os.path.join(temp_dir, 'processed.png')
 
-img = Image.open(input_path)
-# Process image...
-img.save(output_path)
-
-print(f"OUTPUT_FILE_PATH: {{os.path.abspath(output_path)}}")
+try:
+    temp_dir = tempfile.mkdtemp()
+    os.makedirs(temp_dir, exist_ok=True)
+    output_path = os.path.join(temp_dir, 'output.xlsx')
+    
+    # Your main logic here with error handling
+    
+    print(f"OUTPUT_FILE_PATH: {{os.path.abspath(output_path)}}")
+except Exception as e:
+    print(f"ERROR: {{e}}")
+    # Fallback solution
+    try:
+        # Alternative approach
+        pass
+    except:
+        print("All approaches failed")
 
 Output ONLY Python code, no markdown.
     """)
@@ -310,18 +407,20 @@ Output ONLY Python code, no markdown.
     prompt = prompt_template.format(
         instruction=instruction or "No instruction provided",
         file_paths_str=file_paths_str,
-        file_paths_list=file_paths_list
+        file_paths_list=file_paths_list,
+        error_context=error_context,
+        alternative_approaches=alternative_approaches
     )
     
     try:
         response = client.chat.completions.create(
             model=MODEL_NAME,
             messages=[
-                {"role": "system", "content": "Output only clean executable Python code with necessary pip install comments."},
+                {"role": "system", "content": "Output only clean executable Python code with comprehensive error handling."},
                 {"role": "user", "content": prompt}
             ],
             max_tokens=4000,
-            temperature=0.1
+            temperature=0.1 if attempt == 1 else 0.3  # Increase creativity on retries
         )
         
         generated_code = response.choices[0].message.content.strip()
@@ -339,130 +438,234 @@ Output ONLY Python code, no markdown.
 print("OUTPUT_TEXT: Code generation failed due to API error")
 sys.exit(0)"""
 
-def process_request(instruction, files):
+def execute_code_with_retry(code: str, max_attempts: int = 3) -> Tuple[bool, str, Optional[str]]:
+    """Execute code with retry logic and error recovery"""
     tf_path = None
+    attempt = 0
+    
+    while attempt < max_attempts:
+        attempt += 1
+        print(f"\n=== Execution attempt {attempt}/{max_attempts} ===")
+        
+        try:
+            # Step 1: Detect and install packages
+            print("Detecting packages...")
+            required_packages = detect_required_packages(code)
+            print("Detected packages:", required_packages)
+            install_packages_if_needed(required_packages)
+            
+            # Step 2: Wrap code
+            indented = indent_code(code)
+            wrapped_code = f"try:\n{indented}\nexcept Exception as e:\n    print(f'ERROR: {{e}}')\n    import traceback; traceback.print_exc()\n    import sys; sys.exit(1)"
+            
+            # Step 3: Compile check
+            print("Compiling code...")
+            try:
+                compile(wrapped_code, '<string>', 'exec')
+                print("Compile OK.")
+            except SyntaxError as se:
+                error_msg = f"Syntax Error: {se}"
+                if attempt < max_attempts:
+                    print(f"Syntax error on attempt {attempt}, will regenerate code")
+                    return False, error_msg, None
+                else:
+                    return False, error_msg, None
+            
+            # Step 4: Create temp file
+            print("Creating temp file...")
+            with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as tf:
+                tf.write(wrapped_code)
+                tf_path = tf.name
+            print(f"Temp file: {tf_path}")
+            
+            # Step 5: Execute
+            print(f"Executing...")
+            result = subprocess.run(
+                [sys.executable, tf_path],
+                capture_output=True,
+                text=True,
+                timeout=60
+            )
+            stdout, stderr = result.stdout, result.stderr
+            rc = result.returncode
+            
+            # Clean up temp file
+            if tf_path and os.path.exists(tf_path):
+                try:
+                    os.unlink(tf_path)
+                except:
+                    pass
+            
+            if rc != 0:
+                error_msg = f"Execution failed (RC {rc}):\nStderr: {stderr}"
+                print(error_msg)
+                
+                # Check if we should retry
+                if attempt < max_attempts:
+                    # Analyze error for next attempt
+                    error_analysis = ErrorAnalyzer.analyze_error(stderr, code)
+                    
+                    # Try to fix by installing missing packages
+                    if error_analysis['packages']:
+                        print(f"Attempting to install missing packages: {error_analysis['packages']}")
+                        for pkg in error_analysis['packages']:
+                            install_package(pkg)
+                    
+                    return False, stderr, None
+                else:
+                    return False, error_msg, None
+            
+            # Extract output
+            output_path_match = re.search(r'OUTPUT_FILE_PATH:\s*(.+)', stdout, re.I)
+            output_text_match = re.search(r'OUTPUT_TEXT:\s*(.+)', stdout, re.I | re.DOTALL)
+            
+            if output_path_match:
+                output_path = output_path_match.group(1).strip()
+                if os.path.exists(output_path):
+                    return True, stdout, output_path
+                else:
+                    error_msg = f"Output path not found: {output_path}"
+                    if attempt < max_attempts:
+                        print(error_msg)
+                        return False, error_msg, None
+                    else:
+                        return False, error_msg, None
+            elif output_text_match:
+                return True, output_text_match.group(1).strip(), None
+            else:
+                if stdout.strip():
+                    return True, stdout, None
+                else:
+                    return False, "No output generated", None
+                    
+        except subprocess.TimeoutExpired:
+            error_msg = "Timeout: Code execution took too long"
+            if attempt < max_attempts:
+                print(error_msg)
+                return False, error_msg, None
+            else:
+                return False, error_msg, None
+        except Exception as e:
+            error_msg = f"Execution error: {str(e)}"
+            if attempt < max_attempts:
+                print(error_msg)
+                return False, error_msg, None
+            else:
+                return False, error_msg, None
+    
+    return False, "Max attempts reached", None
+
+def process_request(instruction, files):
+    """Main processing function with self-correction"""
     try:
         if not instruction.strip():
             return "لطفاً دستور را وارد کنید. (فایل‌ها اختیاری هستند)", None
         
         file_paths = [f.name for f in files] if files else []
         
-        # Step 1: Generate code
-        print("Generating code...")
-        generated_code = generate_code_with_openrouter(instruction, file_paths)
+        # Track errors for learning
+        previous_errors = []
+        generated_codes = []
         
-        if len(generated_code) < 20:
-            return f"کد ضعیف تولید شد: {generated_code}", None
-        
-        print("Generated code preview:", generated_code[:200])
-        
-        # Step 2: Detect and install packages
-        print("Detecting packages...")
-        required_packages = detect_required_packages(generated_code)
-        print("Detected packages:", required_packages)
-        all_installed = install_packages_if_needed(required_packages)
-        
-        if not all_installed:
-            print("Warning: Some packages failed to install, but continuing...")
-        
-        # Step 3: Wrap code
-        indented = indent_code(generated_code)
-        wrapped_code = f"try:\n{indented}\nexcept Exception as e:\n    print(f'ERROR: {{e}}')\n    import traceback; traceback.print_exc()\n    import sys; sys.exit(1)"
-        
-        # Step 4: Compile check
-        print("Compiling code...")
-        try:
-            compile(wrapped_code, '<string>', 'exec')
-            print("Compile OK.")
-        except SyntaxError as se:
-            error_msg = f"Syntax Error: {se}\nCode preview: {wrapped_code[:500]}...\nFull traceback: {traceback.format_exc()}"
-            return error_msg, None
-        
-        # Step 5: Temp file
-        print("Creating temp file...")
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as tf:
-            tf.write(wrapped_code)
-            tf_path = tf.name
-        print(f"Temp file: {tf_path}")
-        
-        # Step 6: Execute with retries
-        max_retries = 2
-        for retry in range(max_retries + 1):
-            print(f"Executing (attempt {retry + 1})...")
-            try:
-                result = subprocess.run(
-                    [sys.executable, tf_path],
-                    capture_output=True,
-                    text=True,
-                    timeout=60  # Increased timeout
-                )
-                stdout, stderr = result.stdout, result.stderr
-                rc = result.returncode
-
-                if rc != 0:
-                    # Check for ImportError and retry
-                    import_error_match = re.search(r"No module named ['\"]([^'\"]+)['\"]", stderr)
-                    if import_error_match and retry < max_retries:
-                        missing_module = import_error_match.group(1)
-                        print(f"Detected missing module: {missing_module}")
-                        if install_package(missing_module):
-                            print(f"Installed {missing_module}, retrying...")
-                            continue
-                    
-                    error_msg = f"Execution failed (RC {rc} after {retry + 1} tries):\nStdout: {stdout}\nStderr: {stderr}\nCode preview: {wrapped_code[:500]}..."
-                    return error_msg, None
-
-                # Extract output (file or text)
-                output_path_match = re.search(r'OUTPUT_FILE_PATH:\s*(.+)', stdout, re.I)
-                output_text_match = re.search(r'OUTPUT_TEXT:\s*(.+)', stdout, re.I | re.DOTALL)
+        # Main retry loop
+        for attempt in range(1, 4):  # 3 attempts
+            print(f"\n{'='*50}")
+            print(f"MAIN ATTEMPT {attempt}/3")
+            print(f"{'='*50}")
+            
+            # Generate code
+            print("Generating code...")
+            generated_code = generate_code_with_openrouter(
+                instruction, 
+                file_paths, 
+                previous_errors=previous_errors if attempt > 1 else None,
+                attempt=attempt
+            )
+            
+            if len(generated_code) < 20:
+                return f"کد ضعیف تولید شد: {generated_code}", None
+            
+            generated_codes.append(generated_code)
+            print(f"Generated code preview: {generated_code[:200]}...")
+            
+            # Try to execute
+            success, output, file_path = execute_code_with_retry(generated_code, max_attempts=2)
+            
+            if success:
+                # Success!
+                result_text = f"✅ Success on attempt {attempt}!\n\n"
+                result_text += f"Generated Code:\n```python\n{generated_code}\n```\n\n"
+                result_text += f"Output:\n{output}"
+                return result_text, file_path
+            else:
+                # Analyze error
+                print(f"\n❌ Attempt {attempt} failed")
+                error_analysis = ErrorAnalyzer.analyze_error(output, generated_code)
+                previous_errors.append(error_analysis)
                 
-                if output_path_match:
-                    output_path = output_path_match.group(1).strip()
-                    if os.path.exists(output_path):
-                        return f"Success!\nGenerated Code:\n{generated_code}\n\nStdout:\n{stdout}", output_path
-                    else:
-                        return f"Output path not found: {output_path}\n{stdout}", None
-                elif output_text_match:
-                    return f"Success (text output)!\nGenerated Code:\n{generated_code}\n\nOutput:\n{output_text_match.group(1).strip()}", None
-                else:
-                    # Check if there's any output at all
-                    if stdout.strip():
-                        return f"Execution completed but no OUTPUT marker found:\n{stdout}\n\nGenerated code:\n{generated_code}", None
-                    else:
-                        return f"No output generated:\nStderr: {stderr}\nCode: {wrapped_code}", None
-
-            except subprocess.TimeoutExpired:
-                return f"Timeout (60s): Code execution took too long.", None
-            except Exception as sub_error:
-                if retry < max_retries:
-                    print(f"Subprocess error on retry {retry + 1}: {sub_error}")
-                    continue
-                error_msg = f"Subprocess error after {max_retries + 1} tries: {sub_error}\n{traceback.format_exc()}"
-                return error_msg, None
+                print(f"Error type: {error_analysis['error_type']}")
+                print(f"Suggestions: {', '.join(error_analysis['suggestions'])}")
                 
+                # If this was the last attempt
+                if attempt == 3:
+                    error_report = f"❌ Failed after {attempt} attempts.\n\n"
+                    error_report += "Error History:\n"
+                    for i, err in enumerate(previous_errors, 1):
+                        error_report += f"\nAttempt {i}:\n"
+                        error_report += f"- Error type: {err['error_type']}\n"
+                        error_report += f"- Details: {err['original_error'][:200]}...\n"
+                    
+                    error_report += f"\n\nLast generated code:\n```python\n{generated_code}\n```"
+                    return error_report, None
+        
+        return "Unexpected end of retry loop", None
+        
     except Exception as e:
         error_msg = f"General error: {type(e).__name__}: {e}\nFull traceback: {traceback.format_exc()}"
         print(error_msg)
         return error_msg, None
-    finally:
-        if tf_path and os.path.exists(tf_path):
-            try:
-                os.unlink(tf_path)
-                print("Cleaned up temp file.")
-            except:
-                pass
 
 # Gradio Interface
-with gr.Blocks(title="AI File Processor") as demo:
-    gr.Markdown("# AI File Processor\nGive an instruction (e.g., 'generate sample data to Excel' or 'remove background from image'). Files are optional.")
+with gr.Blocks(title="AI File Processor - Self Correcting") as demo:
+    gr.Markdown("""
+    # 🤖 AI File Processor - Self Correcting Edition
+    
+    این سیستم می‌تواند:
+    - کد Python تولید کند
+    - خطاها را تشخیص و تحلیل کند
+    - به طور خودکار مشکلات را برطرف کند
+    - تا 3 بار با رویکردهای مختلف تلاش کند
+    
+    **مثال دستورات:**
+    - "یک فایل اکسل با 1000 نام و شماره تلفن ایرانی بساز"
+    - "پس‌زمینه این تصویر را حذف کن"
+    - "این فایل CSV را به JSON تبدیل کن"
+    """)
+    
+    with gr.Row():
+        instruction = gr.Textbox(
+            label="دستور", 
+            lines=2, 
+            placeholder="مثال: یک نمودار دایره‌ای از داده‌های فروش بکش",
+            rtl=True
+        )
+        files = gr.File(file_count="multiple", label="فایل‌ها (اختیاری)")
+    
+    btn = gr.Button("🚀 اجرا", variant="primary")
     
     with gr.Row():
-        instruction = gr.Textbox(label="Instruction", lines=2, placeholder="e.g., Generate 1000 Iranian names and mobiles to Excel")
-        files = gr.File(file_count="multiple", label="Files (optional)")
+        output = gr.Textbox(label="نتیجه", lines=15)
+        file_out = gr.File(label="فایل خروجی (در صورت تولید)")
     
-    btn = gr.Button("Process")
-    output = gr.Textbox(label="Result", lines=10)
-    file_out = gr.File(label="Output File (if generated)")
+    # Examples
+    gr.Examples(
+        examples=[
+            ["یک فایل اکسل با 100 محصول فروشگاهی شامل نام، قیمت و موجودی بساز", []],
+            ["یک نمودار میله‌ای از داده‌های تصادفی رسم کن", []],
+            ["یک تصویر 500x500 پیکسل با رنگ‌های تصادفی بساز", []],
+        ],
+        inputs=[instruction, files],
+    )
     
     btn.click(fn=process_request, inputs=[instruction, files], outputs=[output, file_out])