feat: Adding OpenAI Compatible Prompts API

Signed-off-by: Francisco Javier Arceo <farceo@redhat.com>

tests/unit/providers/files/conftest.py

@@ -0,0 +1,62 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the terms described in the LICENSE file in
+# the root directory of this source tree.
+
+import boto3
+import pytest
+from moto import mock_aws
+
+from llama_stack.providers.remote.files.s3 import S3FilesImplConfig, get_adapter_impl
+from llama_stack.providers.utils.sqlstore.sqlstore import SqliteSqlStoreConfig
+
+
+class MockUploadFile:
+    def __init__(self, content: bytes, filename: str, content_type: str = "text/plain"):
+        self.content = content
+        self.filename = filename
+        self.content_type = content_type
+
+    async def read(self):
+        return self.content
+
+
+@pytest.fixture
+def sample_text_file():
+    content = b"Hello, this is a test file for the S3 Files API!"
+    return MockUploadFile(content, "sample_text_file-0.txt")
+
+
+@pytest.fixture
+def sample_text_file2():
+    content = b"Hello, this is a second test file for the S3 Files API!"
+    return MockUploadFile(content, "sample_text_file-1.txt")
+
+
+@pytest.fixture
+def s3_config(tmp_path):
+    db_path = tmp_path / "s3_files_metadata.db"
+
+    return S3FilesImplConfig(
+        bucket_name=f"test-bucket-{tmp_path.name}",
+        region="not-a-region",
+        auto_create_bucket=True,
+        metadata_store=SqliteSqlStoreConfig(db_path=db_path.as_posix()),
+    )
+
+
+@pytest.fixture
+def s3_client():
+    # we use `with mock_aws()` because @mock_aws decorator does not support
+    # being a generator
+    with mock_aws():
+        # must yield or the mock will be reset before it is used
+        yield boto3.client("s3")
+
+
+@pytest.fixture
+async def s3_provider(s3_config, s3_client):  # s3_client provides the moto mock, don't remove it
+    provider = await get_adapter_impl(s3_config, {})
+    yield provider
+    await provider.shutdown()

tests/unit/providers/files/test_s3_files.py

@@ -6,63 +6,11 @@
 
 from unittest.mock import patch
 
-import boto3
 import pytest
 from botocore.exceptions import ClientError
-from moto import mock_aws
 
 from llama_stack.apis.common.errors import ResourceNotFoundError
 from llama_stack.apis.files import OpenAIFilePurpose
-from llama_stack.providers.remote.files.s3 import (
-    S3FilesImplConfig,
-    get_adapter_impl,
-)
-from llama_stack.providers.utils.sqlstore.sqlstore import SqliteSqlStoreConfig
-
-
-class MockUploadFile:
-    def __init__(self, content: bytes, filename: str, content_type: str = "text/plain"):
-        self.content = content
-        self.filename = filename
-        self.content_type = content_type
-
-    async def read(self):
-        return self.content
-
-
-@pytest.fixture
-def s3_config(tmp_path):
-    db_path = tmp_path / "s3_files_metadata.db"
-
-    return S3FilesImplConfig(
-        bucket_name="test-bucket",
-        region="not-a-region",
-        auto_create_bucket=True,
-        metadata_store=SqliteSqlStoreConfig(db_path=db_path.as_posix()),
-    )
-
-
-@pytest.fixture
-def s3_client():
-    """Create a mocked S3 client for testing."""
-    # we use `with mock_aws()` because @mock_aws decorator does not support being a generator
-    with mock_aws():
-        # must yield or the mock will be reset before it is used
-        yield boto3.client("s3")
-
-
-@pytest.fixture
-async def s3_provider(s3_config, s3_client):
-    """Create an S3 files provider with mocked S3 for testing."""
-    provider = await get_adapter_impl(s3_config, {})
-    yield provider
-    await provider.shutdown()
-
-
-@pytest.fixture
-def sample_text_file():
-    content = b"Hello, this is a test file for the S3 Files API!"
-    return MockUploadFile(content, "sample_text_file.txt")
 
 
 class TestS3FilesImpl:
