Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
refactor: isolate saved message persistence (#41857)
非法操作c592610ed361
diff --git a/api/controllers/console/explore/saved_message.py b/api/controllers/console/explore/saved_message.pyindex 7facb7fd530..07b40a20e80 100644--- a/api/controllers/console/explore/saved_message.py+++ b/api/controllers/console/explore/saved_message.py@@ -1,6 +1,5 @@from uuid import UUID-from pydantic import TypeAdapterfrom werkzeug.exceptions import NotFoundfrom controllers.common.controller_schemas import SavedMessageCreatePayload, SavedMessageListQuery@@ -9,64 +8,71 @@ from controllers.console import console_nsfrom controllers.console.app.error import AppUnavailableErrorfrom controllers.console.explore.error import NotCompletionAppErrorfrom controllers.console.explore.wraps import InstalledAppResource-from controllers.console.wraps import model_validate, with_current_user-from extensions.ext_database import db-from fields.conversation_fields import MessageResponseSource, ResultResponse-from fields.message_fields import SavedMessageInfiniteScrollPagination, SavedMessageItem-from models import Account+from controllers.console.wraps import model_validate, with_current_user_id+from extensions.ext_application_services import application_services+from fields.conversation_fields import ResultResponse+from fields.message_fields import SavedMessageInfiniteScrollPagination+from libs.helper import dump_responsefrom models.model import InstalledApp+from services.app_definition_query_service import AppDefinitionUnavailableErrorfrom services.errors.message import MessageNotExistsError-from services.saved_message_service import SavedMessageService+from services.saved_message_service import SavedMessageActorregister_schema_models(console_ns, SavedMessageListQuery, SavedMessageCreatePayload)register_response_schema_models(console_ns, ResultResponse, SavedMessageInfiniteScrollPagination)+def _require_completion_app(installed_app: InstalledApp) -> str:+ app_id = installed_app.app_id+ try:+ mode = application_services().app_definitions.get_mode(app_id)+ except AppDefinitionUnavailableError:+ raise AppUnavailableError() from None++ if mode != "completion":+ raise NotCompletionAppError()+ return app_id++@console_ns.route("/installed-apps/<uuid:installed_app_id>/saved-messages", endpoint="installed_app_saved_messages")class SavedMessageListApi(InstalledAppResource):@console_ns.doc(params=query_params_from_model(SavedMessageListQuery))@console_ns.response(200, "Success", console_ns.models[SavedMessageInfiniteScrollPagination.__name__])- @with_current_user+ @with_current_user_id@model_validate(SavedMessageListQuery)- def get(self, req_data: SavedMessageListQuery, current_user: Account, installed_app: InstalledApp):- session = db.session()- app_model = installed_app.app_with_session(session=session)- if app_model is None:- raise AppUnavailableError()- if app_model.mode != "completion":- raise NotCompletionAppError()-- pagination = SavedMessageService.pagination_by_last_id(- app_model,- current_user,- str(req_data.last_id) if req_data.last_id else None,- req_data.limit,- session=session,+ def get(+ self,+ req_data: SavedMessageListQuery,+ current_user_id: str,+ installed_app: InstalledApp,+ ) -> dict[str, object]:+ app_id = _require_completion_app(installed_app)+ pagination = application_services().saved_messages.pagination_by_last_id(+ app_id=app_id,+ actor=SavedMessageActor.account(current_user_id),+ last_id=str(req_data.last_id) if req_data.last_id else None,+ limit=req_data.limit,)- adapter = TypeAdapter(SavedMessageItem)- items = [- adapter.validate_python(MessageResponseSource(message, session=session), from_attributes=True)- for message in pagination.data- ]- return SavedMessageInfiniteScrollPagination(- limit=pagination.limit,- has_more=pagination.has_more,- data=items,- ).model_dump(mode="json")+ return dump_response(SavedMessageInfiniteScrollPagination, pagination)@console_ns.expect(console_ns.models[SavedMessageCreatePayload.__name__])@console_ns.response(200, "Success", console_ns.models[ResultResponse.__name__])- @with_current_user+ @with_current_user_id@model_validate(SavedMessageCreatePayload)- def post(self, req_data: SavedMessageCreatePayload, current_user: Account, installed_app: InstalledApp):- app_model = installed_app.app_with_session(session=db.session())- if app_model is None:- raise AppUnavailableError()- if app_model.mode != "completion":- raise NotCompletionAppError()+ def post(+ self,+ req_data: SavedMessageCreatePayload,+ current_user_id: str,+ installed_app: InstalledApp,+ ) -> dict[str, object]:+ app_id = _require_completion_app(installed_app)try:- SavedMessageService.save(app_model, current_user, str(req_data.message_id), session=db.session())+ application_services().saved_messages.save(+ app_id=app_id,+ actor=SavedMessageActor.account(current_user_id),+ message_id=str(req_data.message_id),+ )except MessageNotExistsError:raise NotFound("Message Not Exists.")@@ -78,17 +84,18 @@ class SavedMessageListApi(InstalledAppResource):)class SavedMessageApi(InstalledAppResource):@console_ns.response(204, "Saved message deleted successfully")- @with_current_user- def delete(self, current_user: Account, installed_app: InstalledApp, message_id: UUID):- app_model = installed_app.app_with_session(session=db.session())- if app_model is None:- raise AppUnavailableError()-- message_id_str = str(message_id)-- if app_model.mode != "completion":- raise NotCompletionAppError()-- SavedMessageService.delete(app_model, current_user, message_id_str, session=db.session())+ @with_current_user_id+ def delete(+ self,+ current_user_id: str,+ installed_app: InstalledApp,+ message_id: UUID,+ ) -> tuple[str, int]:+ app_id = _require_completion_app(installed_app)+ application_services().saved_messages.delete(+ app_id=app_id,+ actor=SavedMessageActor.account(current_user_id),+ message_id=str(message_id),+ )return "", 204diff --git a/api/controllers/web/saved_message.py b/api/controllers/web/saved_message.pyindex eed4aed5ed6..6549a8e2148 100644--- a/api/controllers/web/saved_message.py+++ b/api/controllers/web/saved_message.py@@ -1,21 +1,20 @@from uuid import UUID-from pydantic import TypeAdapter-from sqlalchemy.orm import Sessionfrom werkzeug.exceptions import NotFoundfrom controllers.common.controller_schemas import SavedMessageCreatePayload, SavedMessageListQueryfrom controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_models-from controllers.console.app.wraps import with_sessionfrom controllers.console.wraps import model_validatefrom controllers.web import web_nsfrom controllers.web.error import NotCompletionAppErrorfrom controllers.web.wraps import WebApiResource-from fields.conversation_fields import MessageResponseSource, ResultResponse-from fields.message_fields import SavedMessageInfiniteScrollPagination, SavedMessageItem+from extensions.ext_application_services import application_services+from fields.conversation_fields import ResultResponse+from fields.message_fields import SavedMessageInfiniteScrollPagination+from libs.helper import dump_responsefrom models.model import App, EndUserfrom services.errors.message import MessageNotExistsError-from services.saved_message_service import SavedMessageService+from services.saved_message_service import SavedMessageActorregister_schema_models(web_ns, SavedMessageListQuery, SavedMessageCreatePayload)register_response_schema_models(web_ns, ResultResponse, SavedMessageInfiniteScrollPagination)@@ -37,23 +36,18 @@ class SavedMessageListApi(WebApiResource):})@web_ns.response(200, "Success", web_ns.models[SavedMessageInfiniteScrollPagination.__name__])- @with_session(write=False)@model_validate(SavedMessageListQuery)- def get(self, query: SavedMessageListQuery, session: Session, app_model: App, end_user: EndUser):+ def get(self, query: SavedMessageListQuery, app_model: App, end_user: EndUser) -> dict[str, object]:if app_model.mode != "completion":raise NotCompletionAppError()- pagination = SavedMessageService.pagination_by_last_id(- app_model, end_user, query.last_id, query.limit, session=session+ pagination = application_services().saved_messages.pagination_by_last_id(+ app_id=app_model.id,+ actor=SavedMessageActor.end_user(end_user.id),+ last_id=query.last_id,+ limit=query.limit,)- adapter = TypeAdapter(SavedMessageItem)- items = [- adapter.validate_python(MessageResponseSource(message, session=session), from_attributes=True)- for message in pagination.data- ]- return SavedMessageInfiniteScrollPagination(- limit=pagination.limit, has_more=pagination.has_more, data=items- ).model_dump(mode="json")+ return dump_response(SavedMessageInfiniteScrollPagination, pagination)@web_ns.doc("Save Message")@web_ns.doc(description="Save a specific message for later reference.")@@ -74,14 +68,17 @@ class SavedMessageListApi(WebApiResource):)@web_ns.response(200, "Message saved successfully", web_ns.models[ResultResponse.__name__])@web_ns.expect(web_ns.models[SavedMessageCreatePayload.__name__])- @with_session@model_validate(SavedMessageCreatePayload)- def post(self, payload: SavedMessageCreatePayload, session: Session, app_model: App, end_user: EndUser):+ def post(self, payload: SavedMessageCreatePayload, app_model: App, end_user: EndUser) -> dict[str, object]:if app_model.mode != "completion":raise NotCompletionAppError()try:- SavedMessageService.save(app_model, end_user, payload.message_id, session=session)+ application_services().saved_messages.save(+ app_id=app_model.id,+ actor=SavedMessageActor.end_user(end_user.id),+ message_id=payload.message_id,+ )except MessageNotExistsError:raise NotFound("Message Not Exists.")@@ -104,13 +101,16 @@ class SavedMessageApi(WebApiResource):})@web_ns.response(204, "Message removed successfully")- @with_session- def delete(self, session: Session, app_model: App, end_user: EndUser, message_id: UUID):+ def delete(self, app_model: App, end_user: EndUser, message_id: UUID) -> tuple[str, int]:message_id_str = str(message_id)if app_model.mode != "completion":raise NotCompletionAppError()- SavedMessageService.delete(app_model, end_user, message_id_str, session=session)+ application_services().saved_messages.delete(+ app_id=app_model.id,+ actor=SavedMessageActor.end_user(end_user.id),+ message_id=message_id_str,+ )return "", 204diff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.pyindex 9695f44427b..095e8b3c761 100644--- a/api/extensions/ext_application_services.py+++ b/api/extensions/ext_application_services.py@@ -58,6 +58,7 @@ from repositories.oauth_access_token_repository import SQLAlchemyOAuthAccessTokefrom repositories.oauth_server_repository import RedisOAuthServerTokenRepository, SQLAlchemyOAuthServerRepositoryfrom repositories.plugin_file_upload_repository import SQLAlchemyPluginFileUploadOwnerRepositoryfrom repositories.recommended_app_catalog_repository import DatabaseRecommendedAppCatalogRepository+from repositories.saved_message_repository import SQLAlchemySavedMessageRepositoryfrom repositories.sqlalchemy_api_workflow_run_repository import DifyAPISQLAlchemyWorkflowRunRepositoryfrom repositories.step_by_step_tour_repository import SQLAlchemyStepByStepTourStateRepositoryfrom repositories.tag_repository import TagRepository@@ -197,6 +198,7 @@ from services.retention.workflow_run.archive_download_adapters import ()from services.retention.workflow_run.archive_download_task_cache import WorkflowRunArchiveDownloadTaskCachefrom services.retention.workflow_run.archive_log_service import WorkflowRunArchiveService+from services.saved_message_service import SavedMessageServicefrom services.schema_definition_service import SchemaDefinitionServicefrom services.setup_adapters import RedisSetupLock, RegisterServiceAccountProvisionerfrom services.setup_service import SetupService@@ -311,6 +313,7 @@ class ApplicationServices:partner_tenant_bindings: PartnerTenantBindingServicerecommended_app_queries: RecommendedAppQueryServiceremote_files: RemoteFileService+ saved_messages: SavedMessageServiceapp_tasks: AppTaskControlServicetrial_app_access: TrialAppAccessServiceapp_audio: AppAudio@@ -760,6 +763,9 @@ def build_application_services(),recommended_app_queries=recommended_app_queries,remote_files=remote_file_service,+ saved_messages=SavedMessageService(+ saved_messages=SQLAlchemySavedMessageRepository(session_factory=database_client),+ ),app_tasks=AppTaskControlService(redis_client=redis),trial_app_access=TrialAppAccessService(apps=trial_apps),app_audio=AppAudioRuntime(session_factory=database_client),diff --git a/api/repositories/app_definition_query_repository.py b/api/repositories/app_definition_query_repository.pyindex eeaecd55d32..03114a08d46 100644--- a/api/repositories/app_definition_query_repository.py+++ b/api/repositories/app_definition_query_repository.py@@ -81,6 +81,12 @@ class AppDefinitionQueryRepository(AppDefinitionQuery):def __init__(self, *, session_factory: sessionmaker[Session]) -> None:self._session_factory = session_factory+ @override+ def get_mode(self, app_id: str) -> str | None:+ with self._session_factory() as session:+ mode = session.scalar(select(App.mode).where(App.id == app_id).limit(1))+ return mode.value if mode is not None else None+@overridedef get_published_parameter_config(self,diff --git a/api/repositories/saved_message_repository.py b/api/repositories/saved_message_repository.pynew file mode 100644index 00000000000..e27048c4676--- /dev/null+++ b/api/repositories/saved_message_repository.py@@ -0,0 +1,155 @@+from typing import cast, override++from sqlalchemy import select+from sqlalchemy.orm import Session, sessionmaker++from models.enums import CreatorUserRole+from models.model import Message+from models.web import SavedMessage+from services.errors.message import LastMessageNotExistsError, MessageNotExistsError+from services.saved_message_service import (+ SavedMessageActor,+ SavedMessageFeedback,+ SavedMessageFileRecord,+ SavedMessageInputValue,+ SavedMessagePage,+ SavedMessageRecord,+ SavedMessageStore,+)+++class SQLAlchemySavedMessageRepository(SavedMessageStore):+ def __init__(self, *, session_factory: sessionmaker[Session]) -> None:+ self._session_factory = session_factory++ @override+ def pagination_by_last_id(+ self,+ *,+ app_id: str,+ actor: SavedMessageActor,+ last_id: str | None,+ limit: int,+ ) -> SavedMessagePage:+ with self._session_factory() as session:+ message_ids = session.scalars(+ select(SavedMessage.message_id)+ .where(+ SavedMessage.app_id == app_id,+ SavedMessage.created_by_role == actor.role,+ SavedMessage.created_by == actor.id,+ )+ .order_by(SavedMessage.created_at.desc())+ ).all()+ if not message_ids:+ return SavedMessagePage(limit=limit, has_more=False, data=())++ stmt = select(Message).where(Message.id.in_(message_ids))+ fetch_limit = limit + 1+ if last_id:+ last_message = session.scalar(stmt.where(Message.id == last_id).limit(1))+ if last_message is None:+ raise LastMessageNotExistsError("The last_id cursor does not belong to the current saved messages.")+ stmt = stmt.where(Message.created_at < last_message.created_at, Message.id != last_message.id)++ messages = list(session.scalars(stmt.order_by(Message.created_at.desc()).limit(fetch_limit)).all())+ has_more = len(messages) > limit+ if has_more:+ messages = messages[:limit]++ return SavedMessagePage(+ limit=limit,+ has_more=has_more,+ data=tuple(self._to_record(message=message, session=session) for message in messages),+ )++ @override+ def save(self, *, app_id: str, actor: SavedMessageActor, message_id: str) -> None:+ with self._session_factory() as session:+ saved_message = session.scalar(+ select(SavedMessage)+ .where(+ SavedMessage.app_id == app_id,+ SavedMessage.message_id == message_id,+ SavedMessage.created_by_role == actor.role,+ SavedMessage.created_by == actor.id,+ )+ .limit(1)+ )+ if saved_message is not None:+ return++ message = session.scalar(+ select(Message)+ .where(+ Message.id == message_id,+ Message.app_id == app_id,+ Message.from_source == ("console" if actor.role == "account" else "api"),+ Message.from_end_user_id == (actor.id if actor.role == "end_user" else None),+ Message.from_account_id == (actor.id if actor.role == "account" else None),+ )+ .limit(1)+ )+ if message is None:+ raise MessageNotExistsError()++ session.add(+ SavedMessage(+ app_id=app_id,+ message_id=message.id,+ created_by_role=CreatorUserRole(actor.role),+ created_by=actor.id,+ )+ )+ session.commit()++ @override+ def delete(self, *, app_id: str, actor: SavedMessageActor, message_id: str) -> None:+ with self._session_factory() as session:+ saved_message = session.scalar(+ select(SavedMessage)+ .where(+ SavedMessage.app_id == app_id,+ SavedMessage.message_id == message_id,+ SavedMessage.created_by_role == actor.role,+ SavedMessage.created_by == actor.id,+ )+ .limit(1)+ )+ if saved_message is None:+ return++ session.delete(saved_message)+ session.commit()++ @staticmethod+ def _to_record(*, message: Message, session: Session) -> SavedMessageRecord:+ inputs = cast(dict[str, SavedMessageInputValue], message.inputs_with_session(session=session))+ message_files = SQLAlchemySavedMessageRepository._message_files(message=message, session=session)+ feedback = message.user_feedback_with_session(session=session)+ return SavedMessageRecord(+ id=message.id,+ inputs=inputs,+ query=message.query,+ answer=message.answer,+ message_files=message_files,+ user_feedback=SavedMessageFeedback(rating=feedback.rating.value) if feedback is not None else None,+ created_at=message.created_at,+ )++ @staticmethod+ def _message_files(*, message: Message, session: Session) -> list[SavedMessageFileRecord]:+ return [+ SavedMessageFileRecord(+ id=file["id"],+ filename=cast(str, file["filename"]),+ type=file["type"],+ url=file.get("url"),+ mime_type=file.get("mime_type"),+ size=file.get("size"),+ transfer_method=file["transfer_method"],+ belongs_to=file.get("belongs_to"),+ upload_file_id=file.get("upload_file_id"),+ )+ for file in message.message_files_with_session(session=session)+ ]diff --git a/api/services/app_definition_query_service.py b/api/services/app_definition_query_service.pyindex 6815911b119..327428d2518 100644--- a/api/services/app_definition_query_service.py+++ b/api/services/app_definition_query_service.py@@ -47,6 +47,8 @@ class AppSiteConfiguration(NamedTuple):class AppDefinitionQuery(Protocol):+ def get_mode(self, app_id: str) -> str | None: ...+def get_published_parameter_config(self,app_id: str,@@ -82,6 +84,12 @@ class AppDefinitionQueryService:self._definitions = definitionsself._builtin_icon_url_prefix = builtin_icon_url_prefix+ def get_mode(self, app_id: str) -> str:+ mode = self._definitions.get_mode(app_id)+ if mode is None:+ raise AppDefinitionUnavailableError("App not found")+ return mode+def get_parameters(self, app_id: str) -> AppParametersDict:config = self._definitions.get_published_parameter_config(app_id)return self._map_parameters(config)diff --git a/api/services/saved_message_service.py b/api/services/saved_message_service.pyindex 6165d74333f..db094d7f8a9 100644--- a/api/services/saved_message_service.py+++ b/api/services/saved_message_service.py@@ -1,88 +1,97 @@-from sqlalchemy import select-from sqlalchemy.orm import Session+from dataclasses import dataclass+from datetime import datetime+from typing import Literal, NamedTuple, Protocol-from libs.infinite_scroll_pagination import InfiniteScrollPagination-from models import Account-from models.enums import CreatorUserRole-from models.model import App, EndUser-from models.web import SavedMessage-from services.message_service import MessageService+from pydantic import JsonValue+from graphon.file import File++type SavedMessageActorRole = Literal["account", "end_user"]+type SavedMessageInputValue = JsonValue | File | list[File]+++@dataclass(frozen=True, slots=True)+class SavedMessageActor:+ id: str+ role: SavedMessageActorRole-class SavedMessageService:@classmethod- def pagination_by_last_id(- cls, app_model: App, user: Account | EndUser | None, last_id: str | None, limit: int, *, session: Session- ) -> InfiniteScrollPagination:- if not user:- raise ValueError("User is required")- saved_messages = session.scalars(- select(SavedMessage)- .where(- SavedMessage.app_id == app_model.id,- SavedMessage.created_by_role == ("account" if isinstance(user, Account) else "end_user"),- SavedMessage.created_by == user.id,- )- .order_by(SavedMessage.created_at.desc())- ).all()- message_ids = [sm.message_id for sm in saved_messages]-- return MessageService.pagination_by_last_id(- app_model=app_model,- user=user,- last_id=last_id,- limit=limit,- include_ids=message_ids,- session=session,- )+ def account(cls, account_id: str) -> "SavedMessageActor":+ return cls(id=account_id, role="account")@classmethod- def save(cls, app_model: App, user: Account | EndUser | None, message_id: str, *, session: Session):- if not user:- return- saved_message = session.scalar(- select(SavedMessage)- .where(- SavedMessage.app_id == app_model.id,- SavedMessage.message_id == message_id,- SavedMessage.created_by_role == ("account" if isinstance(user, Account) else "end_user"),- SavedMessage.created_by == user.id,- )- .limit(1)- )+ def end_user(cls, end_user_id: str) -> "SavedMessageActor":+ return cls(id=end_user_id, role="end_user")- if saved_message:- return- message = MessageService.get_message(app_model=app_model, user=user, message_id=message_id, session=session)+class SavedMessageFeedback(NamedTuple):+ rating: str | None- saved_message = SavedMessage(- app_id=app_model.id,- message_id=message.id,- created_by_role=CreatorUserRole.ACCOUNT if isinstance(user, Account) else CreatorUserRole.END_USER,- created_by=user.id,- )- session.add(saved_message)- session.commit()+class SavedMessageFileRecord(NamedTuple):+ id: str+ filename: str+ type: str+ url: str | None+ mime_type: str | None+ size: int | None+ transfer_method: str+ belongs_to: str | None+ upload_file_id: str | None- @classmethod- def delete(cls, app_model: App, user: Account | EndUser | None, message_id: str, *, session: Session):- if not user:- return- saved_message = session.scalar(- select(SavedMessage)- .where(- SavedMessage.app_id == app_model.id,- SavedMessage.message_id == message_id,- SavedMessage.created_by_role == ("account" if isinstance(user, Account) else "end_user"),- SavedMessage.created_by == user.id,- )- .limit(1)++class SavedMessageRecord(NamedTuple):+ id: str+ inputs: dict[str, SavedMessageInputValue]+ query: str+ answer: str+ message_files: list[SavedMessageFileRecord]+ user_feedback: SavedMessageFeedback | None+ created_at: datetime | None+++class SavedMessagePage(NamedTuple):+ limit: int+ has_more: bool+ data: tuple[SavedMessageRecord, ...]+++class SavedMessageStore(Protocol):+ def pagination_by_last_id(+ self,+ *,+ app_id: str,+ actor: SavedMessageActor,+ last_id: str | None,+ limit: int,+ ) -> SavedMessagePage: ...++ def save(self, *, app_id: str, actor: SavedMessageActor, message_id: str) -> None: ...++ def delete(self, *, app_id: str, actor: SavedMessageActor, message_id: str) -> None: ...+++class SavedMessageService:+ def __init__(self, *, saved_messages: SavedMessageStore) -> None:+ self._saved_messages = saved_messages++ def pagination_by_last_id(+ self,+ *,+ app_id: str,+ actor: SavedMessageActor,+ last_id: str | None,+ limit: int,+ ) -> SavedMessagePage:+ return self._saved_messages.pagination_by_last_id(+ app_id=app_id,+ actor=actor,+ last_id=last_id,+ limit=limit,)- if not saved_message:- return+ def save(self, *, app_id: str, actor: SavedMessageActor, message_id: str) -> None:+ self._saved_messages.save(app_id=app_id, actor=actor, message_id=message_id)- session.delete(saved_message)- session.commit()+ def delete(self, *, app_id: str, actor: SavedMessageActor, message_id: str) -> None:+ self._saved_messages.delete(app_id=app_id, actor=actor, message_id=message_id)diff --git a/api/tests/test_containers_integration_tests/pyrefly.toml b/api/tests/test_containers_integration_tests/pyrefly.tomlindex 7c0feb1323f..b86dc8e10ae 100644--- a/api/tests/test_containers_integration_tests/pyrefly.toml+++ b/api/tests/test_containers_integration_tests/pyrefly.toml@@ -88,7 +88,6 @@ project-excludes = ["services/test_model_load_balancing_service.py","services/test_model_provider_service.py","services/test_restore_archived_workflow_run.py",- "services/test_saved_message_service.py","services/test_schedule_service.py","services/test_web_conversation_service.py","services/test_webapp_auth_service.py",diff --git a/api/tests/test_containers_integration_tests/services/test_saved_message_service.py b/api/tests/test_containers_integration_tests/services/test_saved_message_service.pydeleted file mode 100644index a55ed6c9532..00000000000--- a/api/tests/test_containers_integration_tests/services/test_saved_message_service.py+++ /dev/null@@ -1,651 +0,0 @@-from unittest.mock import ANY, patch--import pytest-from faker import Faker-from sqlalchemy.orm import Session--from models import App, CreatorUserRole-from models.enums import ConversationFromSource, EndUserType-from models.model import EndUser, Message-from models.web import SavedMessage-from services.app_service import AppService, CreateAppParams-from services.saved_message_service import SavedMessageService-from tests.test_containers_integration_tests.helpers import generate_valid_password---class TestSavedMessageService:- """Integration tests for SavedMessageService using testcontainers."""-- @pytest.fixture- def mock_external_service_dependencies(self):- """Mock setup for external service dependencies."""- with (- patch("services.account_service.SystemFeatureService") as mock_account_feature_service,- patch("services.app_service.ModelManager.for_tenant") as mock_model_manager,- patch("services.saved_message_service.MessageService") as mock_message_service,- ):- # Setup default mock returns- mock_account_feature_service.is_registration_allowed.return_value = True-- # Mock ModelManager for app creation- mock_model_instance = mock_model_manager.return_value- mock_model_instance.get_default_model_instance.return_value = None- mock_model_instance.get_default_provider_model_name.return_value = ("openai", "gpt-3.5-turbo")-- # Mock MessageService- mock_message_service.get_message.return_value = None- mock_message_service.pagination_by_last_id.return_value = None-- yield {- "account_feature_service": mock_account_feature_service,- "model_manager": mock_model_manager,- "message_service": mock_message_service,- }-- def _create_test_app_and_account(self, db_session_with_containers: Session, mock_external_service_dependencies):- """- Helper method to create a test app and account for testing.-- Args:- db_session_with_containers: Database session from testcontainers infrastructure- mock_external_service_dependencies: Mock dependencies-- Returns:- tuple: (app, account) - Created app and account instances- """- fake = Faker()-- # Setup mocks for account creation- mock_external_service_dependencies["account_feature_service"].is_registration_allowed.return_value = True-- # Create account and tenant first- from services.account_service import AccountService, TenantService-- account = AccountService.create_account(- email=fake.email(),- name=fake.name(),- interface_language="en-US",- password=generate_valid_password(fake),- session=db_session_with_containers,- )- TenantService.create_owner_tenant_if_not_exist(account, name=fake.company(), session=db_session_with_containers)- tenant = account.current_tenant-- # Create app with realistic data- app_args = CreateAppParams(- name=fake.company(),- description=fake.text(max_nb_chars=100),- mode="chat",- icon_type="emoji",- icon="🤖",- icon_background="#FF6B6B",- api_rph=100,- api_rpm=10,- )-- app_service = AppService()- app = app_service.create_app(tenant.id, app_args, account, session=db_session_with_containers)-- return app, account-- def _create_test_end_user(self, db_session_with_containers: Session, app: App):- """- Helper method to create a test end user for testing.-- Args:- db_session_with_containers: Database session from testcontainers infrastructure- app: App instance to associate the end user with-- Returns:- EndUser: Created end user instance- """- fake = Faker()-- end_user = EndUser(- tenant_id=app.tenant_id,- app_id=app.id,- external_user_id=fake.uuid4(),- name=fake.name(),- type=EndUserType.BROWSER,- session_id=fake.uuid4(),- is_anonymous=False,- )-- db_session_with_containers.add(end_user)- db_session_with_containers.commit()-- return end_user-- def _create_test_message(self, db_session_with_containers: Session, app: App, user):- """- Helper method to create a test message for testing.-- Args:- db_session_with_containers: Database session from testcontainers infrastructure- app: App instance to associate the message with- user: User instance (Account or EndUser) to associate the message with-- Returns:- Message: Created message instance- """- fake = Faker()-- # Create a simple conversation first- from models.model import Conversation-- is_account = hasattr(user, "current_tenant")- from_source = ConversationFromSource.CONSOLE if is_account else ConversationFromSource.API-- conversation = Conversation(- app_id=app.id,- from_source=from_source,- from_end_user_id=user.id if not is_account else None,- from_account_id=user.id if is_account else None,- name=fake.sentence(nb_words=3),- inputs={},- status="normal",- mode="chat",- )-- db_session_with_containers.add(conversation)- db_session_with_containers.commit()-- # Create message- message = Message(- app_id=app.id,- conversation_id=conversation.id,- from_source=from_source,- from_end_user_id=user.id if not is_account else None,- from_account_id=user.id if is_account else None,- inputs={},- query=fake.sentence(nb_words=5),- message=fake.text(max_nb_chars=100),- answer=fake.text(max_nb_chars=200),- message_tokens=50,- answer_tokens=100,- message_unit_price=0.001,- answer_unit_price=0.002,- total_price=0.003,- currency="USD",- status="normal",- )-- db_session_with_containers.add(message)- db_session_with_containers.commit()-- return message-- def test_pagination_by_last_id_success_with_account_user(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test successful pagination by last ID with account user.-- This test verifies:- - Proper pagination with account user- - Correct filtering by app_id and user- - Proper role identification for account users- - MessageService integration- """- # Arrange: Create test data- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Create test messages- message1 = self._create_test_message(db_session_with_containers, app, account)- message2 = self._create_test_message(db_session_with_containers, app, account)-- # Create saved messages- saved_message1 = SavedMessage(- app_id=app.id,- message_id=message1.id,- created_by_role=CreatorUserRole.ACCOUNT,- created_by=account.id,- )- saved_message2 = SavedMessage(- app_id=app.id,- message_id=message2.id,- created_by_role=CreatorUserRole.ACCOUNT,- created_by=account.id,- )-- db_session_with_containers.add_all([saved_message1, saved_message2])- db_session_with_containers.commit()-- # Mock MessageService.pagination_by_last_id return value- from libs.infinite_scroll_pagination import InfiniteScrollPagination-- mock_pagination = InfiniteScrollPagination(data=[message1, message2], limit=10, has_more=False)- mock_external_service_dependencies["message_service"].pagination_by_last_id.return_value = mock_pagination-- # Act: Execute the method under test- result = SavedMessageService.pagination_by_last_id(- app_model=app, user=account, last_id=None, limit=10, session=db_session_with_containers- )-- # Assert: Verify the expected outcomes- assert result is not None- assert result.data == [message1, message2]- assert result.limit == 10- assert result.has_more is False-- # Verify MessageService was called with correct parameters- # Sort the IDs to handle database query order variations- expected_include_ids = sorted([message1.id, message2.id])- actual_call = mock_external_service_dependencies["message_service"].pagination_by_last_id.call_args- actual_include_ids = sorted(actual_call.kwargs.get("include_ids", []))-- assert actual_call.kwargs["app_model"] == app- assert actual_call.kwargs["user"] == account- assert actual_call.kwargs["last_id"] is None- assert actual_call.kwargs["limit"] == 10- assert actual_include_ids == expected_include_ids-- # Verify database state- db_session_with_containers.refresh(saved_message1)- db_session_with_containers.refresh(saved_message2)- assert saved_message1.id is not None- assert saved_message2.id is not None- assert saved_message1.created_by_role == "account"- assert saved_message2.created_by_role == "account"-- def test_pagination_by_last_id_success_with_end_user(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test successful pagination by last ID with end user.-- This test verifies:- - Proper pagination with end user- - Correct filtering by app_id and user- - Proper role identification for end users- - MessageService integration- """- # Arrange: Create test data- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)- end_user = self._create_test_end_user(db_session_with_containers, app)-- # Create test messages- message1 = self._create_test_message(db_session_with_containers, app, end_user)- message2 = self._create_test_message(db_session_with_containers, app, end_user)-- # Create saved messages- saved_message1 = SavedMessage(- app_id=app.id,- message_id=message1.id,- created_by_role=CreatorUserRole.END_USER,- created_by=end_user.id,- )- saved_message2 = SavedMessage(- app_id=app.id,- message_id=message2.id,- created_by_role=CreatorUserRole.END_USER,- created_by=end_user.id,- )-- db_session_with_containers.add_all([saved_message1, saved_message2])- db_session_with_containers.commit()-- # Mock MessageService.pagination_by_last_id return value- from libs.infinite_scroll_pagination import InfiniteScrollPagination-- mock_pagination = InfiniteScrollPagination(data=[message1, message2], limit=5, has_more=True)- mock_external_service_dependencies["message_service"].pagination_by_last_id.return_value = mock_pagination-- # Act: Execute the method under test- result = SavedMessageService.pagination_by_last_id(- app_model=app, user=end_user, last_id="test_last_id", limit=5, session=db_session_with_containers- )-- # Assert: Verify the expected outcomes- assert result is not None- assert result.data == [message1, message2]- assert result.limit == 5- assert result.has_more is True-- # Verify MessageService was called with correct parameters- # Sort the IDs to handle database query order variations- expected_include_ids = sorted([message1.id, message2.id])- actual_call = mock_external_service_dependencies["message_service"].pagination_by_last_id.call_args- actual_include_ids = sorted(actual_call.kwargs.get("include_ids", []))-- assert actual_call.kwargs["app_model"] == app- assert actual_call.kwargs["user"] == end_user- assert actual_call.kwargs["last_id"] == "test_last_id"- assert actual_call.kwargs["limit"] == 5- assert actual_include_ids == expected_include_ids-- # Verify database state- db_session_with_containers.refresh(saved_message1)- db_session_with_containers.refresh(saved_message2)- assert saved_message1.id is not None- assert saved_message2.id is not None- assert saved_message1.created_by_role == "end_user"- assert saved_message2.created_by_role == "end_user"-- def test_save_success_with_new_message(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test successful save of a new message.-- This test verifies:- - Proper creation of new saved message- - Correct database state after save- - Proper relationship establishment- - MessageService integration for message retrieval- """- # Arrange: Create test data- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)- message = self._create_test_message(db_session_with_containers, app, account)-- # Mock MessageService.get_message return value- mock_external_service_dependencies["message_service"].get_message.return_value = message-- # Act: Execute the method under test- SavedMessageService.save(app_model=app, user=account, message_id=message.id, session=db_session_with_containers)-- # Assert: Verify the expected outcomes- # Check if saved message was created in database-- saved_message = (- db_session_with_containers.query(SavedMessage)- .where(- SavedMessage.app_id == app.id,- SavedMessage.message_id == message.id,- SavedMessage.created_by_role == "account",- SavedMessage.created_by == account.id,- )- .first()- )-- assert saved_message is not None- assert saved_message.app_id == app.id- assert saved_message.message_id == message.id- assert saved_message.created_by_role == "account"- assert saved_message.created_by == account.id- assert saved_message.created_at is not None-- # Verify MessageService.get_message was called- mock_external_service_dependencies["message_service"].get_message.assert_called_once_with(- app_model=app, user=account, message_id=message.id, session=ANY- )-- # Verify database state- db_session_with_containers.refresh(saved_message)- assert saved_message.id is not None-- def test_pagination_by_last_id_error_no_user(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test error handling when no user is provided.-- This test verifies:- - Proper error handling for missing user- - ValueError is raised when user is None- - No database operations are performed- """- # Arrange: Create test data- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Act & Assert: Verify proper error handling- with pytest.raises(ValueError) as exc_info:- SavedMessageService.pagination_by_last_id(- app_model=app, user=None, last_id=None, limit=10, session=db_session_with_containers- )-- assert "User is required" in str(exc_info.value)-- def test_save_error_no_user(self, db_session_with_containers: Session, mock_external_service_dependencies):- """- Test error handling when saving message with no user.-- This test verifies:- - Method returns early when user is None- - No database operations are performed- - No exceptions are raised- """- # Arrange: Create test data- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)- message = self._create_test_message(db_session_with_containers, app, account)-- # Act: Execute the method under test with None user- result = SavedMessageService.save(- app_model=app, user=None, message_id=message.id, session=db_session_with_containers- )-- # Assert: Verify the expected outcomes- assert result is None-- # Verify no saved message was created-- saved_message = (- db_session_with_containers.query(SavedMessage)- .where(- SavedMessage.app_id == app.id,- SavedMessage.message_id == message.id,- )- .first()- )-- assert saved_message is None-- def test_delete_success_existing_message(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test successful deletion of an existing saved message.-- This test verifies:- - Proper deletion of existing saved message- - Correct database state after deletion- - No errors during deletion process- """- # Arrange: Create test data- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)- message = self._create_test_message(db_session_with_containers, app, account)-- # Create a saved message first- saved_message = SavedMessage(- app_id=app.id,- message_id=message.id,- created_by_role=CreatorUserRole.ACCOUNT,- created_by=account.id,- )-- db_session_with_containers.add(saved_message)- db_session_with_containers.commit()-- # Verify saved message exists- assert (- db_session_with_containers.query(SavedMessage)- .where(- SavedMessage.app_id == app.id,- SavedMessage.message_id == message.id,- SavedMessage.created_by_role == "account",- SavedMessage.created_by == account.id,- )- .first()- is not None- )-- # Act: Execute the method under test- SavedMessageService.delete(- app_model=app, user=account, message_id=message.id, session=db_session_with_containers- )-- # Assert: Verify the expected outcomes- # Check if saved message was deleted from database- deleted_saved_message = (- db_session_with_containers.query(SavedMessage)- .where(- SavedMessage.app_id == app.id,- SavedMessage.message_id == message.id,- SavedMessage.created_by_role == "account",- SavedMessage.created_by == account.id,- )- .first()- )-- assert deleted_saved_message is None-- # Verify database state- db_session_with_containers.commit()- # The message should still exist, only the saved_message should be deleted- assert db_session_with_containers.query(Message).where(Message.id == message.id).first() is not None-- def test_save_for_end_user(self, db_session_with_containers: Session, mock_external_service_dependencies):- """Test saving a message for an EndUser."""- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)- end_user = self._create_test_end_user(db_session_with_containers, app)- message = self._create_test_message(db_session_with_containers, app, end_user)-- mock_external_service_dependencies["message_service"].get_message.return_value = message-- SavedMessageService.save(- app_model=app, user=end_user, message_id=message.id, session=db_session_with_containers- )-- saved = (- db_session_with_containers.query(SavedMessage)- .where(SavedMessage.app_id == app.id, SavedMessage.message_id == message.id)- .first()- )- assert saved is not None- assert saved.created_by == end_user.id- assert saved.created_by_role == "end_user"-- def test_save_duplicate_is_idempotent(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """Test that saving an already-saved message does not create a duplicate."""- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)- message = self._create_test_message(db_session_with_containers, app, account)-- mock_external_service_dependencies["message_service"].get_message.return_value = message-- # Save once- SavedMessageService.save(app_model=app, user=account, message_id=message.id, session=db_session_with_containers)- # Save again- SavedMessageService.save(app_model=app, user=account, message_id=message.id, session=db_session_with_containers)-- count = (- db_session_with_containers.query(SavedMessage)- .where(SavedMessage.app_id == app.id, SavedMessage.message_id == message.id)- .count()- )- assert count == 1-- def test_delete_without_user_does_nothing(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """Test that deleting without a user is a no-op."""- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)- message = self._create_test_message(db_session_with_containers, app, account)-- # Pre-create a saved message- saved = SavedMessage(- app_id=app.id, message_id=message.id, created_by_role=CreatorUserRole.ACCOUNT, created_by=account.id- )- db_session_with_containers.add(saved)- db_session_with_containers.commit()-- SavedMessageService.delete(app_model=app, user=None, message_id=message.id, session=db_session_with_containers)-- # Should still exist- assert (- db_session_with_containers.query(SavedMessage)- .where(SavedMessage.app_id == app.id, SavedMessage.message_id == message.id)- .first()- is not None- )-- def test_delete_non_existent_does_nothing(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """Test that deleting a non-existent saved message is a no-op."""- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Should not raise — use a valid UUID that doesn't exist in DB- from uuid import uuid4-- SavedMessageService.delete(- app_model=app, user=account, message_id=str(uuid4()), session=db_session_with_containers- )-- def test_delete_for_end_user(self, db_session_with_containers: Session, mock_external_service_dependencies):- """Test deleting a saved message for an EndUser."""- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)- end_user = self._create_test_end_user(db_session_with_containers, app)- message = self._create_test_message(db_session_with_containers, app, end_user)-- saved = SavedMessage(- app_id=app.id, message_id=message.id, created_by_role=CreatorUserRole.END_USER, created_by=end_user.id- )- db_session_with_containers.add(saved)- db_session_with_containers.commit()-- SavedMessageService.delete(- app_model=app, user=end_user, message_id=message.id, session=db_session_with_containers- )-- assert (- db_session_with_containers.query(SavedMessage)- .where(SavedMessage.app_id == app.id, SavedMessage.message_id == message.id)- .first()- is None- )-- def test_delete_only_affects_own_saved_messages(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """Test that delete only removes the requesting user's saved message."""- app, account1 = self._create_test_app_and_account(- db_session_with_containers, mock_external_service_dependencies- )- end_user = self._create_test_end_user(db_session_with_containers, app)- message = self._create_test_message(db_session_with_containers, app, account1)-- # Both users save the same message- saved_account = SavedMessage(- app_id=app.id, message_id=message.id, created_by_role=CreatorUserRole.ACCOUNT, created_by=account1.id- )- saved_end_user = SavedMessage(- app_id=app.id, message_id=message.id, created_by_role=CreatorUserRole.END_USER, created_by=end_user.id- )- db_session_with_containers.add_all([saved_account, saved_end_user])- db_session_with_containers.commit()-- # Delete only account1's saved message- SavedMessageService.delete(- app_model=app, user=account1, message_id=message.id, session=db_session_with_containers- )-- # Account's saved message should be gone- assert (- db_session_with_containers.query(SavedMessage)- .where(- SavedMessage.app_id == app.id,- SavedMessage.message_id == message.id,- SavedMessage.created_by == account1.id,- )- .first()- is None- )- # End user's saved message should still exist- assert (- db_session_with_containers.query(SavedMessage)- .where(- SavedMessage.app_id == app.id,- SavedMessage.message_id == message.id,- SavedMessage.created_by == end_user.id,- )- .first()- is not None- )diff --git a/api/tests/unit_tests/controllers/console/explore/test_saved_message.py b/api/tests/unit_tests/controllers/console/explore/test_saved_message.pyindex a55500690be..6b5e91c49ab 100644--- a/api/tests/unit_tests/controllers/console/explore/test_saved_message.py+++ b/api/tests/unit_tests/controllers/console/explore/test_saved_message.py@@ -1,253 +1,316 @@-from decimal import Decimal+from collections.abc import Generator+from dataclasses import dataclass+from datetime import UTC, datetimefrom inspect import unwrap-from unittest.mock import MagicMock, PropertyMock, patch+from unittest.mock import MagicMock, patchfrom uuid import uuid4import pytestfrom flask import Flask-from sqlalchemy.orm import Session, scoped_session, sessionmakerfrom werkzeug.exceptions import NotFoundimport controllers.console.explore.saved_message as module+from controllers.console.app.error import AppUnavailableErrorfrom controllers.console.explore.error import NotCompletionAppError-from models import Account-from models.enums import ConversationFromSource, FeedbackFromSource, FeedbackRating-from models.model import App, AppMode, InstalledApp, Message, MessageFeedback-from services.errors.message import MessageNotExistsError---def make_message(session: Session, *, app_id: str, account_id: str) -> Message:- message = Message(- id=str(uuid4()),- app_id=app_id,- conversation_id=str(uuid4()),- query="hello",- message={"role": "user", "content": "hello"},- answer="world",- message_tokens=1,- message_unit_price=Decimal(0),- answer_tokens=1,- answer_unit_price=Decimal(0),- provider_response_latency=0,- currency="USD",- from_source=ConversationFromSource.API,- from_account_id=account_id,- app_mode=AppMode.COMPLETION,- )- message._inputs = {}- message.status = "normal"- session.add(message)- session.flush()- session.add(- MessageFeedback(- app_id=app_id,- conversation_id=message.conversation_id,- message_id=message.id,- rating=FeedbackRating.LIKE,- from_source=FeedbackFromSource.USER,- from_account_id=account_id,- )- )- session.flush()- return message---def make_installed_app(session: Session, mode: AppMode | str) -> InstalledApp:- app_model = App(- tenant_id="owner-tenant",- name="Explore App",- mode=AppMode.value_of(mode),- enable_site=True,- enable_api=False,- )- session.add(app_model)- session.flush()- installed_app = InstalledApp(- tenant_id="viewer-tenant",- app_id=app_model.id,- app_owner_tenant_id=app_model.tenant_id,+from controllers.console.explore.wraps import InstalledAppResource+from graphon.file import File, FileTransferMethod, FileType+from models.model import InstalledApp+from services.errors.message import LastMessageNotExistsError, MessageNotExistsError+from services.saved_message_service import (+ SavedMessageActor,+ SavedMessageFeedback,+ SavedMessageFileRecord,+ SavedMessagePage,+ SavedMessageRecord,+)++_INPUT_FILE_URL = "https://example.com/input.pdf"+_CREATED_AT = datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)+_ACCOUNT_ID = "11111111-1111-4111-8111-111111111111"+_WORKSPACE_ID = "22222222-2222-4222-8222-222222222222"+++@dataclass(frozen=True)+class _ApplicationServiceMocks:+ app_definitions: MagicMock+ saved_messages: MagicMock+++def _installed_app() -> InstalledApp:+ return InstalledApp(+ tenant_id=_WORKSPACE_ID,+ app_id="33333333-3333-4333-8333-333333333333",+ app_owner_tenant_id="44444444-4444-4444-8444-444444444444",position=0,is_pinned=False,last_used_at=None,)- session.add(installed_app)- session.commit()- return installed_app-def payload_patch():- def _patch(payload):- return patch.object(- type(module.console_ns),- "payload",- new_callable=PropertyMock,- return_value=payload,- )+def _record() -> SavedMessageRecord:+ input_file = File(+ file_id="66666666-6666-4666-8666-666666666666",+ file_type=FileType.DOCUMENT,+ transfer_method=FileTransferMethod.REMOTE_URL,+ remote_url=_INPUT_FILE_URL,+ filename="input.pdf",+ extension=".pdf",+ mime_type="application/pdf",+ size=12,+ )+ return SavedMessageRecord(+ id="55555555-5555-4555-8555-555555555555",+ inputs={"topic": "hello", "document": input_file},+ query="hello",+ answer="world",+ message_files=[+ SavedMessageFileRecord(+ id="77777777-7777-4777-8777-777777777777",+ filename="attachment.pdf",+ type="document",+ url="https://example.com/attachment.pdf",+ mime_type="application/pdf",+ size=34,+ transfer_method="remote_url",+ belongs_to="user",+ upload_file_id="88888888-8888-4888-8888-888888888888",+ )+ ],+ user_feedback=SavedMessageFeedback(rating="like"),+ created_at=_CREATED_AT,+ )- return _patch+def _expected_record() -> dict[str, object]:+ return {+ "id": "55555555-5555-4555-8555-555555555555",+ "inputs": {+ "topic": "hello",+ "document": {+ "dify_model_identity": "__dify__file__",+ "id": "66666666-6666-4666-8666-666666666666",+ "type": "document",+ "transfer_method": "remote_url",+ "remote_url": _INPUT_FILE_URL,+ "reference": None,+ "filename": "input.pdf",+ "extension": ".pdf",+ "mime_type": "application/pdf",+ "size": 12,+ "related_id": None,+ "url": _INPUT_FILE_URL,+ },+ },+ "query": "hello",+ "answer": "world",+ "message_files": [+ {+ "id": "77777777-7777-4777-8777-777777777777",+ "filename": "attachment.pdf",+ "type": "document",+ "url": "https://example.com/attachment.pdf",+ "mime_type": "application/pdf",+ "size": 34,+ "transfer_method": "remote_url",+ "belongs_to": "user",+ "upload_file_id": "88888888-8888-4888-8888-888888888888",+ }+ ],+ "feedback": {"rating": "like"},+ "created_at": 1767323045,+ }-class _UsesSQLiteSession:- sqlite_session: Session- account: Account- @pytest.fixture(autouse=True)- def _bind_database(- self,- sqlite_session: Session,- sqlite_session_factory: sessionmaker[Session],- monkeypatch: pytest.MonkeyPatch,+def services() -> Generator[_ApplicationServiceMocks]:+ service_mocks = _ApplicationServiceMocks(+ app_definitions=MagicMock(),+ saved_messages=MagicMock(),+ )+ service_mocks.app_definitions.get_mode.return_value = "completion"+ with patch.object(+ module,+ "application_services",+ return_value=service_mocks,):- self.sqlite_session = sqlite_session- self.account = Account(name="User", email="[email protected]")- self.sqlite_session.add(self.account)- self.sqlite_session.commit()- session_proxy = scoped_session(sqlite_session_factory)- monkeypatch.setattr(module.db, "session", session_proxy)- yield- session_proxy.remove()+ yield service_mocks-class TestSavedMessageListApi(_UsesSQLiteSession):- def test_get_success(self, app: Flask):- api = module.SavedMessageListApi()- method = unwrap(api.get)+def test_saved_message_resources_use_installed_app_admission() -> None:+ assert issubclass(module.SavedMessageListApi, InstalledAppResource)+ assert issubclass(module.SavedMessageApi, InstalledAppResource)- installed_app = make_installed_app(self.sqlite_session, mode=AppMode.COMPLETION)- pagination = MagicMock(+class TestSavedMessageListApi:+ def test_get_success(self, app: Flask, services: _ApplicationServiceMocks) -> None:+ installed_app = _installed_app()+ services.saved_messages.pagination_by_last_id.return_value = SavedMessagePage(limit=20,has_more=False,- data=[- make_message(self.sqlite_session, app_id=installed_app.app_id, account_id=self.account.id),- make_message(self.sqlite_session, app_id=installed_app.app_id, account_id=self.account.id),- ],+ data=(_record(),),)- self.sqlite_session.commit()with (app.test_request_context("/", query_string={}),- patch.object(- module.SavedMessageService,- "pagination_by_last_id",- return_value=pagination,- ) as pagination_mock,+ patch.object(File, "generate_url", return_value=_INPUT_FILE_URL),):- result = method(api, module.SavedMessageListQuery.model_validate({}), self.account, installed_app)-- pagination_mock.assert_called_once()- assert pagination_mock.call_args.args[1] is self.account- assert result["limit"] == 20- assert result["has_more"] is False- assert len(result["data"]) == 2-- def test_get_with_query_params(self, app: Flask):- api = module.SavedMessageListApi()- method = unwrap(api.get)-- installed_app = make_installed_app(self.sqlite_session, mode=AppMode.COMPLETION)-- pagination = MagicMock(- limit=50,- has_more=True,- data=[- make_message(self.sqlite_session, app_id=installed_app.app_id, account_id=self.account.id),- ],+ result = unwrap(module.SavedMessageListApi().get)(+ module.SavedMessageListApi(),+ module.SavedMessageListQuery.model_validate({}),+ _ACCOUNT_ID,+ installed_app,+ )++ services.app_definitions.get_mode.assert_called_once_with(installed_app.app_id)+ services.saved_messages.pagination_by_last_id.assert_called_once_with(+ app_id=installed_app.app_id,+ actor=SavedMessageActor.account(_ACCOUNT_ID),+ last_id=None,+ limit=20,)- self.sqlite_session.commit()-+ assert result == {+ "limit": 20,+ "has_more": False,+ "data": [_expected_record()],+ }++ def test_get_forwards_query(self, app: Flask, services: _ApplicationServiceMocks) -> None:+ installed_app = _installed_app()last_id = str(uuid4())- query = module.SavedMessageListQuery.model_validate({"last_id": last_id, "limit": 50})-- with (- app.test_request_context("/", query_string={"last_id": last_id, "limit": "50"}),- patch.object(- module.SavedMessageService,- "pagination_by_last_id",- return_value=pagination,- ) as pagination_mock,- ):- result = method(api, query, self.account, installed_app)-- pagination_mock.assert_called_once()- assert pagination_mock.call_args.args[1] is self.account- assert pagination_mock.call_args.args[2] == last_id- assert pagination_mock.call_args.args[3] == 50- assert result["limit"] == 50- assert result["has_more"] is True+ services.saved_messages.pagination_by_last_id.return_value = SavedMessagePage(limit=50, has_more=True, data=())++ with app.test_request_context("/", query_string={"last_id": last_id, "limit": "50"}):+ result = unwrap(module.SavedMessageListApi().get)(+ module.SavedMessageListApi(),+ module.SavedMessageListQuery.model_validate({"last_id": last_id, "limit": "50"}),+ _ACCOUNT_ID,+ installed_app,+ )++ services.saved_messages.pagination_by_last_id.assert_called_once_with(+ app_id=installed_app.app_id,+ actor=SavedMessageActor.account(_ACCOUNT_ID),+ last_id=last_id,+ limit=50,+ )- def test_get_not_completion_app(self):- api = module.SavedMessageListApi()- method = unwrap(api.get)+ assert result == {"limit": 50, "has_more": True, "data": []}- installed_app = make_installed_app(self.sqlite_session, mode=AppMode.CHAT)+ @pytest.mark.parametrize("query_string", [{"limit": "0"}, {"limit": "101"}, {"last_id": "invalid-uuid"}])+ def test_get_rejects_invalid_query(self, services: _ApplicationServiceMocks, query_string: dict[str, str]) -> None:+ http_app = Flask(__name__)- with pytest.raises(NotCompletionAppError):- method(api, module.SavedMessageListQuery.model_validate({}), self.account, installed_app)+ @http_app.get("/saved-messages")+ def get_saved_messages() -> dict[str, object]:+ return module.SavedMessageListApi().get(_installed_app())- def test_post_success(self, app: Flask, payload_patch):- api = module.SavedMessageListApi()- method = unwrap(api.post)+ with patch(+ "controllers.console.wraps.current_account_with_tenant",+ return_value=(MagicMock(id=_ACCOUNT_ID), _WORKSPACE_ID),+ ):+ response = http_app.test_client().get("/saved-messages", query_string=query_string)- installed_app = make_installed_app(self.sqlite_session, mode=AppMode.COMPLETION)+ assert response.status_code == 422+ services.app_definitions.get_mode.assert_not_called()+ services.saved_messages.pagination_by_last_id.assert_not_called()- payload = {"message_id": str(uuid4())}+ def test_get_preserves_invalid_last_id_context(self, app: Flask, services: _ApplicationServiceMocks) -> None:+ installed_app = _installed_app()+ last_id = str(uuid4())+ description = "The last_id cursor does not belong to the current saved messages."+ services.saved_messages.pagination_by_last_id.side_effect = LastMessageNotExistsError(description)with (- app.test_request_context("/", json=payload),- payload_patch(payload),- patch.object(module.SavedMessageService, "save") as save_mock,+ app.test_request_context("/", query_string={"last_id": last_id}),+ pytest.raises(LastMessageNotExistsError, match="last_id") as raised,):- result = method(api, module.SavedMessageCreatePayload.model_validate(payload), self.account, installed_app)+ unwrap(module.SavedMessageListApi().get)(+ module.SavedMessageListApi(),+ module.SavedMessageListQuery.model_validate({"last_id": last_id}),+ _ACCOUNT_ID,+ installed_app,+ )++ assert raised.value.description == description++ def test_get_rejects_missing_app(self, app: Flask, services: _ApplicationServiceMocks) -> None:+ services.app_definitions.get_mode.side_effect = module.AppDefinitionUnavailableError++ with app.test_request_context("/"), pytest.raises(AppUnavailableError):+ unwrap(module.SavedMessageListApi().get)(+ module.SavedMessageListApi(),+ module.SavedMessageListQuery.model_validate({}),+ _ACCOUNT_ID,+ _installed_app(),+ )++ def test_get_rejects_non_completion_app(self, app: Flask, services: _ApplicationServiceMocks) -> None:+ services.app_definitions.get_mode.return_value = "chat"++ with app.test_request_context("/"), pytest.raises(NotCompletionAppError):+ unwrap(module.SavedMessageListApi().get)(+ module.SavedMessageListApi(),+ module.SavedMessageListQuery.model_validate({}),+ _ACCOUNT_ID,+ _installed_app(),+ )++ def test_post_success(self, services: _ApplicationServiceMocks) -> None:+ installed_app = _installed_app()+ message_id = str(uuid4())++ result = unwrap(module.SavedMessageListApi().post)(+ module.SavedMessageListApi(),+ module.SavedMessageCreatePayload.model_validate({"message_id": message_id}),+ _ACCOUNT_ID,+ installed_app,+ )- save_mock.assert_called_once()- assert save_mock.call_args.args[1] is self.account+ services.saved_messages.save.assert_called_once_with(+ app_id=installed_app.app_id,+ actor=SavedMessageActor.account(_ACCOUNT_ID),+ message_id=message_id,+ )assert result == {"result": "success"}- def test_post_message_not_exists(self, app: Flask, payload_patch):- api = module.SavedMessageListApi()- method = unwrap(api.post)-- installed_app = make_installed_app(self.sqlite_session, mode=AppMode.COMPLETION)-- payload = {"message_id": str(uuid4())}-- with (- app.test_request_context("/", json=payload),- payload_patch(payload),- patch.object(- module.SavedMessageService,- "save",- side_effect=MessageNotExistsError(),- ),- ):- with pytest.raises(NotFound):- method(api, module.SavedMessageCreatePayload.model_validate(payload), self.account, installed_app)+ def test_post_maps_missing_message_to_not_found(self, services: _ApplicationServiceMocks) -> None:+ services.saved_messages.save.side_effect = MessageNotExistsError()+ with pytest.raises(NotFound, match="Message Not Exists"):+ unwrap(module.SavedMessageListApi().post)(+ module.SavedMessageListApi(),+ module.SavedMessageCreatePayload.model_validate({"message_id": str(uuid4())}),+ _ACCOUNT_ID,+ _installed_app(),+ )-class TestSavedMessageApi(_UsesSQLiteSession):- def test_delete_success(self):- api = module.SavedMessageApi()- method = unwrap(api.delete)- installed_app = make_installed_app(self.sqlite_session, mode=AppMode.COMPLETION)+class TestSavedMessageApi:+ def test_delete_success(self, services: _ApplicationServiceMocks) -> None:+ installed_app = _installed_app()+ message_id = uuid4()- with (- patch.object(module.SavedMessageService, "delete") as delete_mock,- ):- result, status = method(api, self.account, installed_app, str(uuid4()))-- delete_mock.assert_called_once()- assert delete_mock.call_args.args[1] is self.account- assert status == 204- assert result == ""+ result = unwrap(module.SavedMessageApi().delete)(+ module.SavedMessageApi(),+ _ACCOUNT_ID,+ installed_app,+ message_id,+ )- def test_delete_not_completion_app(self):- api = module.SavedMessageApi()- method = unwrap(api.delete)+ services.saved_messages.delete.assert_called_once_with(+ app_id=installed_app.app_id,+ actor=SavedMessageActor.account(_ACCOUNT_ID),+ message_id=str(message_id),+ )+ assert result == ("", 204)- installed_app = make_installed_app(self.sqlite_session, mode=AppMode.CHAT)+ def test_delete_rejects_non_completion_app(self, services: _ApplicationServiceMocks) -> None:+ services.app_definitions.get_mode.return_value = "chat"with pytest.raises(NotCompletionAppError):- method(api, self.account, installed_app, str(uuid4()))+ unwrap(module.SavedMessageApi().delete)(+ module.SavedMessageApi(),+ _ACCOUNT_ID,+ _installed_app(),+ uuid4(),+ )diff --git a/api/tests/unit_tests/controllers/web/test_saved_message.py b/api/tests/unit_tests/controllers/web/test_saved_message.pyindex 11ef11da686..6e2f3def794 100644--- a/api/tests/unit_tests/controllers/web/test_saved_message.py+++ b/api/tests/unit_tests/controllers/web/test_saved_message.py@@ -1,8 +1,6 @@-"""Unit tests for controllers.web.saved_message endpoints."""--from __future__ import annotations--import inspect+from collections.abc import Generator+from datetime import UTC, datetime+from inspect import unwrapfrom types import SimpleNamespacefrom unittest.mock import MagicMock, patchfrom uuid import uuid4@@ -11,13 +9,24 @@ import pytestfrom flask import Flaskfrom werkzeug.exceptions import NotFound+import controllers.web.saved_message as modulefrom controllers.common.controller_schemas import SavedMessageCreatePayload, SavedMessageListQueryfrom controllers.web.error import NotCompletionAppError-from controllers.web.saved_message import SavedMessageApi, SavedMessageListApi+from graphon.file import File, FileTransferMethod, FileTypefrom models.model import App, AppMode, EndUser-from services.errors.message import MessageNotExistsError+from services.errors.message import LastMessageNotExistsError, MessageNotExistsError+from services.saved_message_service import (+ SavedMessageActor,+ SavedMessageFeedback,+ SavedMessageFileRecord,+ SavedMessagePage,+ SavedMessageRecord,+)from tests.unit_tests.model_factories import make_end_user+_INPUT_FILE_URL = "https://example.com/input.pdf"+_CREATED_AT = datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)+def _completion_app() -> App:return App(id="app-1", tenant_id="tenant-1", mode=AppMode.COMPLETION)@@ -31,78 +40,198 @@ def _end_user() -> EndUser:return make_end_user(end_user_id="eu-1")-# The @with_session and @model_validate decorators wrap the handler; tests call-# the undecorated function so they can pass the validated pydantic payload and a-# stub session directly and skip the flask request-parsing step.-_list_get = inspect.unwrap(SavedMessageListApi.get)-_list_post = inspect.unwrap(SavedMessageListApi.post)+def _record() -> SavedMessageRecord:+ input_file = File(+ file_id="66666666-6666-4666-8666-666666666666",+ file_type=FileType.DOCUMENT,+ transfer_method=FileTransferMethod.REMOTE_URL,+ remote_url=_INPUT_FILE_URL,+ filename="input.pdf",+ extension=".pdf",+ mime_type="application/pdf",+ size=12,+ )+ return SavedMessageRecord(+ id="55555555-5555-4555-8555-555555555555",+ inputs={"topic": "hello", "document": input_file},+ query="hello",+ answer="world",+ message_files=[+ SavedMessageFileRecord(+ id="77777777-7777-4777-8777-777777777777",+ filename="attachment.pdf",+ type="document",+ url="https://example.com/attachment.pdf",+ mime_type="application/pdf",+ size=34,+ transfer_method="remote_url",+ belongs_to="user",+ upload_file_id="88888888-8888-4888-8888-888888888888",+ )+ ],+ user_feedback=SavedMessageFeedback(rating="like"),+ created_at=_CREATED_AT,+ )+++def _expected_record() -> dict[str, object]:+ return {+ "id": "55555555-5555-4555-8555-555555555555",+ "inputs": {+ "topic": "hello",+ "document": {+ "dify_model_identity": "__dify__file__",+ "id": "66666666-6666-4666-8666-666666666666",+ "type": "document",+ "transfer_method": "remote_url",+ "remote_url": _INPUT_FILE_URL,+ "reference": None,+ "filename": "input.pdf",+ "extension": ".pdf",+ "mime_type": "application/pdf",+ "size": 12,+ "related_id": None,+ "url": _INPUT_FILE_URL,+ },+ },+ "query": "hello",+ "answer": "world",+ "message_files": [+ {+ "id": "77777777-7777-4777-8777-777777777777",+ "filename": "attachment.pdf",+ "type": "document",+ "url": "https://example.com/attachment.pdf",+ "mime_type": "application/pdf",+ "size": 34,+ "transfer_method": "remote_url",+ "belongs_to": "user",+ "upload_file_id": "88888888-8888-4888-8888-888888888888",+ }+ ],+ "feedback": {"rating": "like"},+ "created_at": 1767323045,+ }+++def saved_messages() -> Generator[MagicMock]:+ service = MagicMock()+ with patch.object(+ module,+ "application_services",+ return_value=SimpleNamespace(saved_messages=service),+ ):+ yield service+++_list_get = unwrap(module.SavedMessageListApi.get)+_list_post = unwrap(module.SavedMessageListApi.post)-# ----------------------------------------------------------------------------# SavedMessageListApi (GET)-# ---------------------------------------------------------------------------class TestSavedMessageListApiGet:- def test_non_completion_mode_raises(self, app: Flask) -> None:+ def test_non_completion_mode_raises(self, app: Flask, saved_messages: MagicMock) -> None:query = SavedMessageListQuery.model_validate({})- with app.test_request_context("/saved-messages"):- with pytest.raises(NotCompletionAppError):- _list_get(SavedMessageListApi(), query, MagicMock(), _chat_app(), _end_user())-- @patch("controllers.web.saved_message.SavedMessageService.pagination_by_last_id")- def test_happy_path(self, mock_paginate: MagicMock, app: Flask) -> None:- mock_paginate.return_value = SimpleNamespace(limit=20, has_more=False, data=[])- query = SavedMessageListQuery.model_validate({"limit": 20})+ with app.test_request_context("/saved-messages"), pytest.raises(NotCompletionAppError):+ _list_get(module.SavedMessageListApi(), query, _chat_app(), _end_user())- with app.test_request_context("/saved-messages?limit=20"):- result = _list_get(SavedMessageListApi(), query, MagicMock(), _completion_app(), _end_user())+ saved_messages.pagination_by_last_id.assert_not_called()- assert result["limit"] == 20- assert result["has_more"] is False+ def test_happy_path(self, app: Flask, saved_messages: MagicMock) -> None:+ saved_messages.pagination_by_last_id.return_value = SavedMessagePage(+ limit=20,+ has_more=False,+ data=(_record(),),+ )+ query = SavedMessageListQuery.model_validate({"limit": 20})+ app_model = _completion_app()+ end_user = _end_user()++ with (+ app.test_request_context("/saved-messages?limit=20"),+ patch.object(File, "generate_url", return_value=_INPUT_FILE_URL),+ ):+ result = _list_get(module.SavedMessageListApi(), query, app_model, end_user)++ saved_messages.pagination_by_last_id.assert_called_once_with(+ app_id=app_model.id,+ actor=SavedMessageActor.end_user(end_user.id),+ last_id=None,+ limit=20,+ )+ assert result == {"limit": 20, "has_more": False, "data": [_expected_record()]}++ def test_invalid_last_id_preserves_error_context(self, app: Flask, saved_messages: MagicMock) -> None:+ last_id = str(uuid4())+ description = "The last_id cursor does not belong to the current saved messages."+ saved_messages.pagination_by_last_id.side_effect = LastMessageNotExistsError(description)+ query = SavedMessageListQuery.model_validate({"last_id": last_id})++ with (+ app.test_request_context(f"/saved-messages?last_id={last_id}"),+ pytest.raises(LastMessageNotExistsError, match="last_id") as raised,+ ):+ _list_get(module.SavedMessageListApi(), query, _completion_app(), _end_user())++ assert raised.value.description == description-# ----------------------------------------------------------------------------# SavedMessageListApi (POST)-# ---------------------------------------------------------------------------class TestSavedMessageListApiPost:- def test_non_completion_mode_raises(self, app: Flask) -> None:+ def test_non_completion_mode_raises(self, app: Flask, saved_messages: MagicMock) -> None:payload = SavedMessageCreatePayload.model_validate({"message_id": str(uuid4())})- with app.test_request_context("/saved-messages", method="POST"):- with pytest.raises(NotCompletionAppError):- _list_post(SavedMessageListApi(), payload, MagicMock(), _chat_app(), _end_user())+ with app.test_request_context("/saved-messages", method="POST"), pytest.raises(NotCompletionAppError):+ _list_post(module.SavedMessageListApi(), payload, _chat_app(), _end_user())- @patch("controllers.web.saved_message.SavedMessageService.save")- def test_save_success(self, mock_save: MagicMock, app: Flask) -> None:- payload = SavedMessageCreatePayload.model_validate({"message_id": str(uuid4())})+ saved_messages.save.assert_not_called()++ def test_save_success(self, app: Flask, saved_messages: MagicMock) -> None:+ message_id = str(uuid4())+ payload = SavedMessageCreatePayload.model_validate({"message_id": message_id})+ app_model = _completion_app()+ end_user = _end_user()with app.test_request_context("/saved-messages", method="POST"):- result = _list_post(SavedMessageListApi(), payload, MagicMock(), _completion_app(), _end_user())+ result = _list_post(module.SavedMessageListApi(), payload, app_model, end_user)- assert result["result"] == "success"+ saved_messages.save.assert_called_once_with(+ app_id=app_model.id,+ actor=SavedMessageActor.end_user(end_user.id),+ message_id=message_id,+ )+ assert result == {"result": "success"}- @patch("controllers.web.saved_message.SavedMessageService.save", side_effect=MessageNotExistsError())- def test_save_not_found(self, mock_save: MagicMock, app: Flask) -> None:+ def test_save_not_found(self, app: Flask, saved_messages: MagicMock) -> None:+ saved_messages.save.side_effect = MessageNotExistsError()payload = SavedMessageCreatePayload.model_validate({"message_id": str(uuid4())})- with app.test_request_context("/saved-messages", method="POST"):- with pytest.raises(NotFound, match="Message Not Exists"):- _list_post(SavedMessageListApi(), payload, MagicMock(), _completion_app(), _end_user())+ with (+ app.test_request_context("/saved-messages", method="POST"),+ pytest.raises(NotFound, match="Message Not Exists"),+ ):+ _list_post(module.SavedMessageListApi(), payload, _completion_app(), _end_user())-# ----------------------------------------------------------------------------# SavedMessageApi (DELETE)-# ---------------------------------------------------------------------------class TestSavedMessageApi:- def test_non_completion_mode_raises(self, app: Flask) -> None:- msg_id = uuid4()- with app.test_request_context(f"/saved-messages/{msg_id}", method="DELETE"):- with pytest.raises(NotCompletionAppError):- SavedMessageApi().delete(_chat_app(), _end_user(), msg_id)-- @patch("controllers.web.saved_message.SavedMessageService.delete")- def test_delete_success(self, mock_delete: MagicMock, app: Flask) -> None:- msg_id = uuid4()- with app.test_request_context(f"/saved-messages/{msg_id}", method="DELETE"):- result, status = SavedMessageApi().delete(_completion_app(), _end_user(), msg_id)-- assert status == 204- assert result == ""+ def test_non_completion_mode_raises(self, app: Flask, saved_messages: MagicMock) -> None:+ message_id = uuid4()+ with (+ app.test_request_context(f"/saved-messages/{message_id}", method="DELETE"),+ pytest.raises(NotCompletionAppError),+ ):+ module.SavedMessageApi().delete(_chat_app(), _end_user(), message_id)++ saved_messages.delete.assert_not_called()++ def test_delete_success(self, app: Flask, saved_messages: MagicMock) -> None:+ message_id = uuid4()+ app_model = _completion_app()+ end_user = _end_user()+ with app.test_request_context(f"/saved-messages/{message_id}", method="DELETE"):+ result = module.SavedMessageApi().delete(app_model, end_user, message_id)++ saved_messages.delete.assert_called_once_with(+ app_id=app_model.id,+ actor=SavedMessageActor.end_user(end_user.id),+ message_id=str(message_id),+ )+ assert result == ("", 204)diff --git a/api/tests/unit_tests/repositories/test_app_definition_query_repository.py b/api/tests/unit_tests/repositories/test_app_definition_query_repository.pyindex cc9c851bddf..a4888797492 100644--- a/api/tests/unit_tests/repositories/test_app_definition_query_repository.py+++ b/api/tests/unit_tests/repositories/test_app_definition_query_repository.py@@ -53,6 +53,21 @@ def _persist_app(return app+def test_get_mode_returns_none_for_missing_app(sqlite_session_factory: sessionmaker[Session]) -> None:+ repository = AppDefinitionQueryRepository(session_factory=sqlite_session_factory)++ assert repository.get_mode(_APP_ID) is None+++def test_get_mode_returns_app_mode(sqlite_session_factory: sessionmaker[Session]) -> None:+ with sqlite_session_factory.begin() as session:+ _persist_app(session, mode=AppMode.COMPLETION)++ repository = AppDefinitionQueryRepository(session_factory=sqlite_session_factory)++ assert repository.get_mode(_APP_ID) == AppMode.COMPLETION.value++def test_get_published_parameter_config_returns_none_for_missing_app(sqlite_session_factory: sessionmaker[Session],) -> None:diff --git a/api/tests/unit_tests/repositories/test_saved_message_repository.py b/api/tests/unit_tests/repositories/test_saved_message_repository.pynew file mode 100644index 00000000000..30201dcac61--- /dev/null+++ b/api/tests/unit_tests/repositories/test_saved_message_repository.py@@ -0,0 +1,311 @@+from datetime import datetime+from decimal import Decimal+from uuid import uuid4++import pytest+from sqlalchemy import func, select+from sqlalchemy.orm import Session, sessionmaker++from models.enums import (+ ConversationFromSource,+ CreatorUserRole,+ FeedbackFromSource,+ FeedbackRating,+)+from models.model import App, AppMode, Message, MessageFeedback+from models.web import SavedMessage+from repositories.saved_message_repository import SQLAlchemySavedMessageRepository+from services.errors.message import LastMessageNotExistsError, MessageNotExistsError+from services.saved_message_service import SavedMessageActor++_APP_ID = "11111111-1111-4111-8111-111111111111"+_OTHER_APP_ID = "22222222-2222-4222-8222-222222222222"+_ACCOUNT_ID = "33333333-3333-4333-8333-333333333333"+_END_USER_ID = "44444444-4444-4444-8444-444444444444"+_OTHER_ACCOUNT_ID = "66666666-6666-4666-8666-666666666666"+++def _persist_app(session: Session, *, app_id: str = _APP_ID, mode: AppMode = AppMode.COMPLETION) -> App:+ app = App(+ id=app_id,+ tenant_id="55555555-5555-4555-8555-555555555555",+ name="Saved message app",+ description="",+ mode=mode,+ icon_type=None,+ icon=None,+ icon_background=None,+ enable_site=True,+ enable_api=True,+ is_public=True,+ max_active_requests=None,+ )+ session.add(app)+ session.flush()+ return app+++def _persist_message(+ session: Session,+ *,+ app_id: str = _APP_ID,+ actor: SavedMessageActor,+ created_at: datetime,+ feedback: FeedbackRating | None = None,+) -> Message:+ message = Message(+ id=str(uuid4()),+ app_id=app_id,+ conversation_id=str(uuid4()),+ query="hello",+ message={"role": "user", "content": "hello"},+ answer="world",+ message_tokens=1,+ message_unit_price=Decimal(0),+ answer_tokens=1,+ answer_unit_price=Decimal(0),+ provider_response_latency=0,+ currency="USD",+ from_source=(ConversationFromSource.CONSOLE if actor.role == "account" else ConversationFromSource.API),+ from_end_user_id=actor.id if actor.role == "end_user" else None,+ from_account_id=actor.id if actor.role == "account" else None,+ app_mode=AppMode.COMPLETION,+ )+ message._inputs = {"topic": "test"}+ message.created_at = created_at+ session.add(message)+ session.flush()+ if feedback is not None:+ session.add(+ MessageFeedback(+ app_id=app_id,+ conversation_id=message.conversation_id,+ message_id=message.id,+ rating=feedback,+ from_source=FeedbackFromSource.USER,+ from_account_id=actor.id if actor.role == "account" else None,+ from_end_user_id=actor.id if actor.role == "end_user" else None,+ )+ )+ return message+++def _save_message(session: Session, *, app_id: str, actor: SavedMessageActor, message_id: str) -> None:+ session.add(+ SavedMessage(+ app_id=app_id,+ message_id=message_id,+ created_by_role=CreatorUserRole(actor.role),+ created_by=actor.id,+ )+ )+ session.flush()+++def _repository(session_factory: sessionmaker[Session]) -> SQLAlchemySavedMessageRepository:+ return SQLAlchemySavedMessageRepository(session_factory=session_factory)+++def test_list_returns_detached_records(+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ account = SavedMessageActor.account(_ACCOUNT_ID)+ with sqlite_session_factory.begin() as session:+ _persist_app(session)+ oldest = _persist_message(session, actor=account, created_at=datetime(2026, 1, 1))+ middle = _persist_message(session, actor=account, created_at=datetime(2026, 1, 2))+ newest = _persist_message(+ session,+ actor=account,+ created_at=datetime(2026, 1, 3),+ feedback=FeedbackRating.LIKE,+ )+ for message in (oldest, middle, newest):+ _save_message(session, app_id=_APP_ID, actor=account, message_id=message.id)++ result = _repository(sqlite_session_factory).pagination_by_last_id(+ app_id=_APP_ID,+ actor=account,+ last_id=None,+ limit=2,+ )++ assert result.limit == 2+ assert result.has_more is True+ assert [record.id for record in result.data] == [newest.id, middle.id]+ assert result.data[0].inputs == {"topic": "test"}+ assert result.data[0].message_files == []+ assert result.data[0].user_feedback is not None+ assert result.data[0].user_feedback.rating == FeedbackRating.LIKE.value+++ ("saved_app_id", "saved_actor"),+ [+ pytest.param(_OTHER_APP_ID, SavedMessageActor.account(_ACCOUNT_ID), id="app-id"),+ pytest.param(_APP_ID, SavedMessageActor.end_user(_ACCOUNT_ID), id="actor-role"),+ pytest.param(_APP_ID, SavedMessageActor.account(_OTHER_ACCOUNT_ID), id="actor-id"),+ ],+)+def test_list_excludes_saved_messages_outside_actor_scope(+ sqlite_session_factory: sessionmaker[Session],+ saved_app_id: str,+ saved_actor: SavedMessageActor,+) -> None:+ actor = SavedMessageActor.account(_ACCOUNT_ID)+ with sqlite_session_factory.begin() as session:+ _persist_app(session)+ if saved_app_id != _APP_ID:+ _persist_app(session, app_id=saved_app_id)+ owned = _persist_message(session, actor=actor, created_at=datetime(2026, 1, 1))+ out_of_scope = _persist_message(+ session,+ app_id=saved_app_id,+ actor=saved_actor,+ created_at=datetime(2026, 1, 2),+ )+ _save_message(session, app_id=_APP_ID, actor=actor, message_id=owned.id)+ _save_message(session, app_id=saved_app_id, actor=saved_actor, message_id=out_of_scope.id)++ result = _repository(sqlite_session_factory).pagination_by_last_id(+ app_id=_APP_ID,+ actor=actor,+ last_id=None,+ limit=20,+ )++ assert [record.id for record in result.data] == [owned.id]+++def test_list_paginates_after_last_id(sqlite_session_factory: sessionmaker[Session]) -> None:+ actor = SavedMessageActor.account(_ACCOUNT_ID)+ with sqlite_session_factory.begin() as session:+ _persist_app(session)+ oldest = _persist_message(session, actor=actor, created_at=datetime(2026, 1, 1))+ middle = _persist_message(session, actor=actor, created_at=datetime(2026, 1, 2))+ newest = _persist_message(session, actor=actor, created_at=datetime(2026, 1, 3))+ for message in (oldest, middle, newest):+ _save_message(session, app_id=_APP_ID, actor=actor, message_id=message.id)++ result = _repository(sqlite_session_factory).pagination_by_last_id(+ app_id=_APP_ID,+ actor=actor,+ last_id=middle.id,+ limit=20,+ )++ assert result.has_more is False+ assert [record.id for record in result.data] == [oldest.id]+++def test_list_rejects_last_id_outside_saved_set(sqlite_session_factory: sessionmaker[Session]) -> None:+ actor = SavedMessageActor.account(_ACCOUNT_ID)+ with sqlite_session_factory.begin() as session:+ _persist_app(session)+ saved = _persist_message(session, actor=actor, created_at=datetime(2026, 1, 1))+ not_saved = _persist_message(session, actor=actor, created_at=datetime(2026, 1, 2))+ _save_message(session, app_id=_APP_ID, actor=actor, message_id=saved.id)++ with pytest.raises(+ LastMessageNotExistsError,+ match=r"^The last_id cursor does not belong to the current saved messages\.$",+ ):+ _repository(sqlite_session_factory).pagination_by_last_id(+ app_id=_APP_ID,+ actor=actor,+ last_id=not_saved.id,+ limit=20,+ )+++def test_list_with_no_saved_messages_ignores_last_id(sqlite_session_factory: sessionmaker[Session]) -> None:+ result = _repository(sqlite_session_factory).pagination_by_last_id(+ app_id=_APP_ID,+ actor=SavedMessageActor.account(_ACCOUNT_ID),+ last_id=str(uuid4()),+ limit=20,+ )++ assert result.data == ()+ assert result.has_more is False+++ "actor",+ [+ pytest.param(SavedMessageActor.account(_ACCOUNT_ID), id="account"),+ pytest.param(SavedMessageActor.end_user(_END_USER_ID), id="end-user"),+ ],+)+def test_saved_message_lifecycle_is_actor_scoped_and_idempotent(+ sqlite_session_factory: sessionmaker[Session],+ actor: SavedMessageActor,+) -> None:+ with sqlite_session_factory.begin() as session:+ _persist_app(session)+ message = _persist_message(session, actor=actor, created_at=datetime(2026, 1, 1))++ repository = _repository(sqlite_session_factory)+ repository.save(app_id=_APP_ID, actor=actor, message_id=message.id)+ repository.save(app_id=_APP_ID, actor=actor, message_id=message.id)++ with sqlite_session_factory() as session:+ rows = session.scalars(select(SavedMessage)).all()+ assert [(row.created_by_role, row.created_by) for row in rows] == [(CreatorUserRole(actor.role), actor.id)]++ result = repository.pagination_by_last_id(app_id=_APP_ID, actor=actor, last_id=None, limit=20)+ assert [record.id for record in result.data] == [message.id]++ repository.delete(app_id=_APP_ID, actor=actor, message_id=message.id)+ repository.delete(app_id=_APP_ID, actor=actor, message_id=message.id)++ with sqlite_session_factory() as session:+ count = session.scalar(select(func.count()).select_from(SavedMessage))+ assert count == 0+++def test_save_rejects_message_owned_by_another_actor(sqlite_session_factory: sessionmaker[Session]) -> None:+ owner = SavedMessageActor.account(_ACCOUNT_ID)+ other = SavedMessageActor.account(str(uuid4()))+ with sqlite_session_factory.begin() as session:+ _persist_app(session)+ message = _persist_message(session, actor=owner, created_at=datetime(2026, 1, 1))++ with pytest.raises(MessageNotExistsError):+ _repository(sqlite_session_factory).save(app_id=_APP_ID, actor=other, message_id=message.id)+++ ("saved_app_id", "saved_actor"),+ [+ pytest.param(_OTHER_APP_ID, SavedMessageActor.account(_ACCOUNT_ID), id="app-id"),+ pytest.param(_APP_ID, SavedMessageActor.end_user(_ACCOUNT_ID), id="actor-role"),+ pytest.param(_APP_ID, SavedMessageActor.account(_OTHER_ACCOUNT_ID), id="actor-id"),+ ],+)+def test_delete_preserves_saved_messages_outside_actor_scope(+ sqlite_session_factory: sessionmaker[Session],+ saved_app_id: str,+ saved_actor: SavedMessageActor,+) -> None:+ actor = SavedMessageActor.account(_ACCOUNT_ID)+ with sqlite_session_factory.begin() as session:+ _persist_app(session)+ if saved_app_id != _APP_ID:+ _persist_app(session, app_id=saved_app_id)+ message = _persist_message(+ session,+ app_id=saved_app_id,+ actor=saved_actor,+ created_at=datetime(2026, 1, 1),+ )+ _save_message(session, app_id=saved_app_id, actor=saved_actor, message_id=message.id)++ repository = _repository(sqlite_session_factory)+ repository.delete(app_id=_APP_ID, actor=actor, message_id=message.id)++ with sqlite_session_factory() as session:+ rows = session.scalars(select(SavedMessage)).all()+ assert [(row.app_id, row.created_by_role, row.created_by) for row in rows] == [+ (saved_app_id, CreatorUserRole(saved_actor.role), saved_actor.id)+ ]diff --git a/api/tests/unit_tests/services/test_app_definition_query_service.py b/api/tests/unit_tests/services/test_app_definition_query_service.pyindex 4a5d69bb15b..9987d4e50d3 100644--- a/api/tests/unit_tests/services/test_app_definition_query_service.py+++ b/api/tests/unit_tests/services/test_app_definition_query_service.py@@ -28,6 +28,22 @@ def _service() -> tuple[AppDefinitionQueryService, MagicMock]:)+def test_get_mode_returns_repository_value() -> None:+ service, definitions = _service()+ definitions.get_mode.return_value = "completion"++ assert service.get_mode("app-1") == "completion"+ definitions.get_mode.assert_called_once_with("app-1")+++def test_get_mode_rejects_missing_app() -> None:+ service, definitions = _service()+ definitions.get_mode.return_value = None++ with pytest.raises(AppDefinitionUnavailableError, match="App not found"):+ service.get_mode("missing")++def test_get_parameters_maps_published_config() -> None:service, definitions = _service()config = AppParameterConfig(