fix: AI field now correctly handles small text files (baserow#5082) (baserow#5150)

* fix: AI field now correctly handles small text files (baserow#5082)

Small uploadable files (<=10KB) are inlined as TextContent instead of
being uploaded via the Files API, fixing an issue where models failed
to associate very small uploaded files with the prompt. Non-UTF-8 files
fall back to BinaryContent. Also fixes visible_name resolution and
notifies the model about skipped files.

Bumps pydantic-ai-slim to 1.77.0 for TextContent support.

* address copilot feedback

Author: silvestrid

backend/pyproject.toml

@@ -95,7 +95,7 @@ dependencies = [
     "genson==1.3.0",
     "pyotp==2.9.0",
     "qrcode==8.2",
-    "pydantic-ai-slim[anthropic,bedrock,google,groq,mistral,openai]==1.66.0",
+    "pydantic-ai-slim[anthropic,bedrock,google,groq,mistral,openai]==1.77.0",
     "opentelemetry-sdk>=1.20.0",
     "netifaces==0.11.0",
     "requests-futures>=1.0.2",

backend/src/baserow/core/generative_ai/generative_ai_model_types.py

@@ -5,6 +5,8 @@
 
 from django.conf import settings
 
+from loguru import logger
+
 from baserow.core.models import Workspace
 
 from .registries import GenerativeAIModelType
@@ -124,23 +126,76 @@ def get_base_url(
         ".xlsx",
         ".xls",
     }
-    _MAX_EMBED_PAYLOAD_BYTES = 45 * 1024 * 1024  # 50 MB minus some headroom
+    # https://developers.openai.com/api/docs/guides/file-inputs
+    _MAX_EMBED_PAYLOAD_BYTES = 45 * 1024 * 1024  # 50 MB minus headroom
     _MAX_EMBEDS_PER_REQUEST = 500
+    # Below this limit, uploadable files are sent inline.
+    _INLINE_UPLOAD_THRESHOLD_BYTES = 10 * 1024  # 10 KB
 
     def _get_max_upload_bytes(self) -> int:
         return (
             min(512, settings.BASEROW_OPENAI_UPLOADED_FILE_SIZE_LIMIT_MB) * 1024 * 1024
         )
 
+    def _can_embed(self, file_size: int, embed_count: int, embed_payload: int) -> bool:
+        return (
+            embed_count < self._MAX_EMBEDS_PER_REQUEST
+            and embed_payload + file_size <= self._MAX_EMBED_PAYLOAD_BYTES
+        )
+
+    @staticmethod
+    def _embed(ai_file: "AIFile", data: bytes) -> None:
+        from pydantic_ai import BinaryContent
+
+        ai_file.content = BinaryContent(
+            data=data,
+            media_type=ai_file.mime_type,
+            identifier=ai_file.original_name,
+        )
+
+    @staticmethod
+    def _inline_text(ai_file: "AIFile", data: bytes) -> bool:
+        """Try to inline file content as TextContent. Returns False if the
+        content is not valid UTF-8."""
+
+        from pydantic_ai import TextContent
+
+        try:
+            text = data.decode("utf-8")
+        except (UnicodeDecodeError, ValueError):
+            return False
+        ai_file.content = TextContent(
+            content=(
+                f"[Content of file '{ai_file.original_name}']\n{text}\n[End of file]"
+            ),
+            metadata={"source": ai_file.original_name},
+        )
+        return True
+
+    def _upload(
+        self,
+        ai_file: "AIFile",
+        data: bytes,
+        workspace: Optional[Workspace] = None,
+        settings_override: Optional[dict[str, Any]] = None,
+    ) -> None:
+        from pydantic_ai import UploadedFile
+
+        file_id = self._upload_file(ai_file.name, data, workspace, settings_override)
+        ai_file.provider_file_id = file_id
+        ai_file.content = UploadedFile(
+            file_id=file_id,
+            provider_name="openai",
+            media_type=ai_file.mime_type,
+            identifier=ai_file.original_name,
+        )
+
     def prepare_files(
         self,
         files: list[AIFile],
         workspace: Optional[Workspace] = None,
         settings_override: Optional[dict[str, Any]] = None,
     ) -> list[AIFile]:
-        from loguru import logger
-        from pydantic_ai import BinaryContent, UploadedFile
-
         embed_payload = 0
         embed_count = 0
         max_upload = self._get_max_upload_bytes()
@@ -151,38 +206,29 @@ def prepare_files(
 
             try:
                 if ext in self._EMBEDDABLE_EXTENSIONS:
-                    if (
-                        embed_count >= self._MAX_EMBEDS_PER_REQUEST
-                        or embed_payload + ai_file.size > self._MAX_EMBED_PAYLOAD_BYTES
-                    ):
+                    if not self._can_embed(ai_file.size, embed_count, embed_payload):
                         continue
-                    data = ai_file.read_content()
-                    ai_file.content = BinaryContent(
-                        data=data,
-                        media_type=ai_file.mime_type,
-                        identifier=ai_file.original_name,
-                    )
+                    self._embed(ai_file, ai_file.read_content())
                     embed_payload += ai_file.size
                     embed_count += 1
 
                 elif ext in self._UPLOADABLE_EXTENSIONS:
                     if ai_file.size > max_upload:
                         continue
                     data = ai_file.read_content()
-                    file_id = self._upload_file(
-                        ai_file.name, data, workspace, settings_override
-                    )
-                    ai_file.provider_file_id = file_id
-                    ai_file.content = UploadedFile(
-                        file_id=file_id,
-                        provider_name="openai",
-                        media_type=ai_file.mime_type,
-                        identifier=ai_file.original_name,
-                    )
-            except Exception:
-                logger.warning(
-                    f"Skipping file {ai_file.name}: failed to read or upload."
-                )
+
+                    if (
+                        ai_file.size <= self._INLINE_UPLOAD_THRESHOLD_BYTES
+                        and self._can_embed(ai_file.size, embed_count, embed_payload)
+                    ):
+                        if not self._inline_text(ai_file, data):
+                            self._embed(ai_file, data)
+                        embed_payload += ai_file.size
+                        embed_count += 1
+                    else:
+                        self._upload(ai_file, data, workspace, settings_override)
+            except Exception as exc:
+                logger.warning(f"Skipping file {ai_file.name}: {exc}")
                 continue
 
         return [f for f in files if f.content is not None]

backend/src/baserow/core/generative_ai/registries.py

@@ -187,7 +187,7 @@ def _build_user_prompt(
         if content:
             prompt = (
                 f"{prompt}\n\n"
-                "The contents of the attached files are included below. "
+                "The following file contents are provided for context. "
                 "Use them to answer the prompt above."
             )
             return [prompt] + content

backend/tests/baserow/core/generative_ai/test_generative_ai_model_types.py

@@ -1,6 +1,24 @@
+from unittest.mock import patch
+
+from pydantic_ai import BinaryContent, TextContent, UploadedFile
+
 from baserow.core.generative_ai.generative_ai_model_types import (
     OpenAIGenerativeAIModelType,
 )
+from baserow_premium.fields.ai_file import AIFile
+
+
+def _make_ai_file(
+    name: str, size: int, mime_type: str = "text/plain", content_bytes: bytes = b""
+) -> AIFile:
+    ai_file = AIFile(
+        name=name,
+        original_name=name,
+        size=size,
+        mime_type=mime_type,
+    )
+    ai_file.read_content = lambda: content_bytes  # type: ignore[assignment]
+    return ai_file
 
 
 def test_openai_supports_files():
@@ -34,3 +52,118 @@ def test_openai_max_upload_size(settings):
 
     settings.BASEROW_OPENAI_UPLOADED_FILE_SIZE_LIMIT_MB = 100
     assert ai_model_type._get_max_upload_bytes() == 100 * 1024 * 1024
+
+
+def test_prepare_files_small_text_file_is_inlined():
+    """A small .txt file should be inlined as TextContent, not uploaded."""
+
+    ai_model_type = OpenAIGenerativeAIModelType()
+    data = b"talk about hamburger"
+    ai_file = _make_ai_file("a.txt", size=len(data), content_bytes=data)
+
+    result = ai_model_type.prepare_files([ai_file])
+
+    assert len(result) == 1
+    assert isinstance(result[0].content, TextContent)
+    assert "talk about hamburger" in result[0].content.content
+    assert "a.txt" in result[0].content.content
+    assert result[0].provider_file_id is None
+
+
+def test_prepare_files_small_binary_uploadable_is_embedded():
+    """A small non-UTF-8 uploadable file falls back to BinaryContent."""
+
+    ai_model_type = OpenAIGenerativeAIModelType()
+    data = b"\x80\x81\x82"
+    ai_file = _make_ai_file(
+        "data.csv", size=len(data), mime_type="text/csv", content_bytes=data
+    )
+
+    result = ai_model_type.prepare_files([ai_file])
+
+    assert len(result) == 1
+    assert isinstance(result[0].content, BinaryContent)
+    assert result[0].provider_file_id is None
+
+
+def test_prepare_files_large_uploadable_is_uploaded():
+    """A .txt file over the inline threshold should be uploaded via the Files API."""
+
+    ai_model_type = OpenAIGenerativeAIModelType()
+    size = ai_model_type._INLINE_UPLOAD_THRESHOLD_BYTES + 1
+    data = b"x" * size
+    ai_file = _make_ai_file("big.txt", size=size, content_bytes=data)
+
+    with patch.object(ai_model_type, "_upload_file", return_value="file-123"):
+        result = ai_model_type.prepare_files([ai_file])
+
+    assert len(result) == 1
+    assert isinstance(result[0].content, UploadedFile)
+    assert result[0].provider_file_id == "file-123"
+
+
+def test_prepare_files_small_uploadable_respects_embed_limits():
+    """When embed payload would exceed the limit, small files fall back to upload."""
+
+    ai_model_type = OpenAIGenerativeAIModelType()
+    data = b"small"
+    ai_file = _make_ai_file("a.txt", size=len(data), content_bytes=data)
+
+    # Pretend we already used up the embed budget by setting the limit to 0.
+    original = ai_model_type._MAX_EMBED_PAYLOAD_BYTES
+    ai_model_type._MAX_EMBED_PAYLOAD_BYTES = 0
+    try:
+        with patch.object(ai_model_type, "_upload_file", return_value="file-456"):
+            result = ai_model_type.prepare_files([ai_file])
+    finally:
+        ai_model_type._MAX_EMBED_PAYLOAD_BYTES = original
+
+    assert len(result) == 1
+    assert isinstance(result[0].content, UploadedFile)
+    assert result[0].provider_file_id == "file-456"
+
+
+def test_prepare_files_image_still_embedded():
+    """Images should still go through the embeddable path as before."""
+
+    ai_model_type = OpenAIGenerativeAIModelType()
+    data = b"\x89PNG\r\n\x1a\n"
+    ai_file = _make_ai_file(
+        "photo.png", size=len(data), mime_type="image/png", content_bytes=data
+    )
+
+    result = ai_model_type.prepare_files([ai_file])
+
+    assert len(result) == 1
+    assert isinstance(result[0].content, BinaryContent)
+    assert result[0].provider_file_id is None
+
+
+def test_prepare_files_unsupported_extension_is_skipped():
+    """Files with unsupported extensions are excluded from the result."""
+
+    ai_model_type = OpenAIGenerativeAIModelType()
+    data = b"some data"
+    ai_file = _make_ai_file(
+        "video.mp4", size=len(data), mime_type="video/mp4", content_bytes=data
+    )
+
+    result = ai_model_type.prepare_files([ai_file])
+
+    assert len(result) == 0
+    assert ai_file.content is None
+
+
+def test_prepare_files_oversized_uploadable_is_skipped(settings):
+    """Uploadable files exceeding the size limit are excluded."""
+
+    ai_model_type = OpenAIGenerativeAIModelType()
+    settings.BASEROW_OPENAI_UPLOADED_FILE_SIZE_LIMIT_MB = 1
+    limit = ai_model_type._get_max_upload_bytes()
+    data = b"x" * (limit + 1)
+    ai_file = _make_ai_file("huge.txt", size=len(data), content_bytes=data)
+
+    result = ai_model_type.prepare_files([ai_file])
+
+    assert len(result) == 0
+    assert ai_file.content is None

backend/uv.lock

@@ -0,0 +1,9 @@
+{
+    "type": "bug",
+    "message": "Fix AI field not correctly handling small text files",
+    "issue_origin": "github",
+    "issue_number": 5082,
+    "domain": "database",
+    "bullet_points": [],
+    "created_at": "2026-04-08"
+}