@@ -143,7 +91,7 @@ class TestS3FilesImpl:
             s3_client.head_object(Bucket=s3_config.bucket_name, Key=uploaded.id)
         assert exc_info.value.response["Error"]["Code"] == "404"
 
-    async def test_list_files(self, s3_provider, sample_text_file):
+    async def test_list_files(self, s3_provider, sample_text_file, sample_text_file2):
         """Test listing files after uploading some."""
         sample_text_file.filename = "test_list_files_with_content_file1"
         file1 = await s3_provider.openai_upload_file(
@@ -151,9 +99,9 @@ class TestS3FilesImpl:
             purpose=OpenAIFilePurpose.ASSISTANTS,
         )
 
-        file2_content = MockUploadFile(b"Second file content", "test_list_files_with_content_file2")
+        sample_text_file2.filename = "test_list_files_with_content_file2"
         file2 = await s3_provider.openai_upload_file(
-            file=file2_content,
+            file=sample_text_file2,
             purpose=OpenAIFilePurpose.BATCH,
         )
 
@@ -164,7 +112,7 @@ class TestS3FilesImpl:
         assert file1.id in file_ids
         assert file2.id in file_ids
 
-    async def test_list_files_with_purpose_filter(self, s3_provider, sample_text_file):
+    async def test_list_files_with_purpose_filter(self, s3_provider, sample_text_file, sample_text_file2):
         """Test listing files with purpose filter."""
         sample_text_file.filename = "test_list_files_with_purpose_filter_file1"
         file1 = await s3_provider.openai_upload_file(
@@ -172,9 +120,9 @@ class TestS3FilesImpl:
             purpose=OpenAIFilePurpose.ASSISTANTS,
         )
 
-        file2_content = MockUploadFile(b"Batch file content", "test_list_files_with_purpose_filter_file2")
+        sample_text_file2.filename = "test_list_files_with_purpose_filter_file2"
         await s3_provider.openai_upload_file(
-            file=file2_content,
+            file=sample_text_file2,
             purpose=OpenAIFilePurpose.BATCH,
         )
 
@@ -249,3 +197,104 @@ class TestS3FilesImpl:
 
         files_list = await s3_provider.openai_list_files()
         assert len(files_list.data) == 0, "No file metadata should remain after failed upload"
