Ejecutar el código que escribió un LLM

El problema

Qué construimos

• Diez preguntas sobre diez archivos dispersos (CSV, Parquet, JSONL), con las respuestas correctas calculadas aparte.
• El mismo modelo y el mismo esquema para tres variantes: el modelo escribe Synsema (corrido con run_program y un techo de permisos), pandas (corrido con exec, y de nuevo dentro de Docker) o SQL de DuckDB.
• Cuatro pruebas de escape contra cada ejecutor: leer .env, salir a la red, sobrescribir los datos, correr para siempre.

Resultados

El código, lado a lado

def run_py_in_process(code):
    """What most products do: exec in the same process. No limits."""
    out = io.StringIO()
    t0 = time.perf_counter()
    try:
        with contextlib.redirect_stdout(out):
            exec(code, {"__name__": "__main__"})
        return True, out.getvalue(), round((time.perf_counter() - t0) * 1000)
    except Exception as e:
        return False, f"{type(e).__name__}: {e}\n{out.getvalue()}", round((time.perf_counter() - t0) * 1000)

let CEILING be "stdout,file.read=./cases/02-llm-written-analytics/data/*"

-- Fixed preamble: the generated code may ask for more, the ceiling trims it anyway
let PREAMBLE be "require file.read(\"./cases/02-llm-written-analytics/data/*\")\n"

        let run be run_program(PREAMBLE + code, {"ceiling": CEILING, "profile": "native", "timeout": 20})

Por qué Synsema

• run_program arranca un proceso hijo del mismo binario bajo un techo que es la intersección con los permisos del padre. El hijo nunca lo puede superar.
• El código generado hasta pidió la red y .env con require. El techo se los recortó: declarados, pero por encima del techo.
• Sin contenedor, sin imagen, sin daemon. Una respuesta aislada cuesta casi lo mismo que una sin aislar.

Lo que no resuelve

• Los modelos conocen Synsema menos que Python o SQL: 1 intento más en 10 preguntas y más latencia del LLM, porque la guía del lenguaje viaja en cada pedido.
• DuckDB restringido es buena opción cuando alcanza con SQL, pero allowed_directories también habilita escribir y no corta por sí solo las consultas eternas.
• SQL resuelve bien las agregaciones. Para lógica de varios pasos, Python o Synsema se leen más natural.

Compartir