Skip to content

armgit / dify

Public Imported from GitHub
0

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.

refactor(api): unify message list and detail queries (#43754)

非法操作69b58b68aa29
diff --git a/api/.importlinter b/api/.importlinter
index 09746fbc455..76eef4679d0 100644
--- a/api/.importlinter
+++ b/api/.importlinter
@@ -398,11 +398,11 @@ forbidden_modules =
sqlalchemy
werkzeug
-[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 neutral
type = forbidden
source_modules =
- services.installed_app_message_service
+ services.message_query_service
forbidden_modules =
controllers
extensions
@@ -412,15 +412,6 @@ forbidden_modules =
sqlalchemy
werkzeug
-[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 services
type = forbidden
@@ -1007,12 +998,11 @@ forbidden_modules =
flask
models
repositories
- services.message_service
sqlalchemy
werkzeug
[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 service
type = forbidden
source_modules =
services.message_suggested_questions_service
@@ -1020,7 +1010,6 @@ source_modules =
services.message_suggested_questions_generator
repositories.message_repository
forbidden_modules =
- services.message_service
services.app_generate_service
allow_indirect_imports = True
diff --git a/api/controllers/console/app/message.py b/api/controllers/console/app/message.py
index 5267a846f7e..b37eaaff6f1 100644
--- a/api/controllers/console/app/message.py
+++ b/api/controllers/console/app/message.py
@@ -4,9 +4,7 @@ from uuid import UUID
from flask_restx import Resource
from 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, select
from controllers.common.controller_schemas import MessageFeedbackPayload as _MessageFeedbackPayloadBase
from controllers.common.errors import InternalServerError as InternalServerHTTPError
@@ -14,9 +12,7 @@ from controllers.common.errors import MessageFeedbackRatingRequiredError, NotFou
from controllers.common.fields import SimpleResultResponse
from controllers.common.rbac import AgentId, PlainApp, RBACCheck
from controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_models
-from controllers.common.session import with_session
from controllers.console import console_ns
-from controllers.console.agent.app_helpers import resolve_agent_runtime_app_model
from controllers.console.app.error import (
AppNotFoundError,
AppUnavailableError,
@@ -31,46 +27,40 @@ from controllers.console.flask_admission import console_account_admission
from 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 ExecutionExtraContentDomainModel
from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
+from enums.account import TenantAccountRole
from extensions.ext_application_services import application_services
from extensions.ext_database import db
from fields.base import ResponseModel
from fields.conversation_fields import (
MessageDetail as BaseMessageDetailResponse,
)
-from fields.conversation_fields import MessageResponseSource
from fields.message_fields import SuggestedQuestionsResponse
from graphon.model_runtime.errors.invoke import InvokeError
from libs.external_api import error_responses
from libs.helper import dump_response, uuid_value
-from libs.infinite_scroll_pagination import InfiniteScrollPagination
from libs.login import login_required
from machinery.context import RequestContext
-from models.account import Account
from models.enums import FeedbackRating
-from models.model import App, AppMode, Conversation, Message, MessageAnnotation
+from models.model import App, AppMode, MessageAnnotation
from services.agent.errors import AgentNotFoundError, AgentVersionNotFoundError
from services.app.agent_app_contracts import AgentAppNotFoundError
from services.app.console_service import ConsoleAppNotFoundError
from services.app_definition_query_service import AppDefinitionUnavailableError
-from services.conversation_service import ConversationService
from services.entities.message_entities import MessageAccount
from services.errors.conversation import ConversationNotExistsError
from services.errors.message import (
FeedbackRatingRequiredError,
+ FirstMessageNotExistsError,
MessageActorNotFoundError,
MessageNotExistsError,
SuggestedQuestionsAfterAnswerDisabledError,
)
-from services.message_service import attach_message_extra_contents
logger = 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.py
index 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 MessageNotChatAppError
from services.message_more_like_this_service import (
MoreLikeThisConfigNotFoundError,
MoreLikeThisNotCompletionError,
)
+from services.message_query_service import MessageNotChatAppError
logger = 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.py
index 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 Annotated
from uuid import UUID
from flask_restx import Resource
-from pydantic import BaseModel, Field, TypeAdapter, WithJsonSchema
+from pydantic import BaseModel, Field, WithJsonSchema
-import services
from controllers.common.controller_schemas import MessageFeedbackPayload, MessageListQuery
from controllers.common.errors import InternalServerError, MessageFeedbackRatingRequiredError, NotFoundError
from 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_admission
from 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, WhereisUserArg
from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
from extensions.ext_application_services import application_services
-from extensions.ext_database import db
from fields.base import ResponseModel
-from fields.conversation_fields import MessageResponseSource, ResultResponse
+from fields.conversation_fields import ResultResponse
from fields.message_fields import MessageInfiniteScrollPagination, MessageListItem
from graphon.model_runtime.errors.invoke import InvokeError
from libs.external_api import error_responses
from libs.helper import dump_response
from machinery.context import AppRequestContext, ServiceApiEndUserContext
from models.enums import FeedbackRating
-from models.model import App, AppMode, EndUser
+from models.model import AppMode
from services.agent.errors import AgentVersionNotFoundError
from services.app_definition_query_service import AppDefinitionUnavailableError
from services.entities.message_entities import MessageEndUser
@@ -48,7 +46,6 @@ from services.errors.message import (
MessageNotExistsError,
SuggestedQuestionsAfterAnswerDisabledError,
)
-from services.message_service import MessageService
logger = 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_mode
if 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.py
index c1162419e53..037a9642657 100644
--- a/api/controllers/web/message.py
+++ b/api/controllers/web/message.py
@@ -4,7 +4,7 @@ from typing import Literal
from uuid import UUID
from flask import Response
-from pydantic import BaseModel, Field, TypeAdapter
+from pydantic import BaseModel, Field
from controllers.common.controller_schemas import MessageFeedbackPayload, MessageListQuery
from controllers.common.errors import InternalServerError, MessageFeedbackRatingRequiredError, NotFoundError
@@ -26,9 +26,8 @@ from controllers.web.error import (
from controllers.web.wraps import WebApiResource
from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
from 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, WebMessageInfiniteScrollPagination
from graphon.model_runtime.errors.invoke import InvokeError
from libs import helper
from libs.exception import BaseHTTPException
@@ -52,7 +51,6 @@ from services.message_more_like_this_service import (
MoreLikeThisConfigNotFoundError,
MoreLikeThisNotCompletionError,
)
-from services.message_service import MessageService
logger = 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.py
index 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_app
from sqlalchemy.orm import Session, sessionmaker
from repositories.installed_app_conversation_repository import SQLAlchemyInstalledAppConversationRepository
-from repositories.installed_app_message_repository import SQLAlchemyInstalledAppMessageRepository
from repositories.installed_app_repository import SQLAlchemyInstalledAppRepository
from services.conversation_service import ConversationService
from services.installed_app_access_service import InstalledAppAccessService
from services.installed_app_conversation_service import InstalledAppConversationService
from services.installed_app_generation_adapters import AppGenerateServiceRuntime
from services.installed_app_generation_service import InstalledAppGenerationService
-from services.installed_app_message_adapters import InstalledAppMessageRuntime
-from services.installed_app_message_service import InstalledAppMessageService
from services.installed_app_service import InstalledAppService, WorkspaceRoleLookup
from services.webapp_access_query_service import WebAppAccessQueryService
@@ -25,7 +22,6 @@ class InstalledAppServices:
management: InstalledAppService
generation: InstalledAppGenerationService
conversations: InstalledAppConversationService
- messages: InstalledAppMessageService
def _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.py
index 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 SQLAlchemyPluginFileUploa
from repositories.recommended_app_catalog_repository import DatabaseRecommendedAppCatalogRepository
from repositories.saved_message_repository import SQLAlchemySavedMessageRepository
from repositories.sqlalchemy_api_workflow_run_repository import DifyAPISQLAlchemyWorkflowRunRepository
+from repositories.sqlalchemy_execution_extra_content_repository import SQLAlchemyExecutionExtraContentRepository
from repositories.step_by_step_tour_repository import SQLAlchemyStepByStepTourStateRepository
from repositories.tag_repository import TagRepository
from repositories.trial_app_repository import TrialAppRepository
@@ -148,6 +149,8 @@ from services.message_feedback_service import MessageFeedbackService
from services.message_file_preview_service import MessageFilePreviewService
from services.message_more_like_this_generator import MessageMoreLikeThisGenerator
from services.message_more_like_this_service import MessageMoreLikeThisService
+from services.message_query_adapters import ExecutionExtraContentReader, MessageFileResolver
+from services.message_query_service import MessageQueryService
from services.message_suggested_questions_generator import SuggestedQuestionsGenerator
from services.message_suggested_questions_queries import SuggestedQuestionsQuery
from services.message_suggested_questions_service import MessageSuggestedQuestions, MessageSuggestedQuestionsService
@@ -303,6 +306,7 @@ class ApplicationServices:
files: FileService
human_input_file_uploads: HumanInputFileUploadService
message_feedbacks: MessageFeedbackService
+ message_queries: MessageQueryService
message_file_previews: MessageFilePreviewService
message_suggested_questions: MessageSuggestedQuestions
message_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.md
index 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.md
index 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.md
index 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.py
deleted file mode 100644
index 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.py
index ae3e28a333b..1d72b2092bc 100644
--- a/api/repositories/message_repository.py
+++ b/api/repositories/message_repository.py
@@ -15,18 +15,38 @@ from copy import deepcopy
from typing import NamedTuple, cast
from pydantic import JsonValue
-from sqlalchemy import select
+from sqlalchemy import Select, and_, or_, select
from sqlalchemy.orm import Session, sessionmaker
from core.memory.token_buffer_memory import PreparedHistory, TokenBufferMemory
from models import Account, App, AppModelConfig, Conversation, EndUser, Message, MessageFile
from 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_config
from 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 AppModelConfigBrokenError
from 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, InstalledAppRef
from services.message_feedback_service import MessageFeedbackRecord
from 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.py
index 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 | None
diff --git a/api/services/installed_app_message_adapters.py b/api/services/installed_app_message_adapters.py
deleted file mode 100644
index 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.py
deleted file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
deleted file mode 100644
index 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 message
diff --git a/api/tests/e2e_tests/containers/controllers/console/app/test_message.py b/api/tests/e2e_tests/containers/controllers/console/app/test_message.py
index 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 timedelta
from decimal import Decimal
-from unittest.mock import patch
from uuid import uuid4
import pytest
@@ -11,7 +10,6 @@ from sqlalchemy import select
from sqlalchemy.orm import Session
from controllers.console.app.message import AppMessageFeedbackPayload, ChatMessagesQuery
-from controllers.console.app.message import attach_message_extra_contents as _attach_message_extra_contents
from libs.datetime_utils import naive_utc_now
from models.enums import ConversationFromSource, ConversationStatus, FeedbackRating
from models.model import AppMode, AppModelConfig, Conversation, Message, MessageAnnotation, MessageFeedback
@@ -141,15 +139,11 @@ def test_chat_message_list_success(
conversation_id = conversation.id
second_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 == 200
payload = 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 == 200
payload = response.get_json()
diff --git a/api/tests/e2e_tests/containers/pyrefly.toml b/api/tests/e2e_tests/containers/pyrefly.toml
index 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.py
index 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, MessageAnnotation
from services.annotation_service import AppAnnotationService
from services.conversation_service import ConversationService
from services.errors.conversation import ConversationNotExistsError
-from services.errors.message import FirstMessageNotExistsError, MessageNotExistsError
-from services.message_service import MessageService
+from services.errors.message import MessageNotExistsError
class 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:
# Assert
assert 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.py
deleted file mode 100644
index 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.py
index 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 annotations
import pytest
-from sqlalchemy.orm import Session
+from sqlalchemy.orm import Session, sessionmaker
from 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 MessageQueryService
from 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.WAITING
fixture.form.selected_action_id = None
@@ -54,13 +66,21 @@ def test_pagination_returns_waiting_human_input_extra_contents(db_session_with_c
fixture.form.submitted_data = None
db_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.data
diff --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.py
index 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 annotations
from decimal import Decimal
import pytest
+from sqlalchemy.orm import Session, sessionmaker
from libs.helper import to_timestamp
from models.enums import ConversationFromSource
from 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 MessageQueryService
from 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_wit
db_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.form
diff --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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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, sessionmaker
from werkzeug.test import TestResponse
from constants.resource_access_token import ResourceAccessTokenResourceType
-from controllers.service_api.app.message import AppGetFeedbacksApi, MessageFeedbackApi
+from controllers.service_api.app.message import AppGetFeedbacksApi, MessageFeedbackApi, MessageListApi
from enums import DeploymentEdition
from extensions.ext_application_services import build_application_services
from extensions.ext_database import db
@@ -163,6 +163,7 @@ def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]
app.extensions["application_services"] = services
api = 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.py
new file mode 100644
index 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.py
index 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, sessionmaker
from werkzeug.test import TestResponse
from constants import HEADER_NAME_APP_CODE, HEADER_NAME_PASSPORT
-from controllers.web.message import MessageFeedbackApi
+from controllers.web.message import MessageFeedbackApi, MessageListApi
from enums import DeploymentEdition
from extensions.ext_application_services import build_application_services
from 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.py
new file mode 100644
index 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.py
index 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 SimpleNamespace
from unittest import mock
import pytest
from flask.testing import FlaskClient
from controllers.console.app import completion as completion_api
-from controllers.console.app import message as message_api
from controllers.console.app import wraps
from libs.datetime_utils import naive_utc_now
from models import App, Tenant
from models.account import Account, TenantAccountJoin, TenantAccountRole
-from models.enums import AppStatus, ConversationFromSource
+from models.enums import AppStatus
from models.model import AppMode
from 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 == status
diff --git a/api/tests/unit_tests/controllers/console/agent/test_roster.py b/api/tests/unit_tests/controllers/console/agent/test_roster.py
index 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 Generator
from datetime import datetime
-from decimal import Decimal
from inspect import getsource, unwrap
from types import SimpleNamespace
from 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_controller
from controllers.console.app.completion import AgentBuildChatFinalizeApi, AgentChatMessageApi, AgentChatMessageStopApi
from 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 InfiniteScrollPagination
from models.account import Account, TenantAccountRole
from 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, TagBinding
from services.agent.observability_service import AgentLogQueryParams, AgentStatisticsQueryParams
from services.enterprise.rbac_service import RBACService
from services.entities.agent_entities import (
@@ -87,66 +79,6 @@ def rbac_services(monkeypatch: pytest.MonkeyPatch, rbac_domain: RBACDomain) -> N
monkeypatch.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.py
index 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 annotations
from datetime import UTC, datetime
-from inspect import unwrap
-from unittest.mock import MagicMock
import pytest
from flask import Flask
@@ -10,6 +8,7 @@ from sqlalchemy.orm import Session
from controllers.console.app import message as message_module
from core.app.entities.app_invoke_entities import InvokeFrom
+from fields.conversation_fields import MessageResponseSource
from models.account import Account
from models.enums import ConversationFromSource, CreatorUserRole, FeedbackFromSource, FeedbackRating
from 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)
-
@staticmethod
def 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 feedback
diff --git a/api/tests/unit_tests/controllers/console/explore/test_message.py b/api/tests/unit_tests/controllers/console/explore/test_message.py
deleted file mode 100644
index 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.py
index 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, patch
import pytest
-from flask import Flask, request
-from sqlalchemy import Engine
-from sqlalchemy.orm import Session
-from controllers.common.errors import NotFoundError
from controllers.service_api.app.error import NotChatAppError
from 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 AppMode
from 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 session
class 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.py
deleted file mode 100644
index 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.toml
index 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.py
deleted file mode 100644
index 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.py
new file mode 100644
index 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",
+ )
+ 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 None
diff --git a/api/tests/unit_tests/services/test_installed_app_message_adapters.py b/api/tests/unit_tests/services/test_installed_app_message_adapters.py
deleted file mode 100644
index 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_map
diff --git a/api/tests/unit_tests/services/test_installed_app_message_service.py b/api/tests/unit_tests/services/test_installed_app_message_service.py
deleted file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
deleted file mode 100644
index 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.ts
index 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: zAgentN
export 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.ts
index 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.ts
index 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 | ErrorResponse
404: AgentNotFoundError | ErrorResponse
default: ErrorResponse
}
@@ -3921,6 +3922,7 @@ export type GetAgentByAgentIdMessagesByMessageIdData = {
}
export type GetAgentByAgentIdMessagesByMessageIdErrors = {
+ 400: AppUnavailableError | ErrorResponse
404: AgentNotFoundError | ErrorResponse
default: ErrorResponse
}
diff --git a/packages/contracts/generated/api/console/apps/errors.gen.ts b/packages/contracts/generated/api/console/apps/errors.gen.ts
index 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.ts
index 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 = oc
z.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.ts
index 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 | ErrorResponse
404: AppNotFoundError | ErrorResponse
default: ErrorResponse
}
@@ -6522,6 +6523,7 @@ export type GetAppsByAppIdMessagesByMessageIdData = {
}
export type GetAppsByAppIdMessagesByMessageIdErrors = {
+ 400: AppUnavailableError | ErrorResponse
404: AppNotFoundError | ErrorResponse
default: ErrorResponse
}
diff --git a/packages/contracts/generated/api/console/installed-apps/errors.gen.ts b/packages/contracts/generated/api/console/installed-apps/errors.gen.ts
index 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.ts
index 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.ts
index 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 | ErrorResponse
403: AccessDeniedError | ErrorResponse
404:
| ConversationNotFoundError
diff --git a/packages/contracts/generated/api/service/errors.gen.ts b/packages/contracts/generated/api/service/errors.gen.ts
index 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.ts
index 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.ts
index 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 | ErrorResponse
401: ErrorResponse
- 403: ErrorResponse
+ 403:
+ | AppAbnormalStatusError
+ | AppApiDisabledError
+ | AppNotFoundError
+ | WorkspaceArchivedError
+ | WorkspaceNotFoundError
+ | ErrorResponse
404: ErrorResponse
default: ErrorResponse
}
diff --git a/packages/contracts/generated/api/web/errors.gen.ts b/packages/contracts/generated/api/web/errors.gen.ts
index 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.ts
index 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.ts
index 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 | ErrorResponse
401: ErrorResponse
404: ErrorResponse
500: ErrorResponse