Patched code sample

import ast

# A list of modules that are considered dangerous and should not be imported.
DISALLOWED_MODULES = {
    'os',
    'sys',
    'subprocess',
    'shutil',
    'socket',
    'requests',
    'urllib',
    'eval',
    'exec',
    'importlib'
}

# A whitelist of safe built-in functions for the execution environment.
SAFE_BUILTINS = {
    'print', 'len', 'str', 'int', 'float', 'list', 'dict', 'set', 'tuple',
    'range', 'abs', 'min', 'max', 'sum', 'sorted', 'zip', 'enumerate',
    'round', 'pow', 'all', 'any'
}

class ImportValidator(ast.NodeVisitor):
    """
    An AST visitor that checks for disallowed imports.
    """
    def visit_Import(self, node):
        for alias in node.names:
            if alias.name in DISALLOWED_MODULES:
                raise PermissionError(f"Import of disallowed module '{alias.name}' is forbidden.")
        self.generic_visit(node)

    def visit_ImportFrom(self, node):
        if node.module in DISALLOWED_MODULES:
            raise PermissionError(f"Import from disallowed module '{node.module}' is forbidden.")
        self.generic_visit(node)

class CodeAgent:
    """
    A fixed version of the agent that validates and sandboxes code execution.
    """
    def _execute_python(self, code: str):
        """
        Executes LLM-generated Python code after validation and within a sandbox.
        """
        try:
            # 1. AST Validation: Parse the code into an Abstract Syntax Tree.
            # This will fail with a SyntaxError if the code is not valid Python.
            tree = ast.parse(code)

            # 2. Import Restriction: Use a visitor to traverse the AST and
            # check for forbidden import statements.
            validator = ImportValidator()
            validator.visit(tree)

            # 3. Sandbox Enforcement: Execute the code with a restricted environment.
            # Only whitelisted built-ins are available, and no other globals.
            restricted_globals = {
                "__builtins__": {k: v for k, v in __builtins__.__dict__.items() if k in SAFE_BUILTINS}
            }
            
            print("--- Executing sandboxed code ---")
            exec(code, restricted_globals, {})
            print("--- Execution finished successfully ---")

        except SyntaxError as e:
            print(f"Execution failed: Invalid Python syntax. {e}")
        except PermissionError as e:
            print(f"Execution failed: Security policy violation. {e}")
        except Exception as e:
            print(f"Execution failed: An unexpected error occurred. {e}")