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(api): unify message list and detail queries (#43754)
非法操作69b58b68aa29
diff --git a/api/.importlinter b/api/.importlinterindex 09746fbc455..76eef4679d0 100644--- a/api/.importlinter+++ b/api/.importlinter@@ -398,11 +398,11 @@ forbidden_modules =sqlalchemywerkzeug-[importlinter:contract:installed-app-message-boundary]-name = Installed app message service is framework and persistence neutral+[importlinter:contract:message-query-boundary]+name = Message query service is framework and persistence neutraltype = forbiddensource_modules =- services.installed_app_message_service+ services.message_query_serviceforbidden_modules =controllersextensions@@ -412,15 +412,6 @@ forbidden_modules =sqlalchemywerkzeug-[importlinter:contract:installed-app-message-persistence-boundary]-name = Installed app message persistence does not call the legacy message service-type = forbidden-source_modules =- repositories.installed_app_message_repository-forbidden_modules =- services.message_service-allow_indirect_imports = True-[importlinter:contract:conversation-persistence-boundary]name = Conversation persistence does not call legacy conversation or workspace servicestype = forbidden@@ -1007,12 +998,11 @@ forbidden_modules =flaskmodelsrepositories- services.message_servicesqlalchemywerkzeug[importlinter:contract:message-suggested-questions-legacy-boundary]-name = Suggested questions do not return to the legacy message or generation service+name = Suggested questions do not return to the legacy generation servicetype = forbiddensource_modules =services.message_suggested_questions_service@@ -1020,7 +1010,6 @@ source_modules =services.message_suggested_questions_generatorrepositories.message_repositoryforbidden_modules =- services.message_serviceservices.app_generate_serviceallow_indirect_imports = Truediff --git a/api/controllers/console/app/message.py b/api/controllers/console/app/message.pyindex 5267a846f7e..b37eaaff6f1 100644--- a/api/controllers/console/app/message.py+++ b/api/controllers/console/app/message.py@@ -4,9 +4,7 @@ from uuid import UUIDfrom flask_restx import Resourcefrom pydantic import BaseModel, Field, field_validator-from sqlalchemy import exists, func, select-from sqlalchemy.orm import Session-from werkzeug.exceptions import NotFound+from sqlalchemy import func, selectfrom controllers.common.controller_schemas import MessageFeedbackPayload as _MessageFeedbackPayloadBasefrom controllers.common.errors import InternalServerError as InternalServerHTTPError@@ -14,9 +12,7 @@ from controllers.common.errors import MessageFeedbackRatingRequiredError, NotFoufrom controllers.common.fields import SimpleResultResponsefrom controllers.common.rbac import AgentId, PlainApp, RBACCheckfrom controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_models-from controllers.common.session import with_sessionfrom controllers.console import console_ns-from controllers.console.agent.app_helpers import resolve_agent_runtime_app_modelfrom controllers.console.app.error import (AppNotFoundError,AppUnavailableError,@@ -31,46 +27,40 @@ from controllers.console.flask_admission import console_account_admissionfrom controllers.console.wraps import (RBACPermission,account_initialization_required,- edit_permission_required,model_validate,rbac_permission_required,setup_required,- with_current_tenant_id,- with_current_user,)from core.entities.execution_extra_content import ExecutionExtraContentDomainModelfrom core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError+from enums.account import TenantAccountRolefrom extensions.ext_application_services import application_servicesfrom extensions.ext_database import dbfrom fields.base import ResponseModelfrom fields.conversation_fields import (MessageDetail as BaseMessageDetailResponse,)-from fields.conversation_fields import MessageResponseSourcefrom fields.message_fields import SuggestedQuestionsResponsefrom graphon.model_runtime.errors.invoke import InvokeErrorfrom libs.external_api import error_responsesfrom libs.helper import dump_response, uuid_value-from libs.infinite_scroll_pagination import InfiniteScrollPaginationfrom libs.login import login_requiredfrom machinery.context import RequestContext-from models.account import Accountfrom models.enums import FeedbackRating-from models.model import App, AppMode, Conversation, Message, MessageAnnotation+from models.model import App, AppMode, MessageAnnotationfrom services.agent.errors import AgentNotFoundError, AgentVersionNotFoundErrorfrom services.app.agent_app_contracts import AgentAppNotFoundErrorfrom services.app.console_service import ConsoleAppNotFoundErrorfrom services.app_definition_query_service import AppDefinitionUnavailableError-from services.conversation_service import ConversationServicefrom services.entities.message_entities import MessageAccountfrom services.errors.conversation import ConversationNotExistsErrorfrom services.errors.message import (FeedbackRatingRequiredError,+ FirstMessageNotExistsError,MessageActorNotFoundError,MessageNotExistsError,SuggestedQuestionsAfterAnswerDisabledError,)-from services.message_service import attach_message_extra_contentslogger = logging.getLogger(__name__)@@ -135,66 +125,47 @@ register_response_schema_models(@console_ns.route("/apps/<uuid:app_id>/chat-messages")class ChatMessageListApi(Resource):+ @error_responses(AppNotFoundError, AppUnavailableError)@console_ns.doc("list_chat_messages")@console_ns.doc(description="Get chat messages for a conversation with pagination")@console_ns.doc(params={"app_id": "Application ID", **query_params_from_model(ChatMessagesQuery)})- @console_ns.response(200, "Success", console_ns.models[MessageInfiniteScrollPaginationResponse.__name__])- @console_ns.response(404, "Conversation not found")- @login_required- @account_initialization_required- @setup_required- @edit_permission_required- @with_current_user- @rbac_permission_required(RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp()))- @with_session(write=False)- @get_app_model(mode=[AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT])+ @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[MessageInfiniteScrollPaginationResponse.__name__])+ @console_ns.response(HTTPStatus.NOT_FOUND, "Conversation not found")+ @console_account_admission(+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}),+ rbac_checks=(RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp()),),+ )@model_validate(ChatMessagesQuery)- def get(self, req_data: ChatMessagesQuery, session: Session, current_user: Account, app_model: App):- return _list_chat_messages(- args=req_data,- session=session,- app_model=app_model,- current_user=current_user,- )+ def get(self, req_data: ChatMessagesQuery, context: RequestContext, app_id: UUID) -> dict[str, object]:+ try:+ app = application_services().apps.console.get_reference(context, str(app_id))+ except ConsoleAppNotFoundError as exc:+ raise AppNotFoundError() from exc+ if app.mode not in (AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT):+ raise AppNotFoundError("App mode does not support chat messages")+ return _list_chat_messages(args=req_data, context=context, app_id=app.id)@console_ns.route("/agent/<uuid:agent_id>/chat-messages")class AgentChatMessageListApi(Resource):- @error_responses(AgentNotFoundError)+ @error_responses(AgentNotFoundError, AppUnavailableError)@console_ns.doc("list_agent_chat_messages")@console_ns.doc(description="Get Agent App chat messages for a conversation with pagination")@console_ns.doc(params={"agent_id": "Agent ID"})@console_ns.doc(params=query_params_from_model(ChatMessagesQuery))- @console_ns.response(200, "Success", console_ns.models[MessageInfiniteScrollPaginationResponse.__name__])- @console_ns.response(404, "Agent or conversation not found")- @login_required- @account_initialization_required- @setup_required- @edit_permission_required- @rbac_permission_required(RBACCheck(RBACPermission.AGENT_TEST_AND_RUN, AgentId()))- @with_current_user- @with_current_tenant_id- @with_session(write=False)+ @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[MessageInfiniteScrollPaginationResponse.__name__])+ @console_ns.response(HTTPStatus.NOT_FOUND, "Agent or conversation not found")+ @console_account_admission(+ allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}),+ rbac_checks=(RBACCheck(RBACPermission.AGENT_TEST_AND_RUN, AgentId()),),+ )@model_validate(ChatMessagesQuery)- def get(- self,- req_data: ChatMessagesQuery,- session: Session,- current_tenant_id: str,- current_user: Account,- agent_id: UUID,- ):- app_model = resolve_agent_runtime_app_model(- session=session,- tenant_id=current_tenant_id,- agent_id=agent_id,- )- return _list_chat_messages(- args=req_data,- session=session,- app_model=app_model,- current_user=current_user,- )+ def get(self, req_data: ChatMessagesQuery, context: RequestContext, agent_id: UUID) -> dict[str, object]:+ try:+ app_id = application_services().agent_apps.access.resolve_existing_runtime_app_id(context, str(agent_id))+ except AgentAppNotFoundError as exc:+ raise AgentNotFoundError() from exc+ return _list_chat_messages(args=req_data, context=context, app_id=app_id)@console_ns.route("/apps/<uuid:app_id>/feedbacks")@@ -339,125 +310,61 @@ class AgentMessageSuggestedQuestionApi(Resource):@console_ns.route("/apps/<uuid:app_id>/messages/<uuid:message_id>")class MessageApi(Resource):+ @error_responses(AppNotFoundError, AppUnavailableError)@console_ns.doc("get_message")@console_ns.doc(description="Get message details by ID")@console_ns.doc(params={"app_id": "Application ID", "message_id": "Message ID"})- @console_ns.response(200, "Message retrieved successfully", console_ns.models[MessageDetailResponse.__name__])- @console_ns.response(404, "Message not found")- @setup_required- @login_required- @account_initialization_required- @rbac_permission_required(RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp()))- @with_session(write=False)- @get_app_model- def get(self, session: Session, app_model: App, message_id: UUID):- return _get_message_detail(session=session, app_model=app_model, message_id=message_id)+ @console_ns.response(+ HTTPStatus.OK, "Message retrieved successfully", console_ns.models[MessageDetailResponse.__name__]+ )+ @console_ns.response(HTTPStatus.NOT_FOUND, "Message not found")+ @console_account_admission(rbac_checks=(RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp()),))+ def get(self, context: RequestContext, app_id: UUID, message_id: UUID) -> dict[str, object]:+ try:+ app = application_services().apps.console.get_reference(context, str(app_id))+ except ConsoleAppNotFoundError as exc:+ raise AppNotFoundError() from exc+ return _get_message_detail(context=context, app_id=app.id, message_id=message_id)@console_ns.route("/agent/<uuid:agent_id>/messages/<uuid:message_id>")class AgentMessageApi(Resource):- @error_responses(AgentNotFoundError)+ @error_responses(AgentNotFoundError, AppUnavailableError)@console_ns.doc("get_agent_message")@console_ns.doc(description="Get Agent App message details by ID")@console_ns.doc(params={"agent_id": "Agent ID", "message_id": "Message ID"})- @console_ns.response(200, "Message retrieved successfully", console_ns.models[MessageDetailResponse.__name__])- @console_ns.response(404, "Agent or message not found")- @setup_required- @login_required- @account_initialization_required- @rbac_permission_required(RBACCheck(RBACPermission.AGENT_TEST_AND_RUN, AgentId()))- @with_current_tenant_id- @with_session(write=False)- def get(self, session: Session, current_tenant_id: str, agent_id: UUID, message_id: UUID):- app_model = resolve_agent_runtime_app_model(- session=session,- tenant_id=current_tenant_id,- agent_id=agent_id,- )- return _get_message_detail(session=session, app_model=app_model, message_id=message_id)---def _list_chat_messages(- *,- args: ChatMessagesQuery,- session: Session,- app_model: App,- current_user: Account | None = None,-):- if AppMode.value_of(app_model.mode) == AppMode.AGENT and current_user is not None:+ @console_ns.response(+ HTTPStatus.OK, "Message retrieved successfully", console_ns.models[MessageDetailResponse.__name__]+ )+ @console_ns.response(HTTPStatus.NOT_FOUND, "Agent or message not found")+ @console_account_admission(rbac_checks=(RBACCheck(RBACPermission.AGENT_TEST_AND_RUN, AgentId()),))+ def get(self, context: RequestContext, agent_id: UUID, message_id: UUID) -> dict[str, object]:try:- conversation = ConversationService.get_conversation(- app_model=app_model,- conversation_id=args.conversation_id,- user=current_user,- session=session,- )- except ConversationNotExistsError as caught_error:- raise NotFound("Conversation Not Exists.") from caught_error- else:- conversation = session.scalar(- select(Conversation)- .where(Conversation.id == args.conversation_id, Conversation.app_id == app_model.id)- .limit(1)- )-- if not conversation:- raise NotFound("Conversation Not Exists.")-- if args.first_id:- first_message = session.scalar(- select(Message).where(Message.conversation_id == conversation.id, Message.id == args.first_id).limit(1)- )-- if not first_message:- raise NotFound("First message not found")-- history_messages = session.scalars(- select(Message)- .where(- Message.conversation_id == conversation.id,- Message.created_at < first_message.created_at,- Message.id != first_message.id,- )- .order_by(Message.created_at.desc())- .limit(args.limit)- ).all()- else:- history_messages = session.scalars(- select(Message)- .where(Message.conversation_id == conversation.id)- .order_by(Message.created_at.desc())- .limit(args.limit)- ).all()-- # Initialize has_more based on whether we have a full page- if len(history_messages) == args.limit:- current_page_first_message = history_messages[-1]- # Check if there are more messages before the current page- has_more = session.scalar(- select(- exists().where(- Message.conversation_id == conversation.id,- Message.created_at < current_page_first_message.created_at,- Message.id != current_page_first_message.id,- )- )- )- else:- # If we don't have a full page, there are no more messages- has_more = False+ app_id = application_services().agent_apps.access.resolve_existing_runtime_app_id(context, str(agent_id))+ except AgentAppNotFoundError as exc:+ raise AgentNotFoundError() from exc+ return _get_message_detail(context=context, app_id=app_id, message_id=message_id)- history_messages = list(reversed(history_messages))- attach_message_extra_contents(history_messages)- return dump_response(- MessageInfiniteScrollPaginationResponse,- InfiniteScrollPagination(- data=[MessageResponseSource(message, session=session) for message in history_messages],+def _list_chat_messages(*, args: ChatMessagesQuery, context: RequestContext, app_id: str) -> dict[str, object]:+ try:+ page = application_services().message_queries.get_console_page(+ app_id=app_id,+ app_owner_tenant_id=context.active_workspace_id,+ account_id=context.account_id,+ conversation_id=args.conversation_id,+ first_id=args.first_id,limit=args.limit,- has_more=has_more,- ),- )+ )+ except AppDefinitionUnavailableError as exc:+ raise AppUnavailableError() from exc+ except MessageActorNotFoundError as exc:+ raise UnauthorizedError("Account no longer exists") from exc+ except ConversationNotExistsError as exc:+ raise NotFoundError("Conversation Not Exists.") from exc+ except FirstMessageNotExistsError as exc:+ raise NotFoundError("First message not found") from exc+ return dump_response(MessageInfiniteScrollPaginationResponse, page)def _update_message_feedback(@@ -524,15 +431,18 @@ def _get_message_suggested_questions(return dump_response(SuggestedQuestionsResponse, {"data": questions})-def _get_message_detail(*, session: Session, app_model: App, message_id: UUID):- message_id_str = str(message_id)-- message = session.scalar(- select(Message).where(Message.id == message_id_str, Message.app_id == app_model.id).limit(1)- )-- if not message:- raise NotFound("Message Not Exists.")-- attach_message_extra_contents([message])- return dump_response(MessageDetailResponse, MessageResponseSource(message, session=session))+def _get_message_detail(*, context: RequestContext, app_id: str, message_id: UUID) -> dict[str, object]:+ try:+ message = application_services().message_queries.get_console_message(+ app_id=app_id,+ app_owner_tenant_id=context.active_workspace_id,+ account_id=context.account_id,+ message_id=str(message_id),+ )+ except AppDefinitionUnavailableError as exc:+ raise AppUnavailableError() from exc+ except MessageActorNotFoundError as exc:+ raise UnauthorizedError("Account no longer exists") from exc+ except MessageNotExistsError as exc:+ raise NotFoundError("Message Not Exists.") from exc+ return dump_response(MessageDetailResponse, message)diff --git a/api/controllers/console/explore/message.py b/api/controllers/console/explore/message.pyindex f3cee2cd6c5..2267f6c3ad7 100644--- a/api/controllers/console/explore/message.py+++ b/api/controllers/console/explore/message.py@@ -60,11 +60,11 @@ from services.errors.message import (SuggestedQuestionsAfterAnswerDisabledError,)from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppRef-from services.installed_app_message_service import MessageNotChatAppErrorfrom services.message_more_like_this_service import (MoreLikeThisConfigNotFoundError,MoreLikeThisNotCompletionError,)+from services.message_query_service import MessageNotChatAppErrorlogger = logging.getLogger(__name__)@@ -131,7 +131,9 @@ def _message_errors[**P, R](view: Callable[P, R]) -> Callable[P, R]:endpoint="installed_app_messages",)class MessageListApi(Resource):- @error_responses(ConversationNotFoundHTTPError, MessageCursorNotFoundHTTPError, NotChatAppError)+ @error_responses(+ AppUnavailableError, ConversationNotFoundHTTPError, MessageCursorNotFoundHTTPError, NotChatAppError+ )@console_ns.doc(params=query_params_from_model(MessageListQuery))@console_ns.response(HTTPStatus.OK, "Success", console_ns.models[ExploreMessageInfiniteScrollPagination.__name__])@console_account_admission()@@ -141,9 +143,11 @@ class MessageListApi(Resource):def get(self, query: MessageListQuery, request_context: RequestContext, installed_app: InstalledAppRef) -> dict[str, object]:- page = application_services().installed_apps.messages.get_page(+ page = application_services().message_queries.get_page(+ app_id=installed_app.app_id,+ app_owner_tenant_id=installed_app.app_owner_tenant_id,+ actor=MessageAccount(account_id=request_context.account_id),installed_app=installed_app,- account_id=request_context.account_id,conversation_id=query.conversation_id,first_id=query.first_id or None,limit=query.limit,diff --git a/api/controllers/service_api/app/message.py b/api/controllers/service_api/app/message.pyindex b6449d6513a..1d78daa20d5 100644--- a/api/controllers/service_api/app/message.py+++ b/api/controllers/service_api/app/message.py@@ -4,9 +4,8 @@ from typing import Annotatedfrom uuid import UUIDfrom flask_restx import Resource-from pydantic import BaseModel, Field, TypeAdapter, WithJsonSchema+from pydantic import BaseModel, Field, WithJsonSchema-import servicesfrom controllers.common.controller_schemas import MessageFeedbackPayload, MessageListQueryfrom controllers.common.errors import InternalServerError, MessageFeedbackRatingRequiredError, NotFoundErrorfrom controllers.common.fields import SimpleResultStringListResponse@@ -24,19 +23,18 @@ from controllers.service_api.app.error import ()from controllers.service_api.flask_admission import service_api_app_admission, service_api_end_user_admissionfrom controllers.service_api.schema import expect_with_user-from controllers.service_api.wraps import FetchUserArg, WhereisUserArg, validate_app_token+from controllers.service_api.wraps import FetchUserArg, WhereisUserArgfrom core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededErrorfrom extensions.ext_application_services import application_services-from extensions.ext_database import dbfrom fields.base import ResponseModel-from fields.conversation_fields import MessageResponseSource, ResultResponse+from fields.conversation_fields import ResultResponsefrom fields.message_fields import MessageInfiniteScrollPagination, MessageListItemfrom graphon.model_runtime.errors.invoke import InvokeErrorfrom libs.external_api import error_responsesfrom libs.helper import dump_responsefrom machinery.context import AppRequestContext, ServiceApiEndUserContextfrom models.enums import FeedbackRating-from models.model import App, AppMode, EndUser+from models.model import AppModefrom services.agent.errors import AgentVersionNotFoundErrorfrom services.app_definition_query_service import AppDefinitionUnavailableErrorfrom services.entities.message_entities import MessageEndUser@@ -48,7 +46,6 @@ from services.errors.message import (MessageNotExistsError,SuggestedQuestionsAfterAnswerDisabledError,)-from services.message_service import MessageServicelogger = logging.getLogger(__name__)@@ -92,7 +89,7 @@ register_response_schema_models(@service_api_ns.route("/messages")class MessageListApi(Resource):- @error_responses(NotChatAppError)+ @error_responses(AppUnavailableError, NotChatAppError)@service_api_ns.doc("list_messages")@service_api_ns.doc(summary="List Conversation Messages",@@ -102,57 +99,63 @@ class MessageListApi(Resource):),tags=["Conversations"],responses={- 200: "Successfully retrieved conversation history.",- 400: "`not_chat_app` : App mode does not match the API route.",- 404: "- `not_found` : Conversation does not exist.\n- `not_found` : First message does not exist.",+ HTTPStatus.OK: "Successfully retrieved conversation history.",+ HTTPStatus.BAD_REQUEST: (+ "`not_chat_app` : App mode does not match the API route. "+ "`app_unavailable` : App is no longer available."+ ),+ HTTPStatus.NOT_FOUND: (+ "- `not_found` : Conversation does not exist.\n- `not_found` : First message does not exist."+ ),},)@service_api_ns.doc(params=query_params_from_model(MessageListQuery))@service_api_ns.doc(description="List messages in a conversation")@service_api_ns.doc(responses={- 200: "Messages retrieved successfully",- 400: "`not_chat_app` : App mode does not match the API route.",- 401: "Unauthorized - invalid API token",- 404: "Conversation or first message not found",+ HTTPStatus.OK: "Messages retrieved successfully",+ HTTPStatus.BAD_REQUEST: (+ "`not_chat_app` : App mode does not match the API route. "+ "`app_unavailable` : App is no longer available."+ ),+ HTTPStatus.UNAUTHORIZED: "Unauthorized - invalid API token",+ HTTPStatus.NOT_FOUND: "Conversation or first message not found",})@service_api_ns.response(- 200,+ HTTPStatus.OK,"Messages retrieved successfully",service_api_ns.models[MessageInfiniteScrollPagination.__name__],)- @validate_app_token(fetch_user_arg=FetchUserArg(fetch_from=WhereisUserArg.QUERY))+ @service_api_end_user_admission(fetch_user_arg=FetchUserArg(fetch_from=WhereisUserArg.QUERY))@model_validate(MessageListQuery)- def get(self, query_args: MessageListQuery, app_model: App, end_user: EndUser):+ def get(self, query_args: MessageListQuery, context: ServiceApiEndUserContext) -> dict[str, object]:"""List messages in a conversation.Retrieves messages with pagination support using first_id."""- app_mode = AppMode.value_of(app_model.mode)+ app_mode = context.app_modeif app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}:raise NotChatAppError()- conversation_id = query_args.conversation_id- first_id = query_args.first_id or None-try:- session = db.session()- pagination = MessageService.pagination_by_first_id(- app_model, end_user, conversation_id, first_id, query_args.limit, session=session+ pagination = application_services().message_queries.get_page(+ app_id=context.app_id,+ app_owner_tenant_id=context.tenant_id,+ actor=MessageEndUser(end_user_id=context.end_user_id),+ conversation_id=query_args.conversation_id,+ first_id=query_args.first_id or None,+ limit=query_args.limit,)- adapter = TypeAdapter(MessageListItem)- items = [- adapter.validate_python(MessageResponseSource(message, session=session), from_attributes=True)- for message in pagination.data- ]- return MessageInfiniteScrollPagination(- limit=pagination.limit, has_more=pagination.has_more, data=items- ).model_dump(mode="json")- except services.errors.conversation.ConversationNotExistsError as caught_error:- raise NotFoundError("Conversation Not Exists.") from caught_error- except FirstMessageNotExistsError as caught_error:- raise NotFoundError("First Message Not Exists.") from caught_error+ return dump_response(MessageInfiniteScrollPagination, pagination)+ except AppDefinitionUnavailableError as error:+ raise AppUnavailableError() from error+ except MessageActorNotFoundError as error:+ raise NotFoundError("End user not found") from error+ except ConversationNotExistsError as error:+ raise NotFoundError("Conversation Not Exists.") from error+ except FirstMessageNotExistsError as error:+ raise NotFoundError("First Message Not Exists.") from error@service_api_ns.route("/messages/<uuid:message_id>/feedbacks")diff --git a/api/controllers/web/message.py b/api/controllers/web/message.pyindex c1162419e53..037a9642657 100644--- a/api/controllers/web/message.py+++ b/api/controllers/web/message.py@@ -4,7 +4,7 @@ from typing import Literalfrom uuid import UUIDfrom flask import Response-from pydantic import BaseModel, Field, TypeAdapter+from pydantic import BaseModel, Fieldfrom controllers.common.controller_schemas import MessageFeedbackPayload, MessageListQueryfrom controllers.common.errors import InternalServerError, MessageFeedbackRatingRequiredError, NotFoundError@@ -26,9 +26,8 @@ from controllers.web.error import (from controllers.web.wraps import WebApiResourcefrom core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededErrorfrom extensions.ext_application_services import application_services-from extensions.ext_database import db-from fields.conversation_fields import MessageResponseSource, ResultResponse-from fields.message_fields import SuggestedQuestionsResponse, WebMessageInfiniteScrollPagination, WebMessageListItem+from fields.conversation_fields import ResultResponse+from fields.message_fields import SuggestedQuestionsResponse, WebMessageInfiniteScrollPaginationfrom graphon.model_runtime.errors.invoke import InvokeErrorfrom libs import helperfrom libs.exception import BaseHTTPException@@ -52,7 +51,6 @@ from services.message_more_like_this_service import (MoreLikeThisConfigNotFoundError,MoreLikeThisNotCompletionError,)-from services.message_service import MessageServicelogger = logging.getLogger(__name__)@@ -75,45 +73,44 @@ register_response_schema_models(@web_ns.route("/messages")class MessageListApi(WebApiResource):- @error_responses(NotChatAppError)+ @error_responses(AppUnavailableError, NotChatAppError)@web_ns.doc("Get Message List")@web_ns.doc(description="Retrieve paginated list of messages from a conversation in a chat application.")@web_ns.doc(params=query_params_from_model(MessageListQuery))@web_ns.doc(responses={- 200: "Success",- 400: "Bad Request",- 401: "Unauthorized",- 404: "Conversation Not Found or Not a Chat App",- 500: "Internal Server Error",+ HTTPStatus.OK: "Success",+ HTTPStatus.BAD_REQUEST: "Bad Request - Not a chat app or app unavailable",+ HTTPStatus.UNAUTHORIZED: "Unauthorized",+ HTTPStatus.NOT_FOUND: "Conversation, First Message, or End User Not Found",+ HTTPStatus.INTERNAL_SERVER_ERROR: "Internal Server Error",})- @web_ns.response(200, "Success", web_ns.models[WebMessageInfiniteScrollPagination.__name__])+ @web_ns.response(HTTPStatus.OK, "Success", web_ns.models[WebMessageInfiniteScrollPagination.__name__])@model_validate(MessageListQuery)- def get(self, query: MessageListQuery, app_model: App, end_user: EndUser):+ def get(self, query: MessageListQuery, app_model: App, end_user: EndUser) -> dict[str, object]:app_mode = AppMode.value_of(app_model.mode)if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}:raise NotChatAppError()try:- session = db.session()- pagination = MessageService.pagination_by_first_id(- app_model, end_user, query.conversation_id, query.first_id, query.limit, session=session+ pagination = application_services().message_queries.get_page(+ app_id=app_model.id,+ app_owner_tenant_id=app_model.tenant_id,+ actor=MessageEndUser(end_user_id=end_user.id),+ conversation_id=query.conversation_id,+ first_id=query.first_id,+ limit=query.limit,)- adapter = TypeAdapter(WebMessageListItem)- items = [- adapter.validate_python(MessageResponseSource(message, session=session), from_attributes=True)- for message in pagination.data- ]- return WebMessageInfiniteScrollPagination(- limit=pagination.limit,- has_more=pagination.has_more,- data=items,- ).model_dump(mode="json")- except ConversationNotExistsError as caught_error:- raise NotFoundError("Conversation Not Exists.") from caught_error- except FirstMessageNotExistsError as caught_error:- raise NotFoundError("First Message Not Exists.") from caught_error+ return helper.dump_response(WebMessageInfiniteScrollPagination, pagination)+ except AppDefinitionUnavailableError as error:+ raise AppUnavailableError() from error+ except MessageActorNotFoundError as error:+ raise NotFoundError("End user not found") from error+ except ConversationNotExistsError as error:+ raise NotFoundError("Conversation Not Exists.") from error+ except FirstMessageNotExistsError as error:+ raise NotFoundError("First Message Not Exists.") from error@web_ns.route("/messages/<uuid:message_id>/feedbacks")diff --git a/api/extensions/application_services/installed_app.py b/api/extensions/application_services/installed_app.pyindex 30f6d66cfe8..81654b40259 100644--- a/api/extensions/application_services/installed_app.py+++ b/api/extensions/application_services/installed_app.py@@ -6,15 +6,12 @@ from flask import current_appfrom sqlalchemy.orm import Session, sessionmakerfrom repositories.installed_app_conversation_repository import SQLAlchemyInstalledAppConversationRepository-from repositories.installed_app_message_repository import SQLAlchemyInstalledAppMessageRepositoryfrom repositories.installed_app_repository import SQLAlchemyInstalledAppRepositoryfrom services.conversation_service import ConversationServicefrom services.installed_app_access_service import InstalledAppAccessServicefrom services.installed_app_conversation_service import InstalledAppConversationServicefrom services.installed_app_generation_adapters import AppGenerateServiceRuntimefrom services.installed_app_generation_service import InstalledAppGenerationService-from services.installed_app_message_adapters import InstalledAppMessageRuntime-from services.installed_app_message_service import InstalledAppMessageServicefrom services.installed_app_service import InstalledAppService, WorkspaceRoleLookupfrom services.webapp_access_query_service import WebAppAccessQueryService@@ -25,7 +22,6 @@ class InstalledAppServices:management: InstalledAppServicegeneration: InstalledAppGenerationServiceconversations: InstalledAppConversationService- messages: InstalledAppMessageServicedef _generate_installed_app_conversation_name(@@ -54,7 +50,6 @@ def build_installed_app_services(get_access_modes=webapp_access.batch_get_access_modes,get_user_permissions=webapp_access.batch_get_user_permissions,)- message_runtime = InstalledAppMessageRuntime(session_factory=database_client)return InstalledAppServices(access=access,management=InstalledAppService(@@ -71,8 +66,4 @@ def build_installed_app_services(generate_name=_generate_installed_app_conversation_name,enqueue_delete_cleanup=ConversationService.enqueue_delete_cleanup,),- messages=InstalledAppMessageService(- messages=SQLAlchemyInstalledAppMessageRepository(session_factory=database_client),- get_extra_contents=message_runtime.get_extra_contents,- ),)diff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.pyindex 1325b6db99b..3ff2e386901 100644--- a/api/extensions/ext_application_services.py+++ b/api/extensions/ext_application_services.py@@ -80,6 +80,7 @@ from repositories.plugin_file_upload_repository import SQLAlchemyPluginFileUploafrom repositories.recommended_app_catalog_repository import DatabaseRecommendedAppCatalogRepositoryfrom repositories.saved_message_repository import SQLAlchemySavedMessageRepositoryfrom repositories.sqlalchemy_api_workflow_run_repository import DifyAPISQLAlchemyWorkflowRunRepository+from repositories.sqlalchemy_execution_extra_content_repository import SQLAlchemyExecutionExtraContentRepositoryfrom repositories.step_by_step_tour_repository import SQLAlchemyStepByStepTourStateRepositoryfrom repositories.tag_repository import TagRepositoryfrom repositories.trial_app_repository import TrialAppRepository@@ -148,6 +149,8 @@ from services.message_feedback_service import MessageFeedbackServicefrom services.message_file_preview_service import MessageFilePreviewServicefrom services.message_more_like_this_generator import MessageMoreLikeThisGeneratorfrom services.message_more_like_this_service import MessageMoreLikeThisService+from services.message_query_adapters import ExecutionExtraContentReader, MessageFileResolver+from services.message_query_service import MessageQueryServicefrom services.message_suggested_questions_generator import SuggestedQuestionsGeneratorfrom services.message_suggested_questions_queries import SuggestedQuestionsQueryfrom services.message_suggested_questions_service import MessageSuggestedQuestions, MessageSuggestedQuestionsService@@ -303,6 +306,7 @@ class ApplicationServices:files: FileServicehuman_input_file_uploads: HumanInputFileUploadServicemessage_feedbacks: MessageFeedbackService+ message_queries: MessageQueryServicemessage_file_previews: MessageFilePreviewServicemessage_suggested_questions: MessageSuggestedQuestionsmessage_more_like_this: MessageMoreLikeThisService@@ -666,6 +670,13 @@ def build_application_services(remote_files=remote_file_service,),message_feedbacks=MessageFeedbackService(repository=messages),+ message_queries=MessageQueryService(+ messages=messages,+ files=MessageFileResolver(),+ extra_contents=ExecutionExtraContentReader(+ repository=SQLAlchemyExecutionExtraContentRepository(session_maker=database_client)+ ),+ ),message_file_previews=MessageFilePreviewService(files=MessageFilePreviewQueryRepository(session_factory=database_client),storage=storage,diff --git a/api/openapi/markdown/console-openapi.md b/api/openapi/markdown/console-openapi.mdindex 004eae02bd1..dd817d28648 100644--- a/api/openapi/markdown/console-openapi.md+++ b/api/openapi/markdown/console-openapi.md@@ -732,6 +732,7 @@ Get Agent App chat messages for a conversation with pagination| Code | Description | Schema || ---- | ----------- | ------ || 200 | Success | **application/json**: [MessageInfiniteScrollPaginationResponse](#messageinfinitescrollpaginationresponse)<br> |+| 400 | Bad Request | **application/json**: [AppUnavailableError](#appunavailableerror)<br>[ErrorResponse](#errorresponse)<br> || 404 | Agent or conversation not found | **application/json**: [AgentNotFoundError](#agentnotfounderror)<br>[ErrorResponse](#errorresponse)<br> || default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |@@ -1279,6 +1280,7 @@ Get Agent App message details by ID| Code | Description | Schema || ---- | ----------- | ------ || 200 | Message retrieved successfully | **application/json**: [MessageDetailResponse](#messagedetailresponse)<br> |+| 400 | Bad Request | **application/json**: [AppUnavailableError](#appunavailableerror)<br>[ErrorResponse](#errorresponse)<br> || 404 | Agent or message not found | **application/json**: [AgentNotFoundError](#agentnotfounderror)<br>[ErrorResponse](#errorresponse)<br> || default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |@@ -2959,6 +2961,7 @@ Get chat messages for a conversation with pagination| Code | Description | Schema || ---- | ----------- | ------ || 200 | Success | **application/json**: [MessageInfiniteScrollPaginationResponse](#messageinfinitescrollpaginationresponse)<br> |+| 400 | Bad Request | **application/json**: [AppUnavailableError](#appunavailableerror)<br>[ErrorResponse](#errorresponse)<br> || 404 | Conversation not found | **application/json**: [AppNotFoundError](#appnotfounderror)<br>[ErrorResponse](#errorresponse)<br> || default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |@@ -3263,6 +3266,7 @@ Get message details by ID| Code | Description | Schema || ---- | ----------- | ------ || 200 | Message retrieved successfully | **application/json**: [MessageDetailResponse](#messagedetailresponse)<br> |+| 400 | Bad Request | **application/json**: [AppUnavailableError](#appunavailableerror)<br>[ErrorResponse](#errorresponse)<br> || 404 | Message not found | **application/json**: [AppNotFoundError](#appnotfounderror)<br>[ErrorResponse](#errorresponse)<br> || default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |@@ -7989,7 +7993,7 @@ Request body:| Code | Description | Schema || ---- | ----------- | ------ || 200 | Success | **application/json**: [ExploreMessageInfiniteScrollPagination](#exploremessageinfinitescrollpagination)<br> |-| 400 | Bad Request | **application/json**: [NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> |+| 400 | Bad Request | **application/json**: [AppUnavailableError](#appunavailableerror)<br>[NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> || 403 | Forbidden | **application/json**: [AccessDeniedError](#accessdeniederror)<br>[ErrorResponse](#errorresponse)<br> || 404 | Not Found | **application/json**: [ConversationNotFoundError](#conversationnotfounderror)<br>[InstalledAppNotFoundError](#installedappnotfounderror)<br>[MessageCursorNotFoundError](#messagecursornotfounderror)<br>[ErrorResponse](#errorresponse)<br> || 503 | Service Unavailable | **application/json**: [WebAppAccessUnavailableError](#webappaccessunavailableerror)<br>[ErrorResponse](#errorresponse)<br> |diff --git a/api/openapi/markdown/service-openapi.md b/api/openapi/markdown/service-openapi.mdindex 60d05cca434..1ece0b9a0d4 100644--- a/api/openapi/markdown/service-openapi.md+++ b/api/openapi/markdown/service-openapi.md@@ -2410,9 +2410,9 @@ Returns historical chat records in a scrolling load format, with the first page| Code | Description | Schema || ---- | ----------- | ------ || 200 | Successfully retrieved conversation history. | **application/json**: [MessageInfiniteScrollPagination](#messageinfinitescrollpagination)<br> |-| 400 | `not_chat_app` : App mode does not match the API route. | **application/json**: [NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> |+| 400 | `not_chat_app` : App mode does not match the API route. `app_unavailable` : App is no longer available. | **application/json**: [AppUnavailableError](#appunavailableerror)<br>[NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> || 401 | Unauthorized - invalid API token | **application/json**: [ErrorResponse](#errorresponse)<br> |-| 403 | Forbidden - token scope, app, dataset, or workspace access denied | **application/json**: [ErrorResponse](#errorresponse)<br> |+| 403 | Forbidden - token scope, app, dataset, or workspace access denied | **application/json**: [AppAbnormalStatusError](#appabnormalstatuserror)<br>[AppApiDisabledError](#appapidisablederror)<br>[AppNotFoundError](#appnotfounderror)<br>[WorkspaceArchivedError](#workspacearchivederror)<br>[WorkspaceNotFoundError](#workspacenotfounderror)<br>[ErrorResponse](#errorresponse)<br> || 404 | - `not_found` : Conversation does not exist. - `not_found` : First message does not exist. | **application/json**: [ErrorResponse](#errorresponse)<br> || default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |diff --git a/api/openapi/markdown/web-openapi.md b/api/openapi/markdown/web-openapi.mdindex 69af62206a7..a2c81c92bc6 100644--- a/api/openapi/markdown/web-openapi.md+++ b/api/openapi/markdown/web-openapi.md@@ -521,9 +521,9 @@ Retrieve paginated list of messages from a conversation in a chat application.| Code | Description | Schema || ---- | ----------- | ------ || 200 | Success | **application/json**: [WebMessageInfiniteScrollPagination](#webmessageinfinitescrollpagination)<br> |-| 400 | Bad Request | **application/json**: [NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> |+| 400 | Bad Request - Not a chat app or app unavailable | **application/json**: [AppUnavailableError](#appunavailableerror)<br>[NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> || 401 | Unauthorized | **application/json**: [ErrorResponse](#errorresponse)<br> |-| 404 | Conversation Not Found or Not a Chat App | **application/json**: [ErrorResponse](#errorresponse)<br> |+| 404 | Conversation, First Message, or End User Not Found | **application/json**: [ErrorResponse](#errorresponse)<br> || 500 | Internal Server Error | **application/json**: [ErrorResponse](#errorresponse)<br> || default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |diff --git a/api/repositories/installed_app_message_repository.py b/api/repositories/installed_app_message_repository.pydeleted file mode 100644index b5f39648f14..00000000000--- a/api/repositories/installed_app_message_repository.py+++ /dev/null@@ -1,162 +0,0 @@-"""Persist and materialize messages within an admitted installation."""--from typing import cast, override--from pydantic import JsonValue-from sqlalchemy import and_, or_, select-from sqlalchemy.orm import Session, sessionmaker--from models.enums import ConversationFromSource-from models.model import App, Conversation, InstalledApp, Message, MessageAgentThought-from services.errors.conversation import ConversationNotExistsError-from services.errors.message import FirstMessageNotExistsError-from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppRef-from services.installed_app_message_service import (- InstalledAppMessageStore,- MessageAgentThoughtRecord,- MessageFeedbackRecord,- MessageFileRecord,- MessageInputValue,- MessagePage,- MessageRecord,-)---class SQLAlchemyInstalledAppMessageRepository(InstalledAppMessageStore):- def __init__(self, *, session_factory: sessionmaker[Session]) -> None:- self._session_factory: sessionmaker[Session] = session_factory-- @override- def get_page(- self,- *,- installed_app: InstalledAppRef,- account_id: str,- conversation_id: str,- first_id: str | None,- limit: int,- ) -> MessagePage:- with self._session_factory() as session:- app = self._get_app(session=session, installed_app=installed_app)- if not conversation_id:- return MessagePage(limit=limit, has_more=False, data=())- conversation = session.scalar(- select(Conversation).where(- Conversation.id == conversation_id,- Conversation.app_id == app.id,- Conversation.from_source == ConversationFromSource.CONSOLE,- Conversation.from_account_id == account_id,- Conversation.from_end_user_id.is_(None),- Conversation.is_deleted.is_(False),- )- )- if conversation is None:- raise ConversationNotExistsError(- f"Conversation {conversation_id} does not belong to this account and app."- )- statement = select(Message).where(Message.conversation_id == conversation.id)- if first_id:- first_message = session.scalar(statement.where(Message.id == first_id))- if first_message is None:- raise FirstMessageNotExistsError(- f"The first_id cursor {first_id} does not belong to conversation {conversation_id}."- )- statement = statement.where(- or_(- Message.created_at < first_message.created_at,- and_(- Message.created_at == first_message.created_at,- Message.id < first_message.id,- ),- )- )- messages = list(- session.scalars(statement.order_by(Message.created_at.desc(), Message.id.desc()).limit(limit + 1)).all()- )- has_more = len(messages) > limit- # Preserve ascending presentation of each newest-first page.- messages = messages[:limit]- messages.reverse()- return MessagePage(- limit=limit,- has_more=has_more,- data=tuple(self._to_record(message=message, session=session) for message in messages),- )-- @staticmethod- def _get_app(*, session: Session, installed_app: InstalledAppRef) -> App:- app = session.scalar(- select(App)- .join(InstalledApp, InstalledApp.app_id == App.id)- .where(- InstalledApp.id == installed_app.id,- InstalledApp.tenant_id == installed_app.tenant_id,- InstalledApp.app_id == installed_app.app_id,- )- )- if app is None:- raise InstalledAppNotFoundError(f"Installed app {installed_app.id} no longer exists")- return app-- @staticmethod- def _to_record(*, message: Message, session: Session) -> MessageRecord:- # Retain model input/file restoration (including its file I/O and legacy- # commit) until that boundary is migrated; do not recreate the file factory.- inputs = cast(dict[str, MessageInputValue], message.inputs_with_session(session=session))- feedback = message.user_feedback_with_session(session=session)- thoughts = [- SQLAlchemyInstalledAppMessageRepository._thought_record(thought)- for thought in message.agent_thoughts_with_session(session=session)- ]- files = [- MessageFileRecord(- id=file["id"],- filename=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)- ]- return MessageRecord(- id=message.id,- conversation_id=message.conversation_id,- parent_message_id=message.parent_message_id,- inputs=inputs,- query=message.query,- answer=message.re_sign_file_url_answer,- feedback=MessageFeedbackRecord(rating=feedback.rating.value) if feedback is not None else None,- retriever_resources=cast(list[dict[str, JsonValue]] | None, message.retriever_resources),- created_at=message.created_at,- agent_thoughts=thoughts,- message_files=files,- message_tokens=message.message_tokens,- answer_tokens=message.answer_tokens,- provider_response_latency=message.provider_response_latency,- total_price=message.total_price,- currency=message.currency,- status=message.status.value,- error=message.error,- metadata=cast(JsonValue, message.message_metadata_dict),- )-- @staticmethod- def _thought_record(thought: MessageAgentThought) -> MessageAgentThoughtRecord:- return MessageAgentThoughtRecord(- id=thought.id,- message_id=thought.message_id,- message_chain_id=thought.message_chain_id,- position=thought.position,- thought=thought.thought,- answer=thought.answer,- tool=thought.tool,- tool_labels=cast(JsonValue, thought.tool_labels),- tool_input=thought.tool_input,- created_at=thought.created_at,- observation=thought.observation,- files=cast(list[str], thought.files),- )diff --git a/api/repositories/message_repository.py b/api/repositories/message_repository.pyindex ae3e28a333b..1d72b2092bc 100644--- a/api/repositories/message_repository.py+++ b/api/repositories/message_repository.py@@ -15,18 +15,38 @@ from copy import deepcopyfrom typing import NamedTuple, castfrom pydantic import JsonValue-from sqlalchemy import select+from sqlalchemy import Select, and_, or_, selectfrom sqlalchemy.orm import Session, sessionmakerfrom core.memory.token_buffer_memory import PreparedHistory, TokenBufferMemoryfrom models import Account, App, AppModelConfig, Conversation, EndUser, Message, MessageFilefrom models.enums import FeedbackFromSource, FeedbackRating-from models.model import AppMode, InstalledApp, MessageFeedback, load_annotation_reply_config+from models.model import AppMode, InstalledApp, MessageAgentThought, MessageFeedback, load_annotation_reply_configfrom services.app_definition_query_service import AppDefinitionUnavailableError-from services.entities.message_entities import MessageAccount, MessageActor+from services.entities.message_entities import (+ ConsoleMessageFeedbackRecord,+ ConsoleMessageRecord,+ MessageAccount,+ MessageAccountRecord,+ MessageActor,+ MessageAgentThoughtRecord,+ MessageAnnotationHitRecord,+ MessageAnnotationRecord,+ MessageFileReference,+ MessageInputValue,+ MessagePage,+ MessageRating,+ MessageRecord,+ MessageSource,+)from services.errors.app_model_config import AppModelConfigBrokenErrorfrom services.errors.conversation import ConversationNotExistsError-from services.errors.message import FeedbackRatingRequiredError, MessageActorNotFoundError, MessageNotExistsError+from services.errors.message import (+ FeedbackRatingRequiredError,+ FirstMessageNotExistsError,+ MessageActorNotFoundError,+ MessageNotExistsError,+)from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppReffrom services.message_feedback_service import MessageFeedbackRecordfrom services.message_more_like_this_service import (@@ -46,6 +66,217 @@ class MessageRepository:def __init__(self, *, session_factory: sessionmaker[Session]) -> None:self._session_factory: sessionmaker[Session] = session_factory+ def get_message_page(+ self,+ *,+ app_id: str,+ app_owner_tenant_id: str,+ actor: MessageActor,+ conversation_id: str,+ first_id: str | None,+ limit: int,+ installed_app: InstalledAppRef | None,+ ) -> MessagePage[MessageSource[MessageRecord]]:+ """Read an actor's live conversation as detached database snapshots."""+ with self._session_factory() as session:+ self._require_page_app(+ session, app_id=app_id, app_owner_tenant_id=app_owner_tenant_id, installed_app=installed_app+ )+ self._require_page_actor(session, app_id=app_id, tenant_id=app_owner_tenant_id, actor=actor)+ if not conversation_id:+ return MessagePage(limit=limit, has_more=False, data=())+ self._require_page_conversation(session, app_id=app_id, conversation_id=conversation_id, actor=actor)+ statement = self._page_statement(+ session,+ app_id=app_id,+ conversation_id=conversation_id,+ first_id=first_id,+ use_id_tiebreaker=installed_app is not None,+ )+ messages = list(session.scalars(statement.limit(limit + 1)))+ has_more = len(messages) > limit+ return MessagePage(+ limit=limit,+ has_more=has_more,+ data=tuple(+ self._to_source(record=self._to_message_record(message=message, session=session), session=session)+ for message in reversed(messages[:limit])+ ),+ )++ def get_console_message_page(+ self,+ *,+ app_id: str,+ app_owner_tenant_id: str,+ account_id: str,+ conversation_id: str,+ first_id: str | None,+ limit: int,+ ) -> MessagePage[MessageSource[ConsoleMessageRecord]]:+ """Read Console history; Agent conversations remain account-owned."""+ with self._session_factory() as session:+ app = self._require_page_app(+ session, app_id=app_id, app_owner_tenant_id=app_owner_tenant_id, installed_app=None+ )+ actor = MessageAccount(account_id=account_id)+ self._require_page_actor(session, app_id=app_id, tenant_id=app_owner_tenant_id, actor=actor)+ self._require_page_conversation(+ session,+ app_id=app_id,+ conversation_id=conversation_id,+ actor=actor if app.mode == AppMode.AGENT else None,+ )+ statement = self._page_statement(+ session,+ app_id=app_id,+ conversation_id=conversation_id,+ first_id=first_id,+ use_id_tiebreaker=False,+ )+ messages = list(session.scalars(statement.limit(limit)))+ # Console's legacy has_more checks for a strictly older timestamp;+ # actor pages instead count the extra row, including timestamp ties.+ has_more = bool(+ len(messages) == limit+ and messages+ and session.scalar(select(statement.where(Message.created_at < messages[-1].created_at).exists()))+ )+ return MessagePage(+ limit=limit,+ has_more=has_more,+ data=tuple(+ self._to_source(+ record=self._to_console_message_record(message=message, session=session), session=session+ )+ for message in reversed(messages)+ ),+ )++ def get_console_message(+ self,+ *,+ app_id: str,+ app_owner_tenant_id: str,+ account_id: str,+ message_id: str,+ ) -> MessageSource[ConsoleMessageRecord]:+ """Read an admitted Console app's message, including other users' history.++ Detail access is app-wide even for Agent apps and deleted conversations;+ only the Agent list endpoint limits reads to the caller's conversation.+ """+ with self._session_factory() as session:+ self._require_page_app(session, app_id=app_id, app_owner_tenant_id=app_owner_tenant_id, installed_app=None)+ self._require_page_actor(+ session, app_id=app_id, tenant_id=app_owner_tenant_id, actor=MessageAccount(account_id=account_id)+ )+ message = session.scalar(select(Message).where(Message.id == message_id, Message.app_id == app_id))+ if message is None:+ raise MessageNotExistsError(f"Message {message_id} is unavailable for app {app_id}")+ record = self._to_console_message_record(message=message, session=session)+ return self._to_source(record=record, session=session)++ @staticmethod+ def _to_source[RecordT: MessageRecord](*, record: RecordT, session: Session) -> MessageSource[RecordT]:+ """Snapshot file references without restoring files or signing URLs."""+ files = session.scalars(select(MessageFile).where(MessageFile.message_id == record.id))+ return MessageSource(+ record=record,+ files=tuple(+ MessageFileReference(+ id=file.id,+ type=file.type.value,+ transfer_method=file.transfer_method.value,+ url=file.url,+ upload_file_id=file.upload_file_id,+ belongs_to=file.belongs_to.value if file.belongs_to is not None else None,+ )+ for file in files+ ),+ )++ def _require_page_app(+ self,+ session: Session,+ *,+ app_id: str,+ app_owner_tenant_id: str,+ installed_app: InstalledAppRef | None,+ ) -> App:+ if installed_app is None:+ app = self._get_app(session, app_id=app_id, tenant_id=app_owner_tenant_id)+ if app is None:+ raise AppDefinitionUnavailableError(f"App {app_id} is unavailable in tenant {app_owner_tenant_id}")+ return app+ app = session.scalar(+ select(App)+ .join(InstalledApp, InstalledApp.app_id == App.id)+ .where(+ App.id == app_id,+ App.tenant_id == app_owner_tenant_id,+ App.tenant_id == installed_app.app_owner_tenant_id,+ InstalledApp.id == installed_app.id,+ InstalledApp.tenant_id == installed_app.tenant_id,+ InstalledApp.app_id == installed_app.app_id,+ InstalledApp.app_owner_tenant_id == installed_app.app_owner_tenant_id,+ )+ )+ if app is None:+ raise InstalledAppNotFoundError(f"Installed app {installed_app.id} no longer exists")+ return app++ def _require_page_actor(self, session: Session, *, app_id: str, tenant_id: str, actor: MessageActor) -> None:+ if not self._actor_exists(+ session,+ app_id=app_id,+ tenant_id=tenant_id,+ account_id=actor.account_id if isinstance(actor, MessageAccount) else None,+ end_user_id=None if isinstance(actor, MessageAccount) else actor.end_user_id,+ ):+ raise MessageActorNotFoundError(f"Message actor is unavailable for app {app_id}")++ @staticmethod+ def _require_page_conversation(+ session: Session, *, app_id: str, conversation_id: str, actor: MessageActor | None+ ) -> None:+ statement = select(Conversation.id).where(Conversation.id == conversation_id, Conversation.app_id == app_id)+ if actor is not None:+ statement = statement.where(+ Conversation.from_source == ("console" if isinstance(actor, MessageAccount) else "api"),+ Conversation.from_account_id == (actor.account_id if isinstance(actor, MessageAccount) else None),+ Conversation.from_end_user_id == (None if isinstance(actor, MessageAccount) else actor.end_user_id),+ Conversation.is_deleted.is_(False),+ )+ if session.scalar(statement) is None:+ raise ConversationNotExistsError(f"Conversation {conversation_id} is unavailable for this app and actor")++ @staticmethod+ def _page_statement(+ session: Session, *, app_id: str, conversation_id: str, first_id: str | None, use_id_tiebreaker: bool+ ) -> Select[tuple[Message]]:+ statement = select(Message).where(Message.app_id == app_id, Message.conversation_id == conversation_id)+ if first_id:+ first_message = session.scalar(statement.where(Message.id == first_id))+ if first_message is None:+ raise FirstMessageNotExistsError(+ f"The first_id cursor {first_id} does not belong to conversation {conversation_id}"+ )+ if use_id_tiebreaker:+ statement = statement.where(+ or_(+ Message.created_at < first_message.created_at,+ and_(Message.created_at == first_message.created_at, Message.id < first_message.id),+ )+ )+ else:+ statement = statement.where(+ Message.created_at < first_message.created_at, Message.id != first_message.id+ )+ # Explore already uses an ID tiebreaker; the other entrypoints retain timestamp-only cursors.+ statement = statement.order_by(Message.created_at.desc())+ return statement.order_by(Message.id.desc()) if use_id_tiebreaker else statement+def set_feedback(self,*,@@ -426,3 +657,115 @@ class MessageRepository:Message.from_end_user_id == end_user_id,))++ @staticmethod+ def _to_message_record(*, message: Message, session: Session) -> MessageRecord:+ # Snapshot stored JSON; restoration and URL signing belong to the query+ # service's file adapter after this database session has closed.+ inputs = deepcopy(cast(dict[str, MessageInputValue], message._inputs))+ feedback = message.user_feedback_with_session(session=session)+ thoughts = [+ MessageRepository._thought_record(thought)+ for thought in message.agent_thoughts_with_session(session=session)+ ]+ return MessageRecord(+ id=message.id,+ conversation_id=message.conversation_id,+ parent_message_id=message.parent_message_id,+ inputs=inputs,+ query=message.query,+ answer=message.answer,+ feedback=MessageRating(rating=feedback.rating.value) if feedback is not None else None,+ retriever_resources=cast(list[dict[str, JsonValue]] | None, message.retriever_resources),+ created_at=message.created_at,+ agent_thoughts=thoughts,+ message_files=[],+ message_tokens=message.message_tokens,+ answer_tokens=message.answer_tokens,+ provider_response_latency=message.provider_response_latency,+ total_price=message.total_price,+ currency=message.currency,+ status=message.status.value,+ error=message.error,+ metadata=cast(JsonValue, message.message_metadata_dict),+ )++ @staticmethod+ def _thought_record(thought: MessageAgentThought) -> MessageAgentThoughtRecord:+ return MessageAgentThoughtRecord(+ id=thought.id,+ message_id=thought.message_id,+ message_chain_id=thought.message_chain_id,+ position=thought.position,+ thought=thought.thought,+ answer=thought.answer,+ tool=thought.tool,+ tool_labels=cast(JsonValue, thought.tool_labels),+ tool_input=thought.tool_input,+ created_at=thought.created_at,+ observation=thought.observation,+ files=cast(list[str], thought.files),+ )++ @staticmethod+ def _account_record(account: Account | None) -> MessageAccountRecord | None:+ return MessageAccountRecord(id=account.id, name=account.name, email=account.email) if account else None++ def _to_console_message_record(self, *, message: Message, session: Session) -> ConsoleMessageRecord:+ record = self._to_message_record(message=message, session=session)+ annotation = message.annotation_with_session(session=session)+ annotation_hit = message.annotation_hit_history_with_session(session=session)+ return ConsoleMessageRecord(+ id=record.id,+ conversation_id=record.conversation_id,+ parent_message_id=record.parent_message_id,+ inputs=record.inputs,+ query=record.query,+ answer=record.answer,+ feedback=record.feedback,+ retriever_resources=record.retriever_resources or [],+ created_at=record.created_at,+ agent_thoughts=record.agent_thoughts,+ message_files=record.message_files,+ message_tokens=record.message_tokens,+ answer_tokens=record.answer_tokens,+ provider_response_latency=record.provider_response_latency,+ total_price=record.total_price,+ currency=record.currency,+ status=record.status,+ error=record.error,+ metadata=record.metadata,+ message=deepcopy(cast(JsonValue, message.message)),+ from_source=message.from_source,+ from_end_user_id=message.from_end_user_id,+ from_account_id=message.from_account_id,+ workflow_run_id=message.workflow_run_id,+ feedbacks=[+ ConsoleMessageFeedbackRecord(+ rating=feedback.rating.value,+ content=feedback.content,+ from_source=feedback.from_source.value,+ from_end_user_id=feedback.from_end_user_id,+ from_account=self._account_record(feedback.from_account_with_session(session=session)),+ )+ for feedback in message.feedbacks_with_session(session=session)+ ],+ annotation=MessageAnnotationRecord(+ id=annotation.id,+ question=annotation.question,+ content=annotation.content,+ account=self._account_record(annotation.account_with_session(session=session)),+ created_at=annotation.created_at,+ )+ if annotation+ else None,+ annotation_hit_history=MessageAnnotationHitRecord(+ id=annotation_hit.id,+ annotation_create_account=self._account_record(+ annotation_hit.annotation_create_account_with_session(session=session)+ ),+ created_at=annotation_hit.created_at,+ )+ if annotation_hit+ else None,+ )diff --git a/api/services/entities/message_entities.py b/api/services/entities/message_entities.pyindex 2e6830b894a..22418d2ac9a 100644--- a/api/services/entities/message_entities.py+++ b/api/services/entities/message_entities.py@@ -1,6 +1,12 @@-"""Caller identities shared by message operations, independent of invocation origin."""+"""Caller identities and detached projections shared by message operations."""-from dataclasses import dataclass+from dataclasses import dataclass, field+from datetime import datetime+from decimal import Decimal++from pydantic import JsonValue++from graphon.file import File@dataclass(frozen=True, slots=True)@@ -14,3 +20,146 @@ class MessageEndUser:type MessageActor = MessageAccount | MessageEndUser+++type MessageInputValue = JsonValue | File | list[File]+++@dataclass(frozen=True, slots=True)+class MessageRating:+ rating: str | None+++@dataclass(frozen=True, slots=True)+class MessageFileRecord:+ id: str+ filename: str | None+ type: str+ url: str | None+ mime_type: str | None+ size: int | None+ transfer_method: str+ belongs_to: str | None+ upload_file_id: str | None+++@dataclass(frozen=True, slots=True)+class MessageFileReference:+ """Persisted reference; file metadata and URLs are resolved after the read."""++ id: str+ type: str+ transfer_method: str+ url: str | None+ upload_file_id: str | None+ belongs_to: str | None+++@dataclass(frozen=True, slots=True)+class MessageFileProjection:+ inputs: dict[str, MessageInputValue]+ answer: str+ files: list[MessageFileRecord]+++@dataclass(frozen=True, slots=True)+class MessageAgentThoughtRecord:+ id: str+ message_id: str+ message_chain_id: str | None+ position: int+ thought: str | None+ answer: str | None+ tool: str | None+ tool_labels: JsonValue+ tool_input: str | None+ created_at: datetime | None+ observation: str | None+ files: list[str]+++@dataclass(frozen=True, slots=True)+class MessageRecord:+ id: str+ conversation_id: str+ parent_message_id: str | None+ inputs: dict[str, MessageInputValue]+ query: str+ answer: str+ feedback: MessageRating | None+ retriever_resources: list[dict[str, JsonValue]] | None+ created_at: datetime | None+ agent_thoughts: list[MessageAgentThoughtRecord]+ message_files: list[MessageFileRecord]+ message_tokens: int+ answer_tokens: int+ provider_response_latency: float+ total_price: Decimal | None+ currency: str | None+ status: str+ error: str | None+ metadata: JsonValue+ extra_contents: list[dict[str, JsonValue]] = field(default_factory=list)+++@dataclass(frozen=True, slots=True)+class MessagePage[RecordT]:+ limit: int+ has_more: bool+ data: tuple[RecordT, ...]+++@dataclass(frozen=True, slots=True)+class MessageSource[RecordT: MessageRecord]:+ """Database projection before file restoration and extra-content loading.++ The record retains stored JSON inputs and the original answer. Its+ message_files and extra_contents are filled by the shared query service.+ """++ record: RecordT+ files: tuple[MessageFileReference, ...]+++@dataclass(frozen=True, slots=True)+class MessageAccountRecord:+ id: str+ name: str+ email: str+++@dataclass(frozen=True, slots=True)+class ConsoleMessageFeedbackRecord:+ rating: str+ content: str | None+ from_source: str+ from_end_user_id: str | None+ from_account: MessageAccountRecord | None+++@dataclass(frozen=True, slots=True)+class MessageAnnotationRecord:+ id: str+ question: str | None+ content: str+ account: MessageAccountRecord | None+ created_at: datetime | None+++@dataclass(frozen=True, slots=True)+class MessageAnnotationHitRecord:+ id: str+ annotation_create_account: MessageAccountRecord | None+ created_at: datetime | None+++@dataclass(frozen=True, slots=True, kw_only=True)+class ConsoleMessageRecord(MessageRecord):+ message: JsonValue+ from_source: str+ from_end_user_id: str | None+ from_account_id: str | None+ feedbacks: list[ConsoleMessageFeedbackRecord]+ workflow_run_id: str | None+ annotation: MessageAnnotationRecord | None+ annotation_hit_history: MessageAnnotationHitRecord | Nonediff --git a/api/services/installed_app_message_adapters.py b/api/services/installed_app_message_adapters.pydeleted file mode 100644index 561ad3336c3..00000000000--- a/api/services/installed_app_message_adapters.py+++ /dev/null@@ -1,22 +0,0 @@-"""Execution extra contents for installed-app messages."""--from collections.abc import Mapping, Sequence--from pydantic import JsonValue-from sqlalchemy.orm import Session, sessionmaker--from repositories.sqlalchemy_execution_extra_content_repository import SQLAlchemyExecutionExtraContentRepository---class InstalledAppMessageRuntime:- def __init__(self, *, session_factory: sessionmaker[Session]) -> None:- self._extra_contents: SQLAlchemyExecutionExtraContentRepository = SQLAlchemyExecutionExtraContentRepository(- session_maker=session_factory- )-- def get_extra_contents(self, *, message_ids: Sequence[str]) -> Mapping[str, list[dict[str, JsonValue]]]:- contents = self._extra_contents.get_by_message_ids(message_ids)- return {- message_id: [content.model_dump(mode="json", exclude_none=True) for content in items]- for message_id, items in zip(message_ids, contents, strict=True)- }diff --git a/api/services/installed_app_message_service.py b/api/services/installed_app_message_service.pydeleted file mode 100644index f799d4efd31..00000000000--- a/api/services/installed_app_message_service.py+++ /dev/null@@ -1,140 +0,0 @@-"""Message reads for an admitted installation."""--from collections.abc import Mapping, Sequence-from dataclasses import dataclass, field, replace-from datetime import datetime-from decimal import Decimal-from typing import Protocol--from pydantic import JsonValue--from graphon.file import File-from services.installed_app_access_service import InstalledAppRef--type MessageInputValue = JsonValue | File | list[File]---class MessageNotChatAppError(Exception):- pass---@dataclass(frozen=True, slots=True)-class MessageFeedbackRecord:- rating: str | None---@dataclass(frozen=True, slots=True)-class MessageFileRecord:- id: str- filename: str | None- type: str- url: str | None- mime_type: str | None- size: int | None- transfer_method: str- belongs_to: str | None- upload_file_id: str | None---@dataclass(frozen=True, slots=True)-class MessageAgentThoughtRecord:- id: str- message_id: str- message_chain_id: str | None- position: int- thought: str | None- answer: str | None- tool: str | None- tool_labels: JsonValue- tool_input: str | None- created_at: datetime | None- observation: str | None- files: list[str]---@dataclass(frozen=True, slots=True)-class MessageRecord:- id: str- conversation_id: str- parent_message_id: str | None- inputs: dict[str, MessageInputValue]- query: str- answer: str- feedback: MessageFeedbackRecord | None- retriever_resources: list[dict[str, JsonValue]] | None- created_at: datetime | None- agent_thoughts: list[MessageAgentThoughtRecord]- message_files: list[MessageFileRecord]- message_tokens: int- answer_tokens: int- provider_response_latency: float- total_price: Decimal | None- currency: str | None- status: str- error: str | None- metadata: JsonValue- extra_contents: list[dict[str, JsonValue]] = field(default_factory=list)---@dataclass(frozen=True, slots=True)-class MessagePage:- limit: int- has_more: bool- data: tuple[MessageRecord, ...]---class InstalledAppMessageStore(Protocol):- def get_page(- self,- *,- installed_app: InstalledAppRef,- account_id: str,- conversation_id: str,- first_id: str | None,- limit: int,- ) -> MessagePage: ...---class MessageExtraContentsQuery(Protocol):- def __call__(self, *, message_ids: Sequence[str]) -> Mapping[str, list[dict[str, JsonValue]]]: ...---class InstalledAppMessageService:- def __init__(- self,- *,- messages: InstalledAppMessageStore,- get_extra_contents: MessageExtraContentsQuery,- ) -> None:- self._messages: InstalledAppMessageStore = messages- self._get_extra_contents: MessageExtraContentsQuery = get_extra_contents-- def get_page(- self,- *,- installed_app: InstalledAppRef,- account_id: str,- conversation_id: str,- first_id: str | None,- limit: int,- ) -> MessagePage:- self._require_chat_app(installed_app)- page = self._messages.get_page(- installed_app=installed_app,- account_id=account_id,- conversation_id=conversation_id,- first_id=first_id,- limit=limit,- )- if not page.data:- return page- contents = self._get_extra_contents(message_ids=[message.id for message in page.data])- return replace(- page,- data=tuple(replace(message, extra_contents=contents.get(message.id, [])) for message in page.data),- )-- @staticmethod- def _require_chat_app(installed_app: InstalledAppRef) -> None:- if installed_app.app_mode not in {"chat", "agent-chat", "advanced-chat"}:- raise MessageNotChatAppError(f"Installed app {installed_app.id} is not a chat app.")diff --git a/api/services/message_query_adapters.py b/api/services/message_query_adapters.pynew file mode 100644index 00000000000..0d4a44ec365--- /dev/null+++ b/api/services/message_query_adapters.py@@ -0,0 +1,111 @@+"""File and execution-content infrastructure for detached message projections."""++from collections.abc import Sequence+from typing import cast++from pydantic import JsonValue++from core.app.file_access import DatabaseFileAccessController+from factories import file_factory+from graphon.file import FILE_MODEL_IDENTITY, FileTransferMethod+from models.model import Message, MessageFileInfo+from models.utils.file_input_compat import build_file_from_input_mapping+from repositories.execution_extra_content_repository import ExecutionExtraContentRepository+from services.entities.message_entities import (+ MessageFileProjection,+ MessageFileRecord,+ MessageFileReference,+ MessageInputValue,+)+++class MessageFileResolver:+ def __init__(self) -> None:+ self._access_controller: DatabaseFileAccessController = DatabaseFileAccessController()++ def resolve(+ self,+ *,+ tenant_id: str,+ inputs: dict[str, MessageInputValue],+ answer: str,+ files: Sequence[MessageFileReference],+ ) -> MessageFileProjection:+ restored_inputs = dict(inputs)++ def owner_tenant_id() -> str:+ return tenant_id++ for key, value in inputs.items():+ if isinstance(value, dict) and value.get("dify_model_identity") == FILE_MODEL_IDENTITY:+ restored_inputs[key] = build_file_from_input_mapping(+ file_mapping=value, tenant_resolver=owner_tenant_id+ )+ elif isinstance(value, list) and all(+ isinstance(item, dict) and item.get("dify_model_identity") == FILE_MODEL_IDENTITY for item in value+ ):+ restored_inputs[key] = [+ build_file_from_input_mapping(file_mapping=item, tenant_resolver=owner_tenant_id)+ for item in value+ if isinstance(item, dict)+ ]++ restored_files = [self._file(file, tenant_id=tenant_id) for file in files]+ # Keep the model's legacy URL grammar and signing behavior in one place.+ # This transient bridge has no ORM session and cannot commit a message read.+ signed_answer = Message(answer=answer).re_sign_file_url_answer+ return MessageFileProjection(inputs=restored_inputs, answer=signed_answer, files=restored_files)++ def _file(self, source: MessageFileReference, *, tenant_id: str) -> MessageFileRecord:+ upload_file_id = source.upload_file_id+ mapping: dict[str, object] = {+ "id": source.id,+ "type": source.type,+ "transfer_method": source.transfer_method,+ "upload_file_id": upload_file_id,+ }+ match source.transfer_method:+ case FileTransferMethod.LOCAL_FILE:+ if upload_file_id is None:+ raise ValueError(f"MessageFile {source.id} is a local file but has no upload_file_id")+ case FileTransferMethod.REMOTE_URL:+ if source.url is None:+ raise ValueError(f"MessageFile {source.id} is a remote url but has no url")+ mapping["url"] = source.url+ case FileTransferMethod.TOOL_FILE:+ if upload_file_id is None:+ assert source.url is not None+ # Historical tool URLs are recovered only in the response.+ upload_file_id = source.url.split("/")[-1].split(".")[0]+ mapping["tool_file_id"] = upload_file_id+ case _:+ raise ValueError(f"MessageFile {source.id} has an invalid transfer_method {source.transfer_method}")++ file = cast(+ MessageFileInfo,+ file_factory.build_from_mapping(+ mapping=mapping, tenant_id=tenant_id, access_controller=self._access_controller+ ).to_dict(),+ )+ return MessageFileRecord(+ id=file["id"],+ filename=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=source.belongs_to,+ upload_file_id=upload_file_id,+ )+++class ExecutionExtraContentReader:+ def __init__(self, *, repository: ExecutionExtraContentRepository) -> None:+ self._repository: ExecutionExtraContentRepository = repository++ def get_by_message_ids(self, message_ids: Sequence[str]) -> list[list[dict[str, JsonValue]]]:+ return [+ [cast(dict[str, JsonValue], item.model_dump(mode="json", exclude_none=True)) for item in items]+ for items in self._repository.get_by_message_ids(message_ids)+ ]diff --git a/api/services/message_query_service.py b/api/services/message_query_service.pynew file mode 100644index 00000000000..e97a28306c8--- /dev/null+++ b/api/services/message_query_service.py@@ -0,0 +1,178 @@+"""Message queries returning complete, detached records."""++from collections.abc import Sequence+from dataclasses import replace+from typing import Protocol++from pydantic import JsonValue++from services.entities.message_entities import (+ ConsoleMessageRecord,+ MessageActor,+ MessageFileProjection,+ MessageFileReference,+ MessageInputValue,+ MessagePage,+ MessageRecord,+ MessageSource,+)+from services.installed_app_access_service import InstalledAppRef+++class MessageNotChatAppError(Exception):+ pass+++class MessageQueryStore(Protocol):+ def get_message_page(+ self,+ *,+ app_id: str,+ app_owner_tenant_id: str,+ actor: MessageActor,+ conversation_id: str,+ first_id: str | None,+ limit: int,+ installed_app: InstalledAppRef | None,+ ) -> MessagePage[MessageSource[MessageRecord]]: ...++ def get_console_message_page(+ self,+ *,+ app_id: str,+ app_owner_tenant_id: str,+ account_id: str,+ conversation_id: str,+ first_id: str | None,+ limit: int,+ ) -> MessagePage[MessageSource[ConsoleMessageRecord]]: ...++ def get_console_message(+ self,+ *,+ app_id: str,+ app_owner_tenant_id: str,+ account_id: str,+ message_id: str,+ ) -> MessageSource[ConsoleMessageRecord]: ...+++class MessageFiles(Protocol):+ def resolve(+ self,+ *,+ tenant_id: str,+ inputs: dict[str, MessageInputValue],+ answer: str,+ files: Sequence[MessageFileReference],+ ) -> MessageFileProjection: ...+++class MessageExtraContents(Protocol):+ def get_by_message_ids(self, message_ids: Sequence[str]) -> list[list[dict[str, JsonValue]]]: ...+++class MessageQueryService:+ def __init__(+ self, *, messages: MessageQueryStore, files: MessageFiles, extra_contents: MessageExtraContents+ ) -> None:+ self._messages: MessageQueryStore = messages+ self._files: MessageFiles = files+ self._extra_contents: MessageExtraContents = extra_contents++ def get_page(+ self,+ *,+ app_id: str,+ app_owner_tenant_id: str,+ actor: MessageActor,+ conversation_id: str,+ first_id: str | None,+ limit: int,+ installed_app: InstalledAppRef | None = None,+ ) -> MessagePage[MessageRecord]:+ """Read an actor's conversation; installed_app rechecks Explore ownership.++ Web and Service API pass no installation. A missing first_id reads the+ latest page, presented oldest first within that page.+ """+ if installed_app is not None and installed_app.app_mode not in {"chat", "agent-chat", "advanced-chat"}:+ raise MessageNotChatAppError(f"Installed app {installed_app.id} is not a chat app.")+ page = self._messages.get_message_page(+ app_id=app_id,+ app_owner_tenant_id=app_owner_tenant_id,+ actor=actor,+ conversation_id=conversation_id,+ first_id=first_id,+ limit=limit,+ installed_app=installed_app,+ )+ return self._render_page(page, tenant_id=app_owner_tenant_id)++ def get_console_page(+ self,+ *,+ app_id: str,+ app_owner_tenant_id: str,+ account_id: str,+ conversation_id: str,+ first_id: str | None,+ limit: int,+ ) -> MessagePage[ConsoleMessageRecord]:+ """Read Console logs, retaining account ownership for Agent conversations."""+ page = self._messages.get_console_message_page(+ app_id=app_id,+ app_owner_tenant_id=app_owner_tenant_id,+ account_id=account_id,+ conversation_id=conversation_id,+ first_id=first_id,+ limit=limit,+ )+ return self._render_page(page, tenant_id=app_owner_tenant_id)++ def get_console_message(+ self,+ *,+ app_id: str,+ app_owner_tenant_id: str,+ account_id: str,+ message_id: str,+ ) -> ConsoleMessageRecord:+ """Read an app-scoped Console detail, including other accounts' messages."""+ source = self._messages.get_console_message(+ app_id=app_id,+ app_owner_tenant_id=app_owner_tenant_id,+ account_id=account_id,+ message_id=message_id,+ )+ return self._render((source,), tenant_id=app_owner_tenant_id)[0]++ def _render_page[RecordT: MessageRecord](+ self, page: MessagePage[MessageSource[RecordT]], *, tenant_id: str+ ) -> MessagePage[RecordT]:+ return MessagePage(+ limit=page.limit,+ has_more=page.has_more,+ data=self._render(page.data, tenant_id=tenant_id),+ )++ def _render[RecordT: MessageRecord](+ self, sources: Sequence[MessageSource[RecordT]], *, tenant_id: str+ ) -> tuple[RecordT, ...]:+ if not sources:+ return ()++ # The repository has closed its read session before file restoration,+ # which may fetch remote metadata or open its own short lookup sessions.+ records: list[RecordT] = []+ for source in sources:+ files = self._files.resolve(+ tenant_id=tenant_id,+ inputs=source.record.inputs,+ answer=source.record.answer,+ files=source.files,+ )+ records.append(replace(source.record, inputs=files.inputs, answer=files.answer, message_files=files.files))++ contents = self._extra_contents.get_by_message_ids([record.id for record in records])+ return tuple(replace(record, extra_contents=items) for record, items in zip(records, contents, strict=True))diff --git a/api/services/message_service.py b/api/services/message_service.pydeleted file mode 100644index 661f24d0e42..00000000000--- a/api/services/message_service.py+++ /dev/null@@ -1,176 +0,0 @@-from collections.abc import Sequence--from sqlalchemy import select-from sqlalchemy.orm import Session, sessionmaker--from extensions.ext_database import db-from libs.infinite_scroll_pagination import InfiniteScrollPagination-from models import Account-from models.model import (- App,- EndUser,- Message,-)-from repositories.execution_extra_content_repository import ExecutionExtraContentRepository-from repositories.sqlalchemy_execution_extra_content_repository import (- SQLAlchemyExecutionExtraContentRepository,-)-from services.conversation_service import ConversationService-from services.errors.message import (- FirstMessageNotExistsError,- LastMessageNotExistsError,- MessageNotExistsError,-)---def _create_execution_extra_content_repository() -> ExecutionExtraContentRepository:- session_maker = sessionmaker(bind=db.engine, expire_on_commit=False)- return SQLAlchemyExecutionExtraContentRepository(session_maker=session_maker)---def attach_message_extra_contents(messages: Sequence[Message]) -> None:- if not messages:- return-- repository = _create_execution_extra_content_repository()- extra_contents_lists = repository.get_by_message_ids([message.id for message in messages])-- for index, message in enumerate(messages):- contents = extra_contents_lists[index] if index < len(extra_contents_lists) else []- message.set_extra_contents([content.model_dump(mode="json", exclude_none=True) for content in contents])---class MessageService:- @classmethod- def pagination_by_first_id(- cls,- app_model: App,- user: Account | EndUser | None,- conversation_id: str,- first_id: str | None,- limit: int,- order: str = "asc",- *,- session: Session,- ) -> InfiniteScrollPagination:- if not user:- return InfiniteScrollPagination(data=[], limit=limit, has_more=False)-- if not conversation_id:- return InfiniteScrollPagination(data=[], limit=limit, has_more=False)-- conversation = ConversationService.get_conversation(- app_model=app_model, user=user, conversation_id=conversation_id, session=session- )-- fetch_limit = limit + 1-- if first_id:- first_message = session.scalar(- select(Message).where(Message.conversation_id == conversation.id, Message.id == first_id).limit(1)- )-- if not first_message:- raise FirstMessageNotExistsError()-- history_messages = session.scalars(- select(Message)- .where(- Message.conversation_id == conversation.id,- Message.created_at < first_message.created_at,- Message.id != first_message.id,- )- .order_by(Message.created_at.desc())- .limit(fetch_limit)- ).all()- else:- history_messages = session.scalars(- select(Message)- .where(Message.conversation_id == conversation.id)- .order_by(Message.created_at.desc())- .limit(fetch_limit)- ).all()-- has_more = False- if len(history_messages) > limit:- has_more = True- history_messages = history_messages[:-1]-- if order == "asc":- history_messages = list(reversed(history_messages))-- attach_message_extra_contents(history_messages)-- return InfiniteScrollPagination(data=history_messages, limit=limit, has_more=has_more)-- @classmethod- def pagination_by_last_id(- cls,- app_model: App,- user: Account | EndUser | None,- last_id: str | None,- limit: int,- conversation_id: str | None = None,- include_ids: list | None = None,- *,- session: Session,- ) -> InfiniteScrollPagination:- if not user:- return InfiniteScrollPagination(data=[], limit=limit, has_more=False)-- stmt = select(Message)-- fetch_limit = limit + 1-- if conversation_id is not None:- conversation = ConversationService.get_conversation(- app_model=app_model, user=user, conversation_id=conversation_id, session=session- )-- stmt = stmt.where(Message.conversation_id == conversation.id)-- # Check if include_ids is not None and not empty to avoid WHERE false condition- if include_ids is not None:- if len(include_ids) == 0:- return InfiniteScrollPagination(data=[], limit=limit, has_more=False)- stmt = stmt.where(Message.id.in_(include_ids))-- if last_id:- last_message = session.scalar(stmt.where(Message.id == last_id).limit(1))-- if not last_message:- raise LastMessageNotExistsError()-- history_messages = session.scalars(- stmt.where(Message.created_at < last_message.created_at, Message.id != last_message.id)- .order_by(Message.created_at.desc())- .limit(fetch_limit)- ).all()- else:- history_messages = session.scalars(stmt.order_by(Message.created_at.desc()).limit(fetch_limit)).all()-- has_more = False- if len(history_messages) > limit:- has_more = True- history_messages = history_messages[:-1]-- return InfiniteScrollPagination(data=history_messages, limit=limit, has_more=has_more)-- @classmethod- def get_message(cls, app_model: App, user: Account | EndUser | None, message_id: str, *, session: Session):- message = session.scalar(- select(Message)- .where(- Message.id == message_id,- Message.app_id == app_model.id,- Message.from_source == ("api" if isinstance(user, EndUser) else "console"),- Message.from_end_user_id == (user.id if isinstance(user, EndUser) else None),- Message.from_account_id == (user.id if isinstance(user, Account) else None),- )- .limit(1)- )-- if not message:- raise MessageNotExistsError()-- return messagediff --git a/api/tests/e2e_tests/containers/controllers/console/app/test_message.py b/api/tests/e2e_tests/containers/controllers/console/app/test_message.pyindex f3056440396..75e1e9f6cc9 100644--- a/api/tests/e2e_tests/containers/controllers/console/app/test_message.py+++ b/api/tests/e2e_tests/containers/controllers/console/app/test_message.py@@ -2,7 +2,6 @@from datetime import timedeltafrom decimal import Decimal-from unittest.mock import patchfrom uuid import uuid4import pytest@@ -11,7 +10,6 @@ from sqlalchemy import selectfrom sqlalchemy.orm import Sessionfrom controllers.console.app.message import AppMessageFeedbackPayload, ChatMessagesQuery-from controllers.console.app.message import attach_message_extra_contents as _attach_message_extra_contentsfrom libs.datetime_utils import naive_utc_nowfrom models.enums import ConversationFromSource, ConversationStatus, FeedbackRatingfrom models.model import AppMode, AppModelConfig, Conversation, Message, MessageAnnotation, MessageFeedback@@ -141,15 +139,11 @@ def test_chat_message_list_success(conversation_id = conversation.idsecond_id = second.id- with patch(- "controllers.console.app.message.attach_message_extra_contents",- side_effect=_attach_message_extra_contents,- ):- response = test_client_with_containers.get(- f"/console/api/apps/{app_id}/chat-messages",- query_string={"conversation_id": conversation_id, "limit": 1},- headers=authenticate_console_client(test_client_with_containers, account),- )+ response = test_client_with_containers.get(+ f"/console/api/apps/{app_id}/chat-messages",+ query_string={"conversation_id": conversation_id, "limit": 1},+ headers=authenticate_console_client(test_client_with_containers, account),+ )assert response.status_code == 200payload = response.get_json()@@ -304,14 +298,10 @@ def test_message_api_get_success(conversation = _create_conversation(db_session_with_containers, app.id, account.id, app.mode)message = _create_message(db_session_with_containers, app.id, conversation.id, account.id)- with patch(- "controllers.console.app.message.attach_message_extra_contents",- side_effect=_attach_message_extra_contents,- ):- response = test_client_with_containers.get(- f"/console/api/apps/{app.id}/messages/{message.id}",- headers=authenticate_console_client(test_client_with_containers, account),- )+ response = test_client_with_containers.get(+ f"/console/api/apps/{app.id}/messages/{message.id}",+ headers=authenticate_console_client(test_client_with_containers, account),+ )assert response.status_code == 200payload = response.get_json()diff --git a/api/tests/e2e_tests/containers/pyrefly.toml b/api/tests/e2e_tests/containers/pyrefly.tomlindex 419a66163c9..779ac89b7a9 100644--- a/api/tests/e2e_tests/containers/pyrefly.toml+++ b/api/tests/e2e_tests/containers/pyrefly.toml@@ -79,7 +79,6 @@ project-excludes = ["services/test_file_service.py","services/test_human_input_delivery_test.py","services/test_message_export_service.py",- "services/test_message_service.py","services/test_message_service_execution_extra_content.py","services/test_message_service_extra_contents.py","services/test_messages_clean_service.py",diff --git a/api/tests/e2e_tests/containers/services/test_conversation_service.py b/api/tests/e2e_tests/containers/services/test_conversation_service.pyindex 45ac5a7bdeb..0a8f5745584 100644--- a/api/tests/e2e_tests/containers/services/test_conversation_service.py+++ b/api/tests/e2e_tests/containers/services/test_conversation_service.py@@ -17,8 +17,7 @@ from models.model import App, Conversation, EndUser, Message, MessageAnnotationfrom services.annotation_service import AppAnnotationServicefrom services.conversation_service import ConversationServicefrom services.errors.conversation import ConversationNotExistsError-from services.errors.message import FirstMessageNotExistsError, MessageNotExistsError-from services.message_service import MessageService+from services.errors.message import MessageNotExistsErrorclass ConversationServiceIntegrationTestDataFactory:@@ -310,208 +309,6 @@ class TestConversationServicePagination:assert result.data[1].updated_at >= result.data[2].updated_at-class TestConversationServiceMessageCreation:- """- Test message creation and pagination.-- Tests MessageService operations for creating and retrieving messages- within conversations.- """-- def test_pagination_by_first_id_without_first_id(self, db_session_with_containers: Session):- """- Test message pagination without specifying first_id.-- When first_id is None, the service should return the most recent messages- up to the specified limit.- """- # Arrange- app_model, user = ConversationServiceIntegrationTestDataFactory.create_app_and_account(- db_session_with_containers- )- conversation = ConversationServiceIntegrationTestDataFactory.create_conversation(- db_session_with_containers, app_model, user- )-- base_time = datetime(2024, 1, 1, 12, 0, 0)- for i in range(3):- ConversationServiceIntegrationTestDataFactory.create_message(- db_session_with_containers,- app_model,- conversation,- user,- created_at=base_time + timedelta(minutes=i),- )-- # Act - Call the pagination method without first_id- result = MessageService.pagination_by_first_id(- app_model=app_model,- user=user,- conversation_id=conversation.id,- first_id=None, # No starting point specified- limit=10,- session=db_session_with_containers,- )-- # Assert - Verify the results- assert len(result.data) == 3 # All 3 messages returned- assert result.has_more is False # No more messages available (3 < limit of 10)-- def test_pagination_by_first_id_with_first_id(self, db_session_with_containers: Session):- """- Test message pagination with first_id specified.-- When first_id is provided, the service should return messages starting- from the specified message up to the limit.- """- # Arrange- app_model, user = ConversationServiceIntegrationTestDataFactory.create_app_and_account(- db_session_with_containers- )- conversation = ConversationServiceIntegrationTestDataFactory.create_conversation(- db_session_with_containers, app_model, user- )-- first_message = ConversationServiceIntegrationTestDataFactory.create_message(- db_session_with_containers,- app_model,- conversation,- user,- created_at=datetime(2024, 1, 1, 12, 5, 0),- )-- for i in range(2):- ConversationServiceIntegrationTestDataFactory.create_message(- db_session_with_containers,- app_model,- conversation,- user,- created_at=datetime(2024, 1, 1, 12, i, 0),- )-- # Act - Call the pagination method with first_id- result = MessageService.pagination_by_first_id(- app_model=app_model,- user=user,- conversation_id=conversation.id,- first_id=first_message.id,- limit=10,- session=db_session_with_containers,- )-- # Assert - Verify the results- assert len(result.data) == 2 # Only 2 messages returned after first_id- assert result.has_more is False # No more messages available (2 < limit of 10)-- def test_pagination_by_first_id_raises_error_when_first_message_not_found(- self, db_session_with_containers: Session- ):- """- Test that FirstMessageNotExistsError is raised when first_id doesn't exist.-- When the specified first_id does not exist in the conversation,- the service should raise an error.- """- # Arrange- app_model, user = ConversationServiceIntegrationTestDataFactory.create_app_and_account(- db_session_with_containers- )- conversation = ConversationServiceIntegrationTestDataFactory.create_conversation(- db_session_with_containers, app_model, user- )-- # Act & Assert- with pytest.raises(FirstMessageNotExistsError):- MessageService.pagination_by_first_id(- app_model=app_model,- user=user,- conversation_id=conversation.id,- first_id=str(uuid4()),- limit=10,- session=db_session_with_containers,- )-- def test_pagination_with_has_more_flag(self, db_session_with_containers: Session):- """- Test that has_more flag is correctly set when there are more messages.-- The service fetches limit+1 messages to determine if more exist.- """- # Arrange- app_model, user = ConversationServiceIntegrationTestDataFactory.create_app_and_account(- db_session_with_containers- )- conversation = ConversationServiceIntegrationTestDataFactory.create_conversation(- db_session_with_containers, app_model, user- )-- # Create limit+1 messages to trigger has_more- limit = 5- base_time = datetime(2024, 1, 1, 12, 0, 0)- for i in range(limit + 1):- ConversationServiceIntegrationTestDataFactory.create_message(- db_session_with_containers,- app_model,- conversation,- user,- created_at=base_time + timedelta(minutes=i),- )-- # Act- result = MessageService.pagination_by_first_id(- app_model=app_model,- user=user,- conversation_id=conversation.id,- first_id=None,- limit=limit,- session=db_session_with_containers,- )-- # Assert- assert len(result.data) == limit # Extra message should be removed- assert result.has_more is True # Flag should be set-- def test_pagination_with_ascending_order(self, db_session_with_containers: Session):- """- Test message pagination with ascending order.-- Messages should be returned in chronological order (oldest first).- """- # Arrange- app_model, user = ConversationServiceIntegrationTestDataFactory.create_app_and_account(- db_session_with_containers- )- conversation = ConversationServiceIntegrationTestDataFactory.create_conversation(- db_session_with_containers, app_model, user- )-- # Create messages with different timestamps- for i in range(3):- ConversationServiceIntegrationTestDataFactory.create_message(- db_session_with_containers,- app_model,- conversation,- user,- created_at=datetime(2024, 1, i + 1, 12, 0, 0),- )-- # Act- result = MessageService.pagination_by_first_id(- app_model=app_model,- user=user,- conversation_id=conversation.id,- first_id=None,- limit=10,- order="asc", # Ascending order,- session=db_session_with_containers,- )-- # Assert- assert len(result.data) == 3- # Messages should be in ascending order after reversal- assert result.data[0].created_at <= result.data[1].created_at <= result.data[2].created_at--class TestConversationServiceSummarization:"""Test conversation summarization (auto-generated names).@@ -1008,45 +805,6 @@ class TestConversationServiceExport:# Assertassert len(result) == 10- def test_get_message_success(self, db_session_with_containers: Session):- """Test successful retrieval of a message."""- # Arrange- app_model, user = ConversationServiceIntegrationTestDataFactory.create_app_and_account(- db_session_with_containers- )- conversation = ConversationServiceIntegrationTestDataFactory.create_conversation(- db_session_with_containers,- app_model,- user,- )- message = ConversationServiceIntegrationTestDataFactory.create_message(- db_session_with_containers,- app_model,- conversation,- user,- )-- # Act- result = MessageService.get_message(- app_model=app_model, user=user, message_id=message.id, session=db_session_with_containers- )-- # Assert- assert result == message-- def test_get_message_not_found(self, db_session_with_containers: Session):- """Test MessageNotExistsError when message doesn't exist."""- # Arrange- app_model, user = ConversationServiceIntegrationTestDataFactory.create_app_and_account(- db_session_with_containers- )-- # Act & Assert- with pytest.raises(MessageNotExistsError):- MessageService.get_message(- app_model=app_model, user=user, message_id=str(uuid4()), session=db_session_with_containers- )-def test_get_conversation_for_end_user(self, db_session_with_containers: Session):"""Test retrieving conversation created by end user via API.diff --git a/api/tests/e2e_tests/containers/services/test_message_service.py b/api/tests/e2e_tests/containers/services/test_message_service.pydeleted file mode 100644index f107c9fbfd5..00000000000--- a/api/tests/e2e_tests/containers/services/test_message_service.py+++ /dev/null@@ -1,432 +0,0 @@-from unittest.mock import patch--import pytest-from faker import Faker-from sqlalchemy.orm import Session--from models.enums import ConversationFromSource, InvokeFrom-from services.app_service import AppService, CreateAppParams-from services.errors.message import (- FirstMessageNotExistsError,- LastMessageNotExistsError,- MessageNotExistsError,-)-from services.message_service import MessageService-from tests.e2e_tests.containers.helpers import generate_valid_password---class TestMessageService:- """Integration tests for MessageService using testcontainers."""-- @pytest.fixture- def mock_external_service_dependencies(self):- """Mock setup for external service dependencies."""- with patch("services.account.login_adapters.SystemFeatureService") as mock_account_feature_service:- yield {"account_feature_service": mock_account_feature_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 tests.e2e_tests.containers.helpers import accounts as account_fixtures-- account = account_fixtures.create_account(- email=fake.email(),- name=fake.name(),- interface_language="en-US",- password=generate_valid_password(fake),- session=db_session_with_containers,- )- account_fixtures.create_owner_workspace(account, name=fake.company(), session=db_session_with_containers)- tenant = account.current_tenant-- # Setup app creation arguments- app_args = CreateAppParams(- name=fake.company(),- description=fake.text(max_nb_chars=100),- mode="advanced-chat",- icon_type="emoji",- icon="🤖",- icon_background="#FF6B6B",- api_rph=100,- api_rpm=10,- )-- # Create app- app_service = AppService()- app = app_service.create_app(tenant.id, app_args, account, session=db_session_with_containers)-- # Setup current_user mock- self._mock_current_user(mock_external_service_dependencies, account.id, tenant.id)-- return app, account-- def _mock_current_user(self, mock_external_service_dependencies, account_id, tenant_id):- """- Helper method to mock the current user for testing.- """- # mock_external_service_dependencies["current_user"].id = account_id- # mock_external_service_dependencies["current_user"].current_tenant_id = tenant_id-- def _create_test_conversation(self, db_session_with_containers: Session, app, account, fake):- """- Helper method to create a test conversation with all required fields.- """- from models.model import Conversation-- conversation = Conversation(- app_id=app.id,- app_model_config_id=None,- model_provider=None,- model_id="",- override_model_configs=None,- mode=app.mode,- name=fake.sentence(),- _inputs={},- introduction="",- system_instruction="",- system_instruction_tokens=0,- status="normal",- invoke_from=InvokeFrom.EXPLORE,- from_source=ConversationFromSource.CONSOLE,- from_end_user_id=None,- from_account_id=account.id,- )-- db_session_with_containers.add(conversation)- db_session_with_containers.flush()- return conversation-- def _create_test_message(self, db_session_with_containers: Session, app, conversation, account, fake):- """- Helper method to create a test message with all required fields.- """- import json-- from models.model import Message-- message = Message(- app_id=app.id,- model_provider=None,- model_id="",- override_model_configs=None,- conversation_id=conversation.id,- _inputs={},- query=fake.sentence(),- message=json.dumps([{"role": "user", "text": fake.sentence()}]),- message_tokens=0,- message_unit_price=0,- message_price_unit=0.001,- answer=fake.text(max_nb_chars=200),- answer_tokens=0,- answer_unit_price=0,- answer_price_unit=0.001,- parent_message_id=None,- provider_response_latency=0,- total_price=0,- currency="USD",- invoke_from=InvokeFrom.EXPLORE,- from_source=ConversationFromSource.CONSOLE,- from_end_user_id=None,- from_account_id=account.id,- )-- db_session_with_containers.add(message)- db_session_with_containers.commit()- return message-- def test_pagination_by_first_id_success(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test successful pagination by first ID.- """- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Create a conversation and multiple messages- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)- messages = []- for _i in range(5):- message = self._create_test_message(db_session_with_containers, app, conversation, account, fake)- messages.append(message)-- # Test pagination by first ID- result = MessageService.pagination_by_first_id(- app_model=app,- user=account,- conversation_id=conversation.id,- first_id=messages[2].id, # Use middle message as first_id- limit=2,- order="asc",- session=db_session_with_containers,- )-- # Verify results- assert result.limit == 2- assert len(result.data) == 2- # total 5, from the middle, no more- assert result.has_more is False- # Verify messages are in ascending order- assert result.data[0].created_at <= result.data[1].created_at-- def test_pagination_by_first_id_no_user(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test pagination by first ID when no user is provided.- """- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Test pagination with no user- result = MessageService.pagination_by_first_id(- app_model=app,- user=None,- conversation_id=fake.uuid4(),- first_id=None,- limit=10,- session=db_session_with_containers,- )-- # Verify empty result- assert result.limit == 10- assert len(result.data) == 0- assert result.has_more is False-- def test_pagination_by_first_id_no_conversation_id(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test pagination by first ID when no conversation ID is provided.- """-- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Test pagination with no conversation ID- result = MessageService.pagination_by_first_id(- app_model=app,- user=account,- conversation_id="",- first_id=None,- limit=10,- session=db_session_with_containers,- )-- # Verify empty result- assert result.limit == 10- assert len(result.data) == 0- assert result.has_more is False-- def test_pagination_by_first_id_invalid_first_id(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test pagination by first ID with invalid first_id.- """- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Create a conversation and message- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)- self._create_test_message(db_session_with_containers, app, conversation, account, fake)-- # Test pagination with invalid first_id- with pytest.raises(FirstMessageNotExistsError):- MessageService.pagination_by_first_id(- app_model=app,- user=account,- conversation_id=conversation.id,- first_id=fake.uuid4(), # Non-existent message ID- limit=10,- session=db_session_with_containers,- )-- def test_pagination_by_last_id_success(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test successful pagination by last ID.- """- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Create a conversation and multiple messages- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)- messages = []- for _i in range(5):- message = self._create_test_message(db_session_with_containers, app, conversation, account, fake)- messages.append(message)-- # Test pagination by last ID- result = MessageService.pagination_by_last_id(- app_model=app,- user=account,- last_id=messages[2].id, # Use middle message as last_id- limit=2,- conversation_id=conversation.id,- session=db_session_with_containers,- )-- # Verify results- assert result.limit == 2- assert len(result.data) == 2- # total 5, from the middle, no more- assert result.has_more is False- # Verify messages are in descending order- assert result.data[0].created_at >= result.data[1].created_at-- def test_pagination_by_last_id_with_include_ids(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test pagination by last ID with include_ids filter.- """- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Create a conversation and multiple messages- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)- messages = []- for _i in range(5):- message = self._create_test_message(db_session_with_containers, app, conversation, account, fake)- messages.append(message)-- # Test pagination with include_ids- include_ids = [messages[0].id, messages[1].id, messages[2].id]- result = MessageService.pagination_by_last_id(- app_model=app,- user=account,- last_id=messages[1].id,- limit=2,- include_ids=include_ids,- session=db_session_with_containers,- )-- # Verify results- assert result.limit == 2- assert len(result.data) <= 2- # Verify all returned messages are in include_ids- for message in result.data:- assert message.id in include_ids-- def test_pagination_by_last_id_no_user(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test pagination by last ID when no user is provided.- """-- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Test pagination with no user,- result = MessageService.pagination_by_last_id(- app_model=app, user=None, last_id=None, limit=10, session=db_session_with_containers- )-- # Verify empty result- assert result.limit == 10- assert len(result.data) == 0- assert result.has_more is False-- def test_pagination_by_last_id_invalid_last_id(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test pagination by last ID with invalid last_id.- """- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Create a conversation and message- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)- self._create_test_message(db_session_with_containers, app, conversation, account, fake)-- # Test pagination with invalid last_id- with pytest.raises(LastMessageNotExistsError):- MessageService.pagination_by_last_id(- app_model=app,- user=account,- last_id=fake.uuid4(), # Non-existent message ID- limit=10,- conversation_id=conversation.id,- session=db_session_with_containers,- )-- def test_get_message_success(self, db_session_with_containers: Session, mock_external_service_dependencies):- """- Test successful retrieval of message.- """- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Create a conversation and message- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)- message = self._create_test_message(db_session_with_containers, app, conversation, account, fake)-- # Get message,- retrieved_message = MessageService.get_message(- app_model=app, user=account, message_id=message.id, session=db_session_with_containers- )-- # Verify message was retrieved correctly- assert retrieved_message.id == message.id- assert retrieved_message.app_id == app.id- assert retrieved_message.conversation_id == conversation.id- assert retrieved_message.from_source == "console"- assert retrieved_message.from_account_id == account.id-- def test_get_message_not_exists(self, db_session_with_containers: Session, mock_external_service_dependencies):- """- Test getting message that doesn't exist.- """- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Test getting non-existent message- with pytest.raises(MessageNotExistsError):- MessageService.get_message(- app_model=app, user=account, message_id=fake.uuid4(), session=db_session_with_containers- )-- def test_get_message_wrong_user(self, db_session_with_containers: Session, mock_external_service_dependencies):- """- Test getting message with wrong user (different account).- """- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Create a conversation and message- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)- message = self._create_test_message(db_session_with_containers, app, conversation, account, fake)-- # Create another account- from tests.e2e_tests.containers.helpers import accounts as account_fixtures-- other_account = account_fixtures.create_account(- email=fake.email(),- name=fake.name(),- interface_language="en-US",- password=generate_valid_password(fake),- session=db_session_with_containers,- )- account_fixtures.create_owner_workspace(other_account, name=fake.company(), session=db_session_with_containers)-- # Test getting message with different user- with pytest.raises(MessageNotExistsError):- MessageService.get_message(- app_model=app, user=other_account, message_id=message.id, session=db_session_with_containers- )diff --git a/api/tests/e2e_tests/containers/services/test_message_service_execution_extra_content.py b/api/tests/e2e_tests/containers/services/test_message_service_execution_extra_content.pyindex c914daf770e..316d9d2d768 100644--- a/api/tests/e2e_tests/containers/services/test_message_service_execution_extra_content.py+++ b/api/tests/e2e_tests/containers/services/test_message_service_execution_extra_content.py@@ -1,26 +1,38 @@from __future__ import annotationsimport pytest-from sqlalchemy.orm import Session+from sqlalchemy.orm import Session, sessionmakerfrom models.human_input import HumanInputFormStatus-from services.message_service import MessageService+from repositories.message_repository import MessageRepository+from repositories.sqlalchemy_execution_extra_content_repository import SQLAlchemyExecutionExtraContentRepository+from services.entities.message_entities import MessageAccount+from services.message_query_adapters import ExecutionExtraContentReader, MessageFileResolver+from services.message_query_service import MessageQueryServicefrom tests.e2e_tests.containers.helpers.execution_extra_content import (create_human_input_message_fixture,)@pytest.mark.usefixtures("flask_req_ctx_with_containers")-def test_pagination_returns_extra_contents(db_session_with_containers: Session):+def test_pagination_returns_extra_contents(db_session_with_containers: Session) -> None:fixture = create_human_input_message_fixture(db_session_with_containers)- pagination = MessageService.pagination_by_first_id(- app_model=fixture.app,- user=fixture.account,+ sessions = sessionmaker(bind=db_session_with_containers.get_bind(), expire_on_commit=False)+ service = MessageQueryService(+ messages=MessageRepository(session_factory=sessions),+ files=MessageFileResolver(),+ extra_contents=ExecutionExtraContentReader(+ repository=SQLAlchemyExecutionExtraContentRepository(session_maker=sessions)+ ),+ )+ pagination = service.get_page(+ app_id=fixture.app.id,+ app_owner_tenant_id=fixture.app.tenant_id,+ actor=MessageAccount(account_id=fixture.account.id),conversation_id=fixture.conversation.id,first_id=None,limit=10,- session=db_session_with_containers,)assert pagination.data@@ -46,7 +58,7 @@ def test_pagination_returns_extra_contents(db_session_with_containers: Session):@pytest.mark.usefixtures("flask_req_ctx_with_containers")-def test_pagination_returns_waiting_human_input_extra_contents(db_session_with_containers: Session):+def test_pagination_returns_waiting_human_input_extra_contents(db_session_with_containers: Session) -> None:fixture = create_human_input_message_fixture(db_session_with_containers)fixture.form.status = HumanInputFormStatus.WAITINGfixture.form.selected_action_id = None@@ -54,13 +66,21 @@ def test_pagination_returns_waiting_human_input_extra_contents(db_session_with_cfixture.form.submitted_data = Nonedb_session_with_containers.commit()- pagination = MessageService.pagination_by_first_id(- app_model=fixture.app,- user=fixture.account,+ sessions = sessionmaker(bind=db_session_with_containers.get_bind(), expire_on_commit=False)+ service = MessageQueryService(+ messages=MessageRepository(session_factory=sessions),+ files=MessageFileResolver(),+ extra_contents=ExecutionExtraContentReader(+ repository=SQLAlchemyExecutionExtraContentRepository(session_maker=sessions)+ ),+ )+ pagination = service.get_page(+ app_id=fixture.app.id,+ app_owner_tenant_id=fixture.app.tenant_id,+ actor=MessageAccount(account_id=fixture.account.id),conversation_id=fixture.conversation.id,first_id=None,limit=10,- session=db_session_with_containers,)assert pagination.datadiff --git a/api/tests/e2e_tests/containers/services/test_message_service_extra_contents.py b/api/tests/e2e_tests/containers/services/test_message_service_extra_contents.pyindex 0d2a8751ef5..c547b944ea5 100644--- a/api/tests/e2e_tests/containers/services/test_message_service_extra_contents.py+++ b/api/tests/e2e_tests/containers/services/test_message_service_extra_contents.py@@ -3,18 +3,22 @@ from __future__ import annotationsfrom decimal import Decimalimport pytest+from sqlalchemy.orm import Session, sessionmakerfrom libs.helper import to_timestampfrom models.enums import ConversationFromSourcefrom models.model import Message-from services import message_service+from repositories.message_repository import MessageRepository+from repositories.sqlalchemy_execution_extra_content_repository import SQLAlchemyExecutionExtraContentRepository+from services.message_query_adapters import ExecutionExtraContentReader, MessageFileResolver+from services.message_query_service import MessageQueryServicefrom tests.e2e_tests.containers.helpers.execution_extra_content import (create_human_input_message_fixture,)@pytest.mark.usefixtures("flask_req_ctx_with_containers")-def test_attach_message_extra_contents_assigns_serialized_payload(db_session_with_containers) -> None:+def test_message_details_include_serialized_extra_contents(db_session_with_containers: Session) -> None:fixture = create_human_input_message_fixture(db_session_with_containers)message_without_extra_content = Message(@@ -44,9 +48,23 @@ def test_attach_message_extra_contents_assigns_serialized_payload(db_session_witdb_session_with_containers.add(message_without_extra_content)db_session_with_containers.commit()- messages = [fixture.message, message_without_extra_content]-- message_service.attach_message_extra_contents(messages)+ sessions = sessionmaker(bind=db_session_with_containers.get_bind(), expire_on_commit=False)+ service = MessageQueryService(+ messages=MessageRepository(session_factory=sessions),+ files=MessageFileResolver(),+ extra_contents=ExecutionExtraContentReader(+ repository=SQLAlchemyExecutionExtraContentRepository(session_maker=sessions)+ ),+ )+ messages = [+ service.get_console_message(+ app_id=fixture.app.id,+ app_owner_tenant_id=fixture.app.tenant_id,+ account_id=fixture.account.id,+ message_id=message.id,+ )+ for message in (fixture.message, message_without_extra_content)+ ]form = fixture.formdiff --git a/api/tests/e2e_tests/contracts/controllers/console/app/test_message_detail.py b/api/tests/e2e_tests/contracts/controllers/console/app/test_message_detail.pynew file mode 100644index 00000000000..60efcf609d5--- /dev/null+++ b/api/tests/e2e_tests/contracts/controllers/console/app/test_message_detail.py@@ -0,0 +1,165 @@+"""Console detail admission retains app-wide reads without list-only restrictions."""++from collections.abc import Callable+from typing import Literal+from uuid import uuid4++import pytest+from sqlalchemy import delete, func, select, text, update++from models.account import TenantAccountJoin, TenantAccountRole+from models.agent import Agent, AgentScope+from models.enums import ConversationFromSource+from models.model import App, AppMode, Conversation, Message+from tests.e2e_tests.contracts.controllers.console.app.test_message_list import (+ _error,+ _get,+ _route,+ harness,+ installed_app_harness,+)+from tests.e2e_tests.contracts.controllers.console.explore.test_message_suggested_questions import _Harness++__all__ = ["harness", "installed_app_harness"]+++def _detail_route(state: _Harness, kind: Literal["app", "agent"], *, scope: AgentScope = AgentScope.ROSTER) -> str:+ return _route(state, kind, scope=scope).removesuffix("/chat-messages") + f"/messages/{state.message.id}"++[email protected]("kind", ["app", "agent"])[email protected]("role", list(TenantAccountRole))+def test_detail_keeps_all_initialized_workspace_roles(+ harness: _Harness, kind: Literal["app", "agent"], role: TenantAccountRole+) -> None:+ route = _detail_route(harness, kind)+ with harness.factory.begin() as session:+ session.execute(+ update(TenantAccountJoin).where(TenantAccountJoin.account_id == harness.account.id).values(role=role)+ )+ response = _get(harness, route)+ assert response.status_code == 200+ assert response.get_json()["id"] == harness.message.id+ harness.assert_closed()++[email protected]("mode", list(AppMode))+def test_plain_app_detail_keeps_every_app_mode(harness: _Harness, mode: AppMode) -> None:+ route = _detail_route(harness, "app")+ with harness.factory.begin() as session:+ session.execute(update(App).where(App.id == harness.target.id).values(mode=mode))+ response = _get(harness, route)+ assert response.status_code == 200+ assert response.get_json()["id"] == harness.message.id++[email protected]("kind", ["app", "agent"])[email protected]("actor", ["other-account", "end-user", "deleted-conversation", "missing-conversation"])+def test_detail_keeps_other_actors_and_deleted_agent_conversations_visible(+ harness: _Harness, kind: Literal["app", "agent"], actor: str+) -> None:+ route = _detail_route(harness, kind)+ with harness.factory.begin() as session:+ if actor == "deleted-conversation":+ session.execute(+ update(Conversation).where(Conversation.id == harness.conversation.id).values(is_deleted=True)+ )+ elif actor == "missing-conversation":+ session.execute(delete(Conversation).where(Conversation.id == harness.conversation.id))+ else:+ for model in (Message, Conversation):+ record_id = harness.message.id if model is Message else harness.conversation.id+ values = (+ {"from_account_id": str(uuid4())}+ if actor == "other-account"+ else {+ "from_account_id": None,+ "from_end_user_id": str(uuid4()),+ "from_source": ConversationFromSource.API,+ }+ )+ session.execute(update(model).where(model.id == record_id).values(**values))+ response = _get(harness, route)+ assert response.status_code == 200+ assert response.get_json()["id"] == harness.message.id+ harness.assert_closed()++[email protected]("kind", ["app", "agent"])[email protected]("missing", ["login", "csrf"])+def test_detail_requires_real_login_and_csrf(harness: _Harness, kind: Literal["app", "agent"], missing: str) -> None:+ response = _get(harness, _detail_route(harness, kind), authenticated=missing != "login", csrf=missing != "csrf")+ _error(response, status=401, code="unauthorized")+ assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'++[email protected]("kind", ["app", "agent"])[email protected]("missing", ["message", "foreign-message"])+def test_detail_requires_message_in_admitted_app(+ harness: _Harness, kind: Literal["app", "agent"], missing: str+) -> None:+ route = _detail_route(harness, kind)+ with harness.factory.begin() as session:+ if missing == "message":+ session.execute(delete(Message).where(Message.id == harness.message.id))+ else:+ session.execute(update(Message).where(Message.id == harness.message.id).values(app_id=str(uuid4())))+ response = _get(harness, route)+ _error(response, status=404, code="not_found")+ assert response.get_json()["message"] == "Message Not Exists."++[email protected]("kind", ["app", "agent"])[email protected]("missing", ["app", "foreign-workspace"])+def test_detail_rejects_missing_or_foreign_app(harness: _Harness, kind: Literal["app", "agent"], missing: str) -> None:+ route = _detail_route(harness, kind)+ with harness.factory.begin() as session:+ if missing == "app":+ session.execute(delete(App).where(App.id == harness.target.id))+ else:+ session.execute(update(App).where(App.id == harness.target.id).values(tenant_id=str(uuid4())))+ _error(_get(harness, route), status=404, code="app_not_found" if kind == "app" else "agent_not_found_error")+++def test_detail_rejects_archived_app(harness: _Harness) -> None:+ route = _detail_route(harness, "app")+ with harness.factory.begin() as session:+ session.execute(text("UPDATE apps SET status = 'archived' WHERE id = :id"), {"id": harness.target.id})+ _error(_get(harness, route), status=404, code="app_not_found")++[email protected]("scope", [AgentScope.ROSTER, AgentScope.WORKFLOW_ONLY])+def test_detail_resolves_existing_agent_runtime_without_creating_apps(harness: _Harness, scope: AgentScope) -> None:+ route = _detail_route(harness, "agent", scope=scope)+ response = _get(harness, route)+ assert response.status_code == 200+ if scope == AgentScope.WORKFLOW_ONLY:+ _error(+ _get(harness, f"/apps/{harness.target.id}/messages/{harness.message.id}"), status=404, code="app_not_found"+ )+ with harness.factory.begin() as session:+ session.execute(update(Agent).values(backing_app_id=None))+ count = session.scalar(select(func.count()).select_from(App))+ _error(_get(harness, route), status=404, code="agent_not_found_error")+ with harness.factory() as session:+ assert session.scalar(select(func.count()).select_from(App)) == count+ assert session.scalar(select(Agent.backing_app_id)) is None+++def test_plain_detail_rbac_admits_app_maintainer_and_rejects_agent_binding(+ harness: _Harness, config_overrides: Callable[..., None]+) -> None:+ route = _detail_route(harness, "app")+ config_overrides(RBAC_ENABLED=True)+ with harness.factory.begin() as session:+ session.execute(update(App).where(App.id == harness.target.id).values(maintainer=harness.account.id))+ session.execute(+ update(TenantAccountJoin)+ .where(TenantAccountJoin.account_id == harness.account.id)+ .values(role=TenantAccountRole.NORMAL)+ )+ response = _get(harness, route)+ assert response.status_code == 200+ assert response.get_json()["id"] == harness.message.id+ _route(harness, "agent")+ _error(_get(harness, route), status=404, code="not_found")diff --git a/api/tests/e2e_tests/contracts/controllers/console/app/test_message_list.py b/api/tests/e2e_tests/contracts/controllers/console/app/test_message_list.pynew file mode 100644index 00000000000..96f79994a6c--- /dev/null+++ b/api/tests/e2e_tests/contracts/controllers/console/app/test_message_list.py@@ -0,0 +1,369 @@+"""Console message lists through real HTTP admission, services and SQLite."""++import json+from collections.abc import Iterator+from datetime import datetime, timedelta+from decimal import Decimal+from typing import Literal+from uuid import uuid4++import pytest+from sqlalchemy import delete, func, select, update+from werkzeug.test import TestResponse++from constants import COOKIE_NAME_CSRF_TOKEN, HEADER_NAME_CSRF_TOKEN+from controllers.console.app.message import AgentChatMessageListApi, AgentMessageApi, ChatMessageListApi, MessageApi+from core.workflow.nodes.human_input.entities import FormDefinition, UserActionConfig+from enums.account import TenantAccountRole+from graphon.file import FileTransferMethod, FileType+from libs.external_api import ExternalApi+from libs.passport import PassportService+from libs.token import generate_csrf_token+from models.account import TenantAccountJoin+from models.agent import Agent, AgentScope+from models.enums import ConversationFromSource, CreatorUserRole, FeedbackFromSource, FeedbackRating+from models.execution_extra_content import HumanInputContent+from models.human_input import HumanInputForm+from models.model import (+ App,+ AppAnnotationHitHistory,+ AppMode,+ Conversation,+ Message,+ MessageAgentThought,+ MessageAnnotation,+ MessageFeedback,+ MessageFile,+)+from tests.e2e_tests.contracts.controllers.console.explore.test_message_suggested_questions import _Harness+from tests.e2e_tests.contracts.controllers.console.explore.test_message_suggested_questions import (+ harness as installed_app_harness,+)+from tests.e2e_tests.contracts.controllers.console.test_message_feedback import _admin_route+from tests.helpers.unit.model_factories import make_message++__all__ = ["installed_app_harness"]++_CREATED_AT = datetime(2024, 1, 1)+++def harness(installed_app_harness: _Harness) -> Iterator[_Harness]:+ state = installed_app_harness+ api = ExternalApi(state.app)+ api.add_resource(ChatMessageListApi, "/apps/<uuid:app_id>/chat-messages", endpoint="console.app_messages")+ api.add_resource(AgentChatMessageListApi, "/agent/<uuid:agent_id>/chat-messages", endpoint="console.agent_messages")+ api.add_resource(MessageApi, "/apps/<uuid:app_id>/messages/<uuid:message_id>", endpoint="console.app_message")+ api.add_resource(+ AgentMessageApi, "/agent/<uuid:agent_id>/messages/<uuid:message_id>", endpoint="console.agent_message"+ )+ with state.factory.begin() as session:+ session.execute(update(Message).where(Message.id == state.message.id).values(created_at=_CREATED_AT))+ yield state+ if state.sessions:+ state.assert_closed()+++def _route(state: _Harness, kind: Literal["app", "agent"] = "app", *, scope: AgentScope = AgentScope.ROSTER) -> str:+ return _admin_route(state, kind, scope=scope).removesuffix("/feedbacks") + "/chat-messages"+++def _get(+ state: _Harness,+ route: str,+ *,+ conversation_id: str | None = None,+ query: str = "",+ authenticated: bool = True,+ csrf: bool = True,+) -> TestResponse:+ client = state.app.test_client()+ token = generate_csrf_token(state.account.id)+ headers = {HEADER_NAME_CSRF_TOKEN: token} if csrf else {}+ if authenticated:+ headers["Authorization"] = f"Bearer {PassportService().issue({'user_id': state.account.id})}"+ client.set_cookie(COOKIE_NAME_CSRF_TOKEN, token)+ response = client.get(+ f"{route}?conversation_id={state.conversation.id if conversation_id is None else conversation_id}&{query}",+ headers=headers,+ )+ assert response.headers["Content-Type"] == "application/json"+ assert int(response.headers["Content-Length"]) == len(response.data)+ return response+++def _error(response: TestResponse, *, status: int, code: str) -> None:+ assert response.status_code == status+ body = response.get_json()+ assert body["status"] == status+ assert body["code"] == code+ assert body["message"]+++def _older_message(state: _Harness, *, age: int) -> Message:+ message = make_message(+ message_id=str(uuid4()),+ app_id=state.target.id,+ conversation_id=state.conversation.id,+ inputs={"zero": 0, "disabled": False, "null": None, "empty": []},+ query="Hello",+ message={"text": "Hello"},+ answer="你好",+ message_tokens=2,+ answer_tokens=3,+ message_unit_price=Decimal(0),+ answer_unit_price=Decimal(0),+ total_price=Decimal(0),+ provider_response_latency=0,+ currency="USD",+ status="normal",+ from_source=ConversationFromSource.CONSOLE,+ from_account_id=state.account.id,+ created_at=_CREATED_AT - timedelta(minutes=age),+ )+ with state.factory.begin() as session:+ session.add(message)+ return message+++def _add_extra_content(state: _Harness, message_id: str) -> HumanInputForm:+ expiration = datetime(2027, 1, 1)+ definition = FormDefinition(+ form_content="Approve?",+ inputs=[],+ user_actions=[UserActionConfig(id="approve", title="Approve")],+ rendered_content="Approve?",+ expiration_time=expiration,+ node_title="Approval",+ display_in_ui=True,+ )+ form = HumanInputForm(+ tenant_id=state.target.tenant_id,+ app_id=state.target.id,+ workflow_run_id=str(uuid4()),+ node_id="approval",+ form_definition=definition.model_dump_json(),+ rendered_content="Approve?",+ expiration_time=expiration,+ )+ with state.factory.begin() as session:+ app = session.get(App, state.target.id)+ assert app is not None+ form.tenant_id = app.tenant_id+ session.add(form)+ session.flush()+ session.add(+ HumanInputContent.new(workflow_run_id=form.workflow_run_id or "", form_id=form.id, message_id=message_id)+ )+ return form++[email protected]("kind", ["app", "agent"])+def test_list_preserves_complete_response_and_older_page_order(+ harness: _Harness, kind: Literal["app", "agent"]+) -> None:+ route = _route(harness, kind)+ oldest = _older_message(harness, age=2)+ middle = _older_message(harness, age=1)+ form = _add_extra_content(harness, middle.id)+ with harness.factory.begin() as session:+ session.execute(update(Message).where(Message.id == middle.id).values(message_metadata=json.dumps({"zero": 0})))+ annotation = MessageAnnotation(+ app_id=harness.target.id,+ conversation_id=harness.conversation.id,+ message_id=middle.id,+ question="Question",+ content="Answer",+ account_id=harness.account.id,+ )+ session.add(annotation)+ session.flush()+ attachment = MessageFile(+ message_id=middle.id,+ type=FileType.IMAGE,+ transfer_method=FileTransferMethod.REMOTE_URL,+ url="https://example.com/photo.png",+ created_by_role=CreatorUserRole.ACCOUNT,+ created_by=harness.account.id,+ )+ session.add_all(+ [+ attachment,+ MessageFeedback(+ app_id=harness.target.id,+ conversation_id=harness.conversation.id,+ message_id=middle.id,+ rating=FeedbackRating.LIKE,+ from_source=FeedbackFromSource.ADMIN,+ from_account_id=harness.account.id,+ content="Useful",+ ),+ AppAnnotationHitHistory(+ app_id=harness.target.id,+ annotation_id=annotation.id,+ source="annotation",+ question="Question",+ account_id=harness.account.id,+ score=0.5,+ message_id=middle.id,+ annotation_question="Question",+ annotation_content="Answer",+ ),+ MessageAgentThought(+ message_id=middle.id,+ position=1,+ created_by_role=CreatorUserRole.ACCOUNT,+ created_by=harness.account.id,+ thought="Consider the request",+ tool_labels_str="{}",+ tool_meta_str="{}",+ ),+ ]+ )+ response = _get(harness, route, query="limit=2")+ assert response.status_code == 200+ body = response.get_json()+ assert body["limit"] == 2+ assert body["has_more"] is True+ assert [item["id"] for item in body["data"]] == [middle.id, harness.message.id]+ item = body["data"][0]+ assert item["inputs"] == {"zero": 0, "disabled": False, "null": None, "empty": []}+ assert item["query"] == "Hello"+ assert item["message"] == {"text": "Hello"}+ assert item["answer"] == "你好"+ assert item["metadata"] == {"zero": 0}+ assert item["retriever_resources"] == []+ assert item["message_tokens"] == 2+ assert item["answer_tokens"] == 3+ assert item["created_at"] == int((_CREATED_AT - timedelta(minutes=1)).timestamp())+ assert item["feedbacks"][0]["from_account"] == {+ "id": harness.account.id,+ "name": harness.account.name,+ "email": harness.account.email,+ }+ assert item["feedbacks"][0]["content"] == "Useful"+ assert item["annotation"]["id"] == annotation.id+ assert item["annotation"]["account"]["id"] == harness.account.id+ assert item["annotation_hit_history"]["annotation_id"] == annotation.id+ assert item["annotation_hit_history"]["annotation_create_account"]["id"] == harness.account.id+ assert item["agent_thoughts"][0]["thought"] == "Consider the request"+ assert item["message_files"][0]["id"] == attachment.id+ assert item["message_files"][0]["url"] == "https://example.com/photo.png"+ assert item["extra_contents"][0]["workflow_run_id"] == form.workflow_run_id+ assert item["extra_contents"][0]["submitted"] is False+ detail_route = route.removesuffix("/chat-messages") + f"/messages/{middle.id}"+ detail = _get(harness, detail_route)+ assert detail.status_code == 200+ assert detail.get_json() == item+ response = _get(harness, route, query=f"limit=2&first_id={middle.id}")+ assert response.status_code == 200+ assert response.get_json()["has_more"] is False+ assert [item["id"] for item in response.get_json()["data"]] == [oldest.id]+ harness.assert_closed()++[email protected]("kind", ["app", "agent"])[email protected]("missing", ["login", "csrf"])+def test_list_requires_real_login_and_csrf(harness: _Harness, kind: Literal["app", "agent"], missing: str) -> None:+ response = _get(harness, _route(harness, kind), authenticated=missing != "login", csrf=missing != "csrf")+ _error(response, status=401, code="unauthorized")+ assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'++[email protected]("role", list(TenantAccountRole))[email protected]("kind", ["app", "agent"])+def test_list_preserves_edit_permission(+ harness: _Harness, role: TenantAccountRole, kind: Literal["app", "agent"]+) -> None:+ route = _route(harness, kind)+ with harness.factory.begin() as session:+ session.execute(+ update(TenantAccountJoin).where(TenantAccountJoin.account_id == harness.account.id).values(role=role)+ )+ response = _get(harness, route)+ if role in {TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}:+ assert response.status_code == 200+ else:+ _error(response, status=403, code="forbidden")++[email protected]("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT])[email protected]("owner", ["account", "end_user", "deleted"])+def test_plain_console_retains_app_wide_conversation_access(harness: _Harness, mode: AppMode, owner: str) -> None:+ route = _route(harness)+ with harness.factory.begin() as session:+ session.execute(update(App).where(App.id == harness.target.id).values(mode=mode))+ values = {"is_deleted": True} if owner == "deleted" else {"from_account_id": str(uuid4())}+ if owner == "end_user":+ values = {+ "from_account_id": None,+ "from_end_user_id": str(uuid4()),+ "from_source": ConversationFromSource.API,+ }+ session.execute(update(Conversation).where(Conversation.id == harness.conversation.id).values(**values))+ response = _get(harness, route)+ assert response.status_code == 200+ assert response.get_json()["data"][0]["id"] == harness.message.id++[email protected]("kind", ["app", "agent"])[email protected]("owner", ["app_id", "from_account_id", "from_source", "from_end_user_id", "is_deleted"])+def test_agent_app_mode_requires_owned_conversation(+ harness: _Harness, kind: Literal["app", "agent"], owner: str+) -> None:+ route = _route(harness, "agent")+ if kind == "app":+ route = f"/apps/{harness.target.id}/chat-messages"+ value = True if owner == "is_deleted" else ConversationFromSource.API if owner == "from_source" else str(uuid4())+ with harness.factory.begin() as session:+ session.execute(update(Conversation).where(Conversation.id == harness.conversation.id).values({owner: value}))+ _error(_get(harness, route), status=404, code="not_found")++[email protected]("query", ["limit=0", "limit=101", "limit=invalid", "first_id=invalid"])+def test_invalid_queries_use_shared_422(harness: _Harness, query: str) -> None:+ _error(_get(harness, _route(harness), query=query), status=422, code="unprocessable_entity")+++def test_missing_conversation_and_foreign_cursor_keep_precise_errors(harness: _Harness) -> None:+ route = _route(harness)+ response = _get(harness, route, conversation_id=str(uuid4()))+ _error(response, status=404, code="not_found")+ assert response.get_json()["message"] == "Conversation Not Exists."+ with harness.factory.begin() as session:+ session.execute(update(Message).where(Message.id == harness.message.id).values(conversation_id=str(uuid4())))+ response = _get(harness, route, query=f"first_id={harness.message.id}")+ _error(response, status=404, code="not_found")+ assert response.get_json()["message"] == "First message not found"++[email protected]("mode", [AppMode.COMPLETION, AppMode.WORKFLOW])+def test_plain_console_rejects_non_chat_modes(harness: _Harness, mode: AppMode) -> None:+ route = _route(harness)+ with harness.factory.begin() as session:+ session.execute(update(App).where(App.id == harness.target.id).values(mode=mode))+ _error(_get(harness, route), status=404, code="app_not_found")++[email protected]("scope", [AgentScope.ROSTER, AgentScope.WORKFLOW_ONLY])+def test_agent_runtime_resolution_stays_read_only(harness: _Harness, scope: AgentScope) -> None:+ route = _route(harness, "agent", scope=scope)+ assert _get(harness, route).status_code == 200+ if scope == AgentScope.WORKFLOW_ONLY:+ _error(_get(harness, f"/apps/{harness.target.id}/chat-messages"), status=404, code="app_not_found")+ with harness.factory.begin() as session:+ session.execute(update(Agent).values(backing_app_id=None))+ app_count = session.scalar(select(func.count()).select_from(App))+ _error(_get(harness, route), status=404, code="agent_not_found_error")+ with harness.factory() as session:+ assert session.scalar(select(func.count()).select_from(App)) == app_count+ assert session.scalar(select(Agent.backing_app_id)) is None+++def test_empty_conversation_returns_default_envelope(harness: _Harness) -> None:+ route = _route(harness)+ with harness.factory.begin() as session:+ session.execute(delete(Message).where(Message.id == harness.message.id))+ response = _get(harness, route, query="first_id=")+ assert response.status_code == 200+ assert response.get_json() == {"limit": 20, "has_more": False, "data": []}diff --git a/api/tests/e2e_tests/contracts/controllers/console/explore/test_message_list.py b/api/tests/e2e_tests/contracts/controllers/console/explore/test_message_list.pynew file mode 100644index 00000000000..8f67e700e11--- /dev/null+++ b/api/tests/e2e_tests/contracts/controllers/console/explore/test_message_list.py@@ -0,0 +1,185 @@+"""Explore message lists through real HTTP admission, services and SQLite."""++from collections.abc import Iterator+from uuid import uuid4++import pytest+from sqlalchemy import delete, event, update+from sqlalchemy.orm import Session, SessionTransaction++from controllers.console.explore.message import MessageListApi+from libs.external_api import ExternalApi+from models import Account+from models.enums import ConversationFromSource, FeedbackFromSource, FeedbackRating+from models.model import App, AppMode, Conversation, InstalledApp, Message, MessageFeedback+from tests.e2e_tests.contracts.controllers.console.app.test_message_list import (+ _CREATED_AT,+ _add_extra_content,+ _error,+ _get,+ _older_message,+)+from tests.e2e_tests.contracts.controllers.console.explore.test_message_suggested_questions import _Harness+from tests.e2e_tests.contracts.controllers.console.explore.test_message_suggested_questions import (+ harness as installed_app_harness,+)++__all__ = ["installed_app_harness"]+++def harness(installed_app_harness: _Harness) -> Iterator[_Harness]:+ state = installed_app_harness+ api = ExternalApi(state.app)+ api.add_resource(MessageListApi, "/installed-apps/<uuid:installed_app_id>/messages", endpoint="console.messages")+ with state.factory.begin() as session:+ session.execute(update(Message).where(Message.id == state.message.id).values(created_at=_CREATED_AT))+ yield state+ if state.sessions:+ state.assert_closed()+ with state.factory() as session:+ installation = session.get(InstalledApp, state.installation.id)+ if installation is not None:+ assert installation.last_used_at is None+++def _route(state: _Harness) -> str:+ return f"/installed-apps/{state.installation.id}/messages"+++def test_list_preserves_response_and_fetches_older_messages_in_display_order(harness: _Harness) -> None:+ assert harness.target.tenant_id != harness.installation.tenant_id+ oldest = _older_message(harness, age=2)+ middle = _older_message(harness, age=1)+ form = _add_extra_content(harness, middle.id)+ with harness.factory.begin() as session:+ session.add_all(+ [+ MessageFeedback(+ app_id=harness.target.id,+ conversation_id=harness.conversation.id,+ message_id=middle.id,+ rating=rating,+ from_source=source,+ )+ for rating, source in (+ (FeedbackRating.LIKE, FeedbackFromSource.ADMIN),+ (FeedbackRating.DISLIKE, FeedbackFromSource.USER),+ )+ ]+ )+ response = _get(harness, _route(harness), query="limit=2")+ assert response.status_code == 200+ body = response.get_json()+ assert body["limit"] == 2+ assert body["has_more"] is True+ assert [item["id"] for item in body["data"]] == [middle.id, harness.message.id]+ item = body["data"][0]+ assert item["inputs"] == {"zero": 0, "disabled": False, "null": None, "empty": []}+ assert item["feedback"] == {"rating": "dislike"}+ assert item["total_tokens"] == 5+ assert item["total_price"] == "0E-7"+ assert item["currency"] == "USD"+ assert item["extra_contents"][0]["workflow_run_id"] == form.workflow_run_id+ assert item["extra_contents"][0]["submitted"] is False+ assert item["extra_contents"][0]["form_submission_data"] is None+ response = _get(harness, _route(harness), query=f"limit=2&first_id={middle.id}")+ assert response.status_code == 200+ assert response.get_json()["has_more"] is False+ assert [item["id"] for item in response.get_json()["data"]] == [oldest.id]+ harness.assert_closed()++[email protected]("empty_id", [False, True])+def test_empty_list_keeps_defaults(harness: _Harness, empty_id: bool) -> None:+ with harness.factory.begin() as session:+ session.execute(delete(Message).where(Message.id == harness.message.id))+ response = _get(harness, _route(harness), conversation_id="" if empty_id else None)+ assert response.status_code == 200+ assert response.get_json() == {"limit": 20, "has_more": False, "data": []}++[email protected]("query", ["limit=0", "limit=101", "limit=invalid", "first_id=invalid"])+def test_invalid_query_uses_shared_422(harness: _Harness, query: str) -> None:+ _error(_get(harness, _route(harness), query=query), status=422, code="unprocessable_entity")+++ "owner", ["app_id", "from_account_id", "from_source", "from_end_user_id", "is_deleted", "missing"]+)+def test_list_requires_complete_conversation_ownership(harness: _Harness, owner: str) -> None:+ with harness.factory.begin() as session:+ if owner == "missing":+ session.execute(delete(Conversation).where(Conversation.id == harness.conversation.id))+ else:+ value = (+ True+ if owner == "is_deleted"+ else ConversationFromSource.API+ if owner == "from_source"+ else str(uuid4())+ )+ session.execute(+ update(Conversation).where(Conversation.id == harness.conversation.id).values({owner: value})+ )+ _error(_get(harness, _route(harness)), status=404, code="conversation_not_found")+++def test_list_rejects_cursor_from_another_conversation(harness: _Harness) -> None:+ with harness.factory.begin() as session:+ session.execute(update(Message).where(Message.id == harness.message.id).values(conversation_id=str(uuid4())))+ _error(+ _get(harness, _route(harness), query=f"first_id={harness.message.id}"),+ status=404,+ code="message_cursor_not_found",+ )++[email protected]("missing", ["installation", "workspace", "app"])+def test_list_applies_installed_app_admission(harness: _Harness, missing: str) -> None:+ with harness.factory.begin() as session:+ if missing == "installation":+ session.execute(delete(InstalledApp).where(InstalledApp.id == harness.installation.id))+ elif missing == "workspace":+ session.execute(+ update(InstalledApp).where(InstalledApp.id == harness.installation.id).values(tenant_id=str(uuid4()))+ )+ else:+ session.execute(delete(App).where(App.id == harness.target.id))+ _error(_get(harness, _route(harness)), status=404, code="installed_app_not_found")++[email protected]("mode", [AppMode.COMPLETION, AppMode.WORKFLOW, AppMode.AGENT])+def test_non_chat_modes_have_specific_error(harness: _Harness, mode: AppMode) -> None:+ with harness.factory.begin() as session:+ session.execute(update(App).where(App.id == harness.target.id).values(mode=mode))+ _error(_get(harness, _route(harness)), status=400, code="not_chat_app")++[email protected]("missing", ["login", "csrf"])+def test_login_and_csrf_are_required(harness: _Harness, missing: str) -> None:+ response = _get(harness, _route(harness), authenticated=missing != "login", csrf=missing != "csrf")+ _error(response, status=401, code="unauthorized")+ assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'++[email protected]("change", ["installation", "app", "owner", "account"])+def test_stale_admitted_resource_is_revalidated(harness: _Harness, change: str) -> None:+ def change_resource(_session: Session, _transaction: SessionTransaction) -> None:+ with harness.factory.begin() as session:+ if change == "installation":+ session.execute(delete(InstalledApp).where(InstalledApp.id == harness.installation.id))+ elif change == "account":+ session.execute(delete(Account).where(Account.id == harness.account.id))+ elif change == "app":+ session.execute(delete(App).where(App.id == harness.target.id))+ else:+ session.execute(update(App).where(App.id == harness.target.id).values(tenant_id=str(uuid4())))++ event.listen(harness.admission_factory, "after_transaction_end", change_resource, once=True)+ try:+ response = _get(harness, _route(harness))+ finally:+ event.remove(harness.admission_factory, "after_transaction_end", change_resource)+ status, code = (401, "unauthorized") if change == "account" else (404, "installed_app_not_found")+ _error(response, status=status, code=code)diff --git a/api/tests/e2e_tests/contracts/controllers/service_api/app/test_message_feedback.py b/api/tests/e2e_tests/contracts/controllers/service_api/app/test_message_feedback.pyindex 79005331d4f..4765dd02adc 100644--- a/api/tests/e2e_tests/contracts/controllers/service_api/app/test_message_feedback.py+++ b/api/tests/e2e_tests/contracts/controllers/service_api/app/test_message_feedback.py@@ -16,7 +16,7 @@ from sqlalchemy.orm import Session, SessionTransaction, sessionmakerfrom werkzeug.test import TestResponsefrom constants.resource_access_token import ResourceAccessTokenResourceType-from controllers.service_api.app.message import AppGetFeedbacksApi, MessageFeedbackApi+from controllers.service_api.app.message import AppGetFeedbacksApi, MessageFeedbackApi, MessageListApifrom enums import DeploymentEditionfrom extensions.ext_application_services import build_application_servicesfrom extensions.ext_database import db@@ -163,6 +163,7 @@ def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]app.extensions["application_services"] = servicesapi = ExternalApi(app)api.add_resource(MessageFeedbackApi, "/messages/<uuid:message_id>/feedbacks")+ api.add_resource(MessageListApi, "/messages")api.add_resource(AppGetFeedbacksApi, "/app/feedbacks")yield _Harness(app,diff --git a/api/tests/e2e_tests/contracts/controllers/service_api/app/test_message_list.py b/api/tests/e2e_tests/contracts/controllers/service_api/app/test_message_list.pynew file mode 100644index 00000000000..9f71790e643--- /dev/null+++ b/api/tests/e2e_tests/contracts/controllers/service_api/app/test_message_list.py@@ -0,0 +1,249 @@+"""Service API history through real API token admission and detached SQLite reads."""++import json+from datetime import datetime, timedelta+from decimal import Decimal+from http import HTTPStatus+from uuid import uuid4++import pytest+from sqlalchemy import delete, select, update+from werkzeug.test import TestResponse++from models.account import Tenant, TenantStatus+from models.enums import DEFAULT_END_USER_SESSION_ID, ConversationFromSource+from models.model import App, AppMode, Conversation, EndUser, Message+from tests.e2e_tests.contracts.controllers.service_api.app.test_message_feedback import _Harness+from tests.e2e_tests.contracts.controllers.service_api.app.test_message_feedback import harness as admission_harness+from tests.helpers.unit.model_factories import make_conversation, make_message++harness = admission_harness+++def _get(+ harness: _Harness,+ *,+ user: str | None = "alice",+ authorization: str | None = "Bearer feedback-test-token",+ **query: object,+) -> TestResponse:+ query_string = {"conversation_id": harness.message.conversation_id, **query}+ if user is not None:+ query_string["user"] = user+ headers: dict[str, str] = {"Authorization": authorization} if authorization is not None else {}+ return harness.app.test_client().get("/messages", query_string=query_string, headers=headers)+++def test_history_shape_omits_web_metadata_and_preserves_nulls(harness: _Harness) -> None:+ with harness.factory.begin() as session:+ session.execute(+ update(Message)+ .where(Message.id == harness.message.id)+ .values(+ created_at=datetime(2024, 1, 1, 12),+ message_metadata=json.dumps({"private": "web-only", "retriever_resources": []}),+ message_tokens=3,+ answer_tokens=5,+ total_price=Decimal("0.0012"),+ provider_response_latency=0.25,+ )+ )+ response = _get(harness)+ assert response.status_code == HTTPStatus.OK+ assert response.headers["Content-Type"] == "application/json"+ body = response.get_json()+ assert body["limit"] == 20+ assert body["has_more"] is False+ [item] = body["data"]+ assert item == {+ "id": harness.message.id,+ "conversation_id": harness.message.conversation_id,+ "parent_message_id": None,+ "inputs": {},+ "query": "question",+ "answer": "answer",+ "feedback": None,+ "retriever_resources": [],+ "created_at": int(datetime(2024, 1, 1, 12).timestamp()),+ "agent_thoughts": [],+ "message_files": [],+ "message_tokens": 3,+ "answer_tokens": 5,+ "provider_response_latency": 0.25,+ "total_price": item["total_price"],+ "currency": "USD",+ "status": "normal",+ "error": None,+ "extra_contents": [],+ "total_tokens": 8,+ }+ assert isinstance(item["total_price"], str)+ assert Decimal(item["total_price"]) == Decimal("0.0012")+ harness.assert_closed()+++def test_history_pages_are_ascending_and_cursor_excludes_equal_timestamps(harness: _Harness) -> None:+ created_at = datetime(2024, 1, 1)+ messages = [+ make_message(+ message_id=str(uuid4()),+ app_id=harness.target.id,+ conversation_id=harness.message.conversation_id,+ inputs={},+ query=f"question-{index}",+ message={},+ answer=f"answer-{index}",+ message_unit_price=Decimal(0),+ answer_unit_price=Decimal(0),+ currency="USD",+ from_source=ConversationFromSource.API,+ from_end_user_id=harness.end_user.id,+ created_at=created_at + timedelta(seconds=index),+ )+ for index in (1, 2)+ ]+ with harness.factory.begin() as session:+ session.execute(update(Message).where(Message.id == harness.message.id).values(created_at=created_at))+ session.add_all(messages)+ response = _get(harness, limit=2)+ assert response.status_code == HTTPStatus.OK+ body = response.get_json()+ assert body["limit"] == 2+ assert body["has_more"] is True+ assert [item["id"] for item in body["data"]] == [message.id for message in messages]+ previous = _get(harness, first_id=messages[0].id, limit=2).get_json()+ assert previous["has_more"] is False+ assert [item["id"] for item in previous["data"]] == [harness.message.id]+ with harness.factory.begin() as session:+ session.execute(+ update(Message).where(Message.id == harness.message.id).values(created_at=messages[0].created_at)+ )+ assert _get(harness, first_id=messages[0].id, limit=2).get_json() == {"limit": 2, "has_more": False, "data": []}+ harness.assert_closed()+++def test_empty_conversation_keeps_pagination_shape(harness: _Harness) -> None:+ with harness.factory.begin() as session:+ session.execute(delete(Message).where(Message.id == harness.message.id))+ response = _get(harness, limit=100)+ assert response.status_code == HTTPStatus.OK+ assert response.get_json() == {"limit": 100, "has_more": False, "data": []}+ harness.assert_closed()++[email protected]("user", [None, ""])+def test_optional_user_is_provisioned_and_cannot_read_existing_users_history(+ harness: _Harness, user: str | None+) -> None:+ response = _get(harness, user=user)+ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.get_json()["message"] == "Conversation Not Exists."+ with harness.factory() as session:+ users = session.scalars(select(EndUser).where(EndUser.app_id == harness.target.id)).all()+ anonymous = [end_user for end_user in users if end_user.id != harness.end_user.id]+ assert len(anonymous) == 1+ assert anonymous[0].session_id == DEFAULT_END_USER_SESSION_ID+ assert anonymous[0].external_user_id == DEFAULT_END_USER_SESSION_ID+ harness.assert_closed()+++def test_other_end_user_cannot_read_history(harness: _Harness) -> None:+ response = _get(harness, user="other-user")+ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.get_json()["message"] == "Conversation Not Exists."+ harness.assert_closed()+++def test_resource_token_lists_only_the_admitted_users_history(harness: _Harness) -> None:+ token = harness.create_resource_token(harness.target.id)+ authorization = f"Bearer {token.token}"++ response = _get(harness, authorization=authorization)++ assert response.status_code == HTTPStatus.OK+ body = response.get_json()+ assert body["limit"] == 20+ assert body["has_more"] is False+ assert [item["id"] for item in body["data"]] == [harness.message.id]+ harness.assert_closed()++ response = _get(harness, authorization=authorization, user="other-user")++ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.get_json()["message"] == "Conversation Not Exists."+ harness.assert_closed()++[email protected]("field", ["app_id", "from_end_user_id", "from_account_id", "from_source"])+def test_conversation_ownership_is_enforced(harness: _Harness, field: str) -> None:+ value = ConversationFromSource.CONSOLE if field == "from_source" else str(uuid4())+ with harness.factory.begin() as session:+ session.execute(+ update(Conversation).where(Conversation.id == harness.message.conversation_id).values({field: value})+ )+ response = _get(harness)+ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.get_json()["code"] == "not_found"+ assert response.get_json()["message"] == "Conversation Not Exists."+ harness.assert_closed()++[email protected]("query", [{"conversation_id": str(uuid4())}, {"first_id": str(uuid4())}])+def test_missing_conversation_or_cursor_has_precise_error(harness: _Harness, query: dict[str, str]) -> None:+ response = _get(harness, **query)+ assert response.status_code == HTTPStatus.NOT_FOUND+ expected = "Conversation Not Exists." if "conversation_id" in query else "First Message Not Exists."+ assert response.get_json()["message"] == expected+ harness.assert_closed()+++def test_cursor_from_another_conversation_is_rejected(harness: _Harness) -> None:+ conversation = make_conversation(+ conversation_id=str(uuid4()),+ app_id=harness.target.id,+ inputs={},+ from_source=ConversationFromSource.API,+ from_end_user_id=harness.end_user.id,+ )+ with harness.factory.begin() as session:+ session.add(conversation)+ response = _get(harness, conversation_id=conversation.id, first_id=harness.message.id)+ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.get_json()["message"] == "First Message Not Exists."+ harness.assert_closed()++[email protected]("mode", [AppMode.COMPLETION, AppMode.WORKFLOW])+def test_non_chat_app_is_rejected(harness: _Harness, mode: AppMode) -> None:+ with harness.factory.begin() as session:+ session.execute(update(App).where(App.id == harness.target.id).values(mode=mode))+ response = _get(harness)+ assert response.status_code == HTTPStatus.BAD_REQUEST+ assert response.get_json()["code"] == "not_chat_app"+ harness.assert_closed()++[email protected]("query", [{"limit": "0"}, {"limit": "101"}, {"conversation_id": "bad"}, {"first_id": "bad"}])+def test_invalid_query_is_rejected(harness: _Harness, query: dict[str, str]) -> None:+ response = _get(harness, **query)+ assert response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY+ assert response.get_json()["code"] == "unprocessable_entity"+ harness.assert_closed()++[email protected]("authorization", [None, "Basic feedback-test-token"])+def test_invalid_authorization_is_rejected(harness: _Harness, authorization: str | None) -> None:+ response = _get(harness, authorization=authorization)+ assert response.status_code == HTTPStatus.UNAUTHORIZED+ assert response.get_json()["code"] == "unauthorized"+ assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'+ assert harness.sessions == []+++def test_archived_workspace_is_rejected(harness: _Harness) -> None:+ with harness.factory.begin() as session:+ session.execute(update(Tenant).where(Tenant.id == harness.tenant.id).values(status=TenantStatus.ARCHIVE))+ response = _get(harness)+ assert response.status_code == HTTPStatus.FORBIDDEN+ assert response.get_json()["code"] == "workspace_archived"+ harness.assert_closed()diff --git a/api/tests/e2e_tests/contracts/controllers/web/test_message_feedback.py b/api/tests/e2e_tests/contracts/controllers/web/test_message_feedback.pyindex 1ebc304d691..642eadaed59 100644--- a/api/tests/e2e_tests/contracts/controllers/web/test_message_feedback.py+++ b/api/tests/e2e_tests/contracts/controllers/web/test_message_feedback.py@@ -14,7 +14,7 @@ from sqlalchemy.orm import Session, SessionTransaction, sessionmakerfrom werkzeug.test import TestResponsefrom constants import HEADER_NAME_APP_CODE, HEADER_NAME_PASSPORT-from controllers.web.message import MessageFeedbackApi+from controllers.web.message import MessageFeedbackApi, MessageListApifrom enums import DeploymentEditionfrom extensions.ext_application_services import build_application_servicesfrom extensions.ext_database import db@@ -112,6 +112,7 @@ def harness()api = ExternalApi(app)api.add_resource(MessageFeedbackApi, "/messages/<uuid:message_id>/feedbacks")+ api.add_resource(MessageListApi, "/messages")passport = PassportService().issue({"app_code": site.code, "app_id": target.id, "end_user_id": end_user.id})yield _Harness(app,diff --git a/api/tests/e2e_tests/contracts/controllers/web/test_message_list.py b/api/tests/e2e_tests/contracts/controllers/web/test_message_list.pynew file mode 100644index 00000000000..4542a5afbab--- /dev/null+++ b/api/tests/e2e_tests/contracts/controllers/web/test_message_list.py@@ -0,0 +1,346 @@+"""Web message history through real passport admission and detached SQLite reads."""++import json+from collections.abc import Callable, Iterator+from datetime import datetime, timedelta+from decimal import Decimal+from http import HTTPStatus+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer+from threading import Thread+from typing import override+from uuid import uuid4++import pytest+from sqlalchemy import delete, event, update+from sqlalchemy.orm import Session+from werkzeug.test import TestResponse++from core.helper import http_client_pooling+from graphon.file import FileTransferMethod, FileType+from models.enums import (+ ConversationFromSource,+ CreatorUserRole,+ FeedbackFromSource,+ FeedbackRating,+ MessageFileBelongsTo,+)+from models.model import App, AppMode, Conversation, EndUser, Message, MessageAgentThought, MessageFeedback, MessageFile+from models.workflow import Workflow+from tests.e2e_tests.contracts.controllers.web.test_message_feedback import _Harness+from tests.e2e_tests.contracts.controllers.web.test_message_feedback import harness as admission_harness+from tests.helpers.unit.model_factories import make_message++harness = admission_harness+++def remote_files(+ harness: _Harness, config_overrides: Callable[..., None], monkeypatch: pytest.MonkeyPatch+) -> Iterator[tuple[str, list[tuple[str, str, bool]]]]:+ config_overrides(SSRF_PROXY_HTTP_URL="", SSRF_PROXY_HTTPS_URL="", SSRF_PROXY_ALL_URL="")+ requests: list[tuple[str, str, bool]] = []++ class Handler(BaseHTTPRequestHandler):+ @override+ def log_message(self, format: str, *args: object) -> None:+ pass++ def do_HEAD(self) -> None:+ requests.append((self.command, self.path, any(session.in_transaction() for session in harness.sessions)))+ self.send_response(HTTPStatus.OK)+ self.send_header("Content-Type", "application/octet-stream")+ self.send_header("Content-Length", "42")+ self.send_header("Content-Disposition", "attachment; filename*=UTF-8''downloaded%20image.png")+ self.end_headers()++ http_pool = http_client_pooling.HttpClientPoolFactory()+ monkeypatch.setattr(http_client_pooling, "_factory", http_pool)+ server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)+ thread = Thread(target=server.serve_forever, daemon=True)+ thread.start()+ try:+ yield f"http://127.0.0.1:{server.server_port}", requests+ finally:+ server.shutdown()+ server.server_close()+ thread.join()+ http_pool.close_all()+++def _get(harness: _Harness, **query: object) -> TestResponse:+ return harness.app.test_client().get(+ "/messages",+ query_string={"conversation_id": harness.message.conversation_id, **query},+ headers=harness.headers,+ )+++def test_message_list_preserves_wire_shape_and_loaded_relationships(+ harness: _Harness, remote_files: tuple[str, list[tuple[str, str, bool]]]+) -> None:+ remote_url, requests = remote_files+ created_at = datetime(2024, 1, 1, 12)+ thought = MessageAgentThought(+ message_id=harness.message.id,+ message_chain_id=str(uuid4()),+ position=1,+ created_by_role=CreatorUserRole.END_USER,+ created_by=harness.end_user.id,+ thought="thinking",+ tool="search",+ tool_labels_str='{"search": "Search"}',+ message_files='["file-a"]',+ )+ thought.created_at = created_at+ attachment = MessageFile(+ message_id=harness.message.id,+ type=FileType.IMAGE,+ transfer_method=FileTransferMethod.REMOTE_URL,+ created_by_role=CreatorUserRole.END_USER,+ created_by=harness.end_user.id,+ belongs_to=MessageFileBelongsTo.USER,+ url=f"{remote_url}/user-image.png",+ )+ assistant_attachment = MessageFile(+ message_id=harness.message.id,+ type=FileType.IMAGE,+ transfer_method=FileTransferMethod.REMOTE_URL,+ created_by_role=CreatorUserRole.END_USER,+ created_by=harness.end_user.id,+ belongs_to=MessageFileBelongsTo.ASSISTANT,+ url=f"{remote_url}/assistant-image.png",+ )+ resource_id = str(uuid4())+ metadata = {+ "custom": "metadata",+ "retriever_resources": [{"id": resource_id, "message_id": harness.message.id, "position": 1}],+ }+ with harness.factory.begin() as session:+ session.execute(+ update(Message)+ .where(Message.id == harness.message.id)+ .values(+ {+ Message._inputs: {"text": "hello", "nested": {"value": [1, None]}},+ Message.message_metadata: json.dumps(metadata),+ Message.created_at: created_at,+ Message.message_tokens: 3,+ Message.answer_tokens: 5,+ Message.total_price: Decimal("0.0012"),+ Message.provider_response_latency: 0.25,+ }+ )+ )+ session.add_all(+ [+ thought,+ attachment,+ assistant_attachment,+ MessageFeedback(+ app_id=harness.target.id,+ conversation_id=harness.message.conversation_id,+ message_id=harness.message.id,+ rating=FeedbackRating.LIKE,+ from_source=FeedbackFromSource.USER,+ from_end_user_id=harness.end_user.id,+ ),+ ]+ )++ commits: list[Session] = []++ def record_commit(session: Session) -> None:+ commits.append(session)++ event.listen(Session, "before_commit", record_commit)+ try:+ response = _get(harness)+ finally:+ event.remove(Session, "before_commit", record_commit)+ assert response.status_code == HTTPStatus.OK+ assert not commits+ assert sorted(requests) == [("HEAD", "/assistant-image.png", False), ("HEAD", "/user-image.png", False)]+ assert response.headers["Content-Type"] == "application/json"+ body = response.get_json()+ assert body["limit"] == 20+ assert body["has_more"] is False+ [item] = body["data"]+ assert set(item) == {+ "id",+ "conversation_id",+ "parent_message_id",+ "inputs",+ "query",+ "answer",+ "feedback",+ "retriever_resources",+ "created_at",+ "agent_thoughts",+ "message_files",+ "message_tokens",+ "answer_tokens",+ "provider_response_latency",+ "total_price",+ "currency",+ "status",+ "error",+ "extra_contents",+ "total_tokens",+ "metadata",+ }+ assert item["id"] == harness.message.id+ assert item["conversation_id"] == harness.message.conversation_id+ assert item["parent_message_id"] is None+ assert item["inputs"] == {"text": "hello", "nested": {"value": [1, None]}}+ assert item["query"] == "question"+ assert item["answer"] == "answer"+ assert item["feedback"] == {"rating": "like"}+ assert item["metadata"] == metadata+ assert item["retriever_resources"][0]["id"] == resource_id+ assert item["created_at"] == int(created_at.timestamp())+ assert item["message_tokens"] == 3+ assert item["answer_tokens"] == 5+ assert item["total_tokens"] == 8+ assert Decimal(item["total_price"]) == Decimal("0.0012")+ assert item["provider_response_latency"] == 0.25+ assert item["currency"] == "USD"+ assert item["status"] == "normal"+ assert item["error"] is None+ assert item["extra_contents"] == []+ [actual_thought] = item["agent_thoughts"]+ assert actual_thought["id"] == thought.id+ assert actual_thought["chain_id"] == thought.message_chain_id+ assert actual_thought["tool_labels"] == {"search": "Search"}+ assert actual_thought["files"] == ["file-a"]+ assert actual_thought["created_at"] == int(created_at.timestamp())+ assert len(item["message_files"]) == 2+ actual_files = {file["id"]: file for file in item["message_files"]}+ for expected in (attachment, assistant_attachment):+ actual_file = actual_files[expected.id]+ assert expected.belongs_to is not None+ assert actual_file["url"] == expected.url+ assert actual_file["transfer_method"] == "remote_url"+ assert actual_file["type"] == "image"+ assert actual_file["belongs_to"] == expected.belongs_to.value+ assert actual_file["filename"] == "downloaded image.png"+ assert actual_file["mime_type"] == "image/png"+ assert actual_file["size"] == 42+ harness.assert_closed()+++def test_pagination_returns_latest_slice_in_ascending_order(harness: _Harness) -> None:+ created_at = datetime(2024, 1, 1)+ messages = [+ make_message(+ message_id=str(uuid4()),+ app_id=harness.target.id,+ conversation_id=harness.message.conversation_id,+ inputs={},+ query=f"question-{index}",+ message={},+ answer=f"answer-{index}",+ message_unit_price=Decimal(0),+ answer_unit_price=Decimal(0),+ currency="USD",+ from_source=ConversationFromSource.API,+ from_end_user_id=harness.end_user.id,+ created_at=created_at + timedelta(seconds=index),+ )+ for index in (1, 2)+ ]+ with harness.factory.begin() as session:+ session.execute(update(Message).where(Message.id == harness.message.id).values(created_at=created_at))+ session.add_all(messages)+ response = _get(harness, limit=2)+ assert response.status_code == HTTPStatus.OK+ body = response.get_json()+ assert body["limit"] == 2+ assert body["has_more"] is True+ assert [item["id"] for item in body["data"]] == [message.id for message in messages]+ previous = _get(harness, first_id=messages[0].id, limit=2).get_json()+ assert previous["has_more"] is False+ assert [item["id"] for item in previous["data"]] == [harness.message.id]+ assert _get(harness, first_id=harness.message.id, limit=2).get_json() == {"limit": 2, "has_more": False, "data": []}+ harness.assert_closed()+++def test_empty_conversation_keeps_pagination_shape(harness: _Harness) -> None:+ with harness.factory.begin() as session:+ session.execute(delete(Message).where(Message.id == harness.message.id))+ assert _get(harness, limit=100).get_json() == {"limit": 100, "has_more": False, "data": []}+ harness.assert_closed()++[email protected]("field", ["app_id", "from_end_user_id", "from_account_id", "from_source"])+def test_conversation_ownership_is_enforced(harness: _Harness, field: str) -> None:+ value = ConversationFromSource.CONSOLE if field == "from_source" else str(uuid4())+ with harness.factory.begin() as session:+ session.execute(+ update(Conversation).where(Conversation.id == harness.message.conversation_id).values({field: value})+ )+ response = _get(harness)+ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.get_json()["code"] == "not_found"+ assert response.get_json()["message"] == "Conversation Not Exists."+ harness.assert_closed()++[email protected]("query", [{"conversation_id": str(uuid4())}, {"first_id": str(uuid4())}])+def test_missing_conversation_or_cursor_has_precise_error(harness: _Harness, query: dict[str, str]) -> None:+ response = _get(harness, **query)+ assert response.status_code == HTTPStatus.NOT_FOUND+ expected = "Conversation Not Exists." if "conversation_id" in query else "First Message Not Exists."+ assert response.get_json()["message"] == expected+ harness.assert_closed()++[email protected]("mode", [AppMode.COMPLETION, AppMode.WORKFLOW])+def test_non_chat_app_is_rejected(harness: _Harness, mode: AppMode) -> None:+ with harness.factory.begin() as session:+ session.execute(update(App).where(App.id == harness.target.id).values(mode=mode))+ if mode == AppMode.WORKFLOW:+ workflow = Workflow.new(+ tenant_id=harness.target.tenant_id,+ app_id=harness.target.id,+ type="workflow",+ version="published",+ graph="{}",+ features="{}",+ created_by=str(uuid4()),+ environment_variables=[],+ conversation_variables=[],+ rag_pipeline_variables=[],+ )+ session.add(workflow)+ session.flush()+ session.execute(update(App).where(App.id == harness.target.id).values(workflow_id=workflow.id))+ response = _get(harness)+ assert response.status_code == HTTPStatus.BAD_REQUEST+ assert response.get_json()["code"] == "not_chat_app"+ harness.assert_closed()++[email protected]("query", [{"limit": 0}, {"limit": 101}, {"conversation_id": "bad"}, {"first_id": "bad"}])+def test_invalid_query_is_rejected(harness: _Harness, query: dict[str, object]) -> None:+ response = _get(harness, **query)+ assert response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY+ assert response.get_json()["code"] == "unprocessable_entity"+ harness.assert_closed()++[email protected]("field", ["app_id", "tenant_id"])+def test_corrupt_end_user_scope_is_rejected(harness: _Harness, field: str) -> None:+ with harness.factory.begin() as session:+ session.execute(update(EndUser).where(EndUser.id == harness.end_user.id).values({field: str(uuid4())}))+ response = _get(harness)+ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.get_json()["code"] == "not_found"+ harness.assert_closed()+++def test_missing_passport_is_rejected(harness: _Harness) -> None:+ response = harness.app.test_client().get(+ "/messages", query_string={"conversation_id": harness.message.conversation_id}+ )+ assert response.status_code == HTTPStatus.UNAUTHORIZED+ assert response.get_json()["code"] == "unauthorized"diff --git a/api/tests/e2e_tests/middleware/controllers/console/app/test_chat_message_permissions.py b/api/tests/e2e_tests/middleware/controllers/console/app/test_chat_message_permissions.pyindex 1efaa2705cd..08df722889b 100644--- a/api/tests/e2e_tests/middleware/controllers/console/app/test_chat_message_permissions.py+++ b/api/tests/e2e_tests/middleware/controllers/console/app/test_chat_message_permissions.py@@ -1,19 +1,17 @@"""Integration tests for ChatMessageApi permission verification."""import uuid-from types import SimpleNamespacefrom unittest import mockimport pytestfrom flask.testing import FlaskClientfrom controllers.console.app import completion as completion_api-from controllers.console.app import message as message_apifrom controllers.console.app import wrapsfrom libs.datetime_utils import naive_utc_nowfrom models import App, Tenantfrom models.account import Account, TenantAccountJoin, TenantAccountRole-from models.enums import AppStatus, ConversationFromSource+from models.enums import AppStatusfrom models.model import AppModefrom services.app_generate_service import AppGenerateService@@ -111,84 +109,3 @@ class TestChatMessageApiPermissions:)assert response.status_code == status-- @pytest.mark.parametrize(- ("role", "status"),- [- (TenantAccountRole.OWNER, 200),- (TenantAccountRole.ADMIN, 200),- (TenantAccountRole.EDITOR, 200),- (TenantAccountRole.NORMAL, 403),- (TenantAccountRole.DATASET_OPERATOR, 403),- ],- )- def test_get_requires_edit_permission(- self,- test_client: FlaskClient,- auth_header,- monkeypatch: pytest.MonkeyPatch,- mock_app_model,- mock_account,- role: TenantAccountRole,- status: int,- ):- """Ensure GET chat-messages endpoint enforces edit permissions."""-- mock_load_app_model = mock.Mock(return_value=mock_app_model)- monkeypatch.setattr(wraps, "_load_app_model_from_scoped_session", mock_load_app_model)-- conversation_id = uuid.uuid4()- created_at = naive_utc_now()-- mock_conversation = SimpleNamespace(id=str(conversation_id), app_id=str(mock_app_model.id))- mock_message = SimpleNamespace(- id=str(uuid.uuid4()),- conversation_id=str(conversation_id),- inputs=[],- query="hello",- message=[{"text": "hello"}],- message_tokens=0,- re_sign_file_url_answer="",- answer_tokens=0,- provider_response_latency=0.0,- from_source=ConversationFromSource.CONSOLE,- from_end_user_id=None,- from_account_id=mock_account.id,- feedbacks=[],- workflow_run_id=None,- annotation=None,- annotation_hit_history=None,- created_at=created_at,- agent_thoughts=[],- message_files=[],- message_metadata_dict={},- status="normal",- error="",- parent_message_id=None,- )-- mock_session = mock.Mock()- mock_session.scalar.return_value = mock_conversation- mock_session.scalars.return_value.all.return_value = [mock_message]-- monkeypatch.setattr(message_api, "db", SimpleNamespace(session=mock_session))- monkeypatch.setattr(message_api, "current_user", mock_account)- monkeypatch.setattr(message_api, "attach_message_extra_contents", mock.Mock())-- class DummyPagination:- def __init__(self, data, limit, has_more):- self.data = data- self.limit = limit- self.has_more = has_more-- monkeypatch.setattr(message_api, "InfiniteScrollPagination", DummyPagination)-- mock_account.role = role-- response = test_client.get(- f"/console/api/apps/{mock_app_model.id}/chat-messages",- headers=auth_header,- query_string={"conversation_id": str(conversation_id)},- )-- assert response.status_code == statusdiff --git a/api/tests/unit_tests/controllers/console/agent/test_roster.py b/api/tests/unit_tests/controllers/console/agent/test_roster.pyindex c8a2f2bbe89..bdb327eb070 100644--- a/api/tests/unit_tests/controllers/console/agent/test_roster.py+++ b/api/tests/unit_tests/controllers/console/agent/test_roster.py@@ -1,6 +1,5 @@from collections.abc import Generatorfrom datetime import datetime-from decimal import Decimalfrom inspect import getsource, unwrapfrom types import SimpleNamespacefrom typing import Any, Self, cast@@ -53,20 +52,13 @@ from controllers.console.agent.roster import (AgentStatisticsSummaryApi,)from controllers.console.app import completion as completion_controller-from controllers.console.app import message as message_controllerfrom controllers.console.app.completion import AgentBuildChatFinalizeApi, AgentChatMessageApi, AgentChatMessageStopApifrom controllers.console.app.error import CompletionRequestError-from controllers.console.app.message import (- AgentChatMessageListApi,- AgentMessageApi,-)from enums import CloudPlan, DeploymentEdition-from libs.infinite_scroll_pagination import InfiniteScrollPaginationfrom models.account import Account, TenantAccountRolefrom models.agent import Agent, AgentConfigDraftType, AgentScope, AgentSource, AgentStatus-from models.enums import ApiTokenType, ConversationFromSource, ConversationStatus, CustomizeTokenStrategy, TagType-from models.enums import InvokeFrom as ModelInvokeFrom-from models.model import ApiToken, App, AppMode, Conversation, IconType, Message, Site, Tag, TagBinding+from models.enums import ApiTokenType, CustomizeTokenStrategy, TagType+from models.model import ApiToken, App, AppMode, IconType, Site, Tag, TagBindingfrom services.agent.observability_service import AgentLogQueryParams, AgentStatisticsQueryParamsfrom services.enterprise.rbac_service import RBACServicefrom services.entities.agent_entities import (@@ -87,66 +79,6 @@ def rbac_services(monkeypatch: pytest.MonkeyPatch, rbac_domain: RBACDomain) -> Nmonkeypatch.setattr(roster_controller, "application_services", lambda: rbac_domain)-def _persist_conversation_message(- session: Session,- *,- app_id: str,- conversation_id: str,- message_id: str,- created_at: datetime,-) -> tuple[Conversation, Message]:- conversation = session.get(Conversation, conversation_id)- if conversation is None:- conversation = Conversation(- app_id=app_id,- app_model_config_id=None,- model_provider=None,- override_model_configs=None,- model_id=None,- mode=AppMode.CHAT,- name="Conversation",- _inputs={},- introduction="",- system_instruction="",- system_instruction_tokens=0,- status=ConversationStatus.NORMAL,- invoke_from=ModelInvokeFrom.DEBUGGER,- from_source=ConversationFromSource.CONSOLE,- from_end_user_id=None,- from_account_id="00000000-0000-0000-0000-000000000021",- )- conversation.id = conversation_id- session.add(conversation)- session.flush()- message = Message(- app_id=app_id,- conversation_id=conversation.id,- _inputs={},- query="query",- message={},- message_tokens=0,- message_unit_price=Decimal(0),- message_price_unit=Decimal(0),- answer="answer",- answer_tokens=0,- answer_unit_price=Decimal(0),- answer_price_unit=Decimal(0),- provider_response_latency=0,- total_price=Decimal(0),- currency="USD",- invoke_from=ModelInvokeFrom.DEBUGGER,- from_source=ConversationFromSource.CONSOLE,- from_end_user_id=None,- from_account_id="00000000-0000-0000-0000-000000000021",- app_mode=AppMode.CHAT,- )- message.id = message_id- message.created_at = created_at- session.add(message)- session.flush()- return conversation, message--def _version_response(version_id: str = "version-1") -> dict[str, object]:return {"id": version_id,@@ -2206,176 +2138,6 @@ def test_agent_chat_helper_maps_generation_errors()-def test_agent_chat_message_routes_resolve_app_from_agent_id(- app: Flask, monkeypatch: pytest.MonkeyPatch, unbound_session: Session-) -> None:- agent_id = "00000000-0000-0000-0000-000000000001"- message_id = "00000000-0000-0000-0000-000000000002"- app_model = _app_detail_obj(id="app-1", mode=AppMode.AGENT)- current_user = _account()- captured: dict[str, object] = {}- resolver_calls: list[dict[str, object]] = []-- def resolve_agent_app_model(**kwargs: object) -> object:- resolver_calls.append(kwargs)- return app_model-- def list_chat_messages(**kwargs: object) -> dict[str, object]:- captured["list"] = kwargs- return {"data": []}-- def get_message_detail(**kwargs: object) -> dict[str, object]:- captured["detail"] = kwargs- return {"id": message_id}-- monkeypatch.setattr(message_controller, "resolve_agent_runtime_app_model", resolve_agent_app_model)- monkeypatch.setattr(message_controller, "_list_chat_messages", list_chat_messages)- monkeypatch.setattr(message_controller, "_get_message_detail", get_message_detail)- assert unwrap(AgentChatMessageListApi.get)(- AgentChatMessageListApi(),- message_controller.ChatMessagesQuery(conversation_id="00000000-0000-0000-0000-000000000010"),- unbound_session,- "tenant-1",- current_user,- agent_id,- ) == {"data": []}- list_call = cast(dict[str, object], captured["list"])- assert list_call["session"] is unbound_session- assert list_call["app_model"] is app_model- assert unwrap(AgentMessageApi.get)(AgentMessageApi(), unbound_session, "tenant-1", agent_id, message_id) == {- "id": message_id- }- detail_call = cast(dict[str, object], captured["detail"])- assert detail_call == {"session": unbound_session, "app_model": app_model, "message_id": message_id}- assert resolver_calls == [- {"session": unbound_session, "tenant_id": "tenant-1", "agent_id": agent_id},- {"session": unbound_session, "tenant_id": "tenant-1", "agent_id": agent_id},- ]---def test_list_chat_messages_supports_first_id_pagination(- app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session-) -> None:- app_id = "00000000-0000-0000-0000-000000000001"- conversation_id = "00000000-0000-0000-0000-000000000010"- first_message_id = "00000000-0000-0000-0000-000000000011"- older_message_id = "00000000-0000-0000-0000-000000000012"- _persist_conversation_message(- sqlite_session,- app_id=app_id,- conversation_id=conversation_id,- message_id="00000000-0000-0000-0000-000000000013",- created_at=datetime(2025, 1, 1),- )- _persist_conversation_message(- sqlite_session,- app_id=app_id,- conversation_id=conversation_id,- message_id=older_message_id,- created_at=datetime(2025, 1, 2),- )- _persist_conversation_message(- sqlite_session,- app_id=app_id,- conversation_id=conversation_id,- message_id=first_message_id,- created_at=datetime(2025, 1, 3),- )-- class FakeMessagePaginationResponse:- @classmethod- def model_validate(cls, pagination: InfiniteScrollPagination, from_attributes: bool = False) -> SimpleNamespace:- return SimpleNamespace(- model_dump=lambda mode: {- "data": [item.id for item in pagination.data],- "limit": pagination.limit,- "has_more": pagination.has_more,- }- )-- monkeypatch.setattr(message_controller, "attach_message_extra_contents", lambda messages: None)- monkeypatch.setattr(message_controller, "MessageInfiniteScrollPaginationResponse", FakeMessagePaginationResponse)- with app.test_request_context(- f"/console/api/agent/agent-1/chat-messages?conversation_id={conversation_id}&first_id={first_message_id}&limit=1"- ):- result = message_controller._list_chat_messages(- args=message_controller.ChatMessagesQuery(- conversation_id=conversation_id,- first_id=first_message_id,- limit=1,- ),- session=sqlite_session,- app_model=_app_detail_obj(id=app_id, mode=AppMode.CHAT),- )- assert result == {"data": [older_message_id], "limit": 1, "has_more": True}---def test_list_agent_chat_messages_uses_current_user_conversation(- app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session-) -> None:- app_id = "00000000-0000-0000-0000-000000000001"- conversation_id = "00000000-0000-0000-0000-000000000010"- message_id = "00000000-0000-0000-0000-000000000011"- conversation, _ = _persist_conversation_message(- sqlite_session,- app_id=app_id,- conversation_id=conversation_id,- message_id=message_id,- created_at=datetime(2025, 1, 1),- )- current_user = _account()- app_model = _app_detail_obj(id=app_id, mode=AppMode.AGENT)- captured: dict[str, object] = {}-- class FakeMessagePaginationResponse:- @classmethod- def model_validate(cls, pagination: InfiniteScrollPagination, from_attributes: bool = False) -> SimpleNamespace:- return SimpleNamespace(- model_dump=lambda mode: {- "data": [item.id for item in pagination.data],- "limit": pagination.limit,- "has_more": pagination.has_more,- }- )-- def get_conversation(**kwargs: object) -> object:- captured.update(kwargs)- return conversation-- monkeypatch.setattr(message_controller.ConversationService, "get_conversation", get_conversation)- monkeypatch.setattr(message_controller, "attach_message_extra_contents", lambda messages: None)- monkeypatch.setattr(message_controller, "MessageInfiniteScrollPaginationResponse", FakeMessagePaginationResponse)- with app.test_request_context(f"/console/api/agent/agent-1/chat-messages?conversation_id={conversation_id}"):- result = message_controller._list_chat_messages(- args=message_controller.ChatMessagesQuery(conversation_id=conversation_id),- session=sqlite_session,- app_model=app_model,- current_user=current_user,- )- assert result == {"data": [message_id], "limit": 20, "has_more": False}- assert captured.pop("session") is sqlite_session- assert captured == {"app_model": app_model, "conversation_id": conversation_id, "user": current_user}---def test_list_agent_chat_messages_rejects_foreign_conversation(- app: Flask, monkeypatch: pytest.MonkeyPatch, unbound_session: Session-) -> None:- conversation_id = "00000000-0000-0000-0000-000000000010"- monkeypatch.setattr(- message_controller.ConversationService,- "get_conversation",- lambda **kwargs: (_ for _ in ()).throw(message_controller.ConversationNotExistsError()),- )- with app.test_request_context(f"/console/api/agent/agent-1/chat-messages?conversation_id={conversation_id}"):- with pytest.raises(NotFound):- message_controller._list_chat_messages(- args=message_controller.ChatMessagesQuery(conversation_id=conversation_id),- session=unbound_session,- app_model=_app_detail_obj(id="app-1", mode=AppMode.AGENT),- current_user=_account(),- )--def test_dify_tool_candidate_response_keeps_granularity_fields() -> None:"""Both selection granularities must survive the fields-layer model —the frontend needs granularity/tools_count to render the Tools menu."""diff --git a/api/tests/unit_tests/controllers/console/app/test_message.py b/api/tests/unit_tests/controllers/console/app/test_message.pyindex 5b8b7a84b8d..e43504b3bbc 100644--- a/api/tests/unit_tests/controllers/console/app/test_message.py+++ b/api/tests/unit_tests/controllers/console/app/test_message.py@@ -1,8 +1,6 @@from __future__ import annotationsfrom datetime import UTC, datetime-from inspect import unwrap-from unittest.mock import MagicMockimport pytestfrom flask import Flask@@ -10,6 +8,7 @@ from sqlalchemy.orm import Sessionfrom controllers.console.app import message as message_modulefrom core.app.entities.app_invoke_entities import InvokeFrom+from fields.conversation_fields import MessageResponseSourcefrom models.account import Accountfrom models.enums import ConversationFromSource, CreatorUserRole, FeedbackFromSource, FeedbackRatingfrom models.model import (@@ -92,53 +91,6 @@ def _persist_message(session: Session, *, message_id: str, app_id: str = "app-1"class TestMessageApiCases:- @staticmethod- def test_app_message_routes_pass_injected_session(- app: Flask, monkeypatch: pytest.MonkeyPatch, unbound_session: Session- ) -> None:- session = unbound_session- current_user = _account()- app_model = _app()- message_id = "550e8400-e29b-41d4-a716-446655440000"- list_messages = MagicMock(return_value={"data": []})- get_message_detail = MagicMock(return_value={"id": message_id})- monkeypatch.setattr(message_module, "_list_chat_messages", list_messages)- monkeypatch.setattr(message_module, "_get_message_detail", get_message_detail)-- assert unwrap(message_module.ChatMessageListApi.get)(- message_module.ChatMessageListApi(),- message_module.ChatMessagesQuery(conversation_id="550e8400-e29b-41d4-a716-446655440001"),- session,- current_user,- app_model,- ) == {"data": []}- assert unwrap(message_module.MessageApi.get)(message_module.MessageApi(), session, app_model, message_id) == {- "id": message_id- }-- assert list_messages.call_args.kwargs["session"] is session- assert get_message_detail.call_args.kwargs["session"] is session-- @staticmethod- def test_get_message_detail_uses_injected_session(monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> None:- message_id = "550e8400-e29b-41d4-a716-446655440000"- message = _persist_message(sqlite_session, message_id=message_id)- response_source = object()- response_source_factory = MagicMock(return_value=response_source)- session = sqlite_session- monkeypatch.setattr(message_module, "attach_message_extra_contents", MagicMock())- monkeypatch.setattr(message_module, "MessageResponseSource", response_source_factory)- monkeypatch.setattr(message_module, "dump_response", lambda _model, value: value)-- result = message_module._get_message_detail(- session=session,- app_model=_app(),- message_id=message_id,- )-- assert result is response_source- response_source_factory.assert_called_once_with(message, session=session)-@staticmethoddef test_message_response_source_uses_caller_session_for_nested_fields(sqlite_session: Session) -> None:session = sqlite_session@@ -185,7 +137,7 @@ class TestMessageApiCases:sqlite_session.add_all([feedback, annotation, annotation_hit, thought])sqlite_session.commit()- source = message_module.MessageResponseSource(message, session=session)+ source = MessageResponseSource(message, session=session)assert source.inputs == {"topic": "support"}assert source.user_feedback is feedbackdiff --git a/api/tests/unit_tests/controllers/console/explore/test_message.py b/api/tests/unit_tests/controllers/console/explore/test_message.pydeleted file mode 100644index b26c760fbf7..00000000000--- a/api/tests/unit_tests/controllers/console/explore/test_message.py+++ /dev/null@@ -1,320 +0,0 @@-"""Explore message HTTP contracts through real admission, services and SQLite."""--import json-from collections.abc import Mapping, Sequence-from dataclasses import dataclass, field-from datetime import datetime, timedelta-from decimal import Decimal-from uuid import uuid4--import pytest-from pydantic import JsonValue-from sqlalchemy import Connection, event, update-from sqlalchemy.orm import Session, SessionTransaction, sessionmaker-from werkzeug.test import TestResponse--import controllers.console.explore.message as module-from core.app.entities.app_invoke_entities import InvokeFrom-from models import App, AppMode, InstalledApp-from models.enums import ConversationFromSource, ConversationStatus, FeedbackFromSource, FeedbackRating-from models.model import Conversation, Message, MessageFeedback-from repositories.installed_app_message_repository import SQLAlchemyInstalledAppMessageRepository-from services.installed_app_message_service import InstalledAppMessageService-from tests.unit_tests.controllers.console.explore.test_installed_app_admission import (- _assert_json_response,- _Harness,- harness,-)--__all__ = ["harness"]--_CREATED_AT = datetime(2024, 1, 1)---@dataclass(frozen=True)-class _InstalledAppServices:- messages: InstalledAppMessageService---@dataclass(frozen=True)-class _Services:- installed_apps: _InstalledAppServices---@dataclass-class _Messages:- harness: _Harness- factory: sessionmaker[Session]- services: _Services = field(init=False)- sessions: list[Session] = field(default_factory=list)- extras: dict[str, list[dict[str, JsonValue]]] = field(default_factory=dict)- extra_calls: list[list[str]] = field(default_factory=list)-- def assert_sessions_closed(self) -> None:- assert all(not session.in_transaction() and not session.identity_map for session in self.sessions)-- def get_extra_contents(self, *, message_ids: Sequence[str]) -> Mapping[str, list[dict[str, JsonValue]]]:- self.assert_sessions_closed()- self.extra_calls.append(list(message_ids))- return self.extras-- def request(- self,- *,- conversation_id: str = "",- installed_app_id: str | None = None,- query: str | None = None,- ) -> TestResponse:- url = f"/installed-apps/{installed_app_id or self.harness.installed_app.id}/messages"- url += f"?conversation_id={conversation_id}"- if query:- url += f"&{query}"- return self.harness.app.test_client().get(url)---def messages(- harness: _Harness, monkeypatch: pytest.MonkeyPatch, sqlite_session_factory: sessionmaker[Session]-) -> _Messages:- factory = sessionmaker(bind=sqlite_session_factory.kw["bind"], expire_on_commit=False)- state = _Messages(harness=harness, factory=factory)- _set_mode(state, AppMode.CHAT)-- @event.listens_for(factory, "after_begin")- def track_session(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:- state.sessions.append(session)-- state.services = _Services(- installed_apps=_InstalledAppServices(- messages=InstalledAppMessageService(- messages=SQLAlchemyInstalledAppMessageRepository(session_factory=factory),- get_extra_contents=state.get_extra_contents,- ),- ),- )- monkeypatch.setattr(module, "application_services", lambda: state.services)- harness.api.add_resource(module.MessageListApi, "/installed-apps/<uuid:installed_app_id>/messages")- return state---def _set_mode(state: _Messages, mode: AppMode) -> None:- with state.factory.begin() as session:- app = session.get(App, state.harness.target_app.id)- assert app is not None- app.mode = mode---def _conversation(- state: _Messages,- *,- app_id: str | None = None,- account_id: str | None = None,- source: ConversationFromSource = ConversationFromSource.CONSOLE,- end_user_id: str | None = None,- is_deleted: bool = False,-) -> Conversation:- conversation = Conversation(- app_id=app_id or state.harness.target_app.id,- mode=AppMode.CHAT,- name="Conversation",- status=ConversationStatus.NORMAL,- _inputs={},- from_source=source,- from_account_id=account_id or state.harness.account.id,- from_end_user_id=end_user_id,- invoke_from=InvokeFrom.EXPLORE,- is_deleted=is_deleted,- )- with state.factory.begin() as session:- session.add(conversation)- return conversation---def _message(- state: _Messages,- conversation: Conversation,- *,- age: int = 0,- app_id: str | None = None,- account_id: str | None = None,- source: ConversationFromSource = ConversationFromSource.CONSOLE,- end_user_id: str | None = None,-) -> Message:- message = Message(- app_id=app_id or conversation.app_id,- conversation_id=conversation.id,- _inputs={"zero": 0, "disabled": False, "null": None, "empty": []},- query="Hello",- message={},- answer="你好",- message_tokens=2,- answer_tokens=3,- message_unit_price=Decimal(0),- answer_unit_price=Decimal(0),- total_price=Decimal(0),- provider_response_latency=0,- currency="USD",- status="normal",- message_metadata=json.dumps({"retriever_resources": [], "zero": 0}),- from_source=source,- from_account_id=account_id or state.harness.account.id,- from_end_user_id=end_user_id,- )- message.created_at = _CREATED_AT - timedelta(minutes=age)- with state.factory.begin() as session:- session.add(message)- return message---def _error(response: TestResponse, *, status: int, code: str, message: str | None = None) -> None:- assert response.status_code == status- body = response.get_json()- assert body["code"] == code- assert body["status"] == status- assert isinstance(body["message"], str)- assert body["message"]- if message is not None:- assert body["message"] == message- assert response.headers["Content-Type"] == "application/json"- assert int(response.headers["Content-Length"]) == len(response.data)---def test_list_preserves_response_and_fetches_older_messages_in_display_order(messages: _Messages) -> None:- conversation = _conversation(messages)- oldest = _message(messages, conversation, age=2)- middle = _message(messages, conversation, age=1)- newest = _message(messages, conversation)- messages.extras[middle.id] = [{"type": "human_input", "workflow_run_id": "workflow-1", "submitted": False}]- with messages.factory.begin() as session:- session.add_all(- [- MessageFeedback(- app_id=newest.app_id,- conversation_id=conversation.id,- message_id=newest.id,- rating=rating,- from_source=source,- )- for rating, source in (- (FeedbackRating.LIKE, FeedbackFromSource.ADMIN),- (FeedbackRating.DISLIKE, FeedbackFromSource.USER),- )- ]- )- response = messages.request(conversation_id=conversation.id, query="limit=2")- body = response.get_json()- assert response.status_code == 200- assert body["limit"] == 2- assert body["has_more"] is True- assert [item["id"] for item in body["data"]] == [middle.id, newest.id]- assert body["data"][0]["extra_contents"] == [- {- "type": "human_input",- "workflow_run_id": "workflow-1",- "submitted": False,- "form_definition": None,- "form_submission_data": None,- }- ]- assert body["data"][1] == {- "id": newest.id,- "conversation_id": conversation.id,- "parent_message_id": None,- "inputs": {"zero": 0, "disabled": False, "null": None, "empty": []},- "query": "Hello",- "answer": "你好",- "feedback": {"rating": "dislike"},- "retriever_resources": [],- "created_at": int(_CREATED_AT.timestamp()),- "agent_thoughts": [],- "message_files": [],- "message_tokens": 2,- "answer_tokens": 3,- "provider_response_latency": 0.0,- "total_price": "0E-7",- "currency": "USD",- "status": "normal",- "error": None,- "extra_contents": [],- "total_tokens": 5,- "metadata": {"retriever_resources": [], "zero": 0},- }- _assert_json_response(response, status=200, body=body)- response = messages.request(conversation_id=conversation.id, query=f"limit=2&first_id={middle.id}")- assert response.get_json()["has_more"] is False- assert [item["id"] for item in response.get_json()["data"]] == [oldest.id]- assert messages.extra_calls == [[middle.id, newest.id], [oldest.id]]- messages.assert_sessions_closed()--[email protected]("empty_conversation_id", [False, True])-def test_empty_list_keeps_defaults_and_avoids_extra_content_io(- messages: _Messages, empty_conversation_id: bool-) -> None:- conversation = _conversation(messages)- _assert_json_response(- messages.request(conversation_id="" if empty_conversation_id else conversation.id),- status=200,- body={"limit": 20, "has_more": False, "data": []},- )- assert messages.extra_calls == []--[email protected]("query", ["limit=0", "limit=101", "limit=invalid", "first_id=invalid"])-def test_invalid_list_query_uses_shared_422(messages: _Messages, query: str) -> None:- _error(messages.request(conversation_id=str(uuid4()), query=query), status=422, code="unprocessable_entity")- assert messages.extra_calls == []--[email protected]("owner", ["app", "account", "source", "end_user", "deleted", "missing"])-def test_list_requires_conversation_ownership(messages: _Messages, owner: str) -> None:- conversation = _conversation(- messages,- app_id=str(uuid4()) if owner == "app" else None,- account_id=str(uuid4()) if owner == "account" else None,- source=ConversationFromSource.API if owner == "source" else ConversationFromSource.CONSOLE,- end_user_id=str(uuid4()) if owner == "end_user" else None,- is_deleted=owner == "deleted",- )- _error(- messages.request(conversation_id=str(uuid4()) if owner == "missing" else conversation.id),- status=404,- code="conversation_not_found",- )- assert messages.extra_calls == []---def test_list_rejects_cursor_from_another_conversation(messages: _Messages) -> None:- conversation = _conversation(messages)- foreign = _message(messages, _conversation(messages))- _error(- messages.request(conversation_id=conversation.id, query=f"first_id={foreign.id}"),- status=404,- code="message_cursor_not_found",- )- assert messages.extra_calls == []--[email protected]("admission", ["missing", "denied", "wrong-workspace"])-def test_list_applies_installed_app_admission(messages: _Messages, admission: str) -> None:- if admission == "denied":- messages.harness.state.allowed = False- elif admission == "wrong-workspace":- with messages.factory.begin() as session:- session.execute(- update(InstalledApp)- .where(InstalledApp.id == messages.harness.installed_app.id)- .values(tenant_id=str(uuid4()))- )- _error(- messages.request(installed_app_id=str(uuid4()) if admission == "missing" else None),- status=403 if admission == "denied" else 404,- code="access_denied" if admission == "denied" else "installed_app_not_found",- )- assert messages.extra_calls == []---def test_list_mode_rejection_precedes_message_queries(messages: _Messages) -> None:- _set_mode(messages, AppMode.COMPLETION)- _error(messages.request(), status=400, code="not_chat_app")- assert messages.extra_calls == []diff --git a/api/tests/unit_tests/controllers/service_api/app/test_message.py b/api/tests/unit_tests/controllers/service_api/app/test_message.pyindex 31efc405bba..1ff146a0009 100644--- a/api/tests/unit_tests/controllers/service_api/app/test_message.py+++ b/api/tests/unit_tests/controllers/service_api/app/test_message.py@@ -1,79 +1,21 @@-"""-Unit tests for Service API Message controllers.--Tests coverage for:-- MessageListQuery, MessageFeedbackPayload, FeedbackListQuery Pydantic models-- App mode validation for message endpoints-- MessageService integration-- Error handling for message operations--Focus on:-- Pydantic model validation-- UUID normalization-- Error type mappings-- Service method interfaces-"""+"""Request model and error-type validation for Service API message endpoints."""import uuid-from collections.abc import Iterator-from inspect import unwrap-from unittest.mock import Mock, patchimport pytest-from flask import Flask, request-from sqlalchemy import Engine-from sqlalchemy.orm import Session-from controllers.common.errors import NotFoundErrorfrom controllers.service_api.app.error import NotChatAppErrorfrom controllers.service_api.app.message import (FeedbackListQuery,MessageFeedbackPayload,- MessageListApi,MessageListQuery,)-from models.enums import EndUserType-from models.model import App, AppMode, EndUser-from services.errors.conversation import ConversationNotExistsError+from models.model import AppModefrom services.errors.message import (FirstMessageNotExistsError,MessageNotExistsError,SuggestedQuestionsAfterAnswerDisabledError,)-from services.message_service import MessageService---def _app(*, mode: AppMode = AppMode.CHAT) -> App:- return App(- id="app-1",- tenant_id="tenant-1",- name="Service API app",- description="",- mode=mode,- enable_site=True,- enable_api=True,- max_active_requests=0,- )---def _end_user() -> EndUser:- return EndUser(- id="end-user-1",- tenant_id="tenant-1",- app_id="app-1",- type=EndUserType.SERVICE_API,- external_user_id="external-user-1",- name="Service API user",- session_id="session-1",- )---def orm_session(sqlite_engine: Engine) -> Iterator[Session]:- """Provide a real caller-owned session for MessageService interface tests."""-- with Session(sqlite_engine, expire_on_commit=False) as session:- yield sessionclass TestMessageListQuery:@@ -259,133 +201,3 @@ class TestMessageErrorTypes:"""Test SuggestedQuestionsAfterAnswerDisabledError can be raised."""error = SuggestedQuestionsAfterAnswerDisabledError()assert isinstance(error, SuggestedQuestionsAfterAnswerDisabledError)---class TestMessageService:- """Test MessageService interface and methods."""-- def test_pagination_by_first_id_method_exists(self):- """Test MessageService.pagination_by_first_id exists."""- assert hasattr(MessageService, "pagination_by_first_id")- assert callable(MessageService.pagination_by_first_id)-- @patch.object(MessageService, "pagination_by_first_id")- def test_pagination_by_first_id_returns_pagination_result(self, mock_pagination, orm_session: Session):- """Test pagination_by_first_id returns expected format."""- mock_result = Mock()- mock_result.data = []- mock_result.limit = 20- mock_result.has_more = False- mock_pagination.return_value = mock_result-- result = MessageService.pagination_by_first_id(- app_model=_app(),- user=_end_user(),- conversation_id=str(uuid.uuid4()),- first_id=None,- limit=20,- session=orm_session,- )-- assert hasattr(result, "data")- assert hasattr(result, "limit")- assert hasattr(result, "has_more")-- @patch.object(MessageService, "pagination_by_first_id")- def test_pagination_raises_conversation_not_exists_error(self, mock_pagination, orm_session: Session):- """Test pagination raises ConversationNotExistsError."""- import services.errors.conversation-- mock_pagination.side_effect = services.errors.conversation.ConversationNotExistsError()-- with pytest.raises(services.errors.conversation.ConversationNotExistsError):- MessageService.pagination_by_first_id(- app_model=_app(),- user=_end_user(),- conversation_id="invalid_id",- first_id=None,- limit=20,- session=orm_session,- )-- @patch.object(MessageService, "pagination_by_first_id")- def test_pagination_raises_first_message_not_exists_error(self, mock_pagination, orm_session: Session):- """Test pagination raises FirstMessageNotExistsError."""- mock_pagination.side_effect = FirstMessageNotExistsError()-- with pytest.raises(FirstMessageNotExistsError):- MessageService.pagination_by_first_id(- app_model=_app(),- user=_end_user(),- conversation_id=str(uuid.uuid4()),- first_id="invalid_first_id",- limit=20,- session=orm_session,- )---class TestMessageListApi:- def test_not_chat_app(self, app: Flask) -> None:- api = MessageListApi()- handler = unwrap(api.get)- app_model = _app(mode=AppMode.COMPLETION)- end_user = _end_user()-- # @model_validate parses ahead of the app-mode guard, so the id has to be well-formed to- # reach the branch this test is about.- with app.test_request_context("/messages?conversation_id=00000000-0000-0000-0000-000000000001", method="GET"):- with pytest.raises(NotChatAppError):- handler(- api,- MessageListQuery.model_validate(request.args.to_dict(flat=True)),- app_model=app_model,- end_user=end_user,- )-- def test_conversation_not_found(self, app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:- monkeypatch.setattr(- MessageService,- "pagination_by_first_id",- lambda *_args, **_kwargs: (_ for _ in ()).throw(ConversationNotExistsError()),- )-- api = MessageListApi()- handler = unwrap(api.get)- app_model = _app()- end_user = _end_user()-- with app.test_request_context(- "/messages?conversation_id=00000000-0000-0000-0000-000000000001",- method="GET",- ):- with pytest.raises(NotFoundError):- handler(- api,- MessageListQuery.model_validate(request.args.to_dict(flat=True)),- app_model=app_model,- end_user=end_user,- )-- def test_first_message_not_found(self, app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:- monkeypatch.setattr(- MessageService,- "pagination_by_first_id",- lambda *_args, **_kwargs: (_ for _ in ()).throw(FirstMessageNotExistsError()),- )-- api = MessageListApi()- handler = unwrap(api.get)- app_model = _app()- end_user = _end_user()-- with app.test_request_context(- "/messages?conversation_id=00000000-0000-0000-0000-000000000001&first_id=00000000-0000-0000-0000-000000000002",- method="GET",- ):- with pytest.raises(NotFoundError):- handler(- api,- MessageListQuery.model_validate(request.args.to_dict(flat=True)),- app_model=app_model,- end_user=end_user,- )diff --git a/api/tests/unit_tests/controllers/web/test_message.py b/api/tests/unit_tests/controllers/web/test_message.pydeleted file mode 100644index 09362e8b178..00000000000--- a/api/tests/unit_tests/controllers/web/test_message.py+++ /dev/null@@ -1,258 +0,0 @@-from __future__ import annotations--import builtins-import inspect-import json-import uuid-from datetime import datetime-from pathlib import Path-from types import ModuleType, SimpleNamespace-from unittest.mock import ANY, patch-from uuid import uuid4--import pytest-from flask import Flask-from flask.views import MethodView--from controllers.common.controller_schemas import MessageListQuery-from core.app.entities.app_invoke_entities import InvokeFrom-from core.entities.execution_extra_content import HumanInputContent-from models.enums import ConversationFromSource, EndUserType, FeedbackFromSource, FeedbackRating-from models.model import (- App,- AppMode,- Conversation,- EndUser,- Message,- MessageAgentThought,- MessageFeedback,-)--"""Unit tests for controllers.web.message message list mapping."""---# Ensure flask_restx.api finds MethodView during import.-if not hasattr(builtins, "MethodView"):- builtins.MethodView = MethodView # type: ignore[attr-defined]---def _load_controller_module():- """Import controllers.web.message using a stub package."""-- import importlib- import importlib.util- import sys-- parent_module_name = "controllers.web"- module_name = f"{parent_module_name}.message"-- if parent_module_name not in sys.modules:- from flask_restx import Namespace-- stub = ModuleType(parent_module_name)- web_controller_dir = Path(__file__).resolve().parents[4] / "controllers" / "web"- stub.__file__ = str(web_controller_dir / "__init__.py")- stub.__path__ = [str(web_controller_dir)]- stub.__package__ = "controllers"- stub.__spec__ = importlib.util.spec_from_loader(parent_module_name, loader=None, is_package=True)- stub.web_ns = Namespace("web", description="Web API", path="/")- sys.modules[parent_module_name] = stub-- wraps_module_name = f"{parent_module_name}.wraps"- if wraps_module_name not in sys.modules:- wraps_stub = ModuleType(wraps_module_name)-- class WebApiResource:- pass-- wraps_stub.WebApiResource = WebApiResource- sys.modules[wraps_module_name] = wraps_stub-- return importlib.import_module(module_name)---message_module = _load_controller_module()-MessageListApi = message_module.MessageListApi---class TestMessageListCases:- @staticmethod- @pytest.fixture- def app() -> Flask:- app = Flask(__name__)- app.config["TESTING"] = True- return app-- @staticmethod- @pytest.mark.parametrize(- "sqlite_session",- [(App, Conversation, EndUser, Message, MessageAgentThought, MessageFeedback)],- indirect=True,- )- def test_message_list_mapping(app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session) -> None:- conversation_id = str(uuid4())- message_id = str(uuid4())-- created_at = datetime(2024, 1, 1, 12, 0, 0)- resource_created_at = datetime(2024, 1, 1, 13, 0, 0)- thought_created_at = datetime(2024, 1, 1, 14, 0, 0)-- retriever_resource = {- "id": "res-obj",- "message_id": message_id,- "position": 2,- "dataset_id": "ds-1",- "dataset_name": "dataset",- "document_id": "doc-1",- "document_name": "document",- "data_source_type": "file",- "segment_id": "seg-1",- "score": 0.9,- "hit_count": 1,- "word_count": 10,- "segment_position": 0,- "index_node_hash": "hash",- "content": "content",- "created_at": int(resource_created_at.timestamp()),- }-- agent_thought = MessageAgentThought(- message_chain_id="chain-1",- message_id=message_id,- position=1,- created_by_role="end_user",- created_by="end-user-1",- thought="thinking",- tool="tool",- tool_labels_str=json.dumps({"label": "value"}),- tool_input="{}",- observation="observed",- message_files=json.dumps(["file-a"]),- )- agent_thought.id = "thought-1"- agent_thought.created_at = thought_created_at-- message_files = [- {"id": "file-dict", "filename": "a.txt", "type": "file", "transfer_method": "local"},- {"id": "file-obj", "filename": "b.txt", "type": "file", "transfer_method": "local"},- ]-- app_model = App(- id="app-1",- tenant_id="tenant-1",- name="Chat App",- mode=AppMode.CHAT,- enable_site=False,- enable_api=False,- )- end_user = EndUser(- id="end-user-1",- tenant_id="tenant-1",- app_id=app_model.id,- type=EndUserType.BROWSER,- name="Web User",- session_id="session-1",- )- conversation = Conversation(- id=conversation_id,- app_id=app_model.id,- mode=AppMode.CHAT,- name="Conversation",- _inputs={},- status="normal",- from_source=ConversationFromSource.API,- from_end_user_id=end_user.id,- )- message = Message(- id=message_id,- app_id=app_model.id,- conversation_id=conversation_id,- parent_message_id=None,- _inputs={"foo": "bar"},- query="hello",- message={},- answer="answer",- message_unit_price=0,- message_price_unit=0,- answer_unit_price=0,- answer_price_unit=0,- provider_response_latency=0,- total_price=0,- currency="USD",- invoke_from=InvokeFrom.SERVICE_API,- from_source=ConversationFromSource.API,- from_end_user_id=end_user.id,- app_mode=AppMode.CHAT,- message_metadata=json.dumps(- {- "meta": "value",- "retriever_resources": [- {"id": "res-dict", "message_id": message_id, "position": 1},- retriever_resource,- ],- }- ),- status="normal",- error=None,- )- message.created_at = created_at- message.set_extra_contents(- [- HumanInputContent(- workflow_run_id=str(uuid.uuid4()),- submitted=True,- ).model_dump(mode="json")- ]- )- feedback = MessageFeedback(- app_id=app_model.id,- conversation_id=conversation_id,- message_id=message_id,- rating=FeedbackRating.LIKE,- from_source=FeedbackFromSource.USER,- from_end_user_id=end_user.id,- )- sqlite_session.add_all([app_model, end_user, conversation, message, feedback, agent_thought])- sqlite_session.commit()-- pagination = SimpleNamespace(limit=20, has_more=False, data=[message])-- def message_files_with_session(_self, *, session):- del session- return message_files-- monkeypatch.setattr(Message, "message_files_with_session", message_files_with_session)-- with (- patch.object(message_module.MessageService, "pagination_by_first_id", return_value=pagination) as mock_page,- patch.object(message_module.db, "session", return_value=sqlite_session),- app.test_request_context(f"/messages?conversation_id={conversation_id}&limit=20"),- ):- query = MessageListQuery.model_validate({"conversation_id": conversation_id, "limit": 20})- response = inspect.unwrap(MessageListApi.get)(MessageListApi(), query, app_model, end_user)-- mock_page.assert_called_once_with(app_model, end_user, conversation_id, None, 20, session=ANY)- assert response["limit"] == 20- assert response["has_more"] is False- assert len(response["data"]) == 1-- item = response["data"][0]- assert item["id"] == message_id- assert item["conversation_id"] == conversation_id- assert item["inputs"] == {"foo": "bar"}- assert item["answer"] == "answer"- assert item["feedback"]["rating"] == "like"- assert item["metadata"]["meta"] == "value"- assert item["created_at"] == int(created_at.timestamp())-- assert item["retriever_resources"][0]["id"] == "res-dict"- assert item["retriever_resources"][1]["id"] == "res-obj"- assert item["retriever_resources"][1]["created_at"] == int(resource_created_at.timestamp())-- assert item["agent_thoughts"][0]["chain_id"] == "chain-1"- assert item["agent_thoughts"][0]["created_at"] == int(thought_created_at.timestamp())- assert item["extra_contents"][0]["workflow_run_id"] == message.extra_contents[0]["workflow_run_id"]- assert item["extra_contents"][0]["submitted"] == message.extra_contents[0]["submitted"]-- assert item["message_files"][0]["id"] == "file-dict"- assert item["message_files"][1]["id"] == "file-obj"diff --git a/api/tests/unit_tests/pyrefly.toml b/api/tests/unit_tests/pyrefly.tomlindex 67cc25fa6e2..91868d131e1 100644--- a/api/tests/unit_tests/pyrefly.toml+++ b/api/tests/unit_tests/pyrefly.toml@@ -443,7 +443,6 @@ project-excludes = ["services/test_human_input_delivery_test_service.py","services/test_human_input_file_upload_service.py","services/test_knowledge_retrieval_inner_service.py",- "services/test_message_service.py","services/retention/conversation/test_messages_clean_service.py","services/knowledge/metadata/test_application.py","services/model_provider/test_service.py",diff --git a/api/tests/unit_tests/repositories/test_installed_app_message_repository.py b/api/tests/unit_tests/repositories/test_installed_app_message_repository.pydeleted file mode 100644index 972c8d0f4e4..00000000000--- a/api/tests/unit_tests/repositories/test_installed_app_message_repository.py+++ /dev/null@@ -1,273 +0,0 @@-import json-from dataclasses import replace-from datetime import datetime, timedelta-from decimal import Decimal-from uuid import uuid4--import pytest-from sqlalchemy import inspect, update-from sqlalchemy.orm import Session, sessionmaker--from models.enums import ConversationFromSource, CreatorUserRole, FeedbackFromSource, FeedbackRating-from models.model import App, AppMode, Conversation, InstalledApp, Message, MessageAgentThought, MessageFeedback-from repositories.installed_app_message_repository import SQLAlchemyInstalledAppMessageRepository-from services.errors.conversation import ConversationNotExistsError-from services.errors.message import FirstMessageNotExistsError-from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppRef-from services.installed_app_message_service import MessagePage--_ACCOUNT_ID = "11111111-1111-4111-8111-111111111111"-_OWNER_TENANT_ID = "22222222-2222-4222-8222-222222222222"-_TIME = datetime(2026, 9, 8, 12, 30)---def installation(sqlite_session_factory: sessionmaker[Session]) -> InstalledAppRef:- with sqlite_session_factory.begin() as session:- app = App(tenant_id=_OWNER_TENANT_ID, name="Shared chat", mode=AppMode.CHAT, enable_site=True, enable_api=True)- session.add(app)- session.flush()- installation = InstalledApp(- tenant_id=str(uuid4()), app_id=app.id, app_owner_tenant_id=app.tenant_id, position=0, is_pinned=False- )- session.add(installation)- session.flush()- return InstalledAppRef(- id=installation.id,- tenant_id=installation.tenant_id,- app_id=app.id,- app_owner_tenant_id=app.tenant_id,- app_mode="chat",- )---def _conversation(session: Session, installation: InstalledAppRef) -> Conversation:- conversation = Conversation(- app_id=installation.app_id,- mode=AppMode.CHAT,- name="Chat",- _inputs={},- from_source=ConversationFromSource.CONSOLE,- from_account_id=_ACCOUNT_ID,- from_end_user_id=None,- is_deleted=False,- )- session.add(conversation)- session.flush()- return conversation---def _message(session: Session, conversation: Conversation, *, created_at: datetime = _TIME) -> Message:- message = Message(- app_id=conversation.app_id,- conversation_id=conversation.id,- _inputs={"empty": "", "list": [], "zero": 0, "false": False, "none": None},- query="Question",- message={},- answer="Answer",- message_tokens=2,- message_unit_price=Decimal(0),- answer_tokens=3,- answer_unit_price=Decimal(0),- provider_response_latency=0.5,- total_price=Decimal("0.0000001"),- currency="USD",- from_source=ConversationFromSource.CONSOLE,- from_account_id=_ACCOUNT_ID,- from_end_user_id=None,- )- message.created_at = created_at- session.add(message)- session.flush()- return message---def _feedback(session: Session, message: Message, *, source: FeedbackFromSource) -> MessageFeedback:- feedback = MessageFeedback(- app_id=message.app_id,- conversation_id=message.conversation_id,- message_id=message.id,- rating=FeedbackRating.LIKE,- content="Original",- from_source=source,- from_account_id=str(uuid4()),- )- session.add(feedback)- session.flush()- return feedback---def test_page_keeps_cursor_order_and_detaches_complete_message_data(- sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef-) -> None:- with sqlite_session_factory.begin() as session:- conversation = _conversation(session, installation)- old = _message(session, conversation, created_at=_TIME - timedelta(hours=1))- middle = _message(session, conversation)- newest = _message(session, conversation, created_at=_TIME + timedelta(hours=1))- middle.parent_message_id = old.id- middle.message_metadata = json.dumps(- {"retriever_resources": [{"position": 1, "content": "context"}], "usage": {"total_tokens": 5}}- )- _feedback(session, middle, source=FeedbackFromSource.USER)- admin = _feedback(session, middle, source=FeedbackFromSource.ADMIN)- admin.rating = FeedbackRating.DISLIKE- later = MessageAgentThought(- message_id=middle.id, position=2, created_by_role=CreatorUserRole.ACCOUNT, created_by=_ACCOUNT_ID- )- earlier = MessageAgentThought(- message_id=middle.id,- message_chain_id=str(uuid4()),- position=1,- thought="Thinking",- answer="Partial answer",- tool="search",- tool_labels_str='{"search":{"en_US":"Search"}}',- tool_input='{"query":"query"}',- observation="Found",- message_files='["file-id"]',- created_by_role=CreatorUserRole.ACCOUNT,- created_by=_ACCOUNT_ID,- )- session.add_all([later, earlier])- repository = SQLAlchemyInstalledAppMessageRepository(session_factory=sqlite_session_factory)- page = repository.get_page(- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id, first_id=None, limit=2- )- final = repository.get_page(- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id, first_id=middle.id, limit=2- )-- assert [item.id for item in page.data] == [middle.id, newest.id]- assert (page.limit, page.has_more) == (2, True)- assert [item.id for item in final.data] == [old.id]- assert final.has_more is False- record = page.data[0]- assert inspect(record, raiseerr=False) is None- assert (record.conversation_id, record.parent_message_id) == (conversation.id, old.id)- assert record.inputs == {"empty": "", "list": [], "zero": 0, "false": False, "none": None}- assert (record.query, record.answer, record.created_at) == ("Question", "Answer", _TIME)- assert record.feedback is not None- assert record.feedback.rating == "like"- assert inspect(record.feedback, raiseerr=False) is None- assert record.retriever_resources == [{"position": 1, "content": "context"}]- assert record.metadata == {- "retriever_resources": [{"position": 1, "content": "context"}],- "usage": {"total_tokens": 5},- }- assert record.message_files == []- assert record.extra_contents == []- assert (record.message_tokens, record.answer_tokens, record.provider_response_latency) == (2, 3, 0.5)- assert (record.total_price, record.currency, record.status, record.error) == (- Decimal("0.0000001"),- "USD",- "normal",- None,- )- assert [thought.position for thought in record.agent_thoughts] == [1, 2]- thought = record.agent_thoughts[0]- assert inspect(thought, raiseerr=False) is None- assert (thought.id, thought.message_chain_id, thought.message_id) == (- earlier.id,- earlier.message_chain_id,- middle.id,- )- assert (thought.thought, thought.answer, thought.tool) == ("Thinking", "Partial answer", "search")- assert (thought.tool_labels, thought.tool_input, thought.observation) == (- {"search": {"en_US": "Search"}},- '{"query":"query"}',- "Found",- )- assert thought.files == ["file-id"]- assert thought.created_at == earlier.created_at---def test_empty_conversation_and_timestamp_ties_preserve_all_pages(- sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef-) -> None:- repository = SQLAlchemyInstalledAppMessageRepository(session_factory=sqlite_session_factory)- assert repository.get_page(- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id="", first_id=str(uuid4()), limit=20- ) == MessagePage(limit=20, has_more=False, data=())- with sqlite_session_factory.begin() as session:- conversation = _conversation(session, installation)- messages = [_message(session, conversation), _message(session, conversation)]- first = repository.get_page(- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id, first_id=None, limit=1- )- second = repository.get_page(- installed_app=installation,- account_id=_ACCOUNT_ID,- conversation_id=conversation.id,- first_id=first.data[0].id,- limit=1,- )- assert first.has_more is True- assert second.has_more is False- assert [item.id for item in (*first.data, *second.data)] == sorted(- (message.id for message in messages), reverse=True- )--[email protected]("mismatch", ["app_id", "from_account_id", "from_source", "from_end_user_id", "is_deleted"])-def test_listing_checks_each_conversation_ownership_predicate(- sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef, mismatch: str-) -> None:- with sqlite_session_factory.begin() as session:- conversation = _conversation(session, installation)- _message(session, conversation)- value: str | bool = True if mismatch == "is_deleted" else str(uuid4())- if mismatch == "from_source":- value = ConversationFromSource.API- session.execute(update(Conversation).where(Conversation.id == conversation.id).values({mismatch: value}))- with pytest.raises(ConversationNotExistsError):- SQLAlchemyInstalledAppMessageRepository(session_factory=sqlite_session_factory).get_page(- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id, first_id=None, limit=20- )---def test_cursor_must_belong_to_the_requested_conversation(- sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef-) -> None:- with sqlite_session_factory.begin() as session:- conversation = _conversation(session, installation)- other_message = _message(session, _conversation(session, installation))- repository = SQLAlchemyInstalledAppMessageRepository(session_factory=sqlite_session_factory)- for cursor in (other_message.id, str(uuid4())):- with pytest.raises(FirstMessageNotExistsError):- repository.get_page(- installed_app=installation,- account_id=_ACCOUNT_ID,- conversation_id=conversation.id,- first_id=cursor,- limit=20,- )--[email protected]("mismatch", ["id", "tenant_id", "app_id", "deleted_app", "deleted_installation"])-def test_read_revalidates_installation_after_admission(- sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef, mismatch: str-) -> None:- with sqlite_session_factory.begin() as session:- conversation = _conversation(session, installation)- _message(session, conversation)- if mismatch == "deleted_app":- app = session.get(App, installation.app_id)- assert app is not None- session.delete(app)- elif mismatch == "deleted_installation":- installed = session.get(InstalledApp, installation.id)- assert installed is not None- session.delete(installed)- ref = installation- if mismatch == "id":- ref = replace(ref, id=str(uuid4()))- elif mismatch == "tenant_id":- ref = replace(ref, tenant_id=str(uuid4()))- elif mismatch == "app_id":- ref = replace(ref, app_id=str(uuid4()))- repository = SQLAlchemyInstalledAppMessageRepository(session_factory=sqlite_session_factory)- with pytest.raises(InstalledAppNotFoundError):- repository.get_page(- installed_app=ref, account_id=_ACCOUNT_ID, conversation_id=conversation.id, first_id=None, limit=20- )diff --git a/api/tests/unit_tests/repositories/test_message_repository.py b/api/tests/unit_tests/repositories/test_message_repository.pynew file mode 100644index 00000000000..dbcfe64ce98--- /dev/null+++ b/api/tests/unit_tests/repositories/test_message_repository.py@@ -0,0 +1,999 @@+import json+import sys+from dataclasses import dataclass, replace+from datetime import datetime, timedelta+from decimal import Decimal+from uuid import uuid4++import pytest+from sqlalchemy import Connection, event, inspect, update+from sqlalchemy.orm import Session, sessionmaker++from extensions.storage.storage_type import StorageType+from graphon.file import FILE_MODEL_IDENTITY, FileTransferMethod, FileType+from models import Account, EndUser+from models.enums import ConversationFromSource, CreatorUserRole, EndUserType, FeedbackFromSource, FeedbackRating+from models.model import (+ App,+ AppAnnotationHitHistory,+ AppMode,+ Conversation,+ InstalledApp,+ Message,+ MessageAgentThought,+ MessageAnnotation,+ MessageFeedback,+ MessageFile,+ UploadFile,+)+from repositories.message_repository import MessageRepository+from services.app_definition_query_service import AppDefinitionUnavailableError+from services.entities.message_entities import (+ MessageAccount,+ MessageActor,+ MessageEndUser,+ MessagePage,+ MessageRecord,+ MessageSource,+)+from services.errors.conversation import ConversationNotExistsError+from services.errors.message import FirstMessageNotExistsError, MessageActorNotFoundError, MessageNotExistsError+from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppRef++_ACCOUNT_ID = "11111111-1111-4111-8111-111111111111"+_OWNER_TENANT_ID = "22222222-2222-4222-8222-222222222222"+_TIME = datetime(2026, 9, 8, 12, 30)+++def installation(sqlite_session_factory: sessionmaker[Session]) -> InstalledAppRef:+ with sqlite_session_factory.begin() as session:+ account = Account(name="Reviewer", email="[email protected]")+ account.id = _ACCOUNT_ID+ session.add(account)+ app = App(tenant_id=_OWNER_TENANT_ID, name="Shared chat", mode=AppMode.CHAT, enable_site=True, enable_api=True)+ session.add(app)+ session.flush()+ installation = InstalledApp(+ tenant_id=str(uuid4()), app_id=app.id, app_owner_tenant_id=app.tenant_id, position=0, is_pinned=False+ )+ session.add(installation)+ session.flush()+ return InstalledAppRef(+ id=installation.id,+ tenant_id=installation.tenant_id,+ app_id=app.id,+ app_owner_tenant_id=app.tenant_id,+ app_mode="chat",+ )+++def _conversation(session: Session, installation: InstalledAppRef) -> Conversation:+ conversation = Conversation(+ app_id=installation.app_id,+ mode=AppMode.CHAT,+ name="Chat",+ _inputs={},+ from_source=ConversationFromSource.CONSOLE,+ from_account_id=_ACCOUNT_ID,+ from_end_user_id=None,+ is_deleted=False,+ )+ session.add(conversation)+ session.flush()+ return conversation+++def _message(session: Session, conversation: Conversation, *, created_at: datetime = _TIME) -> Message:+ message = Message(+ app_id=conversation.app_id,+ conversation_id=conversation.id,+ _inputs={"empty": "", "list": [], "zero": 0, "false": False, "none": None},+ query="Question",+ message={},+ answer="Answer",+ message_tokens=2,+ message_unit_price=Decimal(0),+ answer_tokens=3,+ answer_unit_price=Decimal(0),+ provider_response_latency=0.5,+ total_price=Decimal("0.0000001"),+ currency="USD",+ from_source=conversation.from_source,+ from_account_id=conversation.from_account_id,+ from_end_user_id=conversation.from_end_user_id,+ )+ message.created_at = created_at+ session.add(message)+ session.flush()+ return message+++def _feedback(session: Session, message: Message, *, source: FeedbackFromSource) -> MessageFeedback:+ feedback = MessageFeedback(+ app_id=message.app_id,+ conversation_id=message.conversation_id,+ message_id=message.id,+ rating=FeedbackRating.LIKE,+ content="Original",+ from_source=source,+ from_account_id=str(uuid4()),+ )+ session.add(feedback)+ session.flush()+ return feedback+++def test_page_keeps_cursor_order_and_detaches_complete_message_data(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ old = _message(session, conversation, created_at=_TIME - timedelta(hours=1))+ middle = _message(session, conversation)+ newest = _message(session, conversation, created_at=_TIME + timedelta(hours=1))+ middle.parent_message_id = old.id+ middle.message_metadata = json.dumps(+ {"retriever_resources": [{"position": 1, "content": "context"}], "usage": {"total_tokens": 5}}+ )+ _feedback(session, middle, source=FeedbackFromSource.USER)+ admin = _feedback(session, middle, source=FeedbackFromSource.ADMIN)+ admin.rating = FeedbackRating.DISLIKE+ later = MessageAgentThought(+ message_id=middle.id, position=2, created_by_role=CreatorUserRole.ACCOUNT, created_by=_ACCOUNT_ID+ )+ earlier = MessageAgentThought(+ message_id=middle.id,+ message_chain_id=str(uuid4()),+ position=1,+ thought="Thinking",+ answer="Partial answer",+ tool="search",+ tool_labels_str='{"search":{"en_US":"Search"}}',+ tool_input='{"query":"query"}',+ observation="Found",+ message_files='["file-id"]',+ created_by_role=CreatorUserRole.ACCOUNT,+ created_by=_ACCOUNT_ID,+ )+ session.add_all([later, earlier])+ repository = MessageRepository(+ session_factory=sqlite_session_factory,+ )+ page = repository.get_message_page(+ installed_app=installation,+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ actor=MessageAccount(account_id=_ACCOUNT_ID),+ conversation_id=conversation.id,+ first_id=None,+ limit=2,+ )+ final = repository.get_message_page(+ installed_app=installation,+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ actor=MessageAccount(account_id=_ACCOUNT_ID),+ conversation_id=conversation.id,+ first_id=middle.id,+ limit=2,+ )++ assert [item.record.id for item in page.data] == [middle.id, newest.id]+ assert (page.limit, page.has_more) == (2, True)+ assert [item.record.id for item in final.data] == [old.id]+ assert final.has_more is False+ record = page.data[0].record+ assert inspect(record, raiseerr=False) is None+ assert (record.conversation_id, record.parent_message_id) == (conversation.id, old.id)+ assert record.inputs == {"empty": "", "list": [], "zero": 0, "false": False, "none": None}+ assert (record.query, record.answer, record.created_at) == ("Question", "Answer", _TIME)+ assert record.feedback is not None+ assert record.feedback.rating == "like"+ assert inspect(record.feedback, raiseerr=False) is None+ assert record.retriever_resources == [{"position": 1, "content": "context"}]+ assert record.metadata == {+ "retriever_resources": [{"position": 1, "content": "context"}],+ "usage": {"total_tokens": 5},+ }+ assert record.message_files == []+ assert record.extra_contents == []+ assert (record.message_tokens, record.answer_tokens, record.provider_response_latency) == (2, 3, 0.5)+ assert (record.total_price, record.currency, record.status, record.error) == (+ Decimal("0.0000001"),+ "USD",+ "normal",+ None,+ )+ assert [thought.position for thought in record.agent_thoughts] == [1, 2]+ thought = record.agent_thoughts[0]+ assert inspect(thought, raiseerr=False) is None+ assert (thought.id, thought.message_chain_id, thought.message_id) == (+ earlier.id,+ earlier.message_chain_id,+ middle.id,+ )+ assert (thought.thought, thought.answer, thought.tool) == ("Thinking", "Partial answer", "search")+ assert (thought.tool_labels, thought.tool_input, thought.observation) == (+ {"search": {"en_US": "Search"}},+ '{"query":"query"}',+ "Found",+ )+ assert thought.files == ["file-id"]+ assert thought.created_at == earlier.created_at+++def test_empty_conversation_returns_empty_page(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef+) -> None:+ repository = MessageRepository(+ session_factory=sqlite_session_factory,+ )+ assert repository.get_message_page(+ installed_app=installation,+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ actor=MessageAccount(account_id=_ACCOUNT_ID),+ conversation_id="",+ first_id=str(uuid4()),+ limit=20,+ ) == MessagePage(limit=20, has_more=False, data=())++[email protected]("with_installation", [True, False])+def test_timestamp_cursor_preserves_each_entrypoint_policy(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef, with_installation: bool+) -> None:+ repository = MessageRepository(session_factory=sqlite_session_factory)+ admitted_installation = installation if with_installation else None+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ older = _message(session, conversation, created_at=_TIME - timedelta(seconds=1))+ first = _message(session, conversation)+ second = _message(session, conversation)+ tied_ids = sorted([first.id, second.id])+ page = repository.get_message_page(+ installed_app=admitted_installation,+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ actor=MessageAccount(account_id=_ACCOUNT_ID),+ conversation_id=conversation.id,+ first_id=None,+ limit=1,+ )+ assert page.has_more is True+ assert len(page.data) == 1+ if with_installation:+ assert page.data[0].record.id == tied_ids[1]+ remaining = repository.get_message_page(+ installed_app=admitted_installation,+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ actor=MessageAccount(account_id=_ACCOUNT_ID),+ conversation_id=conversation.id,+ first_id=page.data[0].record.id,+ limit=2,+ )+ assert remaining.has_more is False+ expected_ids = [older.id, tied_ids[0]] if with_installation else [older.id]+ assert [source.record.id for source in remaining.data] == expected_ids++[email protected]("mismatch", ["app_id", "from_account_id", "from_source", "from_end_user_id", "is_deleted"])+def test_listing_checks_each_conversation_ownership_predicate(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef, mismatch: str+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ _message(session, conversation)+ value: str | bool = True if mismatch == "is_deleted" else str(uuid4())+ if mismatch == "from_source":+ value = ConversationFromSource.API+ session.execute(update(Conversation).where(Conversation.id == conversation.id).values({mismatch: value}))+ with pytest.raises(ConversationNotExistsError):+ MessageRepository(+ session_factory=sqlite_session_factory,+ ).get_message_page(+ installed_app=installation,+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ actor=MessageAccount(account_id=_ACCOUNT_ID),+ conversation_id=conversation.id,+ first_id=None,+ limit=20,+ )+++def test_cursor_must_belong_to_the_requested_conversation(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ other_message = _message(session, _conversation(session, installation))+ repository = MessageRepository(+ session_factory=sqlite_session_factory,+ )+ for cursor in (other_message.id, str(uuid4())):+ with pytest.raises(FirstMessageNotExistsError):+ repository.get_message_page(+ installed_app=installation,+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ actor=MessageAccount(account_id=_ACCOUNT_ID),+ conversation_id=conversation.id,+ first_id=cursor,+ limit=20,+ )+++ "mismatch",+ ["id", "tenant_id", "app_id", "app_owner_tenant_id", "installed_owner", "deleted_app", "deleted_installation"],+)+def test_read_revalidates_installation_after_admission(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef, mismatch: str+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ _message(session, conversation)+ if mismatch == "deleted_app":+ app = session.get(App, installation.app_id)+ assert app is not None+ session.delete(app)+ elif mismatch == "installed_owner":+ session.execute(+ update(InstalledApp).where(InstalledApp.id == installation.id).values(app_owner_tenant_id=str(uuid4()))+ )+ elif mismatch == "deleted_installation":+ installed = session.get(InstalledApp, installation.id)+ assert installed is not None+ session.delete(installed)+ ref = installation+ if mismatch == "id":+ ref = replace(ref, id=str(uuid4()))+ elif mismatch == "tenant_id":+ ref = replace(ref, tenant_id=str(uuid4()))+ elif mismatch == "app_id":+ ref = replace(ref, app_id=str(uuid4()))+ elif mismatch == "app_owner_tenant_id":+ ref = replace(ref, app_owner_tenant_id=str(uuid4()))+ repository = MessageRepository(+ session_factory=sqlite_session_factory,+ )+ with pytest.raises(InstalledAppNotFoundError):+ repository.get_message_page(+ installed_app=ref,+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ actor=MessageAccount(account_id=_ACCOUNT_ID),+ conversation_id=conversation.id,+ first_id=None,+ limit=20,+ )+++@dataclass+class _ActorHarness:+ repository: MessageRepository+ installation: InstalledAppRef+ actor: MessageActor+ conversation: Conversation+ factory: sessionmaker[Session]+ sessions: list[Session]++ def page(self, *, first_id: str | None = None, limit: int = 2) -> MessagePage[MessageSource[MessageRecord]]:+ return self.repository.get_message_page(+ app_id=self.installation.app_id,+ app_owner_tenant_id=self.installation.app_owner_tenant_id,+ actor=self.actor,+ conversation_id=self.conversation.id,+ first_id=first_id,+ limit=limit,+ installed_app=None,+ )++ def assert_closed(self) -> None:+ assert self.sessions+ assert all(not session.in_transaction() and not session.identity_map for session in self.sessions)++[email protected](params=["account", "end_user"])+def actor_harness(+ request: pytest.FixtureRequest, sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef+) -> _ActorHarness:+ actor: MessageActor = MessageAccount(account_id=_ACCOUNT_ID)+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ if request.param == "end_user":+ user = EndUser(+ tenant_id=installation.app_owner_tenant_id,+ app_id=installation.app_id,+ type=EndUserType.SERVICE_API,+ session_id=str(uuid4()),+ )+ session.add(user)+ session.flush()+ actor = MessageEndUser(end_user_id=user.id)+ conversation.from_source = ConversationFromSource.API+ conversation.from_account_id = None+ conversation.from_end_user_id = user.id+ sessions: list[Session] = []++ @event.listens_for(sqlite_session_factory, "after_begin")+ def record_session(session: Session, _transaction: object, _connection: object) -> None:+ sessions.append(session)++ return _ActorHarness(+ repository=MessageRepository(+ session_factory=sqlite_session_factory,+ ),+ installation=installation,+ actor=actor,+ conversation=conversation,+ factory=sqlite_session_factory,+ sessions=sessions,+ )+++def test_account_and_end_user_history_empty_pages_and_order(actor_harness: _ActorHarness) -> None:+ harness = actor_harness+ assert harness.page() == MessagePage(limit=2, has_more=False, data=())+ with harness.factory.begin() as session:+ older = _message(session, harness.conversation, created_at=_TIME - timedelta(hours=1))+ middle = _message(session, harness.conversation)+ newest = _message(session, harness.conversation, created_at=_TIME + timedelta(hours=1))+ decoy = _message(session, _conversation(session, harness.installation))+ page = harness.page()+ assert [message.record.id for message in page.data] == [middle.id, newest.id]+ assert page.has_more is True+ assert decoy.id not in {message.record.id for message in page.data}+ last = harness.page(first_id=middle.id)+ assert [message.record.id for message in last.data] == [older.id]+ assert last.has_more is False+ harness.assert_closed()++[email protected]("mismatch", ["app_id", "from_source", "from_account_id", "from_end_user_id", "is_deleted"])+def test_each_actor_conversation_scope_is_required(actor_harness: _ActorHarness, mismatch: str) -> None:+ harness = actor_harness+ with harness.factory.begin() as session:+ value: str | bool = True if mismatch == "is_deleted" else str(uuid4())+ if mismatch == "from_source":+ value = "console" if isinstance(harness.actor, MessageEndUser) else "api"+ session.execute(+ update(Conversation).where(Conversation.id == harness.conversation.id).values({mismatch: value})+ )+ with pytest.raises(ConversationNotExistsError):+ harness.page()+ harness.assert_closed()+++def test_deleted_actor_is_revalidated_against_current_database(actor_harness: _ActorHarness) -> None:+ harness = actor_harness+ with harness.factory.begin() as session:+ if isinstance(harness.actor, MessageAccount):+ account = session.get(Account, harness.actor.account_id)+ assert account is not None+ session.delete(account)+ else:+ user = session.get(EndUser, harness.actor.end_user_id)+ assert user is not None+ session.delete(user)+ with pytest.raises(MessageActorNotFoundError):+ harness.page()+ harness.assert_closed()+++def test_message_and_cursor_must_match_app_even_with_valid_conversation(actor_harness: _ActorHarness) -> None:+ harness = actor_harness+ with harness.factory.begin() as session:+ valid = _message(session, harness.conversation)+ decoy = _message(session, harness.conversation, created_at=_TIME + timedelta(hours=1))+ decoy.app_id = str(uuid4())+ page = harness.page(limit=1)+ assert [message.record.id for message in page.data] == [valid.id]+ assert page.has_more is False+ with pytest.raises(FirstMessageNotExistsError):+ harness.page(first_id=decoy.id)+ harness.assert_closed()++[email protected]("deleted", [False, True])+def test_app_owner_chain_is_revalidated_before_empty_actor_page(actor_harness: _ActorHarness, deleted: bool) -> None:+ harness = actor_harness+ with harness.factory.begin() as session:+ app = session.get(App, harness.installation.app_id)+ assert app is not None+ if deleted:+ session.delete(app)+ else:+ app.tenant_id = str(uuid4())+ with pytest.raises(AppDefinitionUnavailableError):+ harness.repository.get_message_page(+ app_id=harness.installation.app_id,+ app_owner_tenant_id=harness.installation.app_owner_tenant_id,+ actor=harness.actor,+ conversation_id="",+ first_id=None,+ limit=20,+ installed_app=None,+ )+ harness.assert_closed()++[email protected]("mode", [AppMode.CHAT, AppMode.AGENT])[email protected]("mismatch", ["from_account_id", "from_source", "from_end_user_id", "is_deleted"])+def test_console_uses_actual_app_mode_for_ownership(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef, mode: AppMode, mismatch: str+) -> None:+ with sqlite_session_factory.begin() as session:+ session.execute(update(App).where(App.id == installation.app_id).values(mode=mode))+ conversation = _conversation(session, installation)+ message = _message(session, conversation)+ value: str | bool = True if mismatch == "is_deleted" else str(uuid4())+ if mismatch == "from_source":+ value = "api"+ session.execute(update(Conversation).where(Conversation.id == conversation.id).values({mismatch: value}))+ repository = MessageRepository(+ session_factory=sqlite_session_factory,+ )+ if mode == AppMode.AGENT:+ with pytest.raises(ConversationNotExistsError):+ repository.get_console_message_page(+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ account_id=_ACCOUNT_ID,+ conversation_id=conversation.id,+ first_id=None,+ limit=1,+ )+ else:+ page = repository.get_console_message_page(+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ account_id=_ACCOUNT_ID,+ conversation_id=conversation.id,+ first_id=None,+ limit=1,+ )+ assert [item.record.id for item in page.data] == [message.id]+++def test_console_strict_timestamp_has_more_and_cursor_scope(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ older = _message(session, conversation, created_at=_TIME - timedelta(hours=1))+ first = _message(session, conversation)+ _message(session, conversation)+ decoy = _message(session, conversation, created_at=_TIME - timedelta(hours=2))+ decoy.app_id = str(uuid4())+ repository = MessageRepository(+ session_factory=sqlite_session_factory,+ )+ page = repository.get_console_message_page(+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ account_id=_ACCOUNT_ID,+ conversation_id=conversation.id,+ first_id=None,+ limit=1,+ )+ assert page.has_more is True+ final = repository.get_console_message_page(+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ account_id=_ACCOUNT_ID,+ conversation_id=conversation.id,+ first_id=first.id,+ limit=1,+ )+ assert [item.record.id for item in final.data] == [older.id]+ assert final.has_more is False+ with sqlite_session_factory.begin() as session:+ session.execute(update(Message).where(Message.id == older.id).values(created_at=_TIME))+ tied_page = repository.get_console_message_page(+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ account_id=_ACCOUNT_ID,+ conversation_id=conversation.id,+ first_id=None,+ limit=1,+ )+ assert tied_page.has_more is False+ with pytest.raises(FirstMessageNotExistsError):+ repository.get_console_message_page(+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ account_id=_ACCOUNT_ID,+ conversation_id=conversation.id,+ first_id=decoy.id,+ limit=1,+ )++[email protected]("detail", [False, True], ids=["page", "detail"])+def test_console_detaches_annotation_feedback_file_and_input_data(actor_harness: _ActorHarness, detail: bool) -> None:+ harness = actor_harness+ with harness.factory.begin() as session:+ message = _message(session, harness.conversation)+ message.message = {"messages": [{"role": "user", "text": "Question"}]}+ message.workflow_run_id = str(uuid4())+ upload = UploadFile(+ tenant_id=harness.installation.app_owner_tenant_id,+ storage_type=StorageType.LOCAL,+ key="upload/report.txt",+ name="report.txt",+ size=7,+ extension="txt",+ mime_type="text/plain",+ created_by_role=CreatorUserRole.ACCOUNT,+ created_by=_ACCOUNT_ID,+ created_at=_TIME,+ used=True,+ )+ session.add(upload)+ attachment = MessageFile(+ message_id=message.id,+ type=FileType.DOCUMENT,+ transfer_method=FileTransferMethod.LOCAL_FILE,+ upload_file_id=upload.id,+ created_by_role=CreatorUserRole.ACCOUNT,+ created_by=_ACCOUNT_ID,+ )+ session.add(attachment)+ message.inputs = {+ "file": {+ "dify_model_identity": FILE_MODEL_IDENTITY,+ "transfer_method": "remote_url",+ "type": "document",+ "url": "https://example.com/report.txt",+ "filename": "report.txt",+ "extension": ".txt",+ "mime_type": "text/plain",+ "size": 7,+ }+ }+ message.answer = f"[report](/files/{upload.id}/file-preview?timestamp=1&nonce=old&sign=old)"+ feedback = _feedback(session, message, source=FeedbackFromSource.ADMIN)+ feedback.from_account_id = _ACCOUNT_ID+ annotation = MessageAnnotation(+ app_id=message.app_id,+ conversation_id=message.conversation_id,+ message_id=message.id,+ question="Question",+ content="Annotated answer",+ account_id=_ACCOUNT_ID,+ )+ session.add(annotation)+ session.flush()+ session.add(+ AppAnnotationHitHistory(+ app_id=message.app_id,+ annotation_id=annotation.id,+ message_id=message.id,+ source="api",+ question="Question",+ account_id=_ACCOUNT_ID,+ score=1.0,+ annotation_question="Question",+ annotation_content="Annotated answer",+ )+ )+ if detail:+ source = harness.repository.get_console_message(+ app_id=harness.installation.app_id,+ app_owner_tenant_id=harness.installation.app_owner_tenant_id,+ account_id=_ACCOUNT_ID,+ message_id=message.id,+ )+ else:+ page = harness.repository.get_console_message_page(+ app_id=harness.installation.app_id,+ app_owner_tenant_id=harness.installation.app_owner_tenant_id,+ account_id=_ACCOUNT_ID,+ conversation_id=harness.conversation.id,+ first_id=None,+ limit=20,+ )+ source = page.data[0]+ record = source.record+ harness.assert_closed()+ assert inspect(record, raiseerr=False) is None+ assert record.message == {"messages": [{"role": "user", "text": "Question"}]}+ assert record.workflow_run_id == message.workflow_run_id+ assert record.from_source == harness.conversation.from_source+ assert record.from_account_id == harness.conversation.from_account_id+ assert record.from_end_user_id == harness.conversation.from_end_user_id+ assert record.annotation is not None+ assert record.annotation.id == annotation.id+ assert record.annotation.content == "Annotated answer"+ assert record.annotation.account is not None+ assert (record.annotation.account.id, record.annotation.account.name, record.annotation.account.email) == (+ _ACCOUNT_ID,+ "Reviewer",+ "[email protected]",+ )+ assert record.annotation_hit_history is not None+ assert record.annotation_hit_history.id == annotation.id+ assert record.annotation_hit_history.annotation_create_account == record.annotation.account+ assert record.annotation_hit_history.created_at == annotation.created_at+ assert record.feedbacks[0].from_account == record.annotation.account+ assert (record.feedbacks[0].rating, record.feedbacks[0].content, record.feedbacks[0].from_source) == (+ "like",+ "Original",+ "admin",+ )+ assert record.message_files == []+ file = source.files[0]+ assert inspect(file, raiseerr=False) is None+ assert (file.id, file.type, file.transfer_method, file.upload_file_id, file.url, file.belongs_to) == (+ attachment.id,+ "document",+ "local_file",+ upload.id,+ None,+ None,+ )+ assert record.answer == message.answer+ assert "sign=old" in record.answer+ assert record.inputs == message._inputs+ assert isinstance(record.inputs["file"], dict)+ assert record.extra_contents == []++[email protected]("actor_harness", ["end_user"], indirect=True)[email protected]("mismatch", ["app_id", "tenant_id"])+def test_end_user_must_belong_to_app_and_tenant(actor_harness: _ActorHarness, mismatch: str) -> None:+ harness = actor_harness+ assert isinstance(harness.actor, MessageEndUser)+ with harness.factory.begin() as session:+ session.execute(update(EndUser).where(EndUser.id == harness.actor.end_user_id).values({mismatch: str(uuid4())}))+ with pytest.raises(MessageActorNotFoundError):+ harness.page()+ harness.assert_closed()+++ "mismatch", ["app_tenant", "deleted_app", "deleted_account", "conversation_app", "missing_conversation"]+)+def test_console_revalidates_entire_owner_chain(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef, mismatch: str+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ _message(session, conversation)+ if mismatch == "app_tenant":+ session.execute(update(App).where(App.id == installation.app_id).values(tenant_id=str(uuid4())))+ elif mismatch == "deleted_app":+ app = session.get(App, installation.app_id)+ assert app is not None+ session.delete(app)+ elif mismatch == "deleted_account":+ account = session.get(Account, _ACCOUNT_ID)+ assert account is not None+ session.delete(account)+ elif mismatch == "conversation_app":+ conversation.app_id = str(uuid4())+ expected_error = (+ AppDefinitionUnavailableError+ if mismatch in {"app_tenant", "deleted_app"}+ else MessageActorNotFoundError+ if mismatch == "deleted_account"+ else ConversationNotExistsError+ )+ with pytest.raises(expected_error):+ MessageRepository(+ session_factory=sqlite_session_factory,+ ).get_console_message_page(+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ account_id=_ACCOUNT_ID,+ conversation_id=str(uuid4()) if mismatch == "missing_conversation" else conversation.id,+ first_id=None,+ limit=20,+ )++[email protected]("mode", [AppMode.CHAT, AppMode.AGENT])+def test_console_empty_conversation_and_cursor_from_other_conversation(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef, mode: AppMode+) -> None:+ with sqlite_session_factory.begin() as session:+ session.execute(update(App).where(App.id == installation.app_id).values(mode=mode))+ conversation = _conversation(session, installation)+ other = _message(session, _conversation(session, installation))+ repository = MessageRepository(+ session_factory=sqlite_session_factory,+ )+ assert repository.get_console_message_page(+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ account_id=_ACCOUNT_ID,+ conversation_id=conversation.id,+ first_id=None,+ limit=2,+ ) == MessagePage(limit=2, has_more=False, data=())+ with pytest.raises(FirstMessageNotExistsError):+ repository.get_console_message_page(+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ account_id=_ACCOUNT_ID,+ conversation_id=conversation.id,+ first_id=other.id,+ limit=2,+ )++[email protected]("mode", list(AppMode))+def test_console_detail_preserves_app_wide_access_for_every_mode(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef, mode: AppMode+) -> None:+ with sqlite_session_factory.begin() as session:+ session.execute(update(App).where(App.id == installation.app_id).values(mode=mode))+ other_account = Account(name="Other author", email="[email protected]")+ session.add(other_account)+ session.flush()+ conversation = _conversation(session, installation)+ conversation.from_account_id = other_account.id+ conversation.is_deleted = True+ message = _message(session, conversation)+ repository = MessageRepository(+ session_factory=sqlite_session_factory,+ )+ source = repository.get_console_message(+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ account_id=_ACCOUNT_ID,+ message_id=message.id,+ )+ record = source.record+ assert record.id == message.id+ assert record.conversation_id == conversation.id+ assert record.from_account_id == other_account.id+ assert inspect(record, raiseerr=False) is None++[email protected]("mismatch", ["app_tenant", "deleted_app", "deleted_account", "message_app", "missing_message"])+def test_console_detail_rechecks_app_tenant_actor_and_message_ownership(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef, mismatch: str+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ message = _message(session, conversation)+ foreign_app = App(+ tenant_id=str(uuid4()), name="Foreign app", mode=AppMode.CHAT, enable_site=True, enable_api=True+ )+ session.add(foreign_app)+ session.flush()+ if mismatch == "app_tenant":+ session.execute(update(App).where(App.id == installation.app_id).values(tenant_id=foreign_app.tenant_id))+ elif mismatch == "deleted_app":+ app = session.get(App, installation.app_id)+ assert app is not None+ session.delete(app)+ elif mismatch == "deleted_account":+ account = session.get(Account, _ACCOUNT_ID)+ assert account is not None+ session.delete(account)+ elif mismatch == "message_app":+ message.app_id = foreign_app.id+ expected_error = (+ AppDefinitionUnavailableError+ if mismatch in {"app_tenant", "deleted_app"}+ else MessageActorNotFoundError+ if mismatch == "deleted_account"+ else MessageNotExistsError+ )+ with pytest.raises(expected_error):+ MessageRepository(+ session_factory=sqlite_session_factory,+ ).get_console_message(+ app_id=installation.app_id,+ app_owner_tenant_id=installation.app_owner_tenant_id,+ account_id=_ACCOUNT_ID,+ message_id=str(uuid4()) if mismatch == "missing_message" else message.id,+ )+++def test_all_message_reads_are_select_only_raw_snapshots_without_network(actor_harness: _ActorHarness) -> None:+ harness = actor_harness+ raw_inputs = {+ "file": {+ "dify_model_identity": FILE_MODEL_IDENTITY,+ "transfer_method": "remote_url",+ "type": "document",+ "url": "https://example.com/report.txt",+ },+ "nested": {"values": [1, None, False]},+ }+ with harness.factory.begin() as session:+ message = _message(session, harness.conversation)+ message.inputs = raw_inputs+ message.answer = "[tool](/files/tools/legacy.txt?timestamp=1&nonce=old&sign=old)"+ remote = MessageFile(+ message_id=message.id,+ type=FileType.DOCUMENT,+ transfer_method=FileTransferMethod.REMOTE_URL,+ url="https://example.com/report.txt",+ created_by_role=CreatorUserRole.ACCOUNT,+ created_by=_ACCOUNT_ID,+ )+ legacy_tool = MessageFile(+ message_id=message.id,+ type=FileType.DOCUMENT,+ transfer_method=FileTransferMethod.TOOL_FILE,+ url="https://example.com/legacy.txt",+ created_by_role=CreatorUserRole.ACCOUNT,+ created_by=_ACCOUNT_ID,+ )+ session.add_all([remote, legacy_tool])+ statements: list[str] = []+ commits: list[Session] = []+ network_guard_active = True++ def reject_network(event_name: str, _arguments: tuple[object, ...]) -> None:+ # Observe the real Python I/O boundary without replacing domain methods.+ # Audit hooks cannot be removed, so this guard is active only for these reads.+ if network_guard_active and event_name.startswith("socket."):+ raise AssertionError(f"Message database snapshot attempted network I/O: {event_name}")++ def record_sql(+ _connection: Connection,+ _cursor: object,+ statement: str,+ _parameters: object,+ _context: object,+ _executemany: bool,+ ) -> None:+ statements.append(statement)++ def record_commit(session: Session) -> None:+ commits.append(session)++ engine = harness.factory.kw["bind"]+ sys.addaudithook(reject_network)+ event.listen(engine, "before_cursor_execute", record_sql)+ event.listen(harness.factory, "before_commit", record_commit)+ try:+ actor_source = harness.page().data[0]+ console_source = harness.repository.get_console_message_page(+ app_id=harness.installation.app_id,+ app_owner_tenant_id=harness.installation.app_owner_tenant_id,+ account_id=_ACCOUNT_ID,+ conversation_id=harness.conversation.id,+ first_id=None,+ limit=20,+ ).data[0]+ detail_source = harness.repository.get_console_message(+ app_id=harness.installation.app_id,+ app_owner_tenant_id=harness.installation.app_owner_tenant_id,+ account_id=_ACCOUNT_ID,+ message_id=message.id,+ )+ finally:+ network_guard_active = False+ event.remove(engine, "before_cursor_execute", record_sql)+ event.remove(harness.factory, "before_commit", record_commit)+ assert statements+ assert all(statement.lstrip().upper().startswith("SELECT") for statement in statements)+ assert commits == []+ harness.assert_closed()+ for source in (actor_source, console_source, detail_source):+ assert source.record.id == message.id+ assert source.record.inputs == raw_inputs+ assert source.record.answer == message.answer+ assert source.record.message_files == []+ assert source.record.extra_contents == []+ refs = {file.id: file for file in source.files}+ assert refs.keys() == {remote.id, legacy_tool.id}+ assert refs[remote.id].url == "https://example.com/report.txt"+ assert refs[remote.id].transfer_method == "remote_url"+ assert refs[legacy_tool.id].upload_file_id is None+ assert refs[legacy_tool.id].url == "https://example.com/legacy.txt"+ assert refs[legacy_tool.id].transfer_method == "tool_file"+ with harness.factory() as session:+ persisted = session.get(MessageFile, legacy_tool.id)+ assert persisted is not None+ assert persisted.upload_file_id is Nonediff --git a/api/tests/unit_tests/services/test_installed_app_message_adapters.py b/api/tests/unit_tests/services/test_installed_app_message_adapters.pydeleted file mode 100644index 25b2e191b87..00000000000--- a/api/tests/unit_tests/services/test_installed_app_message_adapters.py+++ /dev/null@@ -1,74 +0,0 @@-"""Installed message extra contents and committed feedback telemetry."""--from datetime import datetime, timedelta-from uuid import uuid4--from sqlalchemy import Connection, Engine, event-from sqlalchemy.orm import Session, SessionTransaction, sessionmaker--from core.workflow.nodes.human_input.entities import FormDefinition, UserActionConfig-from models.execution_extra_content import HumanInputContent-from models.human_input import HumanInputForm-from services.installed_app_message_adapters import InstalledAppMessageRuntime---def test_extra_contents_use_real_repository_preserve_message_order_and_omit_none(- sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]-) -> None:- read_factory = sessionmaker(bind=sqlite_engine)- read_sessions: list[Session] = []-- @event.listens_for(read_factory, "after_begin")- def track_read(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:- read_sessions.append(session)-- runtime = InstalledAppMessageRuntime(session_factory=read_factory)- assert runtime.get_extra_contents(message_ids=[]) == {}- assert read_sessions == []- tenant_id, app_id, first_message_id = str(uuid4()), str(uuid4()), str(uuid4())- second_message_id = str(uuid4())- absent_message_id = str(uuid4())- expiration = datetime(2026, 9, 10)- with sqlite_session_factory.begin() as session:- for index, (message_id, title) in enumerate([(second_message_id, "Second"), (first_message_id, "First")]):- definition = FormDefinition(- form_content="Approve?",- inputs=[],- user_actions=[UserActionConfig(id="approve", title="Approve")],- rendered_content="Approve?",- expiration_time=expiration,- node_title=title,- display_in_ui=True,- )- form = HumanInputForm(- tenant_id=tenant_id,- app_id=app_id,- workflow_run_id=str(uuid4()),- node_id=f"node-{index}",- form_definition=definition.model_dump_json(),- rendered_content="Approve?",- expiration_time=expiration,- )- session.add(form)- session.flush()- content = HumanInputContent.new(- workflow_run_id=form.workflow_run_id or "", form_id=form.id, message_id=message_id- )- content.created_at = expiration - timedelta(days=index)- session.add(content)- contents = runtime.get_extra_contents(message_ids=[first_message_id, absent_message_id, second_message_id])- assert list(contents) == [first_message_id, absent_message_id, second_message_id]- assert contents[absent_message_id] == []- for message_id, title in [(first_message_id, "First"), (second_message_id, "Second")]:- assert len(contents[message_id]) == 1- content = contents[message_id][0]- assert content["type"] == "human_input"- assert content["submitted"] is False- assert "form_submission_data" not in content- definition = content["form_definition"]- assert isinstance(definition, dict)- assert definition["node_title"] == title- assert "form_token" not in definition- assert len(read_sessions) == 1- assert not read_sessions[0].in_transaction()- assert not read_sessions[0].identity_mapdiff --git a/api/tests/unit_tests/services/test_installed_app_message_service.py b/api/tests/unit_tests/services/test_installed_app_message_service.pydeleted file mode 100644index 7dd09c0099b..00000000000--- a/api/tests/unit_tests/services/test_installed_app_message_service.py+++ /dev/null@@ -1,124 +0,0 @@-from collections.abc import Mapping, Sequence-from dataclasses import dataclass, field, replace-from datetime import datetime-from decimal import Decimal--import pytest-from pydantic import JsonValue--from services.installed_app_access_service import InstalledAppRef-from services.installed_app_message_service import (- InstalledAppMessageService,- MessageNotChatAppError,- MessagePage,- MessageRecord,-)--_REF = InstalledAppRef(- id="installed", app_id="app", tenant_id="viewer-workspace", app_owner_tenant_id="owner-workspace", app_mode="chat"-)---def _message(message_id: str) -> MessageRecord:- return MessageRecord(- id=message_id,- conversation_id="conversation",- parent_message_id=None,- inputs={"empty": "", "zero": 0, "none": None, "list": []},- query="Question",- answer="Answer",- feedback=None,- retriever_resources=[],- created_at=datetime(2026, 9, 8),- agent_thoughts=[],- message_files=[],- message_tokens=2,- answer_tokens=3,- provider_response_latency=0,- total_price=Decimal(0),- currency="USD",- status="normal",- error=None,- metadata={"usage": {"total_tokens": 5}},- )---@dataclass-class _Store:- page: MessagePage = field(- default_factory=lambda: MessagePage(limit=2, has_more=True, data=(_message("first"), _message("second")))- )- events: list[str] = field(default_factory=list)-- def get_page(- self,- *,- installed_app: InstalledAppRef,- account_id: str,- conversation_id: str,- first_id: str | None,- limit: int,- ) -> MessagePage:- assert (installed_app, account_id, conversation_id, first_id, limit) == (- _REF,- "account",- "conversation",- None,- 2,- )- self.events.append("read closed")- return self.page---@dataclass-class _Callbacks:- store: _Store- queried_ids: list[tuple[str, ...]] = field(default_factory=list)-- def get_extra_contents(self, *, message_ids: Sequence[str]) -> Mapping[str, list[dict[str, JsonValue]]]:- assert self.store.events == ["read closed"]- self.store.events.append("extra contents")- self.queried_ids.append(tuple(message_ids))- return {"first": [{"type": "workflow", "workflow_run_id": "run"}], "not-in-page": [{"type": "ignored"}]}-- def service(self) -> InstalledAppMessageService:- return InstalledAppMessageService(- messages=self.store,- get_extra_contents=self.get_extra_contents,- )---def test_list_batches_extra_contents_after_read_and_preserves_detached_page() -> None:- state = _Callbacks(store=_Store())- page = state.service().get_page(- installed_app=_REF, account_id="account", conversation_id="conversation", first_id=None, limit=2- )-- assert state.queried_ids == [("first", "second")]- assert (page.limit, page.has_more) == (2, True)- assert [item.id for item in page.data] == ["first", "second"]- assert page.data[0].extra_contents == [{"type": "workflow", "workflow_run_id": "run"}]- assert page.data[1].extra_contents == []- assert replace(page.data[0], extra_contents=[]) == state.store.page.data[0]- assert state.store.page.data[0].extra_contents == []---def test_empty_page_skips_extra_content_query() -> None:- state = _Callbacks(store=_Store(page=MessagePage(limit=2, has_more=False, data=())))- page = state.service().get_page(- installed_app=_REF, account_id="account", conversation_id="conversation", first_id=None, limit=2- )- assert page.data == ()- assert state.store.events == ["read closed"]- assert state.queried_ids == []--[email protected]("mode", ["completion", "workflow"])-def test_non_chat_admission_rejects_reads_before_database(mode: str) -> None:- state = _Callbacks(store=_Store())- ref = replace(_REF, app_mode=mode)- with pytest.raises(MessageNotChatAppError):- state.service().get_page(- installed_app=ref, account_id="account", conversation_id="conversation", first_id=None, limit=2- )- assert state.store.events == []diff --git a/api/tests/unit_tests/services/test_message_query_adapters.py b/api/tests/unit_tests/services/test_message_query_adapters.pynew file mode 100644index 00000000000..af559297407--- /dev/null+++ b/api/tests/unit_tests/services/test_message_query_adapters.py@@ -0,0 +1,343 @@+"""Exercise detached file restoration against real SQLAlchemy and HTTP transports."""++from collections.abc import Callable+from dataclasses import dataclass, replace+from datetime import datetime+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer+from threading import Thread+from typing import override+from urllib.parse import parse_qs, urlsplit+from uuid import uuid4++import pytest+from pydantic import JsonValue+from sqlalchemy import Connection, event, select+from sqlalchemy.orm import Session, SessionTransaction, sessionmaker++from core.app.entities.app_invoke_entities import InvokeFrom, UserFrom+from core.app.file_access import FileAccessScope, bind_file_access_scope+from core.helper import http_client_pooling+from core.tools.signature import verify_tool_file_signature+from core.workflow.file_reference import build_file_reference, resolve_file_record_id+from extensions.storage.storage_type import StorageType+from graphon.file import FILE_MODEL_IDENTITY, File, FileTransferMethod, FileType+from models import AppModelConfig, MessageFile, ToolFile, UploadFile+from models.enums import CreatorUserRole, MessageFileBelongsTo+from repositories.sqlalchemy_execution_extra_content_repository import SQLAlchemyExecutionExtraContentRepository+from services.entities.message_entities import MessageFileReference, MessageInputValue+from services.message_query_adapters import ExecutionExtraContentReader, MessageFileResolver+from tests.e2e_tests.containers.helpers.execution_extra_content import create_human_input_message_fixture++[email protected](autouse=True)+def file_configuration(config_overrides: Callable[..., None]) -> None:+ config_overrides(+ FILES_URL="https://files.example.test",+ SECRET_KEY="message-file-test-key",+ SSRF_PROXY_HTTP_URL="",+ SSRF_PROXY_HTTPS_URL="",+ SSRF_PROXY_ALL_URL="",+ )+++@dataclass(frozen=True)+class _StoredFiles:+ tenant_id: str+ user_id: str+ upload_id: str+ tool_id: str+ legacy: MessageFileReference+++def stored_files(sqlite_session_factory: sessionmaker[Session]) -> _StoredFiles:+ tenant_id, user_id = str(uuid4()), str(uuid4())+ with sqlite_session_factory.begin() as session:+ upload = UploadFile(+ tenant_id=tenant_id,+ storage_type=StorageType.LOCAL,+ key="uploads/canonical.txt",+ name="canonical.txt",+ size=17,+ extension="txt",+ mime_type="text/plain",+ created_by_role=CreatorUserRole.END_USER,+ created_by=user_id,+ created_at=datetime(2026, 10, 9),+ used=True,+ )+ tool = ToolFile(+ user_id=user_id,+ tenant_id=tenant_id,+ conversation_id=None,+ file_key="tools/result.pdf",+ mimetype="application/pdf",+ name="result.pdf",+ size=23,+ )+ session.add_all([upload, tool])+ session.flush()+ legacy = MessageFile(+ message_id=str(uuid4()),+ type=FileType.DOCUMENT,+ transfer_method=FileTransferMethod.TOOL_FILE,+ url=f"https://old.example/files/tools/{tool.id}.pdf",+ upload_file_id=None,+ belongs_to=MessageFileBelongsTo.ASSISTANT,+ created_by_role=CreatorUserRole.END_USER,+ created_by=user_id,+ )+ session.add(legacy)+ session.flush()+ return _StoredFiles(tenant_id, user_id, upload.id, tool.id, _reference(legacy))+++def _reference(row: MessageFile) -> MessageFileReference:+ return MessageFileReference(+ id=row.id,+ type=row.type.value,+ transfer_method=row.transfer_method.value,+ url=row.url,+ upload_file_id=row.upload_file_id,+ belongs_to=row.belongs_to.value if row.belongs_to else None,+ )+++def _upload_reference(upload_id: str) -> MessageFileReference:+ return MessageFileReference(+ id=str(uuid4()),+ type="document",+ transfer_method="local_file",+ url=None,+ upload_file_id=upload_id,+ belongs_to="user",+ )+++def _input_mapping(record_id: str, transfer_method: str = "local_file") -> dict[str, JsonValue]:+ return {+ "dify_model_identity": FILE_MODEL_IDENTITY,+ "transfer_method": transfer_method,+ "reference": build_file_reference(record_id=record_id),+ "type": "document",+ "filename": "stale.json",+ "mime_type": "application/json",+ "size": 999,+ }+++def test_remote_head_runs_after_query_and_file_sessions_close(+ sqlite_session_factory: sessionmaker[Session], stored_files: _StoredFiles, monkeypatch: pytest.MonkeyPatch+) -> None:+ sessions: list[Session] = []+ commits: list[Session] = []+ requests: list[tuple[str, str, bool]] = []++ def observe(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:+ sessions.append(session)++ def committed(session: Session) -> None:+ commits.append(session)++ class Handler(BaseHTTPRequestHandler):+ @override+ def log_message(self, format: str, *args: object) -> None:+ pass++ def do_HEAD(self) -> None:+ requests.append((self.command, self.path, any(session.in_transaction() for session in sessions)))+ self.send_response(200)+ self.send_header("Content-Type", "application/octet-stream")+ self.send_header("Content-Length", "29")+ self.send_header("Content-Disposition", "attachment; filename*=UTF-8''server%20report.txt")+ self.end_headers()++ http_pool = http_client_pooling.HttpClientPoolFactory()+ monkeypatch.setattr(http_client_pooling, "_factory", http_pool)+ server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)+ thread = Thread(target=server.serve_forever, daemon=True)+ thread.start()+ event.listen(sqlite_session_factory, "after_begin", observe)+ event.listen(sqlite_session_factory, "after_commit", committed)+ try:+ with sqlite_session_factory() as session:+ row = session.scalar(select(MessageFile).where(MessageFile.id == stored_files.legacy.id))+ assert row is not None+ source = _reference(row)+ remote = replace(+ source,+ id=str(uuid4()),+ transfer_method="remote_url",+ url=f"http://127.0.0.1:{server.server_port}/download.bin",+ belongs_to="user",+ )+ result = MessageFileResolver().resolve(+ tenant_id=stored_files.tenant_id,+ inputs={"upload": _input_mapping(stored_files.upload_id)},+ answer="Answer",+ files=[source, remote],+ )+ assert requests == [("HEAD", "/download.bin", False)]+ assert not commits+ assert sessions+ assert all(not session.in_transaction() and not session.identity_map for session in sessions)+ assert result.files[1].filename == "server report.txt"+ assert result.files[1].mime_type == "text/plain"+ assert result.files[1].size == 29+ finally:+ event.remove(sqlite_session_factory, "after_begin", observe)+ event.remove(sqlite_session_factory, "after_commit", committed)+ server.shutdown()+ server.server_close()+ thread.join()+ http_pool.close_all()+++def test_canonical_files_and_legacy_tool_fallback_do_not_write(+ sqlite_session_factory: sessionmaker[Session], stored_files: _StoredFiles+) -> None:+ inputs: dict[str, MessageInputValue] = {+ "upload": _input_mapping(stored_files.upload_id),+ "tools": [_input_mapping(stored_files.tool_id, "tool_file")],+ "empty": [],+ "mixed": [_input_mapping(stored_files.upload_id), "leave unchanged"],+ "zero": 0,+ "false": False,+ "none": None,+ }+ with sqlite_session_factory() as pending:+ config = AppModelConfig(app_id=str(uuid4()), opening_statement="Unrelated pending write")+ pending.add(config)+ result = MessageFileResolver().resolve(+ tenant_id=stored_files.tenant_id,+ inputs=inputs,+ answer="Answer",+ files=[_upload_reference(stored_files.upload_id), stored_files.legacy],+ )+ assert config in pending.new+ assert [file.belongs_to for file in result.files] == ["user", "assistant"]+ assert [file.filename for file in result.files] == ["canonical.txt", "result.pdf"]+ assert [file.size for file in result.files] == [17, 23]+ assert result.files[1].upload_file_id == stored_files.tool_id+ assert stored_files.legacy.upload_file_id is None+ upload = result.inputs["upload"]+ assert isinstance(upload, File)+ assert (upload.filename, upload.mime_type, upload.size) == ("canonical.txt", "text/plain", 17)+ assert resolve_file_record_id(upload.reference) == stored_files.upload_id+ tools = result.inputs["tools"]+ assert isinstance(tools, list)+ assert isinstance(tools[0], File)+ assert tools[0].filename == "result.pdf"+ assert result.inputs["empty"] == []+ assert result.inputs["mixed"] == inputs["mixed"]+ assert result.inputs["zero"] == 0+ assert result.inputs["false"] is False+ assert result.inputs["none"] is None+ assert isinstance(inputs["upload"], dict)+ assert inputs["upload"]["filename"] == "stale.json"+ with sqlite_session_factory() as session:+ row = session.get(MessageFile, stored_files.legacy.id)+ assert row is not None+ assert row.upload_file_id is None+ assert session.scalar(select(AppModelConfig.id).where(AppModelConfig.id == config.id)) is None+++def test_input_external_urls_and_embedded_legacy_tenant_are_preserved(stored_files: _StoredFiles) -> None:+ mapping = _input_mapping(stored_files.upload_id)+ mapping["tenant_id"] = stored_files.tenant_id+ remote: dict[str, JsonValue] = {+ "dify_model_identity": FILE_MODEL_IDENTITY,+ "type": "document",+ "transfer_method": "remote_url",+ "url": "http://127.0.0.1:1/never-probed.txt",+ "filename": "stored.txt",+ "extension": ".txt",+ "mime_type": "text/plain",+ "size": 31,+ }+ result = MessageFileResolver().resolve(+ tenant_id=str(uuid4()), inputs={"local": mapping, "remote": remote}, answer="", files=[]+ )+ local = result.inputs["local"]+ assert isinstance(local, File)+ assert local.filename == "canonical.txt"+ external = result.inputs["remote"]+ assert isinstance(external, File)+ assert (external.remote_url, external.filename, external.size) == (remote["url"], "stored.txt", 31)++[email protected]("kind", ["upload", "tool"])+def test_file_restoration_keeps_tenant_and_end_user_filters(stored_files: _StoredFiles, kind: str) -> None:+ source = _upload_reference(stored_files.upload_id) if kind == "upload" else stored_files.legacy+ resolver = MessageFileResolver()+ with pytest.raises(ValueError, match="Invalid upload file|ToolFile .* not found"):+ resolver.resolve(tenant_id=str(uuid4()), inputs={}, answer="", files=[source])+ denied_scope = FileAccessScope(+ tenant_id=stored_files.tenant_id,+ user_id=str(uuid4()),+ user_from=UserFrom.END_USER,+ invoke_from=InvokeFrom.WEB_APP,+ )+ with bind_file_access_scope(denied_scope):+ with pytest.raises(ValueError, match="Invalid upload file|ToolFile .* not found"):+ resolver.resolve(tenant_id=stored_files.tenant_id, inputs={}, answer="", files=[source])+ with bind_file_access_scope(replace(denied_scope, user_id=stored_files.user_id)):+ result = resolver.resolve(tenant_id=stored_files.tenant_id, inputs={}, answer="", files=[source])+ assert len(result.files) == 1+++ ("transfer_method", "upload_file_id", "url", "error", "message"),+ [+ ("local_file", None, None, ValueError, "is a local file but has no upload_file_id"),+ ("local_file", "malformed", None, ValueError, "Invalid upload file id format"),+ ("local_file", "10000000-0000-4000-8000-000000000001", None, ValueError, "Invalid upload file"),+ ("remote_url", None, None, ValueError, "is a remote url but has no url"),+ ("tool_file", None, None, AssertionError, "^$"),+ ("tool_file", "missing", None, ValueError, "ToolFile missing not found"),+ ("datasource_file", None, None, ValueError, "has an invalid transfer_method datasource_file"),+ ],+)+def test_missing_and_invalid_file_references_keep_existing_errors(+ transfer_method: str, upload_file_id: str | None, url: str | None, error: type[Exception], message: str+) -> None:+ source = MessageFileReference(str(uuid4()), "document", transfer_method, url, upload_file_id, None)+ with pytest.raises(error, match=message):+ MessageFileResolver().resolve(tenant_id=str(uuid4()), inputs={}, answer="", files=[source])++[email protected]("shape", ["{}", "`{}`", "[download]({})"])[email protected]("kind", ["tool", "file-preview", "image-preview"])+def test_answer_signing_preserves_legacy_url_shapes(shape: str, kind: str) -> None:+ file_id = str(uuid4())+ path = f"/files/tools/{file_id}.pdf" if kind == "tool" else f"/files/{file_id}/{kind}"+ original = f"http://internal.example{path}?timestamp=1&nonce=old&sign=old&as_attachment=true"+ result = MessageFileResolver().resolve(tenant_id=str(uuid4()), inputs={}, answer=shape.format(original), files=[])+ signed = result.answer.removeprefix("[download](").removesuffix(")").strip("`")+ parsed = urlsplit(signed)+ query = parse_qs(parsed.query)+ assert parsed.netloc == "files.example.test"+ assert query["as_attachment"] == ["true"]+ assert query["nonce"] != ["old"]+ assert query["timestamp"] != ["1"]+ assert verify_tool_file_signature(file_id, query["timestamp"][0], query["nonce"][0], query["sign"][0])+ assert parsed.path == (f"/files/tools/{file_id}.pdf" if kind == "tool" else f"/files/{file_id}/file-preview")+++def test_extra_content_reader_serializes_real_database_content(sqlite_session_factory: sessionmaker[Session]) -> None:+ with sqlite_session_factory.begin() as session:+ fixture = create_human_input_message_fixture(session)+ reader = ExecutionExtraContentReader(+ repository=SQLAlchemyExecutionExtraContentRepository(session_maker=sqlite_session_factory)+ )+ result = reader.get_by_message_ids(["missing", fixture.message.id])+ assert result[0] == []+ assert result[1][0]["type"] == "human_input"+ assert result[1][0]["workflow_run_id"] == fixture.message.workflow_run_id+ assert result[1][0]["submitted"] is True+ definition = result[1][0]["form_definition"]+ assert isinstance(definition, dict)+ assert "form_token" not in definition+ submission = result[1][0]["form_submission_data"]+ assert isinstance(submission, dict)+ assert submission["submitted_data"] == {"name": "Alice"}diff --git a/api/tests/unit_tests/services/test_message_query_service.py b/api/tests/unit_tests/services/test_message_query_service.pynew file mode 100644index 00000000000..c8c368ec46d--- /dev/null+++ b/api/tests/unit_tests/services/test_message_query_service.py@@ -0,0 +1,185 @@+from datetime import timedelta+from decimal import Decimal+from typing import Literal++import pytest+from pydantic import JsonValue+from sqlalchemy import delete, event+from sqlalchemy.engine import Connection+from sqlalchemy.orm import Session, SessionTransaction, sessionmaker++from models.enums import ConversationFromSource+from models.execution_extra_content import HumanInputContent+from models.human_input import HumanInputFormStatus+from models.model import Message+from repositories.message_repository import MessageRepository+from repositories.sqlalchemy_execution_extra_content_repository import SQLAlchemyExecutionExtraContentRepository+from services.entities.message_entities import MessageAccount+from services.message_query_adapters import ExecutionExtraContentReader, MessageFileResolver+from services.message_query_service import MessageQueryService+from tests.e2e_tests.containers.helpers.execution_extra_content import create_human_input_message_fixture++[email protected]("query_kind", ["actor", "console", "detail"])[email protected]("submitted", [False, True], ids=["waiting", "submitted"])+def test_extra_contents_are_loaded_after_message_session_closes(+ sqlite_session_factory: sessionmaker[Session],+ query_kind: Literal["actor", "console", "detail"],+ submitted: bool,+) -> None:+ with sqlite_session_factory() as session:+ fixture = create_human_input_message_fixture(session)+ if not submitted:+ fixture.form.status = HumanInputFormStatus.WAITING+ fixture.form.selected_action_id = None+ fixture.form.submitted_at = None+ fixture.form.submitted_data = None+ app_id, tenant_id = fixture.app.id, fixture.app.tenant_id+ account_id, conversation_id = fixture.account.id, fixture.conversation.id+ message_id, form_id = fixture.message.id, fixture.form.id+ workflow_run_id = fixture.message.workflow_run_id+ expiration_time = int(fixture.form.expiration_time.timestamp())+ later = Message(+ app_id=app_id,+ conversation_id=conversation_id,+ _inputs={},+ query="Later question",+ message={},+ answer="Later answer",+ message_unit_price=Decimal(0),+ answer_unit_price=Decimal(0),+ currency="USD",+ from_source=ConversationFromSource.CONSOLE,+ from_account_id=account_id,+ )+ later.created_at = fixture.message.created_at + timedelta(seconds=1)+ session.add(later)+ session.commit()+ later_id = later.id++ page_sessions: list[Session] = []+ content_sessions: list[Session] = []+ contents_factory = sessionmaker(bind=sqlite_session_factory.kw["bind"], expire_on_commit=False)++ def record_page_session(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:+ page_sessions.append(session)++ def check_page_closed(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:+ assert page_sessions+ assert all(not previous.in_transaction() and not previous.identity_map for previous in page_sessions)+ content_sessions.append(session)++ event.listen(sqlite_session_factory, "after_begin", record_page_session)+ event.listen(contents_factory, "after_begin", check_page_closed)+ service = MessageQueryService(+ messages=MessageRepository(session_factory=sqlite_session_factory),+ files=MessageFileResolver(),+ extra_contents=ExecutionExtraContentReader(+ repository=SQLAlchemyExecutionExtraContentRepository(session_maker=contents_factory)+ ),+ )+ try:+ if query_kind == "detail":+ records = (+ service.get_console_message(+ app_id=app_id,+ app_owner_tenant_id=tenant_id,+ account_id=account_id,+ message_id=message_id,+ ),+ )+ elif query_kind == "console":+ page = service.get_console_page(+ app_id=app_id,+ app_owner_tenant_id=tenant_id,+ account_id=account_id,+ conversation_id=conversation_id,+ first_id=None,+ limit=10,+ )+ records = page.data+ else:+ page = service.get_page(+ app_id=app_id,+ app_owner_tenant_id=tenant_id,+ actor=MessageAccount(account_id=account_id),+ conversation_id=conversation_id,+ first_id=None,+ limit=10,+ )+ records = page.data+ finally:+ event.remove(sqlite_session_factory, "after_begin", record_page_session)+ event.remove(contents_factory, "after_begin", check_page_closed)++ assert content_sessions+ assert all(not session.in_transaction() and not session.identity_map for session in content_sessions)+ expected_ids = [message_id] if query_kind == "detail" else [message_id, later_id]+ assert [message.id for message in records] == expected_ids+ expected_content: dict[str, JsonValue] = {+ "workflow_run_id": workflow_run_id,+ "type": "human_input",+ "submitted": submitted,+ "form_definition": {+ "form_id": form_id,+ "node_id": "node-id",+ "node_title": "Approval",+ "form_content": "Rendered block",+ "inputs": [],+ "actions": [{"id": "approve", "title": "Approve request", "button_style": "default"}],+ "display_in_ui": True,+ "resolved_default_values": {},+ "expiration_time": expiration_time,+ },+ }+ if submitted:+ expected_content["form_submission_data"] = {+ "node_id": "node-id",+ "node_title": "Approval",+ "rendered_content": "Rendered block",+ "action_id": "approve",+ "action_text": "Approve request",+ "submitted_data": {"name": "Alice"},+ }+ assert records[0].extra_contents == [expected_content]+ if query_kind != "detail":+ assert [message.extra_contents for message in records[1:]] == [[]]+++def test_empty_page_does_not_open_extra_content_session(sqlite_session_factory: sessionmaker[Session]) -> None:+ with sqlite_session_factory() as session:+ fixture = create_human_input_message_fixture(session)+ app_id, tenant_id = fixture.app.id, fixture.app.tenant_id+ account_id, conversation_id = fixture.account.id, fixture.conversation.id+ session.execute(delete(HumanInputContent).where(HumanInputContent.message_id == fixture.message.id))+ session.execute(delete(Message).where(Message.id == fixture.message.id))+ session.commit()++ content_sessions: list[Session] = []+ contents_factory = sessionmaker(bind=sqlite_session_factory.kw["bind"], expire_on_commit=False)++ def record_content_session(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:+ content_sessions.append(session)++ event.listen(contents_factory, "after_begin", record_content_session)+ try:+ page = MessageQueryService(+ messages=MessageRepository(session_factory=sqlite_session_factory),+ files=MessageFileResolver(),+ extra_contents=ExecutionExtraContentReader(+ repository=SQLAlchemyExecutionExtraContentRepository(session_maker=contents_factory)+ ),+ ).get_page(+ app_id=app_id,+ app_owner_tenant_id=tenant_id,+ actor=MessageAccount(account_id=account_id),+ conversation_id=conversation_id,+ first_id=None,+ limit=10,+ )+ finally:+ event.remove(contents_factory, "after_begin", record_content_session)++ assert page.data == ()+ assert page.has_more is False+ assert content_sessions == []diff --git a/api/tests/unit_tests/services/test_message_service.py b/api/tests/unit_tests/services/test_message_service.pydeleted file mode 100644index 6e24a21d128..00000000000--- a/api/tests/unit_tests/services/test_message_service.py+++ /dev/null@@ -1,530 +0,0 @@-from collections.abc import Iterator-from dataclasses import dataclass-from datetime import datetime-from decimal import Decimal-from unittest.mock import MagicMock--import pytest-from sqlalchemy.engine import Engine-from sqlalchemy.orm import Session, scoped_session--import models.model as model_module-import services.message_service as service_module-from models.account import Account, AccountStatus-from models.enums import (- ConversationFromSource,- EndUserType,-)-from models.model import (- App,- AppMode,- Conversation,- EndUser,- Message,-)-from repositories.sqlalchemy_execution_extra_content_repository import SQLAlchemyExecutionExtraContentRepository-from services.errors.message import (- FirstMessageNotExistsError,- LastMessageNotExistsError,- MessageNotExistsError,-)-from services.message_service import MessageService, attach_message_extra_contents---@dataclass(eq=False, repr=False)-class _DatabaseBinding:- """Expose the SQLite engine and shared session through the production DB interface."""-- engine: Engine- session: scoped_session[Session]---class MessageServiceTestDataFactory:- """Create real service inputs and persistent message-domain rows."""-- @staticmethod- def create_app(- app_id: str = "app-123",- mode: AppMode = AppMode.ADVANCED_CHAT,- tenant_id: str = "tenant-123",- ) -> App:- return App(- id=app_id,- tenant_id=tenant_id,- name="Test App",- description="",- mode=mode,- enable_site=True,- enable_api=True,- max_active_requests=0,- )-- @staticmethod- def create_end_user(user_id: str = "user-456") -> EndUser:- return EndUser(- id=user_id,- tenant_id="tenant-123",- app_id="app-123",- type=EndUserType.SERVICE_API,- session_id="session-789",- )-- @staticmethod- def create_account(user_id: str = "account-123") -> Account:- account = Account(name="Admin", email="[email protected]", status=AccountStatus.ACTIVE)- account.id = user_id- return account-- @staticmethod- def create_conversation(- conversation_id: str = "conv-001",- app_id: str = "app-123",- *,- app_model_config_id: str | None = None,- override_model_configs: str | None = None,- ) -> Conversation:- conversation = Conversation(- id=conversation_id,- app_id=app_id,- app_model_config_id=app_model_config_id,- override_model_configs=override_model_configs,- mode=AppMode.CHAT,- name="Test conversation",- status="normal",- from_source=ConversationFromSource.API,- from_end_user_id="user-456",- )- conversation._inputs = {}- return conversation-- @staticmethod- def create_message(- message_id: str = "msg-001",- conversation_id: str = "conv-001",- app_id: str = "app-123",- *,- created_at: datetime | None = None,- from_source: ConversationFromSource = ConversationFromSource.API,- from_end_user_id: str | None = "user-456",- from_account_id: str | None = None,- ) -> Message:- message = Message(- id=message_id,- app_id=app_id,- conversation_id=conversation_id,- query="What is AI?",- message={"role": "user", "content": "What is AI?"},- answer="AI stands for Artificial Intelligence.",- message_unit_price=Decimal("0.0001"),- answer_unit_price=Decimal("0.0002"),- currency="USD",- from_source=from_source,- from_end_user_id=from_end_user_id,- from_account_id=from_account_id,- )- message._inputs = {}- timestamp = created_at or datetime.now()- message.created_at = timestamp- message.updated_at = timestamp- return message---def factory() -> MessageServiceTestDataFactory:- return MessageServiceTestDataFactory()--[email protected](autouse=True)-def database_boundaries(- monkeypatch: pytest.MonkeyPatch,- sqlite_engine: Engine,- sqlite_session: Session,-) -> Iterator[None]:- """Bind global model properties and service-owned factories to the shared SQLite session."""- sessions = scoped_session(lambda: sqlite_session)- database = _DatabaseBinding(engine=sqlite_engine, session=sessions)- monkeypatch.setattr(service_module, "db", database)- monkeypatch.setattr(model_module, "db", database)- try:- yield- finally:- sessions.remove()---def empty_extra_content_repository(monkeypatch: pytest.MonkeyPatch) -> MagicMock:- repository = MagicMock()- repository.get_by_message_ids.side_effect = lambda message_ids: [[] for _ in message_ids]- monkeypatch.setattr(service_module, "_create_execution_extra_content_repository", lambda: repository)- return repository---def _persist(session: Session, *records: object) -> None:- session.add_all(records)- session.commit()---def _patch_conversation(monkeypatch: pytest.MonkeyPatch, conversation: Conversation) -> MagicMock:- get_conversation = MagicMock(return_value=conversation)- monkeypatch.setattr(service_module.ConversationService, "get_conversation", get_conversation)- return get_conversation---class TestMessageServicePaginationByFirstId:- """Verify cursor pagination using persisted message timestamps and IDs."""-- @pytest.mark.parametrize(("user", "conversation_id"), [(None, "conv-001"), ("end_user", "")])- def test_early_return(- self,- user: str | None,- conversation_id: str,- factory: MessageServiceTestDataFactory,- sqlite_session: Session,- ) -> None:- result = MessageService.pagination_by_first_id(- app_model=factory.create_app(),- user=factory.create_end_user() if user else None,- conversation_id=conversation_id,- first_id=None,- limit=10,- session=sqlite_session,- )-- assert result.data == []- assert result.limit == 10- assert result.has_more is False-- @pytest.mark.parametrize(- ("order", "expected_ids"),- [- ("desc", ["msg-004", "msg-003", "msg-002", "msg-001", "msg-000"]),- ("asc", ["msg-000", "msg-001", "msg-002", "msg-003", "msg-004"]),- ],- )- def test_orders_persisted_messages(- self,- order: str,- expected_ids: list[str],- monkeypatch: pytest.MonkeyPatch,- factory: MessageServiceTestDataFactory,- sqlite_session: Session,- empty_extra_content_repository: MagicMock,- ) -> None:- conversation = factory.create_conversation()- messages = [- factory.create_message(f"msg-{index:03d}", created_at=datetime(2024, 1, 1, 12, index)) for index in range(5)- ]- _persist(sqlite_session, conversation, *messages)- _patch_conversation(monkeypatch, conversation)-- result = MessageService.pagination_by_first_id(- app_model=factory.create_app(),- user=factory.create_end_user(),- conversation_id=conversation.id,- first_id=None,- limit=10,- order=order,- session=sqlite_session,- )-- assert [message.id for message in result.data] == expected_ids- assert result.has_more is False-- def test_first_id_excludes_cursor_and_newer_messages(- self,- monkeypatch: pytest.MonkeyPatch,- factory: MessageServiceTestDataFactory,- sqlite_session: Session,- empty_extra_content_repository: MagicMock,- ) -> None:- conversation = factory.create_conversation()- messages = [- factory.create_message(f"msg-{index:03d}", created_at=datetime(2024, 1, 1, 12, index)) for index in range(7)- ]- _persist(sqlite_session, conversation, *messages)- _patch_conversation(monkeypatch, conversation)-- result = MessageService.pagination_by_first_id(- app_model=factory.create_app(),- user=factory.create_end_user(),- conversation_id=conversation.id,- first_id="msg-005",- limit=10,- order="desc",- session=sqlite_session,- )-- assert [message.id for message in result.data] == [f"msg-{index:03d}" for index in range(4, -1, -1)]-- def test_missing_first_id_raises(- self,- monkeypatch: pytest.MonkeyPatch,- factory: MessageServiceTestDataFactory,- sqlite_session: Session,- ) -> None:- conversation = factory.create_conversation()- _persist(sqlite_session, conversation)- _patch_conversation(monkeypatch, conversation)-- with pytest.raises(FirstMessageNotExistsError):- MessageService.pagination_by_first_id(- app_model=factory.create_app(),- user=factory.create_end_user(),- conversation_id=conversation.id,- first_id="missing",- limit=10,- session=sqlite_session,- )-- def test_has_more_trims_oldest_extra_row(- self,- monkeypatch: pytest.MonkeyPatch,- factory: MessageServiceTestDataFactory,- sqlite_session: Session,- empty_extra_content_repository: MagicMock,- ) -> None:- conversation = factory.create_conversation()- messages = [- factory.create_message(f"msg-{index:03d}", created_at=datetime(2024, 1, 1, 12, index))- for index in range(11)- ]- _persist(sqlite_session, conversation, *messages)- _patch_conversation(monkeypatch, conversation)-- result = MessageService.pagination_by_first_id(- app_model=factory.create_app(),- user=factory.create_end_user(),- conversation_id=conversation.id,- first_id=None,- limit=10,- order="desc",- session=sqlite_session,- )-- assert len(result.data) == 10- assert result.has_more is True- assert result.data[-1].id == "msg-001"-- def test_empty_conversation(- self,- monkeypatch: pytest.MonkeyPatch,- factory: MessageServiceTestDataFactory,- sqlite_session: Session,- empty_extra_content_repository: MagicMock,- ) -> None:- conversation = factory.create_conversation()- _persist(sqlite_session, conversation)- _patch_conversation(monkeypatch, conversation)-- result = MessageService.pagination_by_first_id(- app_model=factory.create_app(),- user=factory.create_end_user(),- conversation_id=conversation.id,- first_id=None,- limit=10,- session=sqlite_session,- )-- assert result.data == []- assert result.has_more is False---class TestMessageServicePaginationByLastId:- """Verify reverse cursor, conversation, and include-ID filtering."""-- def test_no_user(self, factory: MessageServiceTestDataFactory, sqlite_session: Session) -> None:- result = MessageService.pagination_by_last_id(- app_model=factory.create_app(), user=None, last_id=None, limit=10, session=sqlite_session- )- assert result.data == []- assert result.limit == 10- assert result.has_more is False-- def test_without_last_id(self, factory: MessageServiceTestDataFactory, sqlite_session: Session) -> None:- messages = [- factory.create_message(f"msg-{index:03d}", created_at=datetime(2024, 1, 1, 12, index)) for index in range(5)- ]- _persist(sqlite_session, *messages)-- result = MessageService.pagination_by_last_id(- app_model=factory.create_app(),- user=factory.create_end_user(),- last_id=None,- limit=10,- session=sqlite_session,- )-- assert [message.id for message in result.data] == [f"msg-{index:03d}" for index in range(4, -1, -1)]- assert result.has_more is False-- def test_last_id_returns_older_rows(self, factory: MessageServiceTestDataFactory, sqlite_session: Session) -> None:- messages = [- factory.create_message(f"msg-{index:03d}", created_at=datetime(2024, 1, 1, 12, index)) for index in range(7)- ]- _persist(sqlite_session, *messages)-- result = MessageService.pagination_by_last_id(- app_model=factory.create_app(),- user=factory.create_end_user(),- last_id="msg-005",- limit=10,- session=sqlite_session,- )-- assert [message.id for message in result.data] == [f"msg-{index:03d}" for index in range(4, -1, -1)]-- def test_missing_last_id_raises(self, factory: MessageServiceTestDataFactory, sqlite_session: Session) -> None:- with pytest.raises(LastMessageNotExistsError):- MessageService.pagination_by_last_id(- app_model=factory.create_app(),- user=factory.create_end_user(),- last_id="missing",- limit=10,- session=sqlite_session,- )-- def test_conversation_filter(- self,- monkeypatch: pytest.MonkeyPatch,- factory: MessageServiceTestDataFactory,- sqlite_session: Session,- ) -> None:- conversation = factory.create_conversation()- other_conversation = factory.create_conversation("conv-002")- matching = factory.create_message("matching", conversation_id=conversation.id)- excluded = factory.create_message("excluded", conversation_id=other_conversation.id)- _persist(sqlite_session, conversation, other_conversation, matching, excluded)- get_conversation = _patch_conversation(monkeypatch, conversation)-- result = MessageService.pagination_by_last_id(- app_model=factory.create_app(),- user=factory.create_end_user(),- last_id=None,- limit=10,- conversation_id=conversation.id,- session=sqlite_session,- )-- assert [message.id for message in result.data] == [matching.id]- get_conversation.assert_called_once()-- def test_include_ids_filter(self, factory: MessageServiceTestDataFactory, sqlite_session: Session) -> None:- messages = [- factory.create_message(f"msg-{index:03d}", created_at=datetime(2024, 1, 1, 12, index)) for index in range(4)- ]- _persist(sqlite_session, *messages)-- result = MessageService.pagination_by_last_id(- app_model=factory.create_app(),- user=factory.create_end_user(),- last_id=None,- limit=10,- include_ids=["msg-001", "msg-003"],- session=sqlite_session,- )-- assert [message.id for message in result.data] == ["msg-003", "msg-001"]-- def test_has_more(self, factory: MessageServiceTestDataFactory, sqlite_session: Session) -> None:- messages = [- factory.create_message(f"msg-{index:03d}", created_at=datetime(2024, 1, 1, 12, index))- for index in range(11)- ]- _persist(sqlite_session, *messages)-- result = MessageService.pagination_by_last_id(- app_model=factory.create_app(),- user=factory.create_end_user(),- last_id=None,- limit=10,- session=sqlite_session,- )-- assert len(result.data) == 10- assert result.has_more is True---class TestMessageServiceUtilities:- def test_attach_message_extra_contents_empty(self) -> None:- attach_message_extra_contents([])-- def test_attach_message_extra_contents(- self,- monkeypatch: pytest.MonkeyPatch,- factory: MessageServiceTestDataFactory,- ) -> None:- messages = [factory.create_message("msg-1"), factory.create_message("msg-2")]- content_one = MagicMock()- content_one.model_dump.return_value = {"key": "value1"}- content_two = MagicMock()- content_two.model_dump.return_value = {"key": "value2"}- repository = MagicMock()- repository.get_by_message_ids.return_value = [[content_one], [content_two]]- monkeypatch.setattr(service_module, "_create_execution_extra_content_repository", lambda: repository)-- attach_message_extra_contents(messages)-- assert messages[0].extra_contents == [{"key": "value1"}]- assert messages[1].extra_contents == [{"key": "value2"}]-- def test_attach_message_extra_contents_missing_list(- self,- monkeypatch: pytest.MonkeyPatch,- factory: MessageServiceTestDataFactory,- ) -> None:- message = factory.create_message("msg-1")- repository = MagicMock()- repository.get_by_message_ids.return_value = []- monkeypatch.setattr(service_module, "_create_execution_extra_content_repository", lambda: repository)-- attach_message_extra_contents([message])-- assert message.extra_contents == []-- def test_create_execution_extra_content_repository_uses_sqlite_factory(self, sqlite_engine: Engine) -> None:- repository = service_module._create_execution_extra_content_repository()-- assert isinstance(repository, SQLAlchemyExecutionExtraContentRepository)- assert repository._session_maker.kw["bind"] is sqlite_engine- with repository._session_maker() as session:- assert isinstance(session, Session)---class TestMessageServiceGetMessage:- @pytest.mark.parametrize("actor", ["end_user", "account"])- def test_identity_scoped_success(- self,- actor: str,- factory: MessageServiceTestDataFactory,- sqlite_session: Session,- ) -> None:- if actor == "end_user":- user: Account | EndUser = factory.create_end_user("end-user-123")- message = factory.create_message(- "msg-123", from_end_user_id=user.id, from_account_id=None, from_source=ConversationFromSource.API- )- else:- user = factory.create_account("account-123")- message = factory.create_message(- "msg-123",- from_end_user_id=None,- from_account_id=user.id,- from_source=ConversationFromSource.CONSOLE,- )- distractor = factory.create_message("wrong-app", app_id="app-456")- _persist(sqlite_session, message, distractor)-- result = MessageService.get_message(- app_model=factory.create_app(), user=user, message_id=message.id, session=sqlite_session- )-- assert result.id == message.id-- def test_not_found(self, factory: MessageServiceTestDataFactory, sqlite_session: Session) -> None:- with pytest.raises(MessageNotExistsError):- MessageService.get_message(- app_model=factory.create_app(),- user=factory.create_end_user(),- message_id="missing",- session=sqlite_session,- )diff --git a/packages/contracts/generated/api/console/agent/errors.gen.ts b/packages/contracts/generated/api/console/agent/errors.gen.tsindex e4ab8194790..18e7b0e548e 100644--- a/packages/contracts/generated/api/console/agent/errors.gen.ts+++ b/packages/contracts/generated/api/console/agent/errors.gen.ts@@ -454,7 +454,10 @@ export const get5Errors = {export const post7Errors = { agent_not_found_error: { status: 404, data: zAgentNotFoundError } }-export const get6Errors = { agent_not_found_error: { status: 404, data: zAgentNotFoundError } }+export const get6Errors = {+ agent_not_found_error: { status: 404, data: zAgentNotFoundError },+ app_unavailable: { status: 400, data: zAppUnavailableError },+}export const get7Errors = {agent_version_not_found_error: { status: 404, data: zAgentVersionNotFoundError },@@ -534,7 +537,10 @@ export const get20Errors = { agent_not_found_error: { status: 404, data: zAgentNexport const get21Errors = { agent_not_found_error: { status: 404, data: zAgentNotFoundError } }-export const get22Errors = { agent_not_found_error: { status: 404, data: zAgentNotFoundError } }+export const get22Errors = {+ agent_not_found_error: { status: 404, data: zAgentNotFoundError },+ app_unavailable: { status: 400, data: zAppUnavailableError },+}export const post15Errors = {agent_model_not_configured: { status: 400, data: zAgentModelNotConfiguredError },diff --git a/packages/contracts/generated/api/console/agent/orpc.gen.ts b/packages/contracts/generated/api/console/agent/orpc.gen.tsindex 3c0eb62c2e6..d245b13d65d 100644--- a/packages/contracts/generated/api/console/agent/orpc.gen.ts+++ b/packages/contracts/generated/api/console/agent/orpc.gen.ts@@ -588,7 +588,10 @@ export const get6 = oc}),).output(zGetAgentByAgentIdChatMessagesResponse)- .errors({ agent_not_found_error: { status: 404, data: zAgentNotFoundError } })+ .errors({+ agent_not_found_error: { status: 404, data: zAgentNotFoundError },+ app_unavailable: { status: 400, data: zAppUnavailableError },+ })export const chatMessages = {get: get6,@@ -1155,7 +1158,10 @@ export const get22 = oc}).input(z.object({ params: zGetAgentByAgentIdMessagesByMessageIdPath })).output(zGetAgentByAgentIdMessagesByMessageIdResponse)- .errors({ agent_not_found_error: { status: 404, data: zAgentNotFoundError } })+ .errors({+ agent_not_found_error: { status: 404, data: zAgentNotFoundError },+ app_unavailable: { status: 400, data: zAppUnavailableError },+ })export const byMessageId2 = {get: get22,diff --git a/packages/contracts/generated/api/console/agent/types.gen.ts b/packages/contracts/generated/api/console/agent/types.gen.tsindex 17dc43a42ec..65c04fce683 100644--- a/packages/contracts/generated/api/console/agent/types.gen.ts+++ b/packages/contracts/generated/api/console/agent/types.gen.ts@@ -3141,6 +3141,7 @@ export type GetAgentByAgentIdChatMessagesData = {}export type GetAgentByAgentIdChatMessagesErrors = {+ 400: AppUnavailableError | ErrorResponse404: AgentNotFoundError | ErrorResponsedefault: ErrorResponse}@@ -3921,6 +3922,7 @@ export type GetAgentByAgentIdMessagesByMessageIdData = {}export type GetAgentByAgentIdMessagesByMessageIdErrors = {+ 400: AppUnavailableError | ErrorResponse404: AgentNotFoundError | ErrorResponsedefault: ErrorResponse}diff --git a/packages/contracts/generated/api/console/apps/errors.gen.ts b/packages/contracts/generated/api/console/apps/errors.gen.tsindex ff8103364bb..7ec41ba810b 100644--- a/packages/contracts/generated/api/console/apps/errors.gen.ts+++ b/packages/contracts/generated/api/console/apps/errors.gen.ts@@ -643,7 +643,10 @@ export const get26Errors = {export const post18Errors = { app_not_found: { status: 404, data: zAppNotFoundError } }-export const get27Errors = { app_not_found: { status: 404, data: zAppNotFoundError } }+export const get27Errors = {+ app_not_found: { status: 404, data: zAppNotFoundError },+ app_unavailable: { status: 400, data: zAppUnavailableError },+}export const delete6Errors = { app_not_found: { status: 404, data: zAppNotFoundError } }@@ -676,7 +679,10 @@ export const post23Errors = {message_feedback_rating_required: { status: 400, data: zMessageFeedbackRatingRequiredError },}-export const get32Errors = { app_not_found: { status: 404, data: zAppNotFoundError } }+export const get32Errors = {+ app_not_found: { status: 404, data: zAppNotFoundError },+ app_unavailable: { status: 400, data: zAppUnavailableError },+}export const post25Errors = { app_not_found: { status: 404, data: zAppNotFoundError } }diff --git a/packages/contracts/generated/api/console/apps/orpc.gen.ts b/packages/contracts/generated/api/console/apps/orpc.gen.tsindex 756b0a92fac..882509943dc 100644--- a/packages/contracts/generated/api/console/apps/orpc.gen.ts+++ b/packages/contracts/generated/api/console/apps/orpc.gen.ts@@ -1826,7 +1826,10 @@ export const get27 = ocz.object({ params: zGetAppsByAppIdChatMessagesPath, query: zGetAppsByAppIdChatMessagesQuery }),).output(zGetAppsByAppIdChatMessagesResponse)- .errors({ app_not_found: { status: 404, data: zAppNotFoundError } })+ .errors({+ app_not_found: { status: 404, data: zAppNotFoundError },+ app_unavailable: { status: 400, data: zAppUnavailableError },+ })export const chatMessages = {get: get27,@@ -2112,7 +2115,10 @@ export const get32 = oc}).input(z.object({ params: zGetAppsByAppIdMessagesByMessageIdPath })).output(zGetAppsByAppIdMessagesByMessageIdResponse)- .errors({ app_not_found: { status: 404, data: zAppNotFoundError } })+ .errors({+ app_not_found: { status: 404, data: zAppNotFoundError },+ app_unavailable: { status: 400, data: zAppUnavailableError },+ })export const byMessageId2 = {get: get32,diff --git a/packages/contracts/generated/api/console/apps/types.gen.ts b/packages/contracts/generated/api/console/apps/types.gen.tsindex b436c94748e..6ed343f61f7 100644--- a/packages/contracts/generated/api/console/apps/types.gen.ts+++ b/packages/contracts/generated/api/console/apps/types.gen.ts@@ -6140,6 +6140,7 @@ export type GetAppsByAppIdChatMessagesData = {}export type GetAppsByAppIdChatMessagesErrors = {+ 400: AppUnavailableError | ErrorResponse404: AppNotFoundError | ErrorResponsedefault: ErrorResponse}@@ -6522,6 +6523,7 @@ export type GetAppsByAppIdMessagesByMessageIdData = {}export type GetAppsByAppIdMessagesByMessageIdErrors = {+ 400: AppUnavailableError | ErrorResponse404: AppNotFoundError | ErrorResponsedefault: ErrorResponse}diff --git a/packages/contracts/generated/api/console/installed-apps/errors.gen.ts b/packages/contracts/generated/api/console/installed-apps/errors.gen.tsindex 15ef763a0f3..2c2defe2c16 100644--- a/packages/contracts/generated/api/console/installed-apps/errors.gen.ts+++ b/packages/contracts/generated/api/console/installed-apps/errors.gen.ts@@ -394,6 +394,7 @@ export const get3Errors = {export const get4Errors = {access_denied: { status: 403, data: zAccessDeniedError },+ app_unavailable: { status: 400, data: zAppUnavailableError },conversation_not_found: { status: 404, data: zConversationNotFoundError },installed_app_not_found: { status: 404, data: zInstalledAppNotFoundError },message_cursor_not_found: { status: 404, data: zMessageCursorNotFoundError },diff --git a/packages/contracts/generated/api/console/installed-apps/orpc.gen.ts b/packages/contracts/generated/api/console/installed-apps/orpc.gen.tsindex 394fb30b7fe..2e88a856205 100644--- a/packages/contracts/generated/api/console/installed-apps/orpc.gen.ts+++ b/packages/contracts/generated/api/console/installed-apps/orpc.gen.ts@@ -498,6 +498,7 @@ export const get4 = oc.output(zGetInstalledAppsByInstalledAppIdMessagesResponse).errors({access_denied: { status: 403, data: zAccessDeniedError },+ app_unavailable: { status: 400, data: zAppUnavailableError },conversation_not_found: { status: 404, data: zConversationNotFoundError },installed_app_not_found: { status: 404, data: zInstalledAppNotFoundError },message_cursor_not_found: { status: 404, data: zMessageCursorNotFoundError },diff --git a/packages/contracts/generated/api/console/installed-apps/types.gen.ts b/packages/contracts/generated/api/console/installed-apps/types.gen.tsindex b799a754a63..245b8794c91 100644--- a/packages/contracts/generated/api/console/installed-apps/types.gen.ts+++ b/packages/contracts/generated/api/console/installed-apps/types.gen.ts@@ -1383,7 +1383,7 @@ export type GetInstalledAppsByInstalledAppIdMessagesData = {}export type GetInstalledAppsByInstalledAppIdMessagesErrors = {- 400: NotChatAppError | ErrorResponse+ 400: AppUnavailableError | NotChatAppError | ErrorResponse403: AccessDeniedError | ErrorResponse404:| ConversationNotFoundErrordiff --git a/packages/contracts/generated/api/service/errors.gen.ts b/packages/contracts/generated/api/service/errors.gen.tsindex e60f394d895..de006536671 100644--- a/packages/contracts/generated/api/service/errors.gen.ts+++ b/packages/contracts/generated/api/service/errors.gen.ts@@ -1287,7 +1287,15 @@ export const get61Errors = {workspace_not_found: { status: 403, data: zWorkspaceNotFoundError },}-export const get62Errors = { not_chat_app: { status: 400, data: zNotChatAppError } }+export const get62Errors = {+ app_abnormal_status: { status: 403, data: zAppAbnormalStatusError },+ app_api_disabled: { status: 403, data: zAppApiDisabledError },+ app_not_found: { status: 403, data: zAppNotFoundError },+ app_unavailable: { status: 400, data: zAppUnavailableError },+ not_chat_app: { status: 400, data: zNotChatAppError },+ workspace_archived: { status: 403, data: zWorkspaceArchivedError },+ workspace_not_found: { status: 403, data: zWorkspaceNotFoundError },+}export const get63Errors = { app_unavailable: { status: 400, data: zAppUnavailableError } }diff --git a/packages/contracts/generated/api/service/orpc.gen.ts b/packages/contracts/generated/api/service/orpc.gen.tsindex 8b45b974fba..e07e7d26ff4 100644--- a/packages/contracts/generated/api/service/orpc.gen.ts+++ b/packages/contracts/generated/api/service/orpc.gen.ts@@ -4820,7 +4820,15 @@ export const get62 = oc}).input(z.object({ query: zGetMessagesQuery })).output(zGetMessagesResponse)- .errors({ not_chat_app: { status: 400, data: zNotChatAppError } })+ .errors({+ app_abnormal_status: { status: 403, data: zAppAbnormalStatusError },+ app_api_disabled: { status: 403, data: zAppApiDisabledError },+ app_not_found: { status: 403, data: zAppNotFoundError },+ app_unavailable: { status: 400, data: zAppUnavailableError },+ not_chat_app: { status: 400, data: zNotChatAppError },+ workspace_archived: { status: 403, data: zWorkspaceArchivedError },+ workspace_not_found: { status: 403, data: zWorkspaceNotFoundError },+ })export const messages = {get: get62,diff --git a/packages/contracts/generated/api/service/types.gen.ts b/packages/contracts/generated/api/service/types.gen.tsindex 8d71ef18dbb..a9bc402ecba 100644--- a/packages/contracts/generated/api/service/types.gen.ts+++ b/packages/contracts/generated/api/service/types.gen.ts@@ -8814,9 +8814,15 @@ export type GetMessagesData = {}export type GetMessagesErrors = {- 400: NotChatAppError | ErrorResponse+ 400: AppUnavailableError | NotChatAppError | ErrorResponse401: ErrorResponse- 403: ErrorResponse+ 403:+ | AppAbnormalStatusError+ | AppApiDisabledError+ | AppNotFoundError+ | WorkspaceArchivedError+ | WorkspaceNotFoundError+ | ErrorResponse404: ErrorResponsedefault: ErrorResponse}diff --git a/packages/contracts/generated/api/web/errors.gen.ts b/packages/contracts/generated/api/web/errors.gen.tsindex 0dcf2bf9e56..ed6b754b50b 100644--- a/packages/contracts/generated/api/web/errors.gen.ts+++ b/packages/contracts/generated/api/web/errors.gen.ts@@ -561,7 +561,10 @@ export const get5Errors = {provider_quota_exceeded: { status: 400, data: zProviderQuotaExceededError },}-export const get6Errors = { not_chat_app: { status: 400, data: zNotChatAppError } }+export const get6Errors = {+ app_unavailable: { status: 400, data: zAppUnavailableError },+ not_chat_app: { status: 400, data: zNotChatAppError },+}export const get7Errors = { app_unavailable: { status: 400, data: zAppUnavailableError } }diff --git a/packages/contracts/generated/api/web/orpc.gen.ts b/packages/contracts/generated/api/web/orpc.gen.tsindex e1dfa5214b9..9a69f32dd10 100644--- a/packages/contracts/generated/api/web/orpc.gen.ts+++ b/packages/contracts/generated/api/web/orpc.gen.ts@@ -900,7 +900,10 @@ export const get6 = oc}).input(z.object({ query: zGetMessagesQuery })).output(zGetMessagesResponse)- .errors({ not_chat_app: { status: 400, data: zNotChatAppError } })+ .errors({+ app_unavailable: { status: 400, data: zAppUnavailableError },+ not_chat_app: { status: 400, data: zNotChatAppError },+ })export const messages = {get: get6,diff --git a/packages/contracts/generated/api/web/types.gen.ts b/packages/contracts/generated/api/web/types.gen.tsindex f25aba7e230..976bda7f629 100644--- a/packages/contracts/generated/api/web/types.gen.ts+++ b/packages/contracts/generated/api/web/types.gen.ts@@ -1950,7 +1950,7 @@ export type GetMessagesData = {}export type GetMessagesErrors = {- 400: NotChatAppError | ErrorResponse+ 400: AppUnavailableError | NotChatAppError | ErrorResponse401: ErrorResponse404: ErrorResponse500: ErrorResponse