New assistants api (#3097)

backend/tests/integration/openai_assistants_api/conftest.py

@@ -0,0 +1,55 @@
+from typing import Optional
+from uuid import UUID
+
+import pytest
+import requests
+
+from tests.integration.common_utils.constants import API_SERVER_URL
+from tests.integration.common_utils.constants import GENERAL_HEADERS
+from tests.integration.common_utils.managers.llm_provider import LLMProviderManager
+from tests.integration.common_utils.managers.user import build_email
+from tests.integration.common_utils.managers.user import DEFAULT_PASSWORD
+from tests.integration.common_utils.managers.user import UserManager
+from tests.integration.common_utils.test_models import DATestLLMProvider
+from tests.integration.common_utils.test_models import DATestUser
+
+BASE_URL = f"{API_SERVER_URL}/openai-assistants"
+
+
+@pytest.fixture
+def admin_user() -> DATestUser | None:
+    try:
+        return UserManager.create("admin_user")
+    except Exception:
+        pass
+
+    try:
+        return UserManager.login_as_user(
+            DATestUser(
+                id="",
+                email=build_email("admin_user"),
+                password=DEFAULT_PASSWORD,
+                headers=GENERAL_HEADERS,
+            )
+        )
+    except Exception:
+        pass
+
+    return None
+
+
+@pytest.fixture
+def llm_provider(admin_user: DATestUser | None) -> DATestLLMProvider:
+    return LLMProviderManager.create(user_performing_action=admin_user)
+
+
+@pytest.fixture
+def thread_id(admin_user: Optional[DATestUser]) -> UUID:
+    # Create a thread to use in the tests
+    response = requests.post(
+        f"{BASE_URL}/threads",  # Updated endpoint path
+        json={},
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 200
+    return UUID(response.json()["id"])

backend/tests/integration/openai_assistants_api/test_assistants.py

@@ -0,0 +1,151 @@
+import requests
+
+from tests.integration.common_utils.constants import API_SERVER_URL
+from tests.integration.common_utils.constants import GENERAL_HEADERS
+from tests.integration.common_utils.test_models import DATestUser
+
+ASSISTANTS_URL = f"{API_SERVER_URL}/openai-assistants/assistants"
+
+
+def test_create_assistant(admin_user: DATestUser | None) -> None:
+    response = requests.post(
+        ASSISTANTS_URL,
+        json={
+            "model": "gpt-3.5-turbo",
+            "name": "Test Assistant",
+            "description": "A test assistant",
+            "instructions": "You are a helpful assistant.",
+        },
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["name"] == "Test Assistant"
+    assert data["description"] == "A test assistant"
+    assert data["model"] == "gpt-3.5-turbo"
+    assert data["instructions"] == "You are a helpful assistant."
+
+
+def test_retrieve_assistant(admin_user: DATestUser | None) -> None:
+    # First, create an assistant
+    create_response = requests.post(
+        ASSISTANTS_URL,
+        json={"model": "gpt-3.5-turbo", "name": "Retrieve Test"},
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert create_response.status_code == 200
+    assistant_id = create_response.json()["id"]
+
+    # Now, retrieve the assistant
+    response = requests.get(
+        f"{ASSISTANTS_URL}/{assistant_id}",
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["id"] == assistant_id
+    assert data["name"] == "Retrieve Test"
+
+
+def test_modify_assistant(admin_user: DATestUser | None) -> None:
+    # First, create an assistant
+    create_response = requests.post(
+        ASSISTANTS_URL,
+        json={"model": "gpt-3.5-turbo", "name": "Modify Test"},
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert create_response.status_code == 200
+    assistant_id = create_response.json()["id"]
+
+    # Now, modify the assistant
+    response = requests.post(
+        f"{ASSISTANTS_URL}/{assistant_id}",
+        json={"name": "Modified Assistant", "instructions": "New instructions"},
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["id"] == assistant_id
+    assert data["name"] == "Modified Assistant"
+    assert data["instructions"] == "New instructions"
+
+
+def test_delete_assistant(admin_user: DATestUser | None) -> None:
+    # First, create an assistant
+    create_response = requests.post(
+        ASSISTANTS_URL,
+        json={"model": "gpt-3.5-turbo", "name": "Delete Test"},
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert create_response.status_code == 200
+    assistant_id = create_response.json()["id"]
+
+    # Now, delete the assistant
+    response = requests.delete(
+        f"{ASSISTANTS_URL}/{assistant_id}",
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["id"] == assistant_id
+    assert data["deleted"] is True
+
+
+def test_list_assistants(admin_user: DATestUser | None) -> None:
+    # Create multiple assistants
+    for i in range(3):
+        requests.post(
+            ASSISTANTS_URL,
+            json={"model": "gpt-3.5-turbo", "name": f"List Test {i}"},
+            headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+        )
+
+    # Now, list the assistants
+    response = requests.get(
+        ASSISTANTS_URL,
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["object"] == "list"
+    assert len(data["data"]) >= 3  # At least the 3 we just created
+    assert all(assistant["object"] == "assistant" for assistant in data["data"])
+
+
+def test_list_assistants_pagination(admin_user: DATestUser | None) -> None:
+    # Create 5 assistants
+    for i in range(5):
+        requests.post(
+            ASSISTANTS_URL,
+            json={"model": "gpt-3.5-turbo", "name": f"Pagination Test {i}"},
+            headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+        )
+
+    # List assistants with limit
+    response = requests.get(
+        f"{ASSISTANTS_URL}?limit=2",
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert len(data["data"]) == 2
+    assert data["has_more"] is True
+
+    # Get next page
+    before = data["last_id"]
+    response = requests.get(
+        f"{ASSISTANTS_URL}?limit=2&before={before}",
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert len(data["data"]) == 2
+
+
+def test_assistant_not_found(admin_user: DATestUser | None) -> None:
+    non_existent_id = -99
+    response = requests.get(
+        f"{ASSISTANTS_URL}/{non_existent_id}",
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 404

backend/tests/integration/openai_assistants_api/test_messages.py

@@ -0,0 +1,133 @@
+import uuid
+from typing import Optional
+
+import pytest
+import requests
+
+from tests.integration.common_utils.constants import API_SERVER_URL
+from tests.integration.common_utils.constants import GENERAL_HEADERS
+from tests.integration.common_utils.test_models import DATestUser
+
+BASE_URL = f"{API_SERVER_URL}/openai-assistants/threads"
+
+
+@pytest.fixture
+def thread_id(admin_user: Optional[DATestUser]) -> str:
+    response = requests.post(
+        BASE_URL,
+        json={},
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 200
+    return response.json()["id"]
+
+
+def test_create_message(admin_user: Optional[DATestUser], thread_id: str) -> None:
+    response = requests.post(
+        f"{BASE_URL}/{thread_id}/messages",  # URL structure matches API
+        json={
+            "role": "user",
+            "content": "Hello, world!",
+            "file_ids": [],
+            "metadata": {"key": "value"},
+        },
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 200
+
+    response_json = response.json()
+    assert "id" in response_json
+    assert response_json["thread_id"] == thread_id
+    assert response_json["role"] == "user"
+    assert response_json["content"] == [{"type": "text", "text": "Hello, world!"}]
+    assert response_json["metadata"] == {"key": "value"}
+
+
+def test_list_messages(admin_user: Optional[DATestUser], thread_id: str) -> None:
+    # Create a message first
+    requests.post(
+        f"{BASE_URL}/{thread_id}/messages",
+        json={"role": "user", "content": "Test message"},
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+
+    # Now, list the messages
+    response = requests.get(
+        f"{BASE_URL}/{thread_id}/messages",
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 200
+
+    response_json = response.json()
+    assert response_json["object"] == "list"
+    assert isinstance(response_json["data"], list)
+    assert len(response_json["data"]) > 0
+    assert "first_id" in response_json
+    assert "last_id" in response_json
+    assert "has_more" in response_json
+
+
+def test_retrieve_message(admin_user: Optional[DATestUser], thread_id: str) -> None:
+    # Create a message first
+    create_response = requests.post(
+        f"{BASE_URL}/{thread_id}/messages",
+        json={"role": "user", "content": "Test message"},
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    message_id = create_response.json()["id"]
+
+    # Now, retrieve the message
+    response = requests.get(
+        f"{BASE_URL}/{thread_id}/messages/{message_id}",
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 200
+
+    response_json = response.json()
+    assert response_json["id"] == message_id
+    assert response_json["thread_id"] == thread_id
+    assert response_json["role"] == "user"
+    assert response_json["content"] == [{"type": "text", "text": "Test message"}]
+
+
+def test_modify_message(admin_user: Optional[DATestUser], thread_id: str) -> None:
+    # Create a message first
+    create_response = requests.post(
+        f"{BASE_URL}/{thread_id}/messages",
+        json={"role": "user", "content": "Test message"},
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    message_id = create_response.json()["id"]
+
+    # Now, modify the message
+    response = requests.post(
+        f"{BASE_URL}/{thread_id}/messages/{message_id}",
+        json={"metadata": {"new_key": "new_value"}},
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 200
+
+    response_json = response.json()
+    assert response_json["id"] == message_id
+    assert response_json["thread_id"] == thread_id
+    assert response_json["metadata"] == {"new_key": "new_value"}
+
+
+def test_error_handling(admin_user: Optional[DATestUser]) -> None:
+    non_existent_thread_id = str(uuid.uuid4())
+    non_existent_message_id = -99
+
+    # Test with non-existent thread
+    response = requests.post(
+        f"{BASE_URL}/{non_existent_thread_id}/messages",
+        json={"role": "user", "content": "Test message"},
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 404
+
+    # Test with non-existent message
+    response = requests.get(
+        f"{BASE_URL}/{non_existent_thread_id}/messages/{non_existent_message_id}",
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 404

backend/tests/integration/openai_assistants_api/test_runs.py

@@ -0,0 +1,137 @@
+from uuid import UUID
+
+import pytest
+import requests
+
+from tests.integration.common_utils.constants import API_SERVER_URL
+from tests.integration.common_utils.constants import GENERAL_HEADERS
+from tests.integration.common_utils.test_models import DATestLLMProvider
+from tests.integration.common_utils.test_models import DATestUser
+
+BASE_URL = f"{API_SERVER_URL}/openai-assistants"
+
+
+@pytest.fixture
+def run_id(admin_user: DATestUser | None, thread_id: UUID) -> str:
+    """Create a run and return its ID."""
+    response = requests.post(
+        f"{BASE_URL}/threads/{thread_id}/runs",
+        json={
+            "assistant_id": 0,
+        },
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 200
+    return response.json()["id"]
+
+
+def test_create_run(
+    admin_user: DATestUser | None, thread_id: UUID, llm_provider: DATestLLMProvider
+) -> None:
+    response = requests.post(
+        f"{BASE_URL}/threads/{thread_id}/runs",
+        json={
+            "assistant_id": 0,
+            "model": "gpt-3.5-turbo",
+            "instructions": "Test instructions",
+        },
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 200
+
+    response_json = response.json()
+    assert "id" in response_json
+    assert response_json["object"] == "thread.run"
+    assert "created_at" in response_json
+    assert response_json["assistant_id"] == 0
+    assert UUID(response_json["thread_id"]) == thread_id
+    assert response_json["status"] == "queued"
+    assert response_json["model"] == "gpt-3.5-turbo"
+    assert response_json["instructions"] == "Test instructions"
+
+
+def test_retrieve_run(
+    admin_user: DATestUser | None,
+    thread_id: UUID,
+    run_id: str,
+    llm_provider: DATestLLMProvider,
+) -> None:
+    retrieve_response = requests.get(
+        f"{BASE_URL}/threads/{thread_id}/runs/{run_id}",
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert retrieve_response.status_code == 200
+
+    response_json = retrieve_response.json()
+    assert response_json["id"] == run_id
+    assert response_json["object"] == "thread.run"
+    assert "created_at" in response_json
+    assert UUID(response_json["thread_id"]) == thread_id
+
+
+def test_cancel_run(
+    admin_user: DATestUser | None,
+    thread_id: UUID,
+    run_id: str,
+    llm_provider: DATestLLMProvider,
+) -> None:
+    cancel_response = requests.post(
+        f"{BASE_URL}/threads/{thread_id}/runs/{run_id}/cancel",
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert cancel_response.status_code == 200
+
+    response_json = cancel_response.json()
+    assert response_json["id"] == run_id
+    assert response_json["status"] == "cancelled"
+
+
+def test_list_runs(
+    admin_user: DATestUser | None, thread_id: UUID, llm_provider: DATestLLMProvider
+) -> None:
+    # Create a few runs
+    for _ in range(3):
+        requests.post(
+            f"{BASE_URL}/threads/{thread_id}/runs",
+            json={
+                "assistant_id": 0,
+            },
+            headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+        )
+
+    # Now, list the runs
+    list_response = requests.get(
+        f"{BASE_URL}/threads/{thread_id}/runs",
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert list_response.status_code == 200
+
+    response_json = list_response.json()
+    assert isinstance(response_json, list)
+    assert len(response_json) >= 3
+
+    for run in response_json:
+        assert "id" in run
+        assert run["object"] == "thread.run"
+        assert "created_at" in run
+        assert UUID(run["thread_id"]) == thread_id
+        assert "status" in run
+        assert "model" in run
+
+
+def test_list_run_steps(
+    admin_user: DATestUser | None,
+    thread_id: UUID,
+    run_id: str,
+    llm_provider: DATestLLMProvider,
+) -> None:
+    steps_response = requests.get(
+        f"{BASE_URL}/threads/{thread_id}/runs/{run_id}/steps",
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert steps_response.status_code == 200
+
+    response_json = steps_response.json()
+    assert isinstance(response_json, list)
+    # Since DAnswer doesn't have an equivalent to run steps, we expect an empty list
+    assert len(response_json) == 0

backend/tests/integration/openai_assistants_api/test_threads.py

@@ -0,0 +1,132 @@
+from uuid import UUID
+
+import requests
+
+from danswer.db.models import ChatSessionSharedStatus
+from tests.integration.common_utils.constants import API_SERVER_URL
+from tests.integration.common_utils.constants import GENERAL_HEADERS
+from tests.integration.common_utils.test_models import DATestUser
+
+THREADS_URL = f"{API_SERVER_URL}/openai-assistants/threads"
+
+
+def test_create_thread(admin_user: DATestUser | None) -> None:
+    response = requests.post(
+        THREADS_URL,
+        json={"messages": None, "metadata": {"key": "value"}},
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert response.status_code == 200
+
+    response_json = response.json()
+    assert "id" in response_json
+    assert response_json["object"] == "thread"
+    assert "created_at" in response_json
+    assert response_json["metadata"] == {"key": "value"}
+
+
+def test_retrieve_thread(admin_user: DATestUser | None) -> None:
+    # First, create a thread
+    create_response = requests.post(
+        THREADS_URL,
+        json={},
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert create_response.status_code == 200
+    thread_id = create_response.json()["id"]
+
+    # Now, retrieve the thread
+    retrieve_response = requests.get(
+        f"{THREADS_URL}/{thread_id}",
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert retrieve_response.status_code == 200
+
+    response_json = retrieve_response.json()
+    assert response_json["id"] == thread_id
+    assert response_json["object"] == "thread"
+    assert "created_at" in response_json
+
+
+def test_modify_thread(admin_user: DATestUser | None) -> None:
+    # First, create a thread
+    create_response = requests.post(
+        THREADS_URL,
+        json={},
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert create_response.status_code == 200
+    thread_id = create_response.json()["id"]
+
+    # Now, modify the thread
+    modify_response = requests.post(
+        f"{THREADS_URL}/{thread_id}",
+        json={"metadata": {"new_key": "new_value"}},
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert modify_response.status_code == 200
+
+    response_json = modify_response.json()
+    assert response_json["id"] == thread_id
+    assert response_json["metadata"] == {"new_key": "new_value"}
+
+
+def test_delete_thread(admin_user: DATestUser | None) -> None:
+    # First, create a thread
+    create_response = requests.post(
+        THREADS_URL,
+        json={},
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert create_response.status_code == 200
+    thread_id = create_response.json()["id"]
+
+    # Now, delete the thread
+    delete_response = requests.delete(
+        f"{THREADS_URL}/{thread_id}",
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert delete_response.status_code == 200
+
+    response_json = delete_response.json()
+    assert response_json["id"] == thread_id
+    assert response_json["object"] == "thread.deleted"
+    assert response_json["deleted"] is True
+
+
+def test_list_threads(admin_user: DATestUser | None) -> None:
+    # Create a few threads
+    for _ in range(3):
+        requests.post(
+            THREADS_URL,
+            json={},
+            headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+        )
+
+    # Now, list the threads
+    list_response = requests.get(
+        THREADS_URL,
+        headers=admin_user.headers if admin_user else GENERAL_HEADERS,
+    )
+    assert list_response.status_code == 200
+
+    response_json = list_response.json()
+    assert "sessions" in response_json
+    assert len(response_json["sessions"]) >= 3
+
+    for session in response_json["sessions"]:
+        assert "id" in session
+        assert "name" in session
+        assert "persona_id" in session
+        assert "time_created" in session
+        assert "shared_status" in session
+        assert "folder_id" in session
+        assert "current_alternate_model" in session
+
+        # Validate UUID
+        UUID(session["id"])
+
+        # Validate shared_status
+        assert session["shared_status"] in [
+            status.value for status in ChatSessionSharedStatus
+        ]