+
+    @pytest.mark.parametrize("purpose", [p for p in OpenAIFilePurpose if p != OpenAIFilePurpose.BATCH])
+    async def test_default_no_expiration(self, s3_provider, sample_text_file, purpose):
+        """Test that by default files have no expiration."""
+        sample_text_file.filename = "test_default_no_expiration"
+        uploaded = await s3_provider.openai_upload_file(
+            file=sample_text_file,
+            purpose=purpose,
+        )
+        assert uploaded.expires_at is None, "By default files should have no expiration"
+
+    async def test_default_batch_expiration(self, s3_provider, sample_text_file):
+        """Test that by default batch files have an expiration."""
+        sample_text_file.filename = "test_default_batch_an_expiration"
+        uploaded = await s3_provider.openai_upload_file(
+            file=sample_text_file,
+            purpose=OpenAIFilePurpose.BATCH,
+        )
+        assert uploaded.expires_at is not None, "By default batch files should have an expiration"
+        thirty_days_seconds = 30 * 24 * 3600
+        assert uploaded.expires_at == uploaded.created_at + thirty_days_seconds, (
+            "Batch default expiration should be 30 days"
+        )
+
+    async def test_expired_file_is_unavailable(self, s3_provider, sample_text_file, s3_config, s3_client):
+        """Uploaded file that has expired should not be listed or retrievable/deletable."""
+        with patch.object(s3_provider, "_now") as mock_now:  # control time
+            two_hours = 2 * 60 * 60
+
+            mock_now.return_value = 0
+
+            sample_text_file.filename = "test_expired_file"
+            uploaded = await s3_provider.openai_upload_file(
+                file=sample_text_file,
+                purpose=OpenAIFilePurpose.ASSISTANTS,
+                expires_after_anchor="created_at",
+                expires_after_seconds=two_hours,
+            )
+
+            mock_now.return_value = two_hours * 2  # fast forward 4 hours
+
+            listed = await s3_provider.openai_list_files()
+            assert uploaded.id not in [f.id for f in listed.data]
+
+            with pytest.raises(ResourceNotFoundError, match="not found"):
+                await s3_provider.openai_retrieve_file(uploaded.id)
+
+            with pytest.raises(ResourceNotFoundError, match="not found"):
+                await s3_provider.openai_retrieve_file_content(uploaded.id)
+
+            with pytest.raises(ResourceNotFoundError, match="not found"):
+                await s3_provider.openai_delete_file(uploaded.id)
+
+        with pytest.raises(ClientError) as exc_info:
+            s3_client.head_object(Bucket=s3_config.bucket_name, Key=uploaded.id)
+        assert exc_info.value.response["Error"]["Code"] == "404"
+
+        with pytest.raises(ResourceNotFoundError, match="not found"):
+            await s3_provider._get_file(uploaded.id, return_expired=True)
+
+    async def test_unsupported_expires_after_anchor(self, s3_provider, sample_text_file):
+        """Unsupported anchor value should raise ValueError."""
+        sample_text_file.filename = "test_unsupported_expires_after_anchor"
+
+        with pytest.raises(ValueError, match="Input should be 'created_at'"):
+            await s3_provider.openai_upload_file(
+                file=sample_text_file,
+                purpose=OpenAIFilePurpose.ASSISTANTS,
+                expires_after_anchor="now",
+                expires_after_seconds=3600,
+            )
+
+    async def test_nonint_expires_after_seconds(self, s3_provider, sample_text_file):
+        """Non-integer seconds in expires_after should raise ValueError."""
+        sample_text_file.filename = "test_nonint_expires_after_seconds"
+
+        with pytest.raises(ValueError, match="should be a valid integer"):
+            await s3_provider.openai_upload_file(
+                file=sample_text_file,
+                purpose=OpenAIFilePurpose.ASSISTANTS,
+                expires_after_anchor="created_at",
+                expires_after_seconds="many",
+            )
+
+    async def test_expires_after_seconds_out_of_bounds(self, s3_provider, sample_text_file):
+        """Seconds outside allowed range should raise ValueError."""
+        with pytest.raises(ValueError, match="greater than or equal to 3600"):
+            await s3_provider.openai_upload_file(
+                file=sample_text_file,
+                purpose=OpenAIFilePurpose.ASSISTANTS,
+                expires_after_anchor="created_at",
+                expires_after_seconds=3599,
+            )
+
+        with pytest.raises(ValueError, match="less than or equal to 2592000"):
+            await s3_provider.openai_upload_file(
+                file=sample_text_file,
+                purpose=OpenAIFilePurpose.ASSISTANTS,
+                expires_after_anchor="created_at",
+                expires_after_seconds=2592001,
+            )

tests/unit/providers/files/test_s3_files_auth.py

