feat: Add original filename support in file handling

- Introduced `original_filename` field in the FileInfo model to store pre-sanitization filenames.
- Updated file upload and batch upload functions to include the original filename in metadata.
- Enhanced file listing to return the original filename if available, improving metadata accuracy.
- Adjusted file service methods to handle the new original filename parameter for better file management.

Author: usnavy13

src/api/files.py

@@ -142,6 +142,7 @@ async def upload_file(
                 content=content,
                 content_type=file.content_type,
                 is_agent_file=is_agent_file,
+                original_filename=file.filename,
             )
 
             uploaded_files.append(
@@ -295,6 +296,7 @@ async def upload_files_batch(
                 content_type=upload.content_type,
                 is_agent_file=is_agent_file,
                 is_read_only=is_read_only,
+                original_filename=original_filename,
             )
 
             results.append(
@@ -413,7 +415,8 @@ async def list_files(
                         "etag": f'"{file_info.file_id}"',
                         "metadata": {
                             "content-type": file_info.content_type,
-                            "original-filename": file_info.filename,
+                            "original-filename": file_info.original_filename
+                            or file_info.filename,
                         },
                         "contentType": file_info.content_type,
                     }

src/models/files.py

@@ -40,6 +40,7 @@ class FileInfo(BaseModel):
     content_type: str
     created_at: datetime
     path: str = Field(..., description="File path in the session")
+    original_filename: Optional[str] = None
 
     class Config:
         json_encoders = {datetime: lambda v: v.isoformat()}

src/services/execution/output.py

@@ -215,11 +215,12 @@ def format_error_message(cls, exit_code: int, stderr: str) -> str:
 
     @classmethod
     def sanitize_filename(cls, input_name: str) -> str:
-        """Sanitize filename to match LibreChat's sanitization logic.
+        """Sanitize filename while preserving Unicode letters and digits.
 
-        Replaces all non-alphanumeric characters (except '.' and '-') with
-        underscores. This ensures filenames on disk match what LibreChat
-        reports in the system prompt.
+        Keeps word characters (\\w — letters, digits, underscore in all
+        scripts), dots, and dashes.  Replaces everything else (path
+        separators, control chars, shell metacharacters, quotes, etc.)
+        with underscores.
 
         Args:
             input_name: Original filename (may include path components)
@@ -234,8 +235,9 @@ def sanitize_filename(cls, input_name: str) -> str:
             # Remove any directory components (path traversal prevention)
             name = os.path.basename(input_name)
 
-            # Replace any non-alphanumeric characters except for '.' and '-'
-            name = re.sub(r"[^a-zA-Z0-9.-]", "_", name)
+            # Replace dangerous characters while preserving Unicode letters/digits.
+            # \w matches [a-zA-Z0-9_] plus all Unicode letters and digits.
+            name = re.sub(r"[^\w.\-]", "_", name)
 
             # Ensure the name doesn't start with a dot (hidden file in Unix)
             if name.startswith(".") or name == "":

src/services/file.py

@@ -360,6 +360,7 @@ async def get_file_info(self, session_id: str, file_id: str) -> Optional[FileInf
             content_type=metadata["content_type"],
             created_at=metadata["created_at"],
             path=metadata["path"],
+            original_filename=metadata.get("original_filename"),
         )
 
     async def list_files(self, session_id: str) -> List[FileInfo]:
@@ -419,6 +420,9 @@ async def link_file_into_session(
             "source_session_id": source_session_id,
             "source_file_id": source_file_id,
             "is_read_only": "1",
+            "original_filename": source_metadata.get(
+                "original_filename", source_metadata["filename"]
+            ),
         }
 
         await self._store_file_metadata(target_session_id, linked_file_id, metadata)
@@ -444,6 +448,7 @@ async def link_file_into_session(
             content_type=metadata["content_type"],
             created_at=datetime.fromisoformat(metadata["created_at"]),
             path=metadata["path"],
+            original_filename=metadata.get("original_filename"),
         )
 
     async def download_file(self, session_id: str, file_id: str) -> Optional[str]:
@@ -771,16 +776,18 @@ async def store_uploaded_file(
         content_type: Optional[str] = None,
         is_agent_file: bool = False,
         is_read_only: bool = False,
+        original_filename: Optional[str] = None,
     ) -> str:
         """Store an uploaded file directly.
 
         Args:
             session_id: Session identifier
-            filename: Original filename
+            filename: Sanitized filename used for storage and sandbox mounting
             content: File content as bytes
             content_type: MIME type of the file
             is_agent_file: If True, marks the file as read-only (agent-assigned)
             is_read_only: If True, mounted file should be chmod 444 in sandbox
+            original_filename: Pre-sanitization filename for metadata recovery
 
         Returns:
             The generated file_id
@@ -825,6 +832,7 @@ async def store_uploaded_file(
                     "1" if is_agent_file else "0"
                 ),  # Read-only if agent file
                 "is_read_only": "1" if (is_read_only or is_agent_file) else "0",
+                "original_filename": original_filename or filename,
             }
 
             await self._store_file_metadata(session_id, file_id, metadata)

tests/unit/test_output_processor.py

@@ -62,10 +62,50 @@ def test_absolute_path_stripped(self):
         result = OutputProcessor.sanitize_filename("/absolute/path/file.txt")
         assert result == "file.txt"
 
-    def test_unicode_characters_replaced(self):
-        """Test that non-ASCII characters are replaced."""
+    def test_unicode_characters_preserved(self):
+        """Test that Unicode letters are preserved."""
         result = OutputProcessor.sanitize_filename("résumé.docx")
-        assert result == "r_sum_.docx"
+        assert result == "résumé.docx"
+
+    def test_cjk_characters_preserved(self):
+        """Test that CJK characters are preserved."""
+        result = OutputProcessor.sanitize_filename("日本語レポート.xlsx")
+        assert result == "日本語レポート.xlsx"
+
+    def test_cyrillic_characters_preserved(self):
+        """Test that Cyrillic characters are preserved."""
+        result = OutputProcessor.sanitize_filename("файл.txt")
+        assert result == "файл.txt"
+
+    def test_korean_characters_preserved(self):
+        """Test that Korean characters are preserved."""
+        result = OutputProcessor.sanitize_filename("보고서.xlsx")
+        assert result == "보고서.xlsx"
+
+    def test_arabic_characters_preserved(self):
+        """Test that Arabic characters are preserved."""
+        result = OutputProcessor.sanitize_filename("تقرير.pdf")
+        assert result == "تقرير.pdf"
+
+    def test_mixed_unicode_and_ascii(self):
+        """Test mixed Unicode and ASCII filename."""
+        result = OutputProcessor.sanitize_filename("report_2024_報告.pdf")
+        assert result == "report_2024_報告.pdf"
+
+    def test_unicode_with_spaces_sanitized(self):
+        """Test that spaces in Unicode filenames are still replaced."""
+        result = OutputProcessor.sanitize_filename("日本語 レポート.xlsx")
+        assert result == "日本語_レポート.xlsx"
+
+    def test_dangerous_chars_still_blocked(self):
+        """Test that shell metacharacters are still replaced."""
+        result = OutputProcessor.sanitize_filename("file<>|&;$().txt")
+        assert result == "file________.txt"
+
+    def test_underscores_preserved(self):
+        """Test that underscores are preserved."""
+        result = OutputProcessor.sanitize_filename("my_file_name.txt")
+        assert result == "my_file_name.txt"
 
     def test_brackets_replaced(self):
         """Test that brackets are replaced with underscores."""
@@ -169,6 +209,13 @@ def test_librechat_skill_bundle_pattern(self):
             == "skills/foo/SKILL.md"
         )
 
+    def test_unicode_segments_preserved(self):
+        """Test that Unicode directory and file names are preserved."""
+        assert (
+            OutputProcessor.sanitize_relative_path("報告/2024年/レポート.xlsx")
+            == "報告/2024年/レポート.xlsx"
+        )
+
     def test_sanitize_filename_unchanged_for_basename_callers(self):
         """Regression: sanitize_filename still flattens (legacy upload behavior)."""
         # Existing single-call sites rely on this.