feat: add R support

Author: martvaha

.cursor/rules/global.mdc

@@ -6,4 +6,5 @@ alwaysApply: true
 - Project uses uv and pyproject.toml for deps management
 - Install deps with uv sync --all-extras
 - After making changes, run `pytest tests -v` or for specific test `pytest tests/{test} -v`
+- Check test logs from `logs/test.log`
 - After making changes, verify that [endpoints.py](mdc:app/api/endpoints.py) still follows [librechat-code-interpreter-openapi.json](mdc:project/librechat-code-interpreter-openapi.json)

.cursor/rules/librechat-endpoints.mdc

@@ -12,7 +12,7 @@ All endpoints are prefixed with `/v1/librechat`
 ### 1. Execute Code
 **Endpoint:** `POST /exec`
 
-**Description:** Execute Python code in a secure sandbox environment
+**Description:** Execute Python and R code in a sandboxed environment
 
 **Request Body:**
 ```json

README.md

@@ -10,15 +10,14 @@ A FastAPI-based code interpreter service that provides code execution and file m
 ## Features
 
 - Easy deployment with single docker compose file
-- Code execution in Docker container sandbox
-- File upload and download
-- Multi-user support
+- Code is executed in a isolated Docker container sandbox, custom images supported
+- Supports file upload and download
+- Supports concurrent code execution
+- Supports Python and R languages (possibility to extend to other languages)
 - RESTful API with OpenAPI documentation
 
-
 ## Usage
 
-
 ### Running the project
 
 Run the project with docker compose using `docker compose -f compose.prod.yml up`

app/api/base.py

@@ -30,7 +30,7 @@
 # Initialize services
 file_manager = FileManager()
 
-SUPPORTED_LANGUAGES = {"py"}  # Only Python is supported for now
+SUPPORTED_LANGUAGES = {"py", "r"}  # Python and R are supported
 MAX_RETRIES = 3
 
 
@@ -48,18 +48,26 @@ async def execute_code(
         CodeExecutionRequest,
         Body(
             openapi_examples={
-                "Hello World": {
-                    "summary": "Hello World",
+                "Hello World (Python)": {
+                    "summary": "Hello World in Python",
                     "value": {"code": "print('Hello, world!')", "lang": "py"},
                 },
-                "Random Number": {
-                    "summary": "Random Number",
+                "Random Number (Python)": {
+                    "summary": "Random Number in Python",
                     "value": {"code": "import random; print(random.randint(1, 100))", "lang": "py"},
                 },
-                "Sleep": {
+                "Sleep (Python)": {
                     "summary": "Sleep",
                     "value": {"code": "import time; time.sleep(10); print('Done sleeping')", "lang": "py"},
                 },
+                "Hello World (R)": {
+                    "summary": "Hello World in R",
+                    "value": {"code": "cat('Hello, world!')", "lang": "r"},
+                },
+                "Random Number (R)": {
+                    "summary": "Random Number in R",
+                    "value": {"code": "cat(sample(1:100, 1))", "lang": "r"},
+                },
             }
         ),
     ],
@@ -69,7 +77,7 @@ async def execute_code(
 
     if request.lang not in SUPPORTED_LANGUAGES:
         raise BadLanguageException(  # noqa: F821
-            message=f"Language '{request.lang}' is not supported. Please use Python ('py')."
+            message=f"Language '{request.lang}' is not supported. Please use Python ('py') or R ('r')."
         )
 
     try:
@@ -90,22 +98,40 @@ async def execute_code(
 
         # Execute code in Docker container
         result = await docker_executor.execute(
-            code=request.code, session_id=session_id, files=files, timeout=settings.SANDBOX_MAX_EXECUTION_TIME
+            code=request.code,
+            session_id=session_id,
+            lang=request.lang,
+            files=files,
+            timeout=settings.SANDBOX_MAX_EXECUTION_TIME,
         )
 
-        # Add a more Python specific error message if the stdout is empty (i.e. the code didn't print anything)
+        # Add a language-specific error message if the stdout is empty
         if not result.get("stdout"):
-            result["stdout"] = "Empty. Make sure to explicitly print the results"
+            if request.lang == "py":
+                result["stdout"] = "Empty. Make sure to explicitly print the results in Python"
+            elif request.lang == "r":
+                result["stdout"] = "Empty. Make sure to use print() or cat() to display results in R"
+            else:
+                result["stdout"] = "Empty. Make sure to explicitly output the results"
 
         # Convert output files to FileRef model
         output_files = [
             FileRef(id=file["id"], name=file["filename"], path=file["filepath"]) for file in result.get("files", [])
         ]
 
+        # Get language-specific version information
+        version_info = ""
+        if request.lang == "py":
+            version_info = f"Python {sys.version.split()[0]}"
+        elif request.lang == "r":
+            version_info = "R (Jupyter R-notebook)"
+        else:
+            version_info = f"Unknown language: {request.lang}"
+
         response = CodeExecutionResponse(
             run=result,
             language=request.lang,
-            version=f"Python {sys.version.split()[0]}",
+            version=version_info,
             session_id=session_id,
             files=output_files,
         )
@@ -121,7 +147,7 @@ async def execute_code(
                         "status": result.get("status"),
                     },
                     "language": request.lang,
-                    "version": f"Python {sys.version.split()[0]}",
+                    "version": version_info,
                     "session_id": session_id,
                     "files": [f.model_dump() for f in output_files],
                 }

app/api/librechat.py

@@ -47,21 +47,21 @@ def create_error_response(status_code: int, message: str) -> JSONResponse:
     "/exec",
     responses={400: {"model": LibreChatError}, 500: {"model": LibreChatError}},
     response_model=LibreChatExecuteResponse,
-    description="Execute Python code in a secure sandbox environment",
-    summary="Execute Python code",
+    description="Execute Python or R code in a sandboxed environment",
+    summary="Execute code",
     response_description="Returns the execution results",
 )
 async def execute_code(request: CodeExecutionRequest) -> LibreChatExecuteResponse:
-    """Execute Python code in a secure sandbox environment.
+    """Execute code in a sandboxed environment.
 
     This endpoint handles code execution requests from LibreChat. It processes the provided
-    Python code in an isolated environment and returns the execution results.
+    code in an isolated environment and returns the execution results.
 
     Args:
         request (CodeExecutionRequest): Request object containing:
-            - code: Python code to execute
+            - code: Code to execute
             - files: Optional list of files needed for execution
-            - language: Programming language (must be 'python')
+            - language: Programming language ('py' for Python or 'r' for R)
             - stdin: Optional standard input for the code
 
     Returns:

app/main.py

@@ -45,7 +45,7 @@ async def lifespan(app: FastAPI):
 # Create FastAPI application
 app = FastAPI(
     title="Code Interpreter API",
-    description="API for executing Python code in a secure environment",
+    description="API for executing Python and R code in a sandboxed environment",
     version="1.0.0",
     lifespan=lifespan,
 )

app/models/base.py

@@ -32,7 +32,7 @@ class CodeExecutionRequest(BaseModel):
     lang: str = Field(
         ...,
         description="The programming language of the code",
-        examples=["py"],
+        examples=["py", "r"],
         pattern="^(c|cpp|d|f90|go|java|js|php|py|rs|ts|r)$",
     )
     args: Optional[List[str]] = Field(None, description="Optional command line arguments to pass to the program")

app/services/docker_executor.py

@@ -1,7 +1,7 @@
 import docker
 from loguru import logger
 from pathlib import Path
-from typing import Dict, List, Optional, Any
+from typing import Dict, List, Optional, Any, Literal
 import time
 from docker.errors import APIError, ImageNotFound
 import asyncio
@@ -35,14 +35,29 @@ class DockerExecutor:
 
     WORK_DIR = "/mnt/data"  # Working directory will be the same as data mount point
     DATA_MOUNT = "/mnt/data"  # Mount point for session data
-    MAX_CONCURRENT_CONTAINERS = 10
+    
+    # Language-specific execution commands
+    LANGUAGE_EXECUTORS = {
+        "py": ["python", "-c"],
+        "r": ["Rscript", "-e"],
+    }
+    
+    # Language-specific messages
+    LANGUAGE_SPECIFIC_MESSAGES = {
+        "py": {
+            "empty_output": "Empty. Make sure to explicitly print() the results in Python"
+        },
+        "r": {
+            "empty_output": "Empty. Make sure to use print() or cat() to display results in R"
+        }
+    }
 
     def __init__(self):
-        self._container_semaphore = asyncio.Semaphore(self.MAX_CONCURRENT_CONTAINERS)
+        self._container_semaphore = asyncio.Semaphore(settings.MAX_CONCURRENT_CONTAINERS)
         self._active_containers: Dict[str, ContainerMetrics] = {}
         self._lock = asyncio.Lock()
         self._docker = None  # Will be initialized in initialize()
-        self._image_pull_locks: Dict[str, asyncio.Lock] = {}  # Locks for image pulling
+        self._image_pull_locks: Dict[str, asyncio.Lock] = {}
 
     async def initialize(self):
         """Initialize the Docker client."""
@@ -55,7 +70,7 @@ async def initialize(self):
                     # Reinitialize if there was an error
                     await self.close()
                     self._docker = aiodocker.Docker()
-            
+
             logger.info("Docker client initialized successfully")
             return self
         except Exception as e:
@@ -155,7 +170,12 @@ def _clean_output(self, raw_output: bytes) -> str:
         return b"".join(output_parts).decode("utf-8").strip()
 
     async def execute(
-        self, code: str, session_id: str, files: Optional[List[Dict[str, Any]]] = None, timeout: int = 30
+        self,
+        code: str,
+        session_id: str,
+        lang: Literal["py", "r"],
+        files: Optional[List[Dict[str, Any]]] = None,
+        timeout: int = 30,
     ) -> Dict[str, Any]:
         """Execute code in a Docker container with file management."""
         container = None
@@ -183,9 +203,9 @@ async def execute(
             async with self._container_semaphore:
                 try:
                     # Ensure the image is available
-                    image_name = settings.PYTHON_CONTAINER_IMAGE
+                    image_name = settings.LANGUAGE_CONTAINERS.get(lang)
                     logger.info(f"Using container image: {image_name}")
-                    
+
                     try:
                         # Check if image exists
                         await self._docker.images.inspect(image_name)
@@ -196,15 +216,18 @@ async def execute(
                             # Get or create a lock for this specific image
                             if image_name not in self._image_pull_locks:
                                 self._image_pull_locks[image_name] = asyncio.Lock()
-                            
+
                             # Acquire the lock for this image to prevent multiple pulls
                             async with self._image_pull_locks[image_name]:
                                 # Check again if the image exists (another request might have pulled it while we were waiting)
                                 try:
                                     await self._docker.images.inspect(image_name)
                                     logger.info(f"Image {image_name} is now available (pulled by another request)")
                                 except Exception as check_again_error:
-                                    if isinstance(check_again_error, aiodocker.exceptions.DockerError) and check_again_error.status == 404:
+                                    if (
+                                        isinstance(check_again_error, aiodocker.exceptions.DockerError)
+                                        and check_again_error.status == 404
+                                    ):
                                         # Pull the image if not available
                                         logger.info(f"Image {image_name} not found, pulling...")
                                         try:
@@ -227,7 +250,7 @@ async def execute(
                             # Re-raise if it's not a 404 error
                             logger.error(f"Error checking for image {image_name}: {str(e)}")
                             raise
-                    
+
                     # Create container config
                     config = {
                         "Image": image_name,
@@ -284,8 +307,16 @@ async def execute(
                         output = await response.read()
                         output_text = self._clean_output(output)
 
-                    # Execute the Python code as jovyan user
-                    exec = await container.exec(cmd=["python", "-c", code], user="jovyan", stdout=True, stderr=True)
+                    # Execute the code with the appropriate interpreter
+                    logger.info(f"Code to execute: {code}")
+                    logger.info(f"Language: {lang}")
+                    
+                    # Get the execution command for the specified language
+                    exec_cmd = self.LANGUAGE_EXECUTORS.get(lang, self.LANGUAGE_EXECUTORS["py"])
+                    logger.info(f"Using execution command: {exec_cmd}")
+                    
+                    # Execute the code with the appropriate interpreter
+                    exec = await container.exec(cmd=[*exec_cmd, code], user="jovyan", stdout=True, stderr=True)
                     # Use raw API call to get output
                     exec_url = f"exec/{exec._id}/start"
                     async with self._docker._query(

app/shared/config.py

@@ -2,7 +2,7 @@
 from pydantic_settings import BaseSettings, SettingsConfigDict
 from functools import lru_cache
 from pathlib import Path
-from typing import Set
+from typing import Dict, Set
 
 
 class Settings(BaseSettings):
@@ -84,7 +84,19 @@ def HOST_FILE_UPLOAD_PATH_ABS(self) -> Path:
     CLEANUP_RUN_INTERVAL: int = 3600  # How often to run the cleanup in seconds
     CLEANUP_FILE_MAX_AGE: int = 86400  # How old files can be before they are deleted in seconds
 
-    PYTHON_CONTAINER_IMAGE: str = "jupyter/scipy-notebook:latest"
+    PY_CONTAINER_IMAGE: str = "jupyter/scipy-notebook:latest"
+    R_CONTAINER_IMAGE: str = "jupyter/r-notebook:latest"
+
+    @property
+    def LANGUAGE_CONTAINERS(self) -> Dict[str, str]:
+        """Map language codes to container images."""
+        return {
+            "py": self.PY_CONTAINER_IMAGE,
+            "r": self.R_CONTAINER_IMAGE,
+        }
+
+    # Docker execution settings
+    MAX_CONCURRENT_CONTAINERS: int = 10  # Maximum number of concurrent Docker containers
 
 
 @lru_cache()

tests/conftest.py

@@ -11,11 +11,12 @@
 from app.main import app
 from loguru import logger
 
-
+# We log to a file to avoid polluting the console with logs
 logger.remove()
 logs_path = Path("logs/test.log")
 logs_path.parent.mkdir(exist_ok=True, parents=True)
-# logs_path.unlink(missing_ok=True)
+# Clear logs from previous runs
+logs_path.unlink(missing_ok=True)
 logger.add(logs_path)