@@ -0,0 +1,89 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the terms described in the LICENSE file in
+# the root directory of this source tree.
+
+from unittest.mock import patch
+
+import pytest
+
+from llama_stack.apis.common.errors import ResourceNotFoundError
+from llama_stack.apis.files import OpenAIFilePurpose
+from llama_stack.core.datatypes import User
+from llama_stack.providers.remote.files.s3.files import S3FilesImpl
+
+
+async def test_listing_hides_other_users_file(s3_provider, sample_text_file):
+    """Listing should not show files uploaded by other users."""
+    user_a = User("user-a", {"roles": ["team-a"]})
+    user_b = User("user-b", {"roles": ["team-b"]})
+
+    with patch("llama_stack.providers.utils.sqlstore.authorized_sqlstore.get_authenticated_user") as mock_get_user:
+        mock_get_user.return_value = user_a
+        uploaded = await s3_provider.openai_upload_file(file=sample_text_file, purpose=OpenAIFilePurpose.ASSISTANTS)
+
+    with patch("llama_stack.providers.utils.sqlstore.authorized_sqlstore.get_authenticated_user") as mock_get_user:
+        mock_get_user.return_value = user_b
+        listed = await s3_provider.openai_list_files()
+        assert all(f.id != uploaded.id for f in listed.data)
+
+
+@pytest.mark.parametrize(
+    "op",
+    [S3FilesImpl.openai_retrieve_file, S3FilesImpl.openai_retrieve_file_content, S3FilesImpl.openai_delete_file],
+    ids=["retrieve", "content", "delete"],
+)
+async def test_cannot_access_other_user_file(s3_provider, sample_text_file, op):
+    """Operations (metadata/content/delete) on another user's file should raise ResourceNotFoundError.
+
+    `op` is an async callable (provider, file_id) -> awaits the requested operation.
+    """
+    user_a = User("user-a", {"roles": ["team-a"]})
+    user_b = User("user-b", {"roles": ["team-b"]})
+
+    with patch("llama_stack.providers.utils.sqlstore.authorized_sqlstore.get_authenticated_user") as mock_get_user:
+        mock_get_user.return_value = user_a
+        uploaded = await s3_provider.openai_upload_file(file=sample_text_file, purpose=OpenAIFilePurpose.ASSISTANTS)
+
+    with patch("llama_stack.providers.utils.sqlstore.authorized_sqlstore.get_authenticated_user") as mock_get_user:
+        mock_get_user.return_value = user_b
+        with pytest.raises(ResourceNotFoundError):
+            await op(s3_provider, uploaded.id)
+
+
+async def test_shared_role_allows_listing(s3_provider, sample_text_file):
+    """Listing should show files uploaded by other users when roles are shared."""
+    user_a = User("user-a", {"roles": ["shared-role"]})
+    user_b = User("user-b", {"roles": ["shared-role"]})
+
+    with patch("llama_stack.providers.utils.sqlstore.authorized_sqlstore.get_authenticated_user") as mock_get_user:
+        mock_get_user.return_value = user_a
+        uploaded = await s3_provider.openai_upload_file(file=sample_text_file, purpose=OpenAIFilePurpose.ASSISTANTS)
+
+    with patch("llama_stack.providers.utils.sqlstore.authorized_sqlstore.get_authenticated_user") as mock_get_user:
+        mock_get_user.return_value = user_b
+        listed = await s3_provider.openai_list_files()
+        assert any(f.id == uploaded.id for f in listed.data)
+
+
+@pytest.mark.parametrize(
+    "op",
+    [S3FilesImpl.openai_retrieve_file, S3FilesImpl.openai_retrieve_file_content, S3FilesImpl.openai_delete_file],
+    ids=["retrieve", "content", "delete"],
+)
+async def test_shared_role_allows_access(s3_provider, sample_text_file, op):
+    """Operations (metadata/content/delete) on another user's file should succeed when users share a role.
+
+    `op` is an async callable (provider, file_id) -> awaits the requested operation.
+    """
+    user_x = User("user-x", {"roles": ["shared-role"]})
+    user_y = User("user-y", {"roles": ["shared-role"]})
+
+    with patch("llama_stack.providers.utils.sqlstore.authorized_sqlstore.get_authenticated_user") as mock_get_user:
+        mock_get_user.return_value = user_x
+        uploaded = await s3_provider.openai_upload_file(file=sample_text_file, purpose=OpenAIFilePurpose.ASSISTANTS)
+
+    with patch("llama_stack.providers.utils.sqlstore.authorized_sqlstore.get_authenticated_user") as mock_get_user:
+        mock_get_user.return_value = user_y
+        await op(s3_provider, uploaded.id)