Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
refactor(api): unify more-like-this generation across Web and Explore (#43715)
非法操作173d52d46abe
diff --git a/api/.importlinter b/api/.importlinterindex 1fe30e51c0e..09746fbc455 100644--- a/api/.importlinter+++ b/api/.importlinter@@ -46,8 +46,6 @@ ignore_imports =core.app.apps.base_app_generator -> services.workflow_draft_variable_servicecore.app.apps.chat.app_generator -> services.conversation_servicecore.app.apps.common.workflow_response_converter -> services.variable_truncator- core.app.apps.completion.app_generator -> services.errors.app- core.app.apps.completion.app_generator -> services.errors.messagecore.app.apps.message_based_app_generator -> services.errors.app_model_configcore.app.apps.message_based_app_generator -> services.errors.conversationcore.app.apps.message_based_app_generator -> services.errors.message@@ -1038,6 +1036,20 @@ forbidden_modules =services.agent.roster_serviceallow_indirect_imports = True+[importlinter:contract:message-more-like-this-boundary]+name = More-like-this policy is framework and persistence neutral+type = forbidden+source_modules =+ services.message_more_like_this_service+forbidden_modules =+ controllers+ extensions+ flask+ models+ repositories+ sqlalchemy+ werkzeug+[importlinter:contract:billing-application-boundary]name = Billing application services and ports are framework and infrastructure neutraltype = forbiddendiff --git a/api/controllers/console/explore/message.py b/api/controllers/console/explore/message.pyindex 2ea0945e8dd..405f3277bc7 100644--- a/api/controllers/console/explore/message.py+++ b/api/controllers/console/explore/message.py@@ -49,6 +49,7 @@ from services.account_errors import AccountNotFoundErrorfrom services.app_definition_query_service import AppDefinitionUnavailableErrorfrom services.entities.message_entities import MessageAccountfrom services.errors.app import MoreLikeThisDisabledError+from services.errors.app_model_config import AppModelConfigBrokenErrorfrom services.errors.base import BaseServiceErrorfrom services.errors.conversation import ConversationNotExistsErrorfrom services.errors.message import (@@ -58,8 +59,11 @@ from services.errors.message import (SuggestedQuestionsAfterAnswerDisabledError,)from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppRef-from services.installed_app_generation_service import InstalledAppNotCompletionErrorfrom services.installed_app_message_service import FeedbackRatingRequiredError, MessageNotChatAppError+from services.message_more_like_this_service import (+ MoreLikeThisConfigNotFoundError,+ MoreLikeThisNotCompletionError,+)logger = logging.getLogger(__name__)@@ -84,13 +88,13 @@ def _message_errors[**P, R](view: Callable[P, R]) -> Callable[P, R]:return view(*args, **kwargs)except InstalledAppNotFoundError as error:raise InstalledAppNotFoundHTTPError() from error- except AppDefinitionUnavailableError as error:+ except (AppDefinitionUnavailableError, MoreLikeThisConfigNotFoundError, AppModelConfigBrokenError) as error:raise AppUnavailableError() from errorexcept (AccountNotFoundError, MessageActorNotFoundError) as error:raise UnauthorizedError("Account no longer exists.") from errorexcept MessageNotChatAppError as error:raise NotChatAppError() from error- except InstalledAppNotCompletionError as error:+ except MoreLikeThisNotCompletionError as error:raise NotCompletionAppError() from errorexcept MessageNotExistsError as error:raise MessageNotFoundHTTPError() from error@@ -203,9 +207,12 @@ class MessageMoreLikeThisApi(Resource):installed_app: InstalledAppRef,message_id: UUID,) -> Response:- response = application_services().installed_apps.generation.generate_more_like_this(- installed_app=installed_app,- account_id=request_context.account_id,+ if installed_app.app_mode != "completion":+ raise NotCompletionAppError()+ response = application_services().message_more_like_this.generate(+ app_id=installed_app.app_id,+ app_owner_tenant_id=installed_app.app_owner_tenant_id,+ actor=MessageAccount(account_id=request_context.account_id),message_id=str(message_id),streaming=query.response_mode == "streaming",)diff --git a/api/controllers/web/message.py b/api/controllers/web/message.pyindex b9b27b7cb26..7fa3c025874 100644--- a/api/controllers/web/message.py+++ b/api/controllers/web/message.py@@ -3,14 +3,13 @@ from http import HTTPStatusfrom typing import Literalfrom uuid import UUID+from flask import Responsefrom pydantic import BaseModel, Field, TypeAdapter-from sqlalchemy.orm import Sessionfrom controllers.common.controller_schemas import MessageFeedbackPayload, MessageListQueryfrom controllers.common.errors import InternalServerError, NotFoundErrorfrom controllers.common.fields import GeneratedAppResponsefrom controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_models-from controllers.console.app.wraps import with_sessionfrom controllers.console.wraps import model_validatefrom controllers.web import web_nsfrom controllers.web.error import (@@ -25,7 +24,6 @@ from controllers.web.error import (ProviderQuotaExceededError,)from controllers.web.wraps import WebApiResource-from core.app.entities.app_invoke_entities import InvokeFromfrom core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededErrorfrom extensions.ext_application_services import application_servicesfrom extensions.ext_database import db@@ -33,14 +31,15 @@ from fields.conversation_fields import MessageResponseSource, ResultResponsefrom fields.message_fields import SuggestedQuestionsResponse, WebMessageInfiniteScrollPagination, WebMessageListItemfrom graphon.model_runtime.errors.invoke import InvokeErrorfrom libs import helper+from libs.exception import BaseHTTPExceptionfrom libs.external_api import error_responsesfrom models.enums import FeedbackRatingfrom models.model import App, AppMode, EndUserfrom services.agent.errors import AgentVersionNotFoundErrorfrom services.app_definition_query_service import AppDefinitionUnavailableError-from services.app_generate_service import AppGenerateServicefrom services.entities.message_entities import MessageEndUserfrom services.errors.app import MoreLikeThisDisabledError+from services.errors.app_model_config import AppModelConfigBrokenErrorfrom services.errors.conversation import ConversationNotExistsErrorfrom services.errors.message import (FirstMessageNotExistsError,@@ -48,6 +47,10 @@ from services.errors.message import (MessageNotExistsError,SuggestedQuestionsAfterAnswerDisabledError,)+from services.message_more_like_this_service import (+ MoreLikeThisConfigNotFoundError,+ MoreLikeThisNotCompletionError,+)from services.message_service import MessageServicelogger = logging.getLogger(__name__)@@ -162,6 +165,7 @@ class MessageFeedbackApi(WebApiResource):class MessageMoreLikeThisApi(WebApiResource):@error_responses(AppMoreLikeThisDisabledError,+ AppUnavailableError,CompletionRequestError,NotCompletionAppError,ProviderModelCurrentlyNotSupportError,@@ -173,26 +177,24 @@ class MessageMoreLikeThisApi(WebApiResource):@web_ns.doc(params=query_params_from_model(MessageMoreLikeThisQuery))@web_ns.doc(responses={- 200: "Success",- 400: "Bad Request - Not a completion app or feature disabled",- 401: "Unauthorized",- 403: "Forbidden",- 404: "Message Not Found",- 500: "Internal Server Error",+ HTTPStatus.OK: "Success",+ HTTPStatus.BAD_REQUEST: "Bad Request - Not a completion app, app unavailable, or model invocation failed",+ HTTPStatus.UNAUTHORIZED: "Unauthorized",+ HTTPStatus.FORBIDDEN: "Forbidden - Access denied or more-like-this disabled",+ HTTPStatus.NOT_FOUND: "Message Not Found",+ HTTPStatus.INTERNAL_SERVER_ERROR: "Internal Server Error",})- @web_ns.response(200, "Success", web_ns.models[GeneratedAppResponse.__name__])- @with_session+ @web_ns.response(HTTPStatus.OK, "Success", web_ns.models[GeneratedAppResponse.__name__])@model_validate(MessageMoreLikeThisQuery)def get(self,query: MessageMoreLikeThisQuery,- session: Session,app_model: App,end_user: EndUser,message_id: UUID,- ):- if app_model.mode != "completion":+ ) -> Response:+ if app_model.mode != AppMode.COMPLETION:raise NotCompletionAppError()message_id_str = str(message_id)@@ -200,17 +202,22 @@ class MessageMoreLikeThisApi(WebApiResource):streaming = query.response_mode == "streaming"try:- response = AppGenerateService.generate_more_like_this(- session=session,- app_model=app_model,- user=end_user,+ response = application_services().message_more_like_this.generate(+ app_id=app_model.id,+ app_owner_tenant_id=app_model.tenant_id,+ actor=MessageEndUser(end_user_id=end_user.id),message_id=message_id_str,- invoke_from=InvokeFrom.WEB_APP,streaming=streaming,)# response-contract:ignore compact_generate_responsereturn helper.compact_generate_response(response)+ except (AppDefinitionUnavailableError, MoreLikeThisConfigNotFoundError, AppModelConfigBrokenError) as error:+ raise AppUnavailableError() from error+ except MessageActorNotFoundError as error:+ raise NotFoundError("End user not found") from error+ except MoreLikeThisNotCompletionError as error:+ raise NotCompletionAppError() from errorexcept MessageNotExistsError as caught_error:raise NotFoundError("Message Not Exists.") from caught_errorexcept MoreLikeThisDisabledError as caught_error:@@ -223,8 +230,8 @@ class MessageMoreLikeThisApi(WebApiResource):raise ProviderModelCurrentlyNotSupportError() from caught_errorexcept InvokeError as e:raise CompletionRequestError(e.description) from e- except ValueError as e:- raise e+ except (BaseHTTPException, ValueError):+ raiseexcept Exception as caught_error:logger.exception("internal server error.")raise InternalServerError() from caught_errordiff --git a/api/core/app/apps/agent_app/app_generator.py b/api/core/app/apps/agent_app/app_generator.pyindex e33fde46f77..0c402bccf5f 100644--- a/api/core/app/apps/agent_app/app_generator.py+++ b/api/core/app/apps/agent_app/app_generator.py@@ -209,7 +209,6 @@ class AgentAppGenerator(MessageBasedAppGenerator):queue_manager=queue_manager,conversation=conversation,message=message,- user=user,stream=streaming,)return AgentAppGenerateResponseConverter.convert(response=response, invoke_from=invoke_from)diff --git a/api/core/app/apps/agent_chat/app_generator.py b/api/core/app/apps/agent_chat/app_generator.pyindex 8cc709004d7..2f661f06645 100644--- a/api/core/app/apps/agent_chat/app_generator.py+++ b/api/core/app/apps/agent_chat/app_generator.py@@ -247,7 +247,6 @@ class AgentChatAppGenerator(MessageBasedAppGenerator):queue_manager=queue_manager,conversation=conversation,message=message,- user=user,stream=streaming,)return AgentChatAppGenerateResponseConverter.convert(response=response, invoke_from=invoke_from)diff --git a/api/core/app/apps/chat/app_generator.py b/api/core/app/apps/chat/app_generator.pyindex 8380c0be731..d0be650e487 100644--- a/api/core/app/apps/chat/app_generator.py+++ b/api/core/app/apps/chat/app_generator.py@@ -238,7 +238,6 @@ class ChatAppGenerator(MessageBasedAppGenerator):queue_manager=queue_manager,conversation=conversation,message=message,- user=user,stream=streaming,)diff --git a/api/core/app/apps/completion/app_config_manager.py b/api/core/app/apps/completion/app_config_manager.pyindex 18d49c6edc4..73e753c7046 100644--- a/api/core/app/apps/completion/app_config_manager.py+++ b/api/core/app/apps/completion/app_config_manager.py@@ -55,13 +55,33 @@ class CompletionAppConfigManager(BaseAppConfigManager):raise Exception("override_config_dict is required when config_from is ARGS")config_dict = override_config_dict- app_mode = AppMode.value_of(app_model.mode)- app_config = CompletionAppConfig(+ return cls.get_app_config_from_dict(tenant_id=app_model.tenant_id,app_id=app_model.id,+ app_model_config_id=app_model_config.id,+ app_mode=AppMode.value_of(app_model.mode),+ config_dict=config_dict,+ config_from=config_from,+ )++ @classmethod+ def get_app_config_from_dict(+ cls,+ *,+ tenant_id: str,+ app_id: str,+ app_model_config_id: str,+ app_mode: AppMode,+ config_dict: AppModelConfigDict,+ config_from: EasyUIBasedAppModelConfigFrom,+ ) -> CompletionAppConfig:+ """Convert materialized configuration without requiring ORM records."""+ app_config = CompletionAppConfig(+ tenant_id=tenant_id,+ app_id=app_id,app_mode=app_mode,app_model_config_from=config_from,- app_model_config_id=app_model_config.id,+ app_model_config_id=app_model_config_id,app_model_config_dict=cast(dict[str, Any], config_dict),model=ModelConfigManager.convert(config=config_dict),prompt_template=PromptTemplateConfigManager.convert(config=config_dict),diff --git a/api/core/app/apps/completion/app_generator.py b/api/core/app/apps/completion/app_generator.pyindex 706085fa61e..7312b079fe8 100644--- a/api/core/app/apps/completion/app_generator.py+++ b/api/core/app/apps/completion/app_generator.py@@ -7,8 +7,7 @@ from typing import Any, Literal, overloadfrom flask import Flask, copy_current_request_context, current_appfrom pydantic import ValidationError-from sqlalchemy import select-from sqlalchemy.orm import Session+from sqlalchemy.orm import Session, sessionmakerfrom configs import dify_configfrom core.app.app_config.easy_ui_based_app.model_config.converter import ModelConfigConverter@@ -21,16 +20,15 @@ from core.app.apps.exc import GenerateTaskStoppedErrorfrom core.app.apps.message_based_app_generator import MessageBasedAppGeneratorfrom core.app.apps.message_based_app_queue_manager import MessageBasedAppQueueManagerfrom core.app.entities.app_invoke_entities import CompletionAppGenerateEntity, InvokeFrom+from core.app.entities.task_entities import AppBlockingResponse, AppStreamResponsefrom core.db.session_factory import session_factoryfrom core.helper.trace_id_helper import extract_trace_session_id_from_argsfrom core.ops.ops_trace_manager import TraceQueueManagerfrom extensions.ext_database import dbfrom factories import file_factoryfrom graphon.model_runtime.errors.invoke import InvokeAuthorizationError-from models import Account, App, AppModelConfig, Conversation, EndUser, Message+from models import Account, App, Conversation, EndUser, Messagefrom models.model import load_annotation_reply_config-from services.errors.app import MoreLikeThisDisabledError-from services.errors.message import MessageNotExistsErrorlogger = logging.getLogger(__name__)@@ -184,44 +182,64 @@ class CompletionAppGenerator(MessageBasedAppGenerator):session=session,)- # init queue manager- queue_manager = MessageBasedAppQueueManager(- task_id=application_generate_entity.task_id,- user_id=application_generate_entity.user_id,- invoke_from=application_generate_entity.invoke_from,- conversation_id=conversation.id,- app_mode=conversation.mode,- message_id=message.id,- )-- context = contextvars.copy_context()+ response = self._start_generation(application_generate_entity, conversation, message)+ return CompletionAppGenerateResponseConverter.convert(response=response, invoke_from=invoke_from)- # new thread with request context- @copy_current_request_context- def worker_with_context():- return context.run(- self._generate_worker,- flask_app=current_app._get_current_object(), # type: ignore- application_generate_entity=application_generate_entity,- queue_manager=queue_manager,- message_id=message.id,- )+ def generate_from_entity(+ self,+ application_generate_entity: CompletionAppGenerateEntity,+ *,+ session_factory: sessionmaker[Session],+ ) -> Mapping[str, Any] | Generator[str | Mapping[str, Any]]:+ """Persist prepared completion records before starting provider work.- worker_thread = threading.Thread(target=worker_with_context)+ Preparation owns configuration, inputs and files. This path preserves+ those values and closes its write session before starting the worker or+ waiting for a blocking response.+ """+ with session_factory(expire_on_commit=False) as session:+ conversation, message = self._init_generate_records(application_generate_entity, session=session)+ response = self._start_generation(application_generate_entity, conversation, message)+ return CompletionAppGenerateResponseConverter.convert(+ response=response, invoke_from=application_generate_entity.invoke_from+ )- worker_thread.start()+ def _start_generation(+ self,+ application_generate_entity: CompletionAppGenerateEntity,+ conversation: Conversation,+ message: Message,+ ) -> AppBlockingResponse | Generator[AppStreamResponse]:+ queue_manager = MessageBasedAppQueueManager(+ task_id=application_generate_entity.task_id,+ user_id=application_generate_entity.user_id,+ invoke_from=application_generate_entity.invoke_from,+ conversation_id=conversation.id,+ app_mode=conversation.mode,+ message_id=message.id,+ )+ context = contextvars.copy_context()- # return response or stream generator- response = self._handle_response(+ @copy_current_request_context+ def worker_with_context() -> None:+ context.run(+ self._generate_worker,+ flask_app=current_app._get_current_object(), # type: ignoreapplication_generate_entity=application_generate_entity,queue_manager=queue_manager,- conversation=conversation,- message=message,- user=user,- stream=streaming,+ message_id=message.id,)- return CompletionAppGenerateResponseConverter.convert(response=response, invoke_from=invoke_from)+ worker_thread = threading.Thread(target=worker_with_context)+ worker_thread.start()++ return self._handle_response(+ application_generate_entity=application_generate_entity,+ queue_manager=queue_manager,+ conversation=conversation,+ message=message,+ stream=application_generate_entity.stream,+ )def _generate_worker(self,@@ -229,7 +247,7 @@ class CompletionAppGenerator(MessageBasedAppGenerator):application_generate_entity: CompletionAppGenerateEntity,queue_manager: AppQueueManager,message_id: str,- ):+ ) -> None:"""Generate worker in a new thread.:param flask_app: Flask app@@ -270,142 +288,3 @@ class CompletionAppGenerator(MessageBasedAppGenerator):queue_manager.publish_error(e, PublishFrom.APPLICATION_MANAGER)finally:db.session.close()-- def generate_more_like_this(- self,- app_model: App,- message_id: str,- user: Account | EndUser,- invoke_from: InvokeFrom,- stream: bool = True,- *,- session: Session,- ) -> Mapping | Generator[Mapping | str]:- """- Generate App response.-- :param session: caller-owned database session used for message and historical model-config reads- :param app_model: App- :param message_id: message ID- :param user: account or end user- :param invoke_from: invoke from source- :param stream: is stream- """- stmt = 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),- )- message = session.scalar(stmt)-- if not message:- raise MessageNotExistsError()-- current_app_model_config = (- session.get(AppModelConfig, app_model.app_model_config_id) if app_model.app_model_config_id else None- )- if not current_app_model_config:- raise MoreLikeThisDisabledError()-- more_like_this = current_app_model_config.more_like_this_dict-- if not current_app_model_config.more_like_this or more_like_this.get("enabled", False) is False:- raise MoreLikeThisDisabledError()-- conversation = session.get(Conversation, message.conversation_id) if message.conversation_id else None- app_model_config = (- session.get(AppModelConfig, conversation.app_model_config_id)- if conversation and conversation.app_model_config_id- else None- )- if not app_model_config:- raise ValueError("Message app_model_config is None")- annotation_reply = load_annotation_reply_config(session, app_model_config.app_id)- override_model_config_dict = app_model_config.to_dict(annotation_reply=annotation_reply)- model_dict = override_model_config_dict["model"]- completion_params = model_dict.get("completion_params", {})- completion_params["temperature"] = 0.9- model_dict["completion_params"] = completion_params- override_model_config_dict["model"] = model_dict-- with self._bind_file_access_scope(tenant_id=app_model.tenant_id, user=user, invoke_from=invoke_from):- # parse files- file_extra_config = FileUploadConfigManager.convert(override_model_config_dict)- if file_extra_config:- file_objs = file_factory.build_from_mappings(- mappings=message.message_files_with_session(session=session),- tenant_id=app_model.tenant_id,- config=file_extra_config,- access_controller=self._file_access_controller,- )- else:- file_objs = []-- # convert to app config- app_config = CompletionAppConfigManager.get_app_config(- app_model=app_model,- app_model_config=app_model_config,- override_config_dict=override_model_config_dict,- annotation_reply=annotation_reply,- )-- # init application generate entity- application_generate_entity = CompletionAppGenerateEntity(- task_id=str(uuid.uuid4()),- app_config=app_config,- model_conf=ModelConfigConverter.convert(app_config),- inputs=message.inputs_with_session(session=session),- query=message.query,- files=list(file_objs),- user_id=user.id,- stream=stream,- invoke_from=invoke_from,- extras={},- )-- # init generate records- (conversation, message) = self._init_generate_records(- application_generate_entity,- session=session,- )-- # init queue manager- queue_manager = MessageBasedAppQueueManager(- task_id=application_generate_entity.task_id,- user_id=application_generate_entity.user_id,- invoke_from=application_generate_entity.invoke_from,- conversation_id=conversation.id,- app_mode=conversation.mode,- message_id=message.id,- )-- context = contextvars.copy_context()-- # new thread with request context- @copy_current_request_context- def worker_with_context():- return context.run(- self._generate_worker,- flask_app=current_app._get_current_object(), # type: ignore- application_generate_entity=application_generate_entity,- queue_manager=queue_manager,- message_id=message.id,- )-- worker_thread = threading.Thread(target=worker_with_context)-- worker_thread.start()-- # return response or stream generator- response = self._handle_response(- application_generate_entity=application_generate_entity,- queue_manager=queue_manager,- conversation=conversation,- message=message,- user=user,- stream=stream,- )-- return CompletionAppGenerateResponseConverter.convert(response=response, invoke_from=invoke_from)diff --git a/api/core/app/apps/message_based_app_generator.py b/api/core/app/apps/message_based_app_generator.pyindex cfc0d8e7d4f..7a6ffa334e1 100644--- a/api/core/app/apps/message_based_app_generator.py+++ b/api/core/app/apps/message_based_app_generator.py@@ -34,7 +34,6 @@ from extensions.ext_database import dbfrom extensions.ext_redis import get_pubsub_broadcast_channelfrom libs.broadcast_channel.channel import SupportsPreparedSubscription, Topicfrom libs.datetime_utils import naive_utc_now-from models import Accountfrom models.enums import (ConversationFromSource,ConversationStatus,@@ -44,7 +43,7 @@ from models.enums import (from models.enums import (InvokeFrom as ModelInvokeFrom,)-from models.model import App, AppMode, AppModelConfig, Conversation, EndUser, Message, MessageFile+from models.model import App, AppMode, AppModelConfig, Conversation, Message, MessageFilefrom services.errors.app_model_config import AppModelConfigBrokenErrorfrom services.errors.conversation import ConversationNotExistsErrorfrom services.errors.message import MessageNotExistsError@@ -59,7 +58,6 @@ class MessageBasedAppGenerator(BaseAppGenerator):queue_manager: AppQueueManager,conversation: Conversation,message: Message,- user: Account | EndUser,stream: bool = False,) -> (ChatbotAppBlockingResponse@@ -72,7 +70,6 @@ class MessageBasedAppGenerator(BaseAppGenerator)::param queue_manager: queue manager:param conversation: conversation:param message: message- :param user: user:param stream: is stream:return:"""diff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.pyindex a57d1b1a4bf..9b613251036 100644--- a/api/extensions/ext_application_services.py+++ b/api/extensions/ext_application_services.py@@ -145,6 +145,8 @@ from services.knowledge.api_key_service import DatasetApiKeyServicefrom services.knowledge_fs.builtin_tool.knowledge_fs.knowledge_fs import KnowledgeFSProviderfrom services.knowledge_fs.workflow_runtime import build_knowledge_fs_node_dependenciesfrom services.message_file_preview_service import MessageFilePreviewService+from services.message_more_like_this_generator import MessageMoreLikeThisGenerator+from services.message_more_like_this_service import MessageMoreLikeThisServicefrom services.message_suggested_questions_generator import SuggestedQuestionsGeneratorfrom services.message_suggested_questions_queries import SuggestedQuestionsQueryfrom services.message_suggested_questions_service import MessageSuggestedQuestions, MessageSuggestedQuestionsService@@ -301,6 +303,7 @@ class ApplicationServices:human_input_file_uploads: HumanInputFileUploadServicemessage_file_previews: MessageFilePreviewServicemessage_suggested_questions: MessageSuggestedQuestions+ message_more_like_this: MessageMoreLikeThisServiceplugin_file_uploads: PluginFileUploadServicetool_file_downloads: ToolFileDownloadServiceupload_file_delivery: UploadFileDeliveryService@@ -537,9 +540,10 @@ def build_application_services(registration=account_services.lifecycle,invitation_tokens=invitation_tokens,)+ messages = MessageRepository(session_factory=database_client)suggested_questions = SuggestedQuestionsQuery(session_factory=database_client,- repository_factory=MessageRepository,+ repository=messages,)return ApplicationServices(@@ -663,6 +667,10 @@ def build_application_services(files=MessageFilePreviewQueryRepository(session_factory=database_client),storage=storage,),+ message_more_like_this=MessageMoreLikeThisService(+ repository=messages,+ generator=MessageMoreLikeThisGenerator(session_factory=database_client),+ ),message_suggested_questions=MessageSuggestedQuestionsService(queries=suggested_questions,generator=SuggestedQuestionsGenerator(),diff --git a/api/openapi/markdown/web-openapi.md b/api/openapi/markdown/web-openapi.mdindex b027b21830f..5d02fa7ffc4 100644--- a/api/openapi/markdown/web-openapi.md+++ b/api/openapi/markdown/web-openapi.md@@ -570,9 +570,9 @@ Generate a new completion similar to an existing message (completion apps only).| Code | Description | Schema || ---- | ----------- | ------ || 200 | Success | **application/json**: [GeneratedAppResponse](#generatedappresponse)<br> |-| 400 | Bad Request - Not a completion app or feature disabled | **application/json**: [CompletionRequestError](#completionrequesterror)<br>[ModelCurrentlyNotSupportError](#modelcurrentlynotsupporterror)<br>[NotCompletionAppError](#notcompletionapperror)<br>[ProviderNotInitializeError](#providernotinitializeerror)<br>[ProviderQuotaExceededError](#providerquotaexceedederror)<br>[ErrorResponse](#errorresponse)<br> |+| 400 | Bad Request - Not a completion app, app unavailable, or model invocation failed | **application/json**: [AppUnavailableError](#appunavailableerror)<br>[CompletionRequestError](#completionrequesterror)<br>[ModelCurrentlyNotSupportError](#modelcurrentlynotsupporterror)<br>[NotCompletionAppError](#notcompletionapperror)<br>[ProviderNotInitializeError](#providernotinitializeerror)<br>[ProviderQuotaExceededError](#providerquotaexceedederror)<br>[ErrorResponse](#errorresponse)<br> || 401 | Unauthorized | **application/json**: [ErrorResponse](#errorresponse)<br> |-| 403 | Forbidden | **application/json**: [AppMoreLikeThisDisabledError](#appmorelikethisdisablederror)<br>[ErrorResponse](#errorresponse)<br> |+| 403 | Forbidden - Access denied or more-like-this disabled | **application/json**: [AppMoreLikeThisDisabledError](#appmorelikethisdisablederror)<br>[ErrorResponse](#errorresponse)<br> || 404 | Message 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/message_repository.py b/api/repositories/message_repository.pyindex 7217b2aeb30..86bdc2abc42 100644--- a/api/repositories/message_repository.py+++ b/api/repositories/message_repository.py@@ -1,17 +1,36 @@-"""Message ownership and history reads within the caller's bounded read session."""+"""Message ownership and generation reads shared by message capabilities.-from typing import NamedTuple+History and more-like-this reads own short sessions and return detached data.+Only suggested-question configuration preparation borrows the caller's session.+TODO: Remove the session parameters from get_suggested_questions_context and+get_model_config once AgentRuntimeConfigService, WorkflowService and conversation+config helpers accept detached inputs and return detached results without a+shared caller session. These repository methods can then own their sessions and+return detached data too; configuration selection stays in the query/service layer.+"""++import json+from copy import deepcopy+from typing import NamedTuple, cast++from pydantic import JsonValuefrom sqlalchemy import select-from sqlalchemy.orm import Session+from sqlalchemy.orm import Session, sessionmakerfrom core.memory.token_buffer_memory import PreparedHistory, TokenBufferMemory-from models import Account, App, Conversation, EndUser, Message-from models.model import AppModelConfig+from models import Account, App, AppModelConfig, Conversation, EndUser, Message, MessageFile+from models.model import AppMode, load_annotation_reply_configfrom services.app_definition_query_service import AppDefinitionUnavailableErrorfrom services.entities.message_entities import MessageAccount, MessageActor+from services.errors.app_model_config import AppModelConfigBrokenErrorfrom services.errors.conversation import ConversationNotExistsErrorfrom services.errors.message import MessageActorNotFoundError, MessageNotExistsError+from services.message_more_like_this_service import (+ MoreLikeThisFile,+ MoreLikeThisNotCompletionError,+ MoreLikeThisSource,+)from services.message_suggested_questions_service import SuggestedQuestionsContext@@ -21,57 +40,53 @@ class SuggestedQuestionsRecords(NamedTuple):class MessageRepository:- def __init__(self, session: Session) -> None:- self._session: Session = session+ def __init__(self, *, session_factory: sessionmaker[Session]) -> None:+ self._session_factory: sessionmaker[Session] = session_factory- def get_context(+ def get_suggested_questions_context(self,*,+ session: Session,app_id: str,app_owner_tenant_id: str,expected_app_mode: str,actor: MessageActor,message_id: str,) -> SuggestedQuestionsRecords:- app = self._session.scalar(select(App).where(App.id == app_id, App.tenant_id == app_owner_tenant_id))+ app = self._get_app(session, app_id=app_id, tenant_id=app_owner_tenant_id)if app is None or app.mode != expected_app_mode:raise AppDefinitionUnavailableError(f"App {app_id} is unavailable in tenant {app_owner_tenant_id} with mode {expected_app_mode}")- account_id = None- end_user_id = None- if isinstance(actor, MessageAccount):- account_id = actor.account_id- if self._session.get(Account, account_id) is None:- raise MessageActorNotFoundError(f"Account {account_id} no longer exists")- source = "console"- else:- end_user_id = actor.end_user_id- end_user = self._session.scalar(- select(EndUser).where(- EndUser.id == end_user_id, EndUser.app_id == app_id, EndUser.tenant_id == app_owner_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+ source = "console" if isinstance(actor, MessageAccount) else "api"+ if not self._actor_exists(+ session,+ app_id=app_id,+ tenant_id=app_owner_tenant_id,+ account_id=account_id,+ end_user_id=end_user_id,+ ):+ if isinstance(actor, MessageAccount):+ raise MessageActorNotFoundError(f"Account {actor.account_id} no longer exists")+ raise MessageActorNotFoundError(+ f"End user {actor.end_user_id} does not exist for app {app_id} in tenant {app_owner_tenant_id}")- if end_user is None:- raise MessageActorNotFoundError(- f"End user {end_user_id} does not exist for app {app_id} in tenant {app_owner_tenant_id}"- )- source = "api"- message = self._session.scalar(- select(Message).where(- Message.id == message_id,- Message.app_id == app_id,- Message.from_source == source,- Message.from_account_id == account_id,- Message.from_end_user_id == end_user_id,- )+ message = self._get_message(+ session,+ message_id=message_id,+ app_id=app_id,+ source=source,+ account_id=account_id,+ end_user_id=end_user_id,)if message is None:raise MessageNotExistsError()- conversation = self._session.scalar(+ conversation = session.scalar(select(Conversation).where(Conversation.id == message.conversation_id,Conversation.app_id == app_id,@@ -85,41 +100,192 @@ class MessageRepository:raise ConversationNotExistsError()return SuggestedQuestionsRecords(app, conversation)- def get_model_config(self, *, app_id: str, config_id: str | None) -> AppModelConfig | None:+ def get_model_config(self, *, session: Session, app_id: str, config_id: str | None) -> AppModelConfig | None:"""Return the app-owned configuration; a missing pointer or row returns None."""if config_id is None:return None- return self._session.scalar(+ return session.scalar(select(AppModelConfig).where(AppModelConfig.id == config_id, AppModelConfig.app_id == app_id))- def load_history(self, *, context: SuggestedQuestionsContext) -> PreparedHistory:+ def load_suggested_questions_history(self, *, context: SuggestedQuestionsContext) -> PreparedHistory:# Model resolution separates the two read phases. Reload only the app# and conversation needed by the history reader, retaining their owner# scope without repeating actor and target-message admission queries.- app = self._session.scalar(select(App).where(App.id == context.app_id, App.tenant_id == context.tenant_id))- if app is None or app.mode != context.app_mode:- raise AppDefinitionUnavailableError(- f"App {context.app_id} is unavailable in tenant {context.tenant_id} with mode {context.app_mode}"+ with self._session_factory(expire_on_commit=False) as session:+ app = self._get_app(session, app_id=context.app_id, tenant_id=context.tenant_id)+ if app is None or app.mode != context.app_mode:+ raise AppDefinitionUnavailableError(+ f"App {context.app_id} is unavailable in tenant {context.tenant_id} with mode {context.app_mode}"+ )+ actor = context.actor+ account_id = actor.account_id if isinstance(actor, MessageAccount) else None+ end_user_id = None if isinstance(actor, MessageAccount) else actor.end_user_id+ conversation = session.scalar(+ select(Conversation).where(+ Conversation.id == context.conversation_id,+ Conversation.app_id == context.app_id,+ Conversation.from_source == ("console" if isinstance(actor, MessageAccount) else "api"),+ Conversation.from_account_id == account_id,+ Conversation.from_end_user_id == end_user_id,+ Conversation.is_deleted.is_(False),+ ))- actor = context.actor- account_id = actor.account_id if isinstance(actor, MessageAccount) else None- end_user_id = None if isinstance(actor, MessageAccount) else actor.end_user_id- conversation = self._session.scalar(- select(Conversation).where(- Conversation.id == context.conversation_id,- Conversation.app_id == context.app_id,- Conversation.from_source == ("console" if isinstance(actor, MessageAccount) else "api"),- Conversation.from_account_id == account_id,- Conversation.from_end_user_id == end_user_id,- Conversation.is_deleted.is_(False),+ if conversation is None:+ raise ConversationNotExistsError()+ return TokenBufferMemory.load_history(+ conversation=conversation,+ app_record=app,+ session=session,+ message_limit=3,+ )++ def get_more_like_this_source(+ self,+ *,+ app_id: str,+ app_owner_tenant_id: str,+ actor: MessageActor,+ message_id: str,+ ) -> MoreLikeThisSource:+ with self._session_factory() as session:+ 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} no longer exists in workspace {app_owner_tenant_id}")+ if app.mode != AppMode.COMPLETION:+ raise MoreLikeThisNotCompletionError(f"App {app_id} is not a completion app")++ account_id = actor.account_id if isinstance(actor, MessageAccount) else None+ end_user_id = None if isinstance(actor, MessageAccount) else actor.end_user_id+ source = "console" if isinstance(actor, MessageAccount) else "api"+ if not self._actor_exists(+ session,+ app_id=app_id,+ tenant_id=app_owner_tenant_id,+ account_id=account_id,+ end_user_id=end_user_id,+ ):+ if isinstance(actor, MessageAccount):+ raise MessageActorNotFoundError(f"Account {actor.account_id} no longer exists")+ raise MessageActorNotFoundError(f"End user {actor.end_user_id} is unavailable for app {app_id}")++ message = self._get_message(+ session,+ message_id=message_id,+ app_id=app_id,+ source=source,+ account_id=account_id,+ end_user_id=end_user_id,+ )+ if message is None:+ raise MessageNotExistsError(f"Message {message_id} is unavailable for this app and actor")++ current_feature_config = (+ session.scalar(+ select(AppModelConfig.more_like_this).where(+ AppModelConfig.id == app.app_model_config_id, AppModelConfig.app_id == app_id+ )+ )+ if app.app_model_config_id+ else None+ )+ historical_model_config_id = (+ session.scalar(+ select(Conversation.app_model_config_id).where(+ Conversation.id == message.conversation_id,+ Conversation.app_id == app_id,+ Conversation.from_source == source,+ Conversation.from_account_id == account_id,+ Conversation.from_end_user_id == end_user_id,+ )+ )+ if message.conversation_id+ else None)+ files = session.scalars(select(MessageFile).where(MessageFile.message_id == message.id)).all()+ return MoreLikeThisSource(+ app_id=app.id,+ tenant_id=app.tenant_id,+ query=message.query,+ inputs=deepcopy(cast(dict[str, JsonValue], message._inputs)),+ files=tuple(+ MoreLikeThisFile(+ id=file.id,+ type=file.type,+ transfer_method=file.transfer_method,+ url=file.url,+ upload_file_id=file.upload_file_id,+ )+ for file in files+ ),+ current_feature_config=current_feature_config,+ historical_model_config_id=historical_model_config_id,+ )++ def get_more_like_this_model_config(+ self, *, app_id: str, app_owner_tenant_id: str, model_config_id: str+ ) -> dict[str, JsonValue] | None:+ """Return the owned historical configuration, or None when unavailable."""+ with self._session_factory() as session:+ config = session.scalar(+ select(AppModelConfig)+ .join(App, App.id == AppModelConfig.app_id)+ .where(+ App.id == app_id,+ App.tenant_id == app_owner_tenant_id,+ App.mode == AppMode.COMPLETION,+ AppModelConfig.id == model_config_id,+ )+ )+ if config is None:+ return None+ annotation_reply = load_annotation_reply_config(session, app_id)+ try:+ model_config = config.to_dict(annotation_reply=annotation_reply)+ except json.JSONDecodeError as error:+ raise AppModelConfigBrokenError(+ f"App {app_id}, configuration {model_config_id}: historical configuration contains invalid JSON"+ ) from error+ return deepcopy(cast(dict[str, JsonValue], model_config))++ @staticmethod+ def _get_app(session: Session, *, app_id: str, tenant_id: str) -> App | None:+ """Return the app within its owner tenant, or None when unavailable."""+ return session.scalar(select(App).where(App.id == app_id, App.tenant_id == tenant_id))++ @staticmethod+ def _actor_exists(+ session: Session, *, app_id: str, tenant_id: str, account_id: str | None, end_user_id: str | None+ ) -> bool:+ """Check the normalized actor scope; the other actor kind's ID is None."""+ if account_id is not None:+ return session.get(Account, account_id) is not None+ return (+ session.scalar(+ select(EndUser.id).where(+ EndUser.id == end_user_id, EndUser.app_id == app_id, EndUser.tenant_id == tenant_id+ )+ )+ is not None)- if conversation is None:- raise ConversationNotExistsError()- return TokenBufferMemory.load_history(- conversation=conversation,- app_record=app,- session=self._session,- message_limit=3,++ @staticmethod+ def _get_message(+ session: Session,+ *,+ message_id: str,+ app_id: str,+ source: str,+ account_id: str | None,+ end_user_id: str | None,+ ) -> Message | None:+ """Return the owned message, or None; the other actor kind's ID is None."""+ return session.scalar(+ select(Message).where(+ Message.id == message_id,+ Message.app_id == app_id,+ Message.from_source == source,+ Message.from_account_id == account_id,+ Message.from_end_user_id == end_user_id,+ ))diff --git a/api/services/app_generate_service.py b/api/services/app_generate_service.pyindex 94b0f108084..48e6d50ae1f 100644--- a/api/services/app_generate_service.py+++ b/api/services/app_generate_service.py@@ -3,7 +3,7 @@ from __future__ import annotationsimport loggingimport threadingimport uuid-from collections.abc import Callable, Generator, Mapping+from collections.abc import Callable, Mappingfrom typing import TYPE_CHECKING, Anyfrom sqlalchemy.orm import Session@@ -474,35 +474,6 @@ class AppGenerateService:case _:raise ValueError(f"Invalid app mode {app_model.mode}")- @classmethod- def generate_more_like_this(- cls,- app_model: App,- user: Account | EndUser,- message_id: str,- invoke_from: InvokeFrom,- *,- session: Session,- streaming: bool = True,- ) -> Mapping | Generator:- """- Generate more like this- :param app_model: app model- :param user: user- :param message_id: message id- :param invoke_from: invoke from- :param streaming: streaming- :return:- """- return CompletionAppGenerator().generate_more_like_this(- session=session,- app_model=app_model,- message_id=message_id,- user=user,- invoke_from=invoke_from,- stream=streaming,- )-@classmethoddef _get_workflow(cls,diff --git a/api/services/installed_app_generation_adapters.py b/api/services/installed_app_generation_adapters.pyindex b519e338bea..7ab45c157a3 100644--- a/api/services/installed_app_generation_adapters.py+++ b/api/services/installed_app_generation_adapters.py@@ -1,12 +1,11 @@"""Bridge pure installed app requests to the existing generation runtime."""import logging-from collections.abc import Callable, Generator, Mapping-from typing import cast, override+from collections.abc import Callable, Mapping+from typing import overridefrom sqlalchemy.orm import Session, sessionmaker-from core.app.apps.completion.app_generator import CompletionAppGeneratorfrom core.app.entities.app_invoke_entities import InvokeFromfrom models import Account, Appfrom services.account_errors import AccountNotFoundError@@ -15,45 +14,12 @@ from services.app_generate_service import AppGenerateServicefrom services.conversation_service import ConversationServicefrom services.installed_app_generation_service import (GenerationResponse,- GenerationStream,InstalledAppGenerationRuntime,)logger = logging.getLogger(__name__)-class _MoreLikeThisEventStream:- def __init__(self, source: Generator[Mapping[str, object] | str]) -> None:- self._source: Generator[Mapping[str, object] | str] = source- self._events: GenerationStream = cast(GenerationStream, CompletionAppGenerator.convert_to_event_stream(source))- self._closed: bool = False-- def __iter__(self) -> "_MoreLikeThisEventStream":- return self-- def __next__(self) -> str:- if self._closed:- raise StopIteration- try:- return next(self._events)- except BaseException:- try:- self.close()- except BaseException:- logger.exception("Failed to close the more-like-this response after an error")- raise-- def close(self) -> None:- if self._closed:- return- self._closed = True- try:- self._events.close()- finally:- # Closing an unstarted conversion generator does not reach its source.- self._source.close()--class AppGenerateServiceRuntime(InstalledAppGenerationRuntime):def __init__(self, *, session_factory: sessionmaker[Session]) -> None:self._session_factory: sessionmaker[Session] = session_factory@@ -84,32 +50,6 @@ class AppGenerateServiceRuntime(InstalledAppGenerationRuntime):))- @override- def generate_more_like_this(- self,- *,- app_id: str,- account_id: str,- message_id: str,- streaming: bool,- ) -> GenerationResponse:- app, account = self._load_generation_context(app_id=app_id, account_id=account_id)-- def generate(session: Session) -> GenerationResponse:- response = AppGenerateService.generate_more_like_this(- session=session,- app_model=app,- user=account,- message_id=message_id,- invoke_from=InvokeFrom.EXPLORE,- streaming=streaming,- )- if isinstance(response, Mapping):- return response- return _MoreLikeThisEventStream(response)-- return self._run_generation(generate)-def _load_generation_context(self, *, app_id: str, account_id: str, conversation_id: str | None = None) -> tuple[App, Account]:diff --git a/api/services/installed_app_generation_service.py b/api/services/installed_app_generation_service.pyindex 8d7bb01aa2c..708e777ee9c 100644--- a/api/services/installed_app_generation_service.py+++ b/api/services/installed_app_generation_service.py@@ -45,15 +45,6 @@ class InstalledAppGenerationRuntime(Protocol):streaming: bool,) -> GenerationResponse: ...- def generate_more_like_this(- self,- *,- app_id: str,- account_id: str,- message_id: str,- streaming: bool,- ) -> GenerationResponse: ...-class InstalledAppGenerationService:def __init__(@@ -86,25 +77,6 @@ class InstalledAppGenerationService:return self._generate(installed_app=installed_app, account_id=account_id, args=args, streaming=True)- def generate_more_like_this(- self,- *,- installed_app: InstalledAppRef,- account_id: str,- message_id: str,- streaming: bool,- ) -> GenerationResponse:- if installed_app.app_mode != "completion":- raise InstalledAppNotCompletionError(f"App {installed_app.app_id} is not a completion app")-- # Regenerating an earlier message does not record installation usage.- return self._runtime.generate_more_like_this(- app_id=installed_app.app_id,- account_id=account_id,- message_id=message_id,- streaming=streaming,- )-def generate_workflow(self, *, installed_app: InstalledAppRef, account_id: str, args: Mapping[str, object]) -> GenerationResponse:diff --git a/api/services/message_more_like_this_generator.py b/api/services/message_more_like_this_generator.pynew file mode 100644index 00000000000..b55092b50d9--- /dev/null+++ b/api/services/message_more_like_this_generator.py@@ -0,0 +1,173 @@+"""Prepare detached completion history and execute it through the shared completion runtime.++Only the existing model/file infrastructure needs an isolated Flask scope. Source+reads finish before entering this scope, and record writes finish before the+completion worker starts. The worker retains its existing internal I/O owners.+"""++from collections.abc import Iterator, Mapping+from typing import Any, cast+from uuid import uuid4++from flask import current_app+from pydantic import JsonValue+from sqlalchemy.orm import Session, sessionmaker++from core.app.app_config.easy_ui_based_app.model_config.converter import ModelConfigConverter+from core.app.app_config.entities import EasyUIBasedAppModelConfigFrom+from core.app.app_config.features.file_upload.manager import FileUploadConfigManager+from core.app.apps.completion.app_config_manager import CompletionAppConfigManager+from core.app.apps.completion.app_generator import CompletionAppGenerator+from core.app.entities.app_invoke_entities import CompletionAppGenerateEntity, InvokeFrom, UserFrom+from core.app.file_access import DatabaseFileAccessController, FileAccessScope, bind_file_access_scope+from extensions.ext_database import db+from factories import file_factory+from graphon.file import FileTransferMethod+from graphon.file.constants import FILE_MODEL_IDENTITY+from libs.orjson import orjson_dumps+from libs.stream import close_stream+from models.model import AppMode, AppModelConfigDict+from models.utils.file_input_compat import build_file_from_stored_mapping+from services.entities.message_entities import MessageAccount, MessageActor+from services.message_more_like_this_service import (+ MoreLikeThisFile,+ MoreLikeThisResponse,+ MoreLikeThisSource,+)+++class _MoreLikeThisEventStream:+ """Encode completion events and own the source even before the first iteration."""++ def __init__(self, source: Iterator[Mapping[str, object] | str]) -> None:+ self._source = source+ self._closed = False++ def __iter__(self) -> "_MoreLikeThisEventStream":+ return self++ def __next__(self) -> str:+ if self._closed:+ raise StopIteration+ try:+ event = next(self._source)+ if isinstance(event, Mapping):+ return f"data: {orjson_dumps(event)}\n\n"+ return f"event: {event}\n\n"+ except BaseException:+ self.close()+ raise++ def close(self) -> None:+ if not self._closed:+ self._closed = True+ close_stream(self._source)+++class MessageMoreLikeThisGenerator:+ def __init__(self, *, session_factory: sessionmaker[Session]) -> None:+ self._session_factory = session_factory+ self._file_access_controller = DatabaseFileAccessController()++ def generate(+ self,+ *,+ source: MoreLikeThisSource,+ actor: MessageActor,+ model_config: dict[str, JsonValue],+ streaming: bool,+ ) -> MoreLikeThisResponse:+ assert source.historical_model_config_id is not None+ account = isinstance(actor, MessageAccount)+ user_id = actor.account_id if isinstance(actor, MessageAccount) else actor.end_user_id+ invoke_from = InvokeFrom.EXPLORE if account else InvokeFrom.WEB_APP+ scope = FileAccessScope(+ tenant_id=source.tenant_id,+ user_id=user_id,+ user_from=UserFrom.ACCOUNT if account else UserFrom.END_USER,+ invoke_from=invoke_from,+ )+ # Credential resolution can commit its scoped session. Isolate it from+ # pending work in the caller; this scope also cleans up preparation errors.+ with current_app.app_context(), bind_file_access_scope(scope):+ config_dict = cast(AppModelConfigDict, model_config)+ file_config = FileUploadConfigManager.convert(config_dict)+ files = (+ file_factory.build_from_mappings(+ mappings=[_file_mapping(file) for file in source.files],+ tenant_id=source.tenant_id,+ config=file_config,+ access_controller=self._file_access_controller,+ )+ if file_config is not None+ else []+ )+ app_config = CompletionAppConfigManager.get_app_config_from_dict(+ tenant_id=source.tenant_id,+ app_id=source.app_id,+ app_model_config_id=source.historical_model_config_id,+ app_mode=AppMode.COMPLETION,+ config_dict=config_dict,+ config_from=EasyUIBasedAppModelConfigFrom.ARGS,+ )+ db.session.remove()+ model = ModelConfigConverter.convert(app_config)+ db.session.remove()+ inputs = _restore_inputs(source.inputs, tenant_id=source.tenant_id)+ db.session.remove()+ entity = CompletionAppGenerateEntity(+ task_id=str(uuid4()),+ app_config=app_config,+ model_conf=model,+ inputs=inputs,+ query=source.query,+ files=list(files),+ user_id=user_id,+ stream=streaming,+ invoke_from=invoke_from,+ extras={},+ )+ response = CompletionAppGenerator().generate_from_entity(entity, session_factory=self._session_factory)+ return response if isinstance(response, Mapping) else _MoreLikeThisEventStream(response)+++def _file_mapping(file: MoreLikeThisFile) -> dict[str, object]:+ mapping: dict[str, object] = {+ "id": file.id,+ "type": file.type,+ "transfer_method": file.transfer_method,+ "url": file.url,+ "upload_file_id": file.upload_file_id,+ }+ if file.transfer_method == FileTransferMethod.TOOL_FILE:+ # Recover old tool references without rewriting historical message rows.+ tool_file_id = file.upload_file_id+ if tool_file_id is None:+ if file.url is None:+ raise ValueError(f"MessageFile {file.id} has no tool file reference")+ tool_file_id = file.url.split("/")[-1].split(".")[0]+ mapping["tool_file_id"] = tool_file_id+ elif file.transfer_method == FileTransferMethod.LOCAL_FILE and file.upload_file_id is None:+ raise ValueError(f"MessageFile {file.id} is a local file but has no upload_file_id")+ elif file.transfer_method == FileTransferMethod.REMOTE_URL and file.url is None:+ raise ValueError(f"MessageFile {file.id} is a remote url but has no url")+ elif file.transfer_method == FileTransferMethod.DATASOURCE_FILE:+ raise ValueError(f"MessageFile {file.id} has an invalid transfer_method {file.transfer_method}")+ return mapping+++def _restore_inputs(inputs: Mapping[str, JsonValue], *, tenant_id: str) -> dict[str, Any]:+ """Recover stored files without revalidating or normalizing historical inputs."""+ restored: dict[str, Any] = dict(inputs)+ for key, value in inputs.items():+ if isinstance(value, dict) and value.get("dify_model_identity") == FILE_MODEL_IDENTITY:+ restored[key] = build_file_from_stored_mapping(file_mapping=value, tenant_id=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[key] = [+ build_file_from_stored_mapping(file_mapping=item, tenant_id=tenant_id)+ for item in value+ if isinstance(item, dict)+ ]+ return restoreddiff --git a/api/services/message_more_like_this_service.py b/api/services/message_more_like_this_service.pynew file mode 100644index 00000000000..7a572c70a27--- /dev/null+++ b/api/services/message_more_like_this_service.py@@ -0,0 +1,164 @@+"""Regenerate an owned completion using its historical configuration.++HTTP callers admit the app and actor. This service checks the current feature+setting before loading the historical model configuration, then releases all+query sessions before the generator restores files or resolves a model.+"""++import json+from collections.abc import Iterator, Mapping+from copy import deepcopy+from dataclasses import dataclass+from typing import Protocol++from pydantic import JsonValue++from services.entities.message_entities import MessageActor+from services.errors.app import MoreLikeThisDisabledError+from services.errors.app_model_config import AppModelConfigBrokenError+++@dataclass(frozen=True, slots=True)+class MoreLikeThisFile:+ """Persisted attachment reference, without metadata or content I/O.++ ``url`` is absent for local uploads; ``upload_file_id`` is absent for remote+ URLs and some historical tool files whose identifier is encoded in the URL.+ """++ id: str+ type: str+ transfer_method: str+ url: str | None+ upload_file_id: str | None+++@dataclass(frozen=True, slots=True)+class MoreLikeThisSource:+ """Authorized source data detached from its database session.++ A null current feature configuration means the feature is disabled. A null+ historical model configuration id means the original configuration is no+ longer available, including when its conversation is missing or out of scope.+ """++ app_id: str+ tenant_id: str+ query: str+ inputs: dict[str, JsonValue]+ files: tuple[MoreLikeThisFile, ...]+ current_feature_config: str | None+ historical_model_config_id: str | None+++class MoreLikeThisNotCompletionError(ValueError):+ """The current app mode cannot regenerate a completion."""+++class MoreLikeThisConfigNotFoundError(LookupError):+ """The source message's historical model configuration is unavailable."""+++class MoreLikeThisStream(Protocol):+ def __iter__(self) -> Iterator[str]: ...++ def __next__(self) -> str: ...++ def close(self) -> None: ...+++type MoreLikeThisResponse = Mapping[str, object] | MoreLikeThisStream+++class MoreLikeThisRepository(Protocol):+ def get_more_like_this_source(+ self,+ *,+ app_id: str,+ app_owner_tenant_id: str,+ actor: MessageActor,+ message_id: str,+ ) -> MoreLikeThisSource: ...++ def get_more_like_this_model_config(+ self, *, app_id: str, app_owner_tenant_id: str, model_config_id: str+ ) -> dict[str, JsonValue] | None:+ """Return the app-owned historical configuration, or None when unavailable."""+ ...+++class MoreLikeThisGenerator(Protocol):+ def generate(+ self,+ *,+ source: MoreLikeThisSource,+ actor: MessageActor,+ model_config: dict[str, JsonValue],+ streaming: bool,+ ) -> MoreLikeThisResponse: ...+++class MessageMoreLikeThisService:+ def __init__(self, *, repository: MoreLikeThisRepository, generator: MoreLikeThisGenerator) -> None:+ self._repository: MoreLikeThisRepository = repository+ self._generator: MoreLikeThisGenerator = generator++ def generate(+ self,+ *,+ app_id: str,+ app_owner_tenant_id: str,+ actor: MessageActor,+ message_id: str,+ streaming: bool,+ ) -> MoreLikeThisResponse:+ source = self._repository.get_more_like_this_source(+ app_id=app_id,+ app_owner_tenant_id=app_owner_tenant_id,+ actor=actor,+ message_id=message_id,+ )+ feature = source.current_feature_config+ if not feature:+ raise MoreLikeThisDisabledError()+ try:+ feature_config: JsonValue = json.loads(feature)+ except json.JSONDecodeError as error:+ raise AppModelConfigBrokenError(+ f"App {app_id}, message {message_id}: current more_like_this configuration is not valid JSON"+ ) from error+ if not isinstance(feature_config, dict):+ raise AppModelConfigBrokenError(+ f"App {app_id}, message {message_id}: current more_like_this configuration must be an object"+ )+ if feature_config.get("enabled", False) is False:+ raise MoreLikeThisDisabledError()++ if source.historical_model_config_id is None:+ raise MoreLikeThisConfigNotFoundError(f"Historical model configuration for message {message_id} is missing")+ model_config = self._repository.get_more_like_this_model_config(+ app_id=source.app_id,+ app_owner_tenant_id=source.tenant_id,+ model_config_id=source.historical_model_config_id,+ )+ if model_config is None:+ raise MoreLikeThisConfigNotFoundError(f"Historical model configuration for message {message_id} is missing")++ # Regeneration changes only sampling temperature, keeping the historical+ # model, prompt and inputs independent of the app's current configuration.+ model_config = deepcopy(model_config)+ model = model_config.get("model")+ if not isinstance(model, dict) or not model:+ raise AppModelConfigBrokenError(+ f"App {app_id}, message {message_id}, configuration {source.historical_model_config_id}: "+ "historical configuration must contain a model object"+ )+ parameters = model.get("completion_params", {})+ if not isinstance(parameters, dict):+ raise AppModelConfigBrokenError(+ f"App {app_id}, message {message_id}, configuration {source.historical_model_config_id}: "+ "historical model.completion_params must be an object"+ )+ parameters["temperature"] = 0.9+ model["completion_params"] = parameters+ return self._generator.generate(source=source, actor=actor, model_config=model_config, streaming=streaming)diff --git a/api/services/message_suggested_questions_queries.py b/api/services/message_suggested_questions_queries.pyindex 310e409b043..8370e484754 100644--- a/api/services/message_suggested_questions_queries.py+++ b/api/services/message_suggested_questions_queries.py@@ -1,10 +1,11 @@"""Select message configuration using the existing Agent and Workflow policy owners.-Each operation owns a short read session. Only scalar configuration or detached-history leaves this module; model resolution and attachment I/O happen afterwards.+Configuration preparation owns a short read session; history reads delegate+session ownership to the repository. Only scalar configuration or detached history+leaves this module; model resolution and attachment I/O happen afterwards."""-from collections.abc import Callable, Mapping+from collections.abc import Mappingfrom copy import deepcopyfrom types import MappingProxyType@@ -31,23 +32,21 @@ from services.workflow_service import WorkflowServiceclass SuggestedQuestionsQuery:"""Coordinate repository reads with the existing ORM-based config readers.- This query owns each short session because AgentRuntimeConfigService,+ Only prepare owns a short session because AgentRuntimeConfigService,WorkflowService and conversation config helpers still need a caller session.- The composition root supplies repository_factory to select the repository;- it borrows that same session rather than opening another one.-- TODO: Move session ownership into repositories once those config readers- expose detached results, keeping their configuration policies in services.+ The shared MessageRepository borrows that session for configuration reads+ and owns the separate history session. Its module docstring describes when+ the remaining caller-session parameters can be removed."""def __init__(self,*,session_factory: sessionmaker[Session],- repository_factory: Callable[[Session], MessageRepository],+ repository: MessageRepository,) -> None:self._session_factory: sessionmaker[Session] = session_factory- self._repository_factory: Callable[[Session], MessageRepository] = repository_factory+ self._repository: MessageRepository = repositorydef prepare(self,@@ -60,8 +59,8 @@ class SuggestedQuestionsQuery:message_id: str,) -> SuggestedQuestionsContext | None:with self._session_factory(expire_on_commit=False) as session:- repository = self._repository_factory(session)- records = repository.get_context(+ records = self._repository.get_suggested_questions_context(+ session=session,app_id=app_id,app_owner_tenant_id=app_owner_tenant_id,expected_app_mode=expected_app_mode,@@ -69,7 +68,7 @@ class SuggestedQuestionsQuery:message_id=message_id,)config = self._configuration(- session=session, repository=repository, records=records, actor=actor, invoke_from=invoke_from+ session=session, repository=self._repository, records=records, actor=actor, invoke_from=invoke_from)if config is None:return None@@ -119,7 +118,9 @@ class SuggestedQuestionsQuery:account_id=actor.account_id if isinstance(actor, MessageAccount) else None,use_debug_draft=invoke_from == "debugger",)- model_config = repository.get_model_config(app_id=app.id, config_id=app.app_model_config_id)+ model_config = repository.get_model_config(+ session=session, app_id=app.id, config_id=app.app_model_config_id+ )annotation_reply = load_annotation_reply_config(session, app.id) if model_config else Nonefeatures = merge_agent_app_features(agent_soul=soul or AgentSoulConfig(),@@ -134,11 +135,12 @@ class SuggestedQuestionsQuery:conversation.model_config_with_session(session=session))else:- model_config = repository.get_model_config(app_id=app.id, config_id=conversation.app_model_config_id)+ model_config = repository.get_model_config(+ session=session, app_id=app.id, config_id=conversation.app_model_config_id+ )if model_config is None:raise ValueError("did not find app model config")return model_config.suggested_questions_after_answer_dictdef load_history(self, context: SuggestedQuestionsContext) -> PreparedHistory:- with self._session_factory(expire_on_commit=False) as session:- return self._repository_factory(session).load_history(context=context)+ return self._repository.load_suggested_questions_history(context=context)diff --git a/api/tests/e2e_tests/containers/services/test_app_generate_service.py b/api/tests/e2e_tests/containers/services/test_app_generate_service.pyindex 9c39c8cb1bd..ccb7e0658a1 100644--- a/api/tests/e2e_tests/containers/services/test_app_generate_service.py+++ b/api/tests/e2e_tests/containers/services/test_app_generate_service.py@@ -84,7 +84,6 @@ class TestAppGenerateService:# Setup default mock returns for app generatorsmock_completion_generator_instance = mock_completion_generator.return_valuemock_completion_generator_instance.generate.return_value = ["completion_response"]- mock_completion_generator_instance.generate_more_like_this.return_value = ["more_like_this_response"]mock_completion_generator.convert_to_event_stream.return_value = ["completion_stream"]mock_chat_generator_instance = mock_chat_generator.return_value@@ -904,77 +903,6 @@ class TestAppGenerateService:# Verify error messageassert "Invalid app mode" in str(exc_info.value)- def test_generate_more_like_this_success(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test successful more like this generation.- """- fake = Faker()- app, account = self._create_test_app_and_account(- db_session_with_containers, mock_external_service_dependencies, mode="completion"- )-- message_id = fake.uuid4()-- # Execute the method under test- result = AppGenerateService.generate_more_like_this(- session=db_session_with_containers,- app_model=app,- user=account,- message_id=message_id,- invoke_from=InvokeFrom.SERVICE_API,- streaming=True,- )-- # Verify the result- assert result == ["more_like_this_response"]-- # Verify completion generator was called- mock_external_service_dependencies[- "completion_generator"- ].return_value.generate_more_like_this.assert_called_once()-- def test_generate_more_like_this_with_end_user(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test more like this generation with EndUser.- """- fake = Faker()- app, account = self._create_test_app_and_account(- db_session_with_containers, mock_external_service_dependencies, mode="completion"- )-- # Create end user- end_user = EndUser(- tenant_id=account.current_tenant.id,- app_id=app.id,- type=EndUserType.BROWSER,- external_user_id=fake.uuid4(),- name=fake.name(),- _is_anonymous=False,- session_id=fake.uuid4(),- )-- db_session_with_containers.add(end_user)- db_session_with_containers.commit()-- message_id = fake.uuid4()-- # Execute the method under test- result = AppGenerateService.generate_more_like_this(- session=db_session_with_containers,- app_model=app,- user=end_user,- message_id=message_id,- invoke_from=InvokeFrom.SERVICE_API,- streaming=True,- )-- # Verify the result- assert result == ["more_like_this_response"]-def test_get_max_active_requests_with_app_limit(self, db_session_with_containers: Session, mock_external_service_dependencies):diff --git a/api/tests/e2e_tests/containers/services/test_message_more_like_this_generator.py b/api/tests/e2e_tests/containers/services/test_message_more_like_this_generator.pynew file mode 100644index 00000000000..15b45ca5d5a--- /dev/null+++ b/api/tests/e2e_tests/containers/services/test_message_more_like_this_generator.py@@ -0,0 +1,502 @@+"""Regeneration through real HTTP, worker, persistence, Redis and plugin transport.++Cached provider declarations/credentials/schema are real data, not replacement+methods. Keyword moderation supplies a real successful completion without an+external LLM. Missing installation and credentials exercise actual failures.+"""++import json+import threading+from base64 import b64decode+from dataclasses import dataclass+from decimal import Decimal+from http import HTTPStatus+from pathlib import Path+from uuid import uuid4++import httpx+import pytest+from flask.testing import FlaskClient+from sqlalchemy import Connection, delete, event, func, select+from sqlalchemy.orm import Session, SessionTransaction, UOWTransaction+from yarl import URL++from configs import dify_config+from constants import HEADER_NAME_APP_CODE, HEADER_NAME_PASSPORT+from core.helper.model_provider_cache import ProviderCredentialsCache, ProviderCredentialsCacheType+from core.plugin.entities.plugin_daemon import PluginModelProviderDeclaration+from core.plugin.impl import base as plugin_base+from core.plugin.impl.model_runtime_factory import create_plugin_model_runtime+from core.plugin.plugin_service import PluginService+from core.workflow.file_reference import resolve_file_record_id+from extensions.ext_database import db+from extensions.ext_redis import redis_client+from extensions.ext_storage import storage+from extensions.storage.opendal_storage import OpenDALStorage+from extensions.storage.storage_type import StorageType+from graphon.file import FileTransferMethod, FileType+from graphon.file.constants import FILE_MODEL_IDENTITY+from graphon.model_runtime.entities.common_entities import I18nObject+from graphon.model_runtime.entities.model_entities import AIModelEntity, FetchFrom, ModelType+from graphon.model_runtime.entities.provider_entities import ConfigurateMethod+from libs.datetime_utils import naive_utc_now+from libs.passport import PassportService+from models.account import Account+from models.enums import ConversationFromSource, CreatorUserRole, CustomizeTokenStrategy, EndUserType, MessageStatus+from models.model import (+ AppMode,+ AppModelConfig,+ Conversation,+ EndUser,+ InstalledApp,+ Message,+ MessageFile,+ Site,+ UploadFile,+)+from models.provider import Provider+from models.tools import ToolFile+from tests.e2e_tests.containers.controllers.console.helpers import (+ authenticate_console_client,+ create_console_account_and_tenant,+ create_console_app,+)++_PROVIDER = "tests/regeneration/regeneration"+_MODEL = "completion-model"+_ANSWER = "Moderated response"+++@dataclass(frozen=True)+class _Scenario:+ account: Account+ tenant_id: str+ app_id: str+ message_id: str+ historical_config_id: str+ actor_id: str+ actor_role: CreatorUserRole+ url: str+ headers: dict[str, str]+ provider_id: str++[email protected](params=["web", "explore"])+def scenario(+ request: pytest.FixtureRequest,+ db_session_with_containers: Session,+ test_client_with_containers: FlaskClient,+ monkeypatch: pytest.MonkeyPatch,+) -> _Scenario:+ monkeypatch.setattr(dify_config, "PLUGIN_MODEL_PROVIDERS_CACHE_ENABLED", True)+ monkeypatch.setattr(dify_config, "PLUGIN_BASED_TOKEN_COUNTING_ENABLED", False)+ monkeypatch.setattr(plugin_base, "plugin_daemon_inner_api_baseurl", URL(str(dify_config.PLUGIN_DAEMON_URL)))+ session = db_session_with_containers+ account, tenant = create_console_account_and_tenant(session)+ app = create_console_app(session, tenant.id, account.id, AppMode.COMPLETION)+ end_user = EndUser(tenant_id=tenant.id, app_id=app.id, type=EndUserType.BROWSER, session_id=str(uuid4()))+ site = Site(+ app_id=app.id,+ title="Completion",+ default_language="en-US",+ customize_token_strategy=CustomizeTokenStrategy.UUID,+ code=str(uuid4()),+ )+ installation = InstalledApp(tenant_id=tenant.id, app_id=app.id, app_owner_tenant_id=tenant.id)+ current = AppModelConfig(app_id=app.id, more_like_this='{"enabled":true}', pre_prompt="Current prompt")+ historical = AppModelConfig(+ app_id=app.id,+ more_like_this='{"enabled":false}',+ model=json.dumps(+ {"provider": _PROVIDER, "name": _MODEL, "mode": "chat", "completion_params": {"temperature": 0.1}}+ ),+ pre_prompt="Historical prompt",+ sensitive_word_avoidance=json.dumps(+ {+ "enabled": True,+ "type": "keywords",+ "config": {+ "keywords": "Original query",+ "inputs_config": {"enabled": True, "preset_response": _ANSWER},+ "outputs_config": {"enabled": False, "preset_response": ""},+ },+ }+ ),+ )+ session.add_all([end_user, site, installation, current, historical])+ session.flush()+ app.app_model_config_id = current.id+ console = request.param == "explore"+ actor_id = account.id if console else end_user.id+ conversation = Conversation(+ app_id=app.id,+ app_model_config_id=historical.id,+ mode=AppMode.COMPLETION,+ name="Original",+ _inputs={},+ from_source=ConversationFromSource.CONSOLE if console else ConversationFromSource.API,+ from_account_id=account.id if console else None,+ from_end_user_id=None if console else end_user.id,+ )+ session.add(conversation)+ session.flush()+ message = Message(+ app_id=app.id,+ conversation_id=conversation.id,+ _inputs={"count": 0, "empty": "", "items": [], "optional": None},+ query="Original query",+ message={},+ answer="Original answer",+ message_unit_price=Decimal(0),+ answer_unit_price=Decimal(0),+ currency="USD",+ from_source=conversation.from_source,+ from_account_id=conversation.from_account_id,+ from_end_user_id=conversation.from_end_user_id,+ )+ provider = Provider(tenant_id=tenant.id, provider_name=_PROVIDER, is_valid=True)+ session.add_all([message, provider])+ session.commit()+ schema = AIModelEntity(+ model=_MODEL,+ label=I18nObject(en_US="Completion"),+ model_type=ModelType.LLM,+ fetch_from=FetchFrom.PREDEFINED_MODEL,+ model_properties={},+ parameter_rules=[],+ )+ declaration = PluginModelProviderDeclaration(+ provider=_PROVIDER,+ plugin_unique_identifier="tests/regeneration:0.0.1@" + "0" * 64,+ installation_source=None,+ label=I18nObject(en_US="Regeneration"),+ supported_model_types=[ModelType.LLM],+ configurate_methods=[ConfigurateMethod.PREDEFINED_MODEL],+ models=[schema],+ )+ PluginService._store_cached_plugin_model_providers(tenant.id, 0, [declaration])+ credentials = {"api_key": "unused-test-key"}+ ProviderCredentialsCache(tenant.id, provider.id, ProviderCredentialsCacheType.PROVIDER).set(credentials)+ redis_client.setex(f"tenant:{tenant.id}:model_load_balancing_enabled", 60, "False")+ runtime = create_plugin_model_runtime(tenant_id=tenant.id)+ runtime.bind_provider_schema(declaration)+ redis_client.setex(+ runtime._get_schema_cache_key(+ provider=_PROVIDER, model_type=ModelType.LLM, model=_MODEL, credentials=credentials+ ),+ 60,+ schema.model_dump_json(),+ )+ if console:+ headers = authenticate_console_client(test_client_with_containers, account)+ url = f"/console/api/installed-apps/{installation.id}/messages/{message.id}/more-like-this"+ else:+ assert site.code is not None+ headers = {+ HEADER_NAME_APP_CODE: site.code,+ HEADER_NAME_PASSPORT: PassportService().issue(+ {"app_code": site.code, "app_id": app.id, "end_user_id": end_user.id}+ ),+ }+ url = f"/api/messages/{message.id}/more-like-this"+ result = _Scenario(+ account,+ tenant.id,+ app.id,+ message.id,+ historical.id,+ actor_id,+ CreatorUserRole.ACCOUNT if console else CreatorUserRole.END_USER,+ url,+ headers,+ provider.id,+ )+ db.session.remove()+ return result++[email protected]("streaming", [False, True])[email protected]("include_parameters", [False, True])+def test_moderated_completion_preserves_history_and_releases_writes_before_worker_reads(+ scenario: _Scenario, test_client_with_containers: FlaskClient, streaming: bool, include_parameters: bool+) -> None:+ with Session(db.engine) as session:+ historical = session.get(AppModelConfig, scenario.historical_config_id)+ assert historical is not None+ model = historical.model_dict+ if not include_parameters:+ model.pop("completion_params")+ historical.model = json.dumps(model)+ session.commit()+ original_model = historical.model+ writes: list[Session] = []+ worker_checks: list[bool] = []+ main_thread = threading.get_ident()+ requests: list[httpx.Request] = []++ def observe_flush(session: Session, _context: UOWTransaction) -> None:+ if any(isinstance(item, Message) and item.app_id == scenario.app_id for item in session.new):+ writes.append(session)++ def observe_query(_session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:+ if threading.get_ident() != main_thread:+ worker_checks.append(+ bool(writes) and all(not writer.in_transaction() and not writer.identity_map for writer in writes)+ )++ event.listen(Session, "after_flush", observe_flush)+ event.listen(Session, "after_begin", observe_query)+ hooks = plugin_base._httpx_client.event_hooks["request"]+ hooks.append(requests.append)+ try:+ response = test_client_with_containers.get(+ scenario.url,+ query_string={"response_mode": "streaming" if streaming else "blocking"},+ headers=scenario.headers,+ )+ assert response.status_code == HTTPStatus.OK+ if streaming:+ assert response.mimetype == "text/event-stream"+ events = [+ json.loads(line[6:])+ for line in response.get_data(as_text=True).splitlines()+ if line.startswith("data: ")+ ]+ assert "".join(item.get("answer", "") for item in events if item["event"] == "message") == _ANSWER+ assert events[-1]["event"] == "message_end"+ message_id = events[-1]["message_id"]+ else:+ payload = response.get_json()+ assert isinstance(payload, dict)+ assert payload["answer"] == _ANSWER+ message_id = payload["message_id"]+ response.close()+ finally:+ hooks.remove(requests.append)+ event.remove(Session, "after_flush", observe_flush)+ event.remove(Session, "after_begin", observe_query)+ assert not requests+ assert worker_checks+ assert all(worker_checks)+ assert len(writes) == 1+ with Session(db.engine) as session:+ regenerated = session.get(Message, message_id)+ original = session.get(Message, scenario.message_id)+ historical = session.get(AppModelConfig, scenario.historical_config_id)+ assert regenerated is not None+ assert original is not None+ assert historical is not None+ assert regenerated.id != original.id+ assert regenerated.conversation_id != original.conversation_id+ assert regenerated.query == original.query+ assert regenerated._inputs == {"count": 0, "empty": "", "items": [], "optional": None}+ assert regenerated.from_account_id == original.from_account_id+ assert regenerated.from_end_user_id == original.from_end_user_id+ assert regenerated.answer == _ANSWER+ assert regenerated.override_model_configs is not None+ config = json.loads(regenerated.override_model_configs)+ assert config["pre_prompt"] == "Historical prompt"+ assert config["model"]["completion_params"] == {"temperature": 0.9}+ assert historical.model == original_model+ assert session.scalar(select(func.count()).select_from(Message)) == 2+ installation = session.scalar(select(InstalledApp).where(InstalledApp.app_id == scenario.app_id))+ assert installation is not None+ assert installation.last_used_at is None++[email protected]("transfer_method", [FileTransferMethod.LOCAL_FILE, FileTransferMethod.TOOL_FILE])+def test_moderated_completion_rebuilds_files_and_inputs_without_rewriting_history(+ scenario: _Scenario,+ test_client_with_containers: FlaskClient,+ transfer_method: FileTransferMethod,+ tmp_path: Path,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ monkeypatch.setattr(dify_config, "MULTIMODAL_SEND_FORMAT", "base64")+ backend = OpenDALStorage(scheme="fs", root=str(tmp_path))+ monkeypatch.setattr(storage, "storage_runner", backend)+ image = b64decode("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+xU5sAAAAASUVORK5CYII=")+ backend.save("stored/image.png", image)+ with Session(db.engine) as session:+ config = session.get(AppModelConfig, scenario.historical_config_id)+ original = session.get(Message, scenario.message_id)+ assert config is not None+ assert original is not None+ config.file_upload = json.dumps(+ {+ "enabled": True,+ "allowed_file_types": ["image"],+ "allowed_file_upload_methods": ["local_file", "tool_file"],+ "number_limits": 2,+ }+ )+ if transfer_method == FileTransferMethod.LOCAL_FILE:+ file = UploadFile(+ tenant_id=scenario.tenant_id,+ storage_type=StorageType.LOCAL,+ key="stored/image.png",+ name="image.png",+ size=len(image),+ extension="png",+ mime_type="image/png",+ created_by_role=scenario.actor_role,+ created_by=scenario.actor_id,+ created_at=naive_utc_now(),+ used=True,+ )+ else:+ file = ToolFile(+ user_id=scenario.actor_id,+ tenant_id=scenario.tenant_id,+ conversation_id=None,+ file_key="stored/image.png",+ mimetype="image/png",+ original_url="https://example.com/image.png",+ name="image.png",+ size=len(image),+ )+ session.add(file)+ session.flush()+ record_id = file.id+ attachment = MessageFile(+ message_id=original.id,+ type=FileType.IMAGE,+ transfer_method=transfer_method,+ url=f"https://example.com/tools/{record_id}.png"+ if transfer_method == FileTransferMethod.TOOL_FILE+ else None,+ upload_file_id=record_id if transfer_method == FileTransferMethod.LOCAL_FILE else None,+ created_by_role=scenario.actor_role,+ created_by=scenario.actor_id,+ )+ session.add(attachment)+ stored_input = {+ "dify_model_identity": FILE_MODEL_IDENTITY,+ "type": "image",+ "transfer_method": transfer_method,+ "related_id": record_id,+ "tenant_id": str(uuid4()),+ "filename": "untrusted.png",+ }+ original.inputs = {"file": stored_input}+ session.commit()+ attachment_id = attachment.id+ response = test_client_with_containers.get(+ scenario.url, query_string={"response_mode": "blocking"}, headers=scenario.headers+ )+ assert response.status_code == HTTPStatus.OK+ payload = response.get_json()+ assert isinstance(payload, dict)+ assert payload["answer"] == _ANSWER+ with Session(db.engine) as session:+ generated = session.get(Message, payload["message_id"])+ original = session.get(Message, scenario.message_id)+ saved_attachment = session.get(MessageFile, attachment_id)+ new_attachment = session.scalar(select(MessageFile).where(MessageFile.message_id == payload["message_id"]))+ assert generated is not None+ assert original is not None+ assert saved_attachment is not None+ assert new_attachment is not None+ assert generated._inputs["file"]["filename"] == "image.png"+ assert resolve_file_record_id(generated._inputs["file"]["reference"]) == record_id+ assert original._inputs == {"file": stored_input}+ assert new_attachment.upload_file_id == record_id+ assert new_attachment.created_by == scenario.actor_id+ assert saved_attachment.upload_file_id == (+ record_id if transfer_method == FileTransferMethod.LOCAL_FILE else None+ )+++def test_real_missing_credentials_returns_http_error_without_creating_records(+ scenario: _Scenario,+ test_client_with_containers: FlaskClient,+) -> None:+ with Session(db.engine) as session:+ session.execute(delete(Provider).where(Provider.id == scenario.provider_id))+ session.commit()+ response = test_client_with_containers.get(+ scenario.url, query_string={"response_mode": "blocking"}, headers=scenario.headers+ )+ assert response.status_code == HTTPStatus.BAD_REQUEST+ payload = response.get_json()+ assert isinstance(payload, dict)+ assert payload["code"] == "provider_not_initialize"+ with Session(db.engine) as session:+ assert session.scalar(select(func.count()).select_from(Message)) == 1++[email protected]("streaming", [False, True])[email protected]("failure", ["missing_plugin", "invalid_transport"])+def test_real_provider_failure_persists_worker_error_and_preserves_http_or_sse_contract(+ scenario: _Scenario,+ test_client_with_containers: FlaskClient,+ streaming: bool,+ failure: str,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ if failure == "invalid_transport":+ monkeypatch.setattr(plugin_base, "plugin_daemon_inner_api_baseurl", URL("unsupported://plugin-daemon"))+ # PluginModelClient converts both missing-plugin (-404) and transport (-500)+ # PluginDaemonInnerError failures to ValueError, yielding invalid_param.+ expected_error = "-404" if failure == "missing_plugin" else "Request to Plugin Daemon Service failed-500"+ with Session(db.engine) as session:+ config = session.get(AppModelConfig, scenario.historical_config_id)+ assert config is not None+ config.sensitive_word_avoidance = '{"enabled":false}'+ session.commit()+ requests: list[httpx.Request] = []+ source_sessions: list[Session] = []+ active_source_sessions: list[Session] = []+ main_thread = threading.get_ident()++ def observe_session(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:+ if threading.get_ident() == main_thread:+ source_sessions.append(session)++ def observe_request(request: httpx.Request) -> None:+ requests.append(request)+ active_source_sessions.extend(session for session in source_sessions if session.in_transaction())++ event.listen(Session, "after_begin", observe_session)+ hooks = plugin_base._httpx_client.event_hooks["request"]+ hooks.append(observe_request)+ try:+ response = test_client_with_containers.get(+ scenario.url,+ query_string={"response_mode": "streaming" if streaming else "blocking"},+ headers=scenario.headers,+ )+ if streaming:+ assert response.status_code == HTTPStatus.OK+ assert response.mimetype == "text/event-stream"+ events = [+ json.loads(line[6:])+ for line in response.get_data(as_text=True).splitlines()+ if line.startswith("data: ")+ ]+ errors = [item for item in events if item["event"] == "error"]+ assert len(errors) == 1+ assert errors[0]["code"] == "invalid_param"+ assert expected_error in errors[0]["message"]+ assert errors[0]["status"] == HTTPStatus.BAD_REQUEST+ else:+ assert response.status_code == HTTPStatus.BAD_REQUEST+ payload = response.get_json()+ assert isinstance(payload, dict)+ assert payload["code"] == "invalid_param"+ assert expected_error in payload["message"]+ response.close()+ finally:+ hooks.remove(observe_request)+ event.remove(Session, "after_begin", observe_session)+ assert source_sessions+ assert not active_source_sessions+ assert any(request.url.path == f"/plugin/{scenario.tenant_id}/dispatch/llm/invoke" for request in requests)+ with Session(db.engine) as session:+ generated = session.scalars(select(Message).where(Message.id != scenario.message_id)).one()+ assert generated.status == MessageStatus.ERROR+ assert generated.error is not None+ assert expected_error in generated.error+ original = session.get(Message, scenario.message_id)+ assert original is not None+ assert original.answer == "Original answer"diff --git a/api/tests/e2e_tests/contracts/controllers/console/app/test_message_suggested_questions.py b/api/tests/e2e_tests/contracts/controllers/console/app/test_message_suggested_questions.pyindex dc2e8c23960..87b21be992e 100644--- a/api/tests/e2e_tests/contracts/controllers/console/app/test_message_suggested_questions.py+++ b/api/tests/e2e_tests/contracts/controllers/console/app/test_message_suggested_questions.py@@ -198,7 +198,9 @@ def harness(flask_app = Flask(__name__)flask_app.config.update(TESTING=True, RESTX_ERROR_404_HELP=False, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))db.init_app(flask_app)- queries = SuggestedQuestionsQuery(session_factory=sqlite_session_factory, repository_factory=MessageRepository)+ queries = SuggestedQuestionsQuery(+ session_factory=sqlite_session_factory, repository=MessageRepository(session_factory=sqlite_session_factory)+ )services = _Services(app_services,_Agents(AgentAppAccessService(references=AgentAppRepository(session_factory=sqlite_session_factory))),diff --git a/api/tests/e2e_tests/contracts/controllers/console/explore/test_message_more_like_this.py b/api/tests/e2e_tests/contracts/controllers/console/explore/test_message_more_like_this.pynew file mode 100644index 00000000000..87f609c9c10--- /dev/null+++ b/api/tests/e2e_tests/contracts/controllers/console/explore/test_message_more_like_this.py@@ -0,0 +1,239 @@+"""More-like-this HTTP failures through real account admission and SQLite services."""++import json+from collections.abc import Iterator+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.explore.message import MessageMoreLikeThisApi+from libs.external_api import ExternalApi+from libs.passport import PassportService+from libs.token import generate_csrf_token+from models.enums import ConversationFromSource+from models.model import App, AppMode, AppModelConfig, Conversation, InstalledApp, 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]:+ """Reuse real console admission while storing separate current and historical config."""+ state = installed_app_harness+ historical = AppModelConfig(+ app_id=state.target.id,+ model=json.dumps({"provider": "langgenius/openai/openai", "name": "old-model", "completion_params": {}}),+ )+ with state.factory.begin() as session:+ session.add(historical)+ session.flush()+ session.execute(update(App).where(App.id == state.target.id).values(mode=AppMode.COMPLETION))+ session.execute(+ update(AppModelConfig)+ .where(AppModelConfig.id == state.target.app_model_config_id)+ .values(more_like_this='{"enabled":true}')+ )+ conversation = session.get(Conversation, state.conversation.id)+ assert conversation is not None+ conversation.mode = AppMode.COMPLETION+ conversation.app_model_config_id = historical.id+ api = ExternalApi(state.app)+ api.add_resource(+ MessageMoreLikeThisApi,+ "/installed-apps/<uuid:installed_app_id>/messages/<uuid:message_id>/more-like-this",+ endpoint="console.more_like_this",+ )+ yield state+ state.assert_closed()+ with state.factory() as session:+ installation = session.get(InstalledApp, state.installation.id)+ if installation is None:+ assert session.get(App, state.target.id) is None+ else:+ assert installation.last_used_at is None+++def _get(+ state: _Harness,+ *,+ installation_id: str | None = None,+ authenticated: bool = True,+ csrf: bool = True,+ query: str = "response_mode=blocking",+) -> 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)+ return client.get(+ f"/installed-apps/{installation_id or state.installation.id}/messages/{state.message.id}"+ f"/more-like-this?{query}",+ headers=headers,+ )+++def _error(response: TestResponse, *, status: int, code: str) -> None:+ assert response.status_code == status+ assert response.headers["Content-Type"] == "application/json"+ assert int(response.headers["Content-Length"]) == len(response.data)+ body = response.get_json()+ assert body["status"] == status+ assert body["code"] == code+ assert isinstance(body["message"], str)+ assert body["message"]++[email protected]("response_mode", ["blocking", "streaming"])+def test_real_provider_resolution_failure_releases_sessions_without_updating_usage(+ harness: _Harness, response_mode: str+) -> None:+ assert harness.target.tenant_id != harness.installation.tenant_id+ response = _get(harness, query=f"response_mode={response_mode}")+ # The persisted invalid owner provider reaches the actual model resolver;+ # provider discovery and generation are never replaced by test methods.+ _error(response, status=400, code="invalid_param")+ assert response.get_json()["message"] == "Invalid plugin id invalid/provider"+ with harness.factory() as session:+ assert session.scalar(select(func.count()).select_from(Message)) == 1+ historical_model = session.scalar(+ select(AppModelConfig.model).where(+ AppModelConfig.id+ == select(Conversation.app_model_config_id)+ .where(Conversation.id == harness.conversation.id)+ .scalar_subquery()+ )+ )+ assert historical_model is not None+ assert json.loads(historical_model)["completion_params"] == {}++[email protected]("missing", ["login", "csrf"])+def test_real_login_and_csrf_are_required(harness: _Harness, missing: str) -> None:+ response = _get(harness, authenticated=missing != "login", csrf=missing != "csrf")+ _error(response, status=401, code="unauthorized")+ assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'++[email protected]("query", ["", "response_mode=invalid"])+def test_invalid_response_mode_uses_shared_validation_error(harness: _Harness, query: str) -> None:+ _error(_get(harness, query=query), status=422, code="unprocessable_entity")++[email protected]("mode", [mode for mode in AppMode if mode != AppMode.COMPLETION])+def test_non_completion_modes_reject_generation(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), status=400, code="not_completion_app")++[email protected]("missing", ["installation", "workspace", "app"])+def test_missing_or_foreign_installation_is_rejected(harness: _Harness, missing: str) -> None:+ installation_id = harness.installation.id+ if missing == "installation":+ installation_id = str(uuid4())+ else:+ with harness.factory.begin() as session:+ if missing == "workspace":+ session.execute(+ update(InstalledApp).where(InstalledApp.id == installation_id).values(tenant_id=str(uuid4()))+ )+ else:+ session.execute(delete(App).where(App.id == harness.target.id))+ _error(_get(harness, installation_id=installation_id), status=404, code="installed_app_not_found")++[email protected]("model", [Message, Conversation])[email protected]("field", ["app_id", "from_account_id", "from_source", "from_end_user_id"])+def test_source_requires_complete_account_ownership(+ harness: _Harness, model: type[Message] | type[Conversation], field: str+) -> None:+ record_id = harness.message.id if model is Message else harness.conversation.id+ value = ConversationFromSource.API if field == "from_source" else str(uuid4())+ with harness.factory.begin() as session:+ session.execute(update(model).where(model.id == record_id).values({field: value}))+ _error(+ _get(harness),+ status=404 if model is Message else 400,+ code="message_not_found" if model is Message else "app_unavailable",+ )++[email protected]("missing", ["message", "conversation", "current-config", "historical-config"])+def test_missing_records_keep_resource_specific_errors(harness: _Harness, missing: str) -> None:+ with harness.factory.begin() as session:+ if missing == "message":+ session.execute(delete(Message).where(Message.id == harness.message.id))+ elif missing == "conversation":+ session.execute(delete(Conversation).where(Conversation.id == harness.conversation.id))+ elif missing == "current-config":+ session.execute(delete(AppModelConfig).where(AppModelConfig.id == harness.target.app_model_config_id))+ else:+ session.execute(+ delete(AppModelConfig).where(+ AppModelConfig.id+ == select(Conversation.app_model_config_id)+ .where(Conversation.id == harness.conversation.id)+ .scalar_subquery()+ )+ )+ status, code = {+ "message": (404, "message_not_found"),+ "conversation": (400, "app_unavailable"),+ "current-config": (403, "app_more_like_this_disabled"),+ "historical-config": (400, "app_unavailable"),+ }[missing]+ _error(_get(harness), status=status, code=code)++[email protected]("feature", [None, "", "{}", '{"enabled":false}'])+def test_current_feature_policy_rejects_disabled_regeneration(harness: _Harness, feature: str | None) -> None:+ """A null or empty persisted feature is the legacy disabled setting."""+ with harness.factory.begin() as session:+ session.execute(+ update(AppModelConfig)+ .where(AppModelConfig.id == harness.target.app_model_config_id)+ .values(more_like_this=feature)+ )+ _error(_get(harness), status=403, code="app_more_like_this_disabled")+++ ("current", "field", "value"),+ [+ (True, "more_like_this", '{"secret":"private-config-value"'),+ (True, "more_like_this", '["private-config-value"]'),+ (False, "model", '{"secret":"private-config-value"'),+ (False, "model", '["private-config-value"]'),+ (False, "model", '{"completion_params":["private-config-value"]}'),+ (False, "model", None),+ ],+ ids=["feature-json", "feature-shape", "model-json", "model-shape", "parameter-shape", "missing-model"],+)+def test_corrupt_persisted_configuration_returns_app_unavailable(+ harness: _Harness, current: bool, field: str, value: str | None+) -> None:+ """None represents a missing model payload in an existing configuration row."""+ with harness.factory.begin() as session:+ config_id = (+ harness.target.app_model_config_id+ if current+ else session.scalar(+ select(Conversation.app_model_config_id).where(Conversation.id == harness.conversation.id)+ )+ )+ session.execute(update(AppModelConfig).where(AppModelConfig.id == config_id).values({field: value}))+ response = _get(harness)+ _error(response, status=400, code="app_unavailable")+ assert response.get_json()["message"] == "App unavailable, please check your app configurations."+ assert b"private-config-value" not in response.datadiff --git a/api/tests/e2e_tests/contracts/controllers/console/explore/test_trial_suggested_questions.py b/api/tests/e2e_tests/contracts/controllers/console/explore/test_trial_suggested_questions.pyindex 534e07c5f69..0c2acd7cd90 100644--- a/api/tests/e2e_tests/contracts/controllers/console/explore/test_trial_suggested_questions.py+++ b/api/tests/e2e_tests/contracts/controllers/console/explore/test_trial_suggested_questions.py@@ -178,7 +178,9 @@ def harness(trial_apps=trial_apps,trial_enabled=True,)- queries = SuggestedQuestionsQuery(session_factory=read_factory, repository_factory=MessageRepository)+ queries = SuggestedQuestionsQuery(+ session_factory=read_factory, repository=MessageRepository(session_factory=read_factory)+ )services = _ApplicationServices(trial_apps=_TrialAppServices(access=TrialAppAccessService(apps=trial_apps)),recommended_app_queries=features,diff --git a/api/tests/e2e_tests/contracts/controllers/service_api/app/test_message_suggested_questions.py b/api/tests/e2e_tests/contracts/controllers/service_api/app/test_message_suggested_questions.pyindex a9c3da13bcd..5d4200326f9 100644--- a/api/tests/e2e_tests/contracts/controllers/service_api/app/test_message_suggested_questions.py+++ b/api/tests/e2e_tests/contracts/controllers/service_api/app/test_message_suggested_questions.py@@ -183,7 +183,9 @@ def harness(event.listen(query_factory, "after_begin", track_query)event.listen(db.session.session_factory, "after_begin", track_scoped)- queries = SuggestedQuestionsQuery(session_factory=query_factory, repository_factory=MessageRepository)+ queries = SuggestedQuestionsQuery(+ session_factory=query_factory, repository=MessageRepository(session_factory=query_factory)+ )service = MessageSuggestedQuestionsService(queries=queries, generator=SuggestedQuestionsGenerator())app.extensions["application_services"] = _Services(app_definitions=AppDefinitionQueryService(diff --git a/api/tests/e2e_tests/contracts/controllers/web/test_message_more_like_this.py b/api/tests/e2e_tests/contracts/controllers/web/test_message_more_like_this.pynew file mode 100644index 00000000000..10bfc9a0cc9--- /dev/null+++ b/api/tests/e2e_tests/contracts/controllers/web/test_message_more_like_this.py@@ -0,0 +1,415 @@+"""Web more-like-this through real JWT, services, generator, and SQLite.++Persisted invalid provider metadata triggers model preparation failure without a+model server. Successful generation belongs to runtime integration coverage.+"""++import json+from collections.abc import Callable, Iterator+from dataclasses import dataclass+from decimal import Decimal+from http import HTTPStatus+from uuid import uuid4++import pytest+from flask import Flask+from redis import Redis+from sqlalchemy import Connection, Engine, delete, event, update+from sqlalchemy.orm import Session, SessionTransaction, sessionmaker+from werkzeug.test import TestResponse++import controllers.web.message as module+from constants import HEADER_NAME_APP_CODE, HEADER_NAME_PASSPORT+from enums import DeploymentEdition+from extensions.ext_application_services import build_application_services+from extensions.ext_database import db+from extensions.ext_redis import RedisClientWrapper+from libs.external_api import ExternalApi+from libs.passport import PassportService+from models.agent import (+ Agent,+ AgentConfigRevision,+ AgentConfigRevisionOperation,+ AgentConfigSnapshot,+ AgentScope,+ AgentSource,+)+from models.agent_config_entities import AgentSoulConfig+from models.enums import ConversationFromSource, CustomizeTokenStrategy+from models.model import App, AppMode, AppModelConfig, Conversation, EndUser, Message, Site+from models.provider import Provider+from models.workflow import Workflow+from tests.helpers.unit.model_factories import make_app, make_conversation, make_end_user, make_message+++@dataclass(frozen=True)+class _Harness:+ app: Flask+ target: App+ end_user: EndUser+ message: Message+ current_config: AppModelConfig+ historical_config: AppModelConfig+ factory: sessionmaker[Session]+ sessions: list[Session]+ query_sessions: list[Session]+ passport: str++ @property+ def headers(self) -> dict[str, str]:+ return {HEADER_NAME_APP_CODE: "more-like-this-app", HEADER_NAME_PASSPORT: self.passport}++ def url(self, *, query: str = "response_mode=blocking") -> str:+ return f"/messages/{self.message.id}/more-like-this?{query}"++ def get(self, *, query: str = "response_mode=blocking") -> TestResponse:+ return self.app.test_client().get(self.url(query=query), headers=self.headers)++ def assert_closed(self, *, caller: Session | None = None) -> None:+ assert self.sessions+ assert all(+ not session.in_transaction() and not session.identity_map+ for session in self.sessions+ if session is not caller+ )+++def harness(+ config_overrides: Callable[..., None],+ sqlite_engine: Engine,+ sqlite_session_factory: sessionmaker[Session],+) -> Iterator[_Harness]:+ config_overrides(+ DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY, SECRET_KEY="more-like-this-http-test-key-at-least-32-bytes"+ )+ target = make_app(app_id=str(uuid4()), tenant_id=str(uuid4()), mode=AppMode.COMPLETION)+ end_user = make_end_user(end_user_id=str(uuid4()), tenant_id=target.tenant_id, app_id=target.id)+ current_config = AppModelConfig(app_id=target.id, more_like_this='{"enabled":true}', pre_prompt="New prompt")+ historical_config = AppModelConfig(+ app_id=target.id,+ more_like_this='{"enabled":false}',+ pre_prompt="Historical prompt",+ model=json.dumps(+ {+ "provider": "openai",+ "name": "historical-model",+ "mode": "completion",+ "completion_params": {"temperature": 0.2},+ }+ ),+ )+ site = Site(+ app_id=target.id,+ title="Completion app",+ default_language="en-US",+ customize_token_strategy=CustomizeTokenStrategy.UUID,+ code="more-like-this-app",+ )+ conversation = make_conversation(+ conversation_id=str(uuid4()),+ app_id=target.id,+ mode=AppMode.COMPLETION,+ from_source=ConversationFromSource.API,+ from_end_user_id=end_user.id,+ inputs={"topic": "Earlier topic"},+ )+ message = make_message(+ message_id=str(uuid4()),+ app_id=target.id,+ conversation_id=conversation.id,+ inputs={"topic": "Earlier topic"},+ message={},+ query="Original query",+ answer="Original answer",+ message_unit_price=Decimal(0),+ answer_unit_price=Decimal(0),+ currency="USD",+ from_source=ConversationFromSource.API,+ from_end_user_id=end_user.id,+ )+ with sqlite_session_factory.begin() as session:+ # A real stored provider ID fails validation before plugin discovery.+ provider = Provider(tenant_id=target.tenant_id, provider_name="invalid/provider", is_valid=True)+ session.add_all([target, end_user, current_config, historical_config, site, conversation, message, provider])+ session.flush()+ target.app_model_config_id = current_config.id+ conversation.app_model_config_id = historical_config.id++ admission_factory = sqlite_session_factory+ query_factory = sessionmaker(bind=sqlite_engine, expire_on_commit=False)+ sessions: list[Session] = []+ query_sessions: list[Session] = []++ def track(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:+ sessions.append(session)++ def track_query(session: Session, transaction: SessionTransaction, connection: Connection) -> None:+ query_sessions.append(session)+ track(session, transaction, connection)++ event.listen(admission_factory, "after_begin", track)+ event.listen(query_factory, "after_begin", track_query)+ passport = PassportService().issue({"app_code": site.code, "app_id": target.id, "end_user_id": end_user.id})+ app = Flask(__name__)+ app.config.update(TESTING=True, RESTX_ERROR_404_HELP=False, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))+ db.init_app(app)+ event.listen(db.session.session_factory, "after_begin", track)+ redis_client = Redis()+ redis = RedisClientWrapper()+ redis.initialize(redis_client)+ app.extensions["application_services"] = build_application_services(+ database_client=query_factory,+ deployment_edition=DeploymentEdition.COMMUNITY,+ initialization_password="",+ redis=redis,+ )+ api = ExternalApi(app)+ api.add_resource(module.MessageMoreLikeThisApi, "/messages/<uuid:message_id>/more-like-this")+ yield _Harness(+ app,+ target,+ end_user,+ message,+ current_config,+ historical_config,+ sqlite_session_factory,+ sessions,+ query_sessions,+ passport,+ )+ event.remove(admission_factory, "after_begin", track)+ event.remove(query_factory, "after_begin", track_query)+ event.remove(db.session.session_factory, "after_begin", track)+ redis_client.close()+ with app.app_context():+ db.session.remove()+ db.engine.dispose()++[email protected]("response_mode", ["blocking", "streaming"])+def test_stored_provider_error_propagates_through_the_real_generator(harness: _Harness, response_mode: str) -> None:+ response = harness.get(query=f"response_mode={response_mode}")+ assert response.status_code == HTTPStatus.BAD_REQUEST+ assert response.get_json() == {+ "code": "invalid_param",+ "message": "Invalid plugin id invalid/provider",+ "status": HTTPStatus.BAD_REQUEST,+ }+ assert response.headers["Content-Type"] == "application/json"+ with harness.factory() as session:+ persisted = session.get(AppModelConfig, harness.historical_config.id)+ assert persisted is not None+ assert persisted.model_dict["completion_params"]["temperature"] == 0.2+ harness.assert_closed()+++def test_real_preparation_failure_preserves_caller_session_and_pending_edits(harness: _Harness) -> None:+ with harness.app.app_context():+ caller = db.session()+ app_model = caller.get(App, harness.target.id)+ assert app_model is not None+ app_model.name = "Uncommitted caller change"+ response = harness.get()+ assert response.status_code == HTTPStatus.BAD_REQUEST+ assert response.get_json()["message"] == "Invalid plugin id invalid/provider"+ assert db.session() is caller+ assert caller.in_transaction()+ assert app_model in caller.dirty+ harness.assert_closed(caller=caller)+ with harness.factory() as session:+ persisted = session.get(App, harness.target.id)+ assert persisted is not None+ assert persisted.name == harness.target.name++[email protected]("query", ["", "response_mode=invalid"])+def test_invalid_response_mode_is_rejected_before_source_queries(harness: _Harness, query: str) -> None:+ response = harness.get(query=query)+ assert response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY+ assert response.get_json()["code"] == "unprocessable_entity"+ assert harness.query_sessions == []+ harness.assert_closed()++[email protected]("mode", [AppMode.CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT, AppMode.WORKFLOW])+def test_non_completion_app_is_rejected_before_source_queries(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 in {AppMode.ADVANCED_CHAT, AppMode.WORKFLOW}:+ workflow = Workflow.new(+ tenant_id=harness.target.tenant_id,+ app_id=harness.target.id,+ type="chat" if mode == AppMode.ADVANCED_CHAT else "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))+ elif mode == AppMode.AGENT:+ agent = Agent(+ tenant_id=harness.target.tenant_id,+ app_id=harness.target.id,+ name="Published agent",+ scope=AgentScope.ROSTER,+ source=AgentSource.AGENT_APP,+ )+ session.add(agent)+ session.flush()+ snapshot = AgentConfigSnapshot(+ tenant_id=agent.tenant_id,+ agent_id=agent.id,+ version=1,+ config_snapshot=AgentSoulConfig(),+ )+ session.add(snapshot)+ session.flush()+ agent.active_config_snapshot_id = snapshot.id+ session.add(+ AgentConfigRevision(+ tenant_id=agent.tenant_id,+ agent_id=agent.id,+ current_snapshot_id=snapshot.id,+ revision=1,+ operation=AgentConfigRevisionOperation.PUBLISH_DRAFT,+ )+ )+ response = harness.get()+ assert response.status_code == HTTPStatus.BAD_REQUEST+ assert response.get_json()["code"] == "not_completion_app"+ assert harness.query_sessions == []++[email protected]("feature", [None, "", "{}", '{"enabled":false}'])+def test_disabled_current_feature_wins_over_corrupt_historical_configuration(+ harness: _Harness, feature: str | None+) -> None:+ with harness.factory.begin() as session:+ session.execute(+ update(AppModelConfig).where(AppModelConfig.id == harness.current_config.id).values(more_like_this=feature)+ )+ session.execute(+ update(AppModelConfig).where(AppModelConfig.id == harness.historical_config.id).values(model="broken-json")+ )+ response = harness.get()+ assert response.status_code == HTTPStatus.FORBIDDEN+ assert response.get_json()["code"] == "app_more_like_this_disabled"+ harness.assert_closed()+++ ("current", "field", "value"),+ [+ (True, "more_like_this", '{"secret":"private-config-value"'),+ (True, "more_like_this", '["private-config-value"]'),+ (False, "model", '{"secret":"private-config-value"'),+ (False, "model", '["private-config-value"]'),+ (False, "model", '{"completion_params":["private-config-value"]}'),+ (False, "model", None),+ ],+ ids=["feature-json", "feature-shape", "model-json", "model-shape", "parameter-shape", "missing-model"],+)+def test_corrupt_persisted_configuration_returns_app_unavailable(+ harness: _Harness, current: bool, field: str, value: str | None+) -> None:+ """None represents a missing model payload in an existing configuration row."""+ config_id = harness.current_config.id if current else harness.historical_config.id+ with harness.factory.begin() as session:+ session.execute(update(AppModelConfig).where(AppModelConfig.id == config_id).values({field: value}))++ response = harness.get()++ assert response.status_code == HTTPStatus.BAD_REQUEST+ assert response.get_json() == {+ "code": "app_unavailable",+ "message": "App unavailable, please check your app configurations.",+ "status": HTTPStatus.BAD_REQUEST,+ }+ assert b"private-config-value" not in response.data+ harness.assert_closed()++[email protected]("field", ["app_id", "from_end_user_id", "from_account_id", "from_source"])+def test_message_ownership_is_enforced_through_http(harness: _Harness, field: str) -> None:+ value = ConversationFromSource.CONSOLE if field == "from_source" else str(uuid4())+ with harness.factory.begin() as session:+ session.execute(update(Message).where(Message.id == harness.message.id).values({field: value}))+ response = harness.get()+ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.get_json()["code"] == "not_found"+ harness.assert_closed()++[email protected]("field", ["app_id", "tenant_id"])+def test_foreign_end_user_is_rejected_at_jwt_admission(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 = harness.get()+ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.get_json()["code"] == "not_found"+ assert harness.query_sessions == []+ harness.assert_closed()++[email protected]("field", ["app_id", "from_end_user_id", "from_account_id", "from_source"])+def test_foreign_conversation_cannot_supply_historical_config(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 = harness.get()+ assert response.status_code == HTTPStatus.BAD_REQUEST+ assert response.get_json()["code"] == "app_unavailable"+ harness.assert_closed()++[email protected]("resource", ["conversation", "historical_config", "foreign_config"])+def test_missing_or_foreign_history_is_app_unavailable(harness: _Harness, resource: str) -> None:+ with harness.factory.begin() as session:+ if resource == "conversation":+ session.execute(delete(Conversation).where(Conversation.id == harness.message.conversation_id))+ elif resource == "historical_config":+ session.execute(delete(AppModelConfig).where(AppModelConfig.id == harness.historical_config.id))+ else:+ session.execute(+ update(AppModelConfig)+ .where(AppModelConfig.id == harness.historical_config.id)+ .values(app_id=str(uuid4()))+ )+ response = harness.get()+ assert response.status_code == HTTPStatus.BAD_REQUEST+ assert response.get_json()["code"] == "app_unavailable"+ harness.assert_closed()+++def test_incomplete_historical_model_reaches_generic_error_without_exposing_configuration(+ harness: _Harness, caplog: pytest.LogCaptureFixture+) -> None:+ # The persisted model is an object, but it lacks the provider field required+ # by the real completion configuration converter.+ with harness.factory.begin() as session:+ session.execute(+ update(AppModelConfig)+ .where(AppModelConfig.id == harness.historical_config.id)+ .values(model=json.dumps({"name": "private-model-name", "completion_params": {}}))+ )+ response = harness.get()+ assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR+ assert response.get_json()["code"] == "internal_server_error"+ assert b"private-model-name" not in response.data+ failures = [+ record.exc_info[1]+ for record in caplog.records+ if record.name == "controllers.web.message" and record.exc_info is not None+ ]+ assert len(failures) == 1+ assert isinstance(failures[0], KeyError)+ assert failures[0].args == ("provider",)+ harness.assert_closed()diff --git a/api/tests/e2e_tests/contracts/controllers/web/test_message_suggested_questions.py b/api/tests/e2e_tests/contracts/controllers/web/test_message_suggested_questions.pyindex 52a91286d7d..a8a4ae88aa1 100644--- a/api/tests/e2e_tests/contracts/controllers/web/test_message_suggested_questions.py+++ b/api/tests/e2e_tests/contracts/controllers/web/test_message_suggested_questions.py@@ -154,7 +154,9 @@ def harness(app.config.update(TESTING=True, RESTX_ERROR_404_HELP=False, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))db.init_app(app)event.listen(db.session.session_factory, "after_begin", track_session)- queries = SuggestedQuestionsQuery(session_factory=read_factory, repository_factory=MessageRepository)+ queries = SuggestedQuestionsQuery(+ session_factory=read_factory, repository=MessageRepository(session_factory=read_factory)+ )services = _Services(MessageSuggestedQuestionsService(queries=queries, generator=SuggestedQuestionsGenerator()))app.extensions["application_services"] = servicesapi = ExternalApi(app)diff --git a/api/tests/e2e_tests/contracts/core/app/apps/completion/test_prepared_completion.py b/api/tests/e2e_tests/contracts/core/app/apps/completion/test_prepared_completion.pynew file mode 100644index 00000000000..6ffc67e61bc--- /dev/null+++ b/api/tests/e2e_tests/contracts/core/app/apps/completion/test_prepared_completion.py@@ -0,0 +1,92 @@+"""Persist prepared completions and roll back invalid payloads through real SQL.++The container generation suite checks that the write session closes before the+actual worker and provider requests; no thread scheduler is replaced here.+"""++import json+from uuid import uuid4++import pytest+from sqlalchemy import func, select+from sqlalchemy.exc import StatementError+from sqlalchemy.orm import Session, sessionmaker++from core.app.app_config.entities import (+ AppAdditionalFeatures,+ EasyUIBasedAppModelConfigFrom,+ ModelConfigEntity,+ PromptTemplateEntity,+)+from core.app.apps.completion.app_config_manager import CompletionAppConfig+from core.app.apps.completion.app_generator import CompletionAppGenerator+from core.app.entities.app_invoke_entities import CompletionAppGenerateEntity, InvokeFrom+from models import AppMode, Conversation, Message+from tests.helpers.unit.core.model_fixtures import make_model_config+++def _entity(invoke_from: InvokeFrom) -> CompletionAppGenerateEntity:+ return CompletionAppGenerateEntity(+ task_id=str(uuid4()),+ app_config=CompletionAppConfig(+ tenant_id=str(uuid4()),+ app_id=str(uuid4()),+ app_mode=AppMode.COMPLETION,+ app_model_config_from=EasyUIBasedAppModelConfigFrom.ARGS,+ app_model_config_id=str(uuid4()),+ app_model_config_dict={"pre_prompt": "Historical prompt"},+ additional_features=AppAdditionalFeatures(),+ model=ModelConfigEntity(provider="test-provider", model="test-model"),+ prompt_template=PromptTemplateEntity(prompt_type=PromptTemplateEntity.PromptType.SIMPLE),+ ),+ model_conf=make_model_config(provider="test-provider", model="test-model", mode="completion"),+ inputs={"original": " input "},+ files=[],+ query=" original query ",+ user_id=str(uuid4()),+ stream=True,+ invoke_from=invoke_from,+ extras={},+ )++[email protected]("invoke_from", [InvokeFrom.WEB_APP, InvokeFrom.EXPLORE])+def test_prepared_records_preserve_input_and_actor_ownership(+ sqlite_session_factory: sessionmaker[Session], invoke_from: InvokeFrom+) -> None:+ entity = _entity(invoke_from)+ with sqlite_session_factory(expire_on_commit=False) as session:+ conversation, message = CompletionAppGenerator()._init_generate_records(entity, session=session)+ with sqlite_session_factory() as verification:+ saved = verification.get(Message, message.id)+ saved_conversation = verification.get(Conversation, conversation.id)+ assert saved is not None+ assert saved_conversation is not None+ assert saved.query == entity.query+ assert saved._inputs == entity.inputs+ assert saved_conversation.app_model_config_id == entity.app_config.app_model_config_id+ assert saved_conversation.override_model_configs is not None+ assert json.loads(saved_conversation.override_model_configs) == {"pre_prompt": "Historical prompt"}+ if invoke_from == InvokeFrom.WEB_APP:+ assert saved.from_end_user_id == entity.user_id+ assert saved.from_account_id is None+ else:+ assert saved.from_account_id == entity.user_id+ assert saved.from_end_user_id is None+ assert verification.scalar(select(func.count()).select_from(Message)) == 1+ assert verification.scalar(select(func.count()).select_from(Conversation)) == 1+ assert entity.trace_manager is None+ assert entity.file_upload_config is None+++def test_invalid_prepared_input_rolls_back_without_starting_a_worker(+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ entity = _entity(InvokeFrom.WEB_APP)+ entity.inputs = {**entity.inputs, "invalid_json": object()}+ with pytest.raises(StatementError) as error:+ CompletionAppGenerator().generate_from_entity(entity, session_factory=sqlite_session_factory)+ assert isinstance(error.value.orig, TypeError)+ with sqlite_session_factory() as verification:+ assert verification.scalar(select(func.count()).select_from(Message)) == 0+ assert verification.scalar(select(func.count()).select_from(Conversation)) == 0diff --git a/api/tests/unit_tests/controllers/console/explore/test_message.py b/api/tests/unit_tests/controllers/console/explore/test_message.pyindex 48e0cb28c55..c8be961dea6 100644--- a/api/tests/unit_tests/controllers/console/explore/test_message.py+++ b/api/tests/unit_tests/controllers/console/explore/test_message.py@@ -1,7 +1,7 @@"""Explore message HTTP contracts through real admission, services and SQLite."""import json-from collections.abc import Generator, Mapping, Sequence+from collections.abc import Mapping, Sequencefrom dataclasses import dataclass, fieldfrom datetime import datetime, timedeltafrom decimal import Decimal@@ -12,21 +12,14 @@ import pytestfrom pydantic import JsonValuefrom sqlalchemy import Connection, event, select, updatefrom sqlalchemy.orm import Session, SessionTransaction, sessionmaker-from werkzeug.exceptions import Forbiddenfrom werkzeug.test import TestResponseimport controllers.console.explore.message as modulefrom core.app.entities.app_invoke_entities import InvokeFrom-from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError-from graphon.model_runtime.errors.invoke import InvokeErrorfrom models import App, AppMode, InstalledAppfrom models.enums import ConversationFromSource, ConversationStatus, FeedbackFromSource, FeedbackRatingfrom models.model import Conversation, Message, MessageFeedbackfrom repositories.installed_app_message_repository import SQLAlchemyInstalledAppMessageRepository-from repositories.installed_app_repository import SQLAlchemyInstalledAppRepository-from services.errors.app import MoreLikeThisDisabledError-from services.errors.message import MessageNotExistsError-from services.installed_app_generation_service import GenerationResponse, InstalledAppGenerationServicefrom services.installed_app_message_service import InstalledAppMessageService, MessageFeedbackEventfrom tests.unit_tests.controllers.console.explore.test_installed_app_admission import (_assert_json_response,@@ -37,15 +30,13 @@ from tests.unit_tests.controllers.console.explore.test_installed_app_admission i__all__ = ["harness"]_CREATED_AT = datetime(2024, 1, 1)-type _Operation = Literal["list", "feedback", "more-like-this"]-_OPERATIONS: tuple[_Operation, ...] = ("list", "feedback", "more-like-this")-_BLOCKING: dict[str, object] = {"answer": "你好", "metadata": {}, "usage": None}+type _Operation = Literal["list", "feedback"]+_OPERATIONS: tuple[_Operation, ...] = ("list", "feedback")@dataclass(frozen=True)class _InstalledAppServices:messages: InstalledAppMessageService- generation: InstalledAppGenerationService@dataclass(frozen=True)@@ -62,9 +53,6 @@ class _Messages:extras: dict[str, list[dict[str, JsonValue]]] = field(default_factory=dict)extra_calls: list[list[str]] = field(default_factory=list)feedback_events: list[MessageFeedbackEvent] = field(default_factory=list)- generation_calls: list[tuple[str, str, str, bool]] = field(default_factory=list)- generation_response: GenerationResponse = field(default_factory=lambda: dict(_BLOCKING))- external_error: Exception | None = Nonedef assert_sessions_closed(self) -> None:assert all(not session.in_transaction() and not session.identity_map for session in self.sessions)@@ -83,27 +71,6 @@ class _Messages:assert persisted.content == feedback.contentself.feedback_events.append(feedback)- def generate(- self, *, app_id: str, account_id: str, args: Mapping[str, object], streaming: bool- ) -> GenerationResponse:- pytest.fail(f"Unexpected normal generation: {app_id=}, {account_id=}, {args=}, {streaming=}")-- def generate_more_like_this(- self, *, app_id: str, account_id: str, message_id: str, streaming: bool- ) -> GenerationResponse:- self.assert_sessions_closed()- self.assert_unused()- self.generation_calls.append((app_id, account_id, message_id, streaming))- if self.external_error is not None:- raise self.external_error- return self.generation_response-- def assert_unused(self) -> None:- with self.factory() as session:- installation = session.get(InstalledApp, self.harness.installed_app.id)- assert installation is not None- assert installation.last_used_at is None-def request(self,operation: _Operation,@@ -120,10 +87,7 @@ class _Messages:if query:url += f"&{query}"else:- suffix = "feedbacks" if operation == "feedback" else operation- url += f"/{message_id or uuid4()}/{suffix}"- if operation == "more-like-this":- url += f"?{query if query is not None else 'response_mode=blocking'}"+ url += f"/{message_id or uuid4()}/feedbacks"return self.harness.app.test_client().open(url, method="POST" if operation == "feedback" else "GET", json=body)@@ -146,16 +110,12 @@ def messages(get_extra_contents=state.get_extra_contents,emit_feedback=state.emit_feedback,),- generation=InstalledAppGenerationService(- usage=SQLAlchemyInstalledAppRepository(session_factory=factory), runtime=state- ),),)monkeypatch.setattr(module, "application_services", lambda: state.services)for resource, suffix in ((module.MessageListApi, ""),(module.MessageFeedbackApi, "/<uuid:message_id>/feedbacks"),- (module.MessageMoreLikeThisApi, "/<uuid:message_id>/more-like-this"),):harness.api.add_resource(resource, f"/installed-apps/<uuid:installed_app_id>/messages{suffix}")return state@@ -461,112 +421,10 @@ def test_all_message_handlers_apply_installed_app_admission(status=403 if admission == "denied" else 404,code="access_denied" if admission == "denied" else "installed_app_not_found",)- assert messages.extra_calls == messages.feedback_events == messages.generation_calls == []--[email protected]("operation", ["list", "more-like-this"])-def test_mode_rejection_precedes_message_queries_and_generation(messages: _Messages, operation: _Operation) -> None:- _set_mode(messages, AppMode.CHAT if operation == "more-like-this" else AppMode.COMPLETION)- _error(- messages.request(operation),- status=400,- code="not_completion_app" if operation == "more-like-this" else "not_chat_app",- )- assert messages.extra_calls == messages.generation_calls == []+ assert messages.extra_calls == messages.feedback_events == []-def test_more_like_this_preserves_blocking_response_and_does_not_update_usage(messages: _Messages) -> None:+def test_list_mode_rejection_precedes_message_queries(messages: _Messages) -> None:_set_mode(messages, AppMode.COMPLETION)- message_id = str(uuid4())- response = messages.request("more-like-this", message_id=message_id)- assert response.status_code == 200- assert response.get_json() == _BLOCKING- assert dict(response.headers) == {- "Content-Type": "application/json; charset=utf-8",- "Content-Length": str(len(response.data)),- }- assert messages.generation_calls == [- (messages.harness.target_app.id, messages.harness.account.id, message_id, False)- ]- messages.assert_unused()--[email protected]("consume_all", [False, True])-def test_more_like_this_stream_keeps_sse_and_closes_iterator(messages: _Messages, consume_all: bool) -> None:- _set_mode(messages, AppMode.COMPLETION)- closed: list[bool] = []-- def chunks() -> Generator[str]:- try:- yield 'data: {"answer":"你好"}\n\n'- yield "data: [DONE]\n\n"- finally:- closed.append(True)-- messages.generation_response = chunks()- response = messages.request("more-like-this", query="response_mode=streaming")- assert response.status_code == 200- assert dict(response.headers) == {"Content-Type": "text/event-stream; charset=utf-8"}- if consume_all:- assert response.data == 'data: {"answer":"你好"}\n\ndata: [DONE]\n\n'.encode()- else:- assert next(iter(response.response)) == 'data: {"answer":"你好"}\n\n'.encode()- assert closed == []- response.close()- assert closed == [True]- assert messages.generation_calls[0][-1] is True- messages.assert_unused()--[email protected]("query", ["", "response_mode=invalid"])-def test_more_like_this_invalid_query_uses_shared_422(messages: _Messages, query: str) -> None:- _set_mode(messages, AppMode.COMPLETION)- _error(messages.request("more-like-this", query=query), status=422, code="unprocessable_entity")- assert messages.generation_calls == []--[email protected]("operation", ["more-like-this"])- ("failure", "status", "code", "description"),- [- (ProviderTokenNotInitError("Missing credentials"), 400, "provider_not_initialize", "Missing credentials"),- (QuotaExceededError(), 400, "provider_quota_exceeded", None),- (ModelCurrentlyNotSupportError(), 400, "model_currently_not_support", None),- (InvokeError("Provider rejected input"), 400, "completion_request_error", "Provider rejected input"),- (- Forbidden("Private provider details"),- 500,- "internal_server_error",- "The server encountered an internal error and was unable to complete your request. "- "Either the server is overloaded or there is an error in the application.",- ),- (RuntimeError("Unexpected failure"), 500, "internal_server_error", None),- ],-)-def test_generation_failures_keep_provider_errors_and_context(- messages: _Messages, operation: _Operation, failure: Exception, status: int, code: str, description: str | None-) -> None:- if operation == "more-like-this":- _set_mode(messages, AppMode.COMPLETION)- messages.external_error = failure- _error(messages.request(operation), status=status, code=code, message=description)- assert len(messages.generation_calls) == 1- messages.assert_unused()--- ("operation", "failure", "status", "code"),- [- ("more-like-this", MessageNotExistsError(), 404, "message_not_found"),- ("more-like-this", MoreLikeThisDisabledError(), 403, "app_more_like_this_disabled"),- ("more-like-this", ValueError("Bad runtime arguments"), 400, "invalid_param"),- ],-)-def test_generation_resource_errors_remain_specific(- messages: _Messages, operation: _Operation, failure: Exception, status: int, code: str-) -> None:- if operation == "more-like-this":- _set_mode(messages, AppMode.COMPLETION)- messages.external_error = failure- _error(messages.request(operation), status=status, code=code)- messages.assert_unused()+ _error(messages.request("list"), status=400, code="not_chat_app")+ assert messages.extra_calls == []diff --git a/api/tests/unit_tests/controllers/web/test_message.py b/api/tests/unit_tests/controllers/web/test_message.pyindex c464b1e0e79..c1036e6c67a 100644--- a/api/tests/unit_tests/controllers/web/test_message.py+++ b/api/tests/unit_tests/controllers/web/test_message.py@@ -16,14 +16,8 @@ from flask.views import MethodViewfrom controllers.common.controller_schemas import MessageFeedbackPayload, MessageListQueryfrom controllers.common.errors import NotFoundError-from controllers.web.error import (- AppMoreLikeThisDisabledError,- NotCompletionAppError,-)from controllers.web.message import (MessageFeedbackApi,- MessageMoreLikeThisApi,- MessageMoreLikeThisQuery,)from core.app.entities.app_invoke_entities import InvokeFromfrom core.entities.execution_extra_content import HumanInputContent@@ -37,7 +31,6 @@ from models.model import (MessageAgentThought,MessageFeedback,)-from services.errors.app import MoreLikeThisDisabledErrorfrom services.errors.message import MessageNotExistsErrorfrom tests.helpers.unit.model_factories import make_end_user@@ -48,10 +41,6 @@ def _chat_app() -> App:return App(id="app-1", tenant_id="tenant-1", mode=AppMode.CHAT)-def _completion_app() -> App:- return App(id="app-1", tenant_id="tenant-1", mode=AppMode.COMPLETION)--def _end_user() -> EndUser:return make_end_user(end_user_id="eu-1")@@ -60,7 +49,6 @@ def _end_user() -> EndUser:# call the undecorated function so they can pass a pydantic payload / a fake# session directly._feedback_post = inspect.unwrap(MessageFeedbackApi.post)-_more_like_this_get = inspect.unwrap(MessageMoreLikeThisApi.get)class TestMessageEndpointsCases:@@ -104,57 +92,6 @@ class TestMessageEndpointsCases:# ---------------------------------------------------------------------------# MessageMoreLikeThisApi# ---------------------------------------------------------------------------- class TestMessageMoreLikeThisApi:- def test_wrong_mode_raises(self, app: Flask) -> None:- msg_id = uuid4()- query = MessageMoreLikeThisQuery.model_validate({"response_mode": "blocking"})- session = MagicMock()- with app.test_request_context(f"/messages/{msg_id}/more-like-this?response_mode=blocking"):- with pytest.raises(NotCompletionAppError):- _more_like_this_get(MessageMoreLikeThisApi(), query, session, _chat_app(), _end_user(), msg_id)-- @patch("controllers.web.message.helper.compact_generate_response", return_value={"answer": "similar"})- @patch("controllers.web.message.AppGenerateService.generate_more_like_this")- def test_happy_path(self, mock_gen: MagicMock, mock_compact: MagicMock, app: Flask) -> None:- msg_id = uuid4()- mock_gen.return_value = "response"- query = MessageMoreLikeThisQuery.model_validate({"response_mode": "blocking"})- session = MagicMock()-- with app.test_request_context(f"/messages/{msg_id}/more-like-this?response_mode=blocking"):- result = _more_like_this_get(- MessageMoreLikeThisApi(), query, session, _completion_app(), _end_user(), msg_id- )-- assert result == {"answer": "similar"}-- @patch(- "controllers.web.message.AppGenerateService.generate_more_like_this",- side_effect=MessageNotExistsError(),- )- def test_message_not_found(self, mock_gen: MagicMock, app: Flask) -> None:- msg_id = uuid4()- query = MessageMoreLikeThisQuery.model_validate({"response_mode": "blocking"})- session = MagicMock()- with app.test_request_context(f"/messages/{msg_id}/more-like-this?response_mode=blocking"):- with pytest.raises(NotFoundError, match="Message Not Exists"):- _more_like_this_get(- MessageMoreLikeThisApi(), query, session, _completion_app(), _end_user(), msg_id- )-- @patch(- "controllers.web.message.AppGenerateService.generate_more_like_this",- side_effect=MoreLikeThisDisabledError(),- )- def test_feature_disabled(self, mock_gen: MagicMock, app: Flask) -> None:- msg_id = uuid4()- query = MessageMoreLikeThisQuery.model_validate({"response_mode": "blocking"})- session = MagicMock()- with app.test_request_context(f"/messages/{msg_id}/more-like-this?response_mode=blocking"):- with pytest.raises(AppMoreLikeThisDisabledError):- _more_like_this_get(- MessageMoreLikeThisApi(), query, session, _completion_app(), _end_user(), msg_id- )# ---------------------------------------------------------------------------# MessageSuggestedQuestionApidiff --git a/api/tests/unit_tests/core/app/apps/completion/test_app_config_manager.py b/api/tests/unit_tests/core/app/apps/completion/test_app_config_manager.pyindex ef524d64059..6f5f9521b48 100644--- a/api/tests/unit_tests/core/app/apps/completion/test_app_config_manager.py+++ b/api/tests/unit_tests/core/app/apps/completion/test_app_config_manager.py@@ -1,3 +1,4 @@+from copy import deepcopyfrom types import SimpleNamespaceimport pytest@@ -7,7 +8,8 @@ from sqlalchemy.orm import Sessionimport core.app.apps.completion.app_config_manager as modulefrom core.app.app_config.entities import EasyUIBasedAppModelConfigFromfrom core.app.apps.completion.app_config_manager import CompletionAppConfigManager-from models.model import App, AppMode, AppModelConfig+from models.enums import PromptType+from models.model import AnnotationReplyConfig, App, AppMode, AppModelConfigdef _app() -> App:@@ -157,3 +159,45 @@ class TestCompletionAppConfigManager:"more_like_this","moderation",}++[email protected]("use_override", [False, True])+def test_materialized_config_matches_orm_conversion(use_override: bool) -> None:+ app = _app()+ config = AppModelConfig(+ app_id=app.id,+ model='{"provider": "langgenius/openai/openai", "name": "gpt-4", "mode": "chat", '+ '"completion_params": {"temperature": 0.9, "stop": ["END"]}}',+ prompt_type=PromptType.SIMPLE,+ pre_prompt="Answer {{topic}}",+ user_input_form='[{"text-input": {"label": "Topic", "variable": "topic", "required": true}}]',+ more_like_this='{"enabled": true}',+ )+ config.id = "historical-config"+ annotation_reply: AnnotationReplyConfig = {"enabled": False}+ materialized = config.to_dict(annotation_reply=annotation_reply)+ expected = CompletionAppConfigManager.get_app_config(+ app_model=app,+ app_model_config=config,+ override_config_dict=deepcopy(materialized) if use_override else None,+ annotation_reply=annotation_reply,+ )++ actual = CompletionAppConfigManager.get_app_config_from_dict(+ tenant_id=app.tenant_id,+ app_id=app.id,+ app_model_config_id=config.id,+ app_mode=AppMode.COMPLETION,+ config_dict=materialized,+ config_from=(+ EasyUIBasedAppModelConfigFrom.ARGS if use_override else EasyUIBasedAppModelConfigFrom.APP_LATEST_CONFIG+ ),+ )++ assert actual == expected+ assert actual.model.parameters == {"temperature": 0.9}+ assert actual.model.stop == ["END"]+ assert actual.additional_features is not None+ assert actual.additional_features.more_like_this is True+ assert actual.variables[0].variable == "topic"+ assert actual.prompt_template.simple_prompt_template == "Answer {{topic}}"diff --git a/api/tests/unit_tests/core/app/apps/completion/test_app_generator.py b/api/tests/unit_tests/core/app/apps/completion/test_app_generator.pyindex 9fda53567e9..1a6dacff8e8 100644--- a/api/tests/unit_tests/core/app/apps/completion/test_app_generator.py+++ b/api/tests/unit_tests/core/app/apps/completion/test_app_generator.py@@ -16,8 +16,6 @@ from graphon.model_runtime.errors.invoke import InvokeAuthorizationErrorfrom models import Accountfrom models.enums import ConversationFromSourcefrom models.model import App, AppMode, AppModelConfig, Conversation, Message-from services.errors.app import MoreLikeThisDisabledError-from services.errors.message import MessageNotExistsErrorTABLES = (AppModelConfig, Conversation, Message)@@ -331,146 +329,6 @@ class TestCompletionAppGenerator:assert get_app_config.call_args.kwargs["override_config_dict"] == override_config- def test_generate_more_like_this_message_not_found(self, generator, sqlite_session: Session):- _persist_message(sqlite_session, app_id="other-app")-- with pytest.raises(MessageNotExistsError):- generator.generate_more_like_this(- session=sqlite_session,- app_model=_build_app_model(),- message_id="msg",- user=_build_user(),- invoke_from=InvokeFrom.WEB_APP,- )-- def test_generate_more_like_this_disabled(self, generator, sqlite_session: Session):- app_model = _build_app_model()- current_config = AppModelConfig(app_id=app_model.id, more_like_this='{"enabled": false}')- sqlite_session.add(current_config)- sqlite_session.flush()- app_model.app_model_config_id = current_config.id- _persist_message(sqlite_session)-- with pytest.raises(MoreLikeThisDisabledError):- generator.generate_more_like_this(- session=sqlite_session,- app_model=app_model,- message_id="msg",- user=_build_user(),- invoke_from=InvokeFrom.WEB_APP,- )-- def test_generate_more_like_this_app_model_config_missing(self, generator, sqlite_session: Session):- app_model = _build_app_model()- app_model.app_model_config_id = None-- _persist_message(sqlite_session)-- with pytest.raises(MoreLikeThisDisabledError):- generator.generate_more_like_this(- session=sqlite_session,- app_model=app_model,- message_id="msg",- user=_build_user(),- invoke_from=InvokeFrom.WEB_APP,- )-- def test_generate_more_like_this_message_config_none(self, generator, sqlite_session: Session):- app_model = _build_app_model()- current_config = AppModelConfig(app_id=app_model.id, more_like_this='{"enabled": true}')- sqlite_session.add(current_config)- sqlite_session.flush()- app_model.app_model_config_id = current_config.id- _persist_message(sqlite_session)-- with pytest.raises(ValueError, match="Message app_model_config is None"):- generator.generate_more_like_this(- session=sqlite_session,- app_model=app_model,- message_id="msg",- user=_build_user(),- invoke_from=InvokeFrom.WEB_APP,- )-- def test_generate_more_like_this_success(self, generator, mocker: MockerFixture, sqlite_session: Session):- app_model = _build_app_model()- app_model_config = AppModelConfig(app_id=app_model.id, more_like_this='{"enabled": true}')- sqlite_session.add(app_model_config)- sqlite_session.flush()- app_model.app_model_config_id = app_model_config.id- _persist_message(sqlite_session, app_model_config=app_model_config)- to_dict = mocker.patch.object(- AppModelConfig,- "to_dict",- return_value={- "model": {"completion_params": {"temperature": 0.1}},- "file_upload": {"enabled": True},- },- )- annotation_reply = {"enabled": False}- load_annotation_reply_config = mocker.patch.object(- module,- "load_annotation_reply_config",- return_value=annotation_reply,- )- mocker.patch.object(module.FileUploadConfigManager, "convert", return_value=None)- build_from_mappings = mocker.patch.object(module.file_factory, "build_from_mappings")-- app_config = MagicMock(variables=["v"], to_dict=MagicMock(return_value={}))- get_app_config = mocker.patch.object(- module.CompletionAppConfigManager,- "get_app_config",- return_value=app_config,- )- mocker.patch.object(module.ModelConfigConverter, "convert", return_value=MagicMock())-- mocker.patch.object(- generator,- "_init_generate_records",- return_value=(- Conversation(- id="conv",- app_id="app1",- mode=AppMode.COMPLETION,- name="Conversation",- _inputs={},- from_source=ConversationFromSource.CONSOLE,- ),- Message(- id="msg",- app_id="app1",- conversation_id="conv",- _inputs={},- query="q",- message={},- message_unit_price=Decimal(0),- answer="",- answer_unit_price=Decimal(0),- currency="USD",- from_source=ConversationFromSource.CONSOLE,- ),- ),- )- mocker.patch.object(generator, "_handle_response", return_value="response")- mocker.patch.object(module.CompletionAppGenerateResponseConverter, "convert", return_value="converted")-- result = generator.generate_more_like_this(- session=sqlite_session,- app_model=app_model,- message_id="msg",- user=_build_user(),- invoke_from=InvokeFrom.WEB_APP,- stream=True,- )-- assert result == "converted"- load_annotation_reply_config.assert_called_once_with(sqlite_session, app_model.id)- to_dict.assert_called_once_with(annotation_reply=annotation_reply)- assert generator.generate_entity.call_args.kwargs["inputs"] == {"a": 1}- override_dict = get_app_config.call_args.kwargs["override_config_dict"]- assert override_dict["model"]["completion_params"]["temperature"] == 0.9- build_from_mappings.assert_not_called()-@pytest.mark.parametrize(("error", "should_publish"),[diff --git a/api/tests/unit_tests/core/app/apps/test_message_based_app_generator.py b/api/tests/unit_tests/core/app/apps/test_message_based_app_generator.pyindex c2c9d7443d9..57bccb9696b 100644--- a/api/tests/unit_tests/core/app/apps/test_message_based_app_generator.py+++ b/api/tests/unit_tests/core/app/apps/test_message_based_app_generator.py@@ -16,10 +16,9 @@ from core.app.app_config.entities import (from core.app.apps.exc import GenerateTaskStoppedErrorfrom core.app.apps.message_based_app_generator import MessageBasedAppGeneratorfrom core.app.entities.app_invoke_entities import ChatAppGenerateEntity, InvokeFrom-from models.account import Accountfrom models.model import App, AppMode, Conversation, Messagefrom services.errors.app_model_config import AppModelConfigBrokenError-from tests.helpers.unit.model_factories import make_account, make_app+from tests.helpers.unit.model_factories import make_app@dataclass(eq=False, repr=False)@@ -52,10 +51,6 @@ def _app(*, app_id: str = "app") -> App:return make_app(app_id=app_id, tenant_id="tenant-id", name="Message App", icon_type=None)-def _account() -> Account:- return make_account(account_id="user-id", name="Message User", email="[email protected]")--def _make_app_config(app_mode: AppMode) -> EasyUIBasedAppConfig:return EasyUIBasedAppConfig(tenant_id="tenant-id",@@ -151,7 +146,6 @@ class TestMessageBasedAppGeneratorExtras:queue_manager=SimpleNamespace(),conversation=Conversation(id="conv", app_id="app"),message=Message(id="msg", app_id="app", conversation_id="conv"),- user=_account(),stream=False,)diff --git a/api/tests/unit_tests/services/test_app_generate_service.py b/api/tests/unit_tests/services/test_app_generate_service.pyindex 854323c1b91..0fcd8ce8932 100644--- a/api/tests/unit_tests/services/test_app_generate_service.py+++ b/api/tests/unit_tests/services/test_app_generate_service.py@@ -1036,25 +1036,6 @@ class TestAppGenerateServiceCases:# ---------------------------------------------------------------------------# generate_more_like_this# ---------------------------------------------------------------------------- class TestGenerateMoreLikeThis(_RealSessionTest):- def test_delegates_to_completion_generator(self, mocker: MockerFixture):- gen_spy = mocker.patch(- "services.app_generate_service.CompletionAppGenerator.generate_more_like_this",- return_value={"result": "similar"},- )- session = self.session- result = AppGenerateService.generate_more_like_this(- app_model=_make_app(AppMode.COMPLETION),- user=_make_user(),- message_id="msg-1",- invoke_from=InvokeFrom.SERVICE_API,- session=session,- streaming=True,- )- assert result == {"result": "similar"}- gen_spy.assert_called_once()- assert gen_spy.call_args.kwargs["session"] is session- assert gen_spy.call_args.kwargs["stream"] is True# -----------------------------diff --git a/api/tests/unit_tests/services/test_installed_app_generation_adapters.py b/api/tests/unit_tests/services/test_installed_app_generation_adapters.pyindex 277725c8fc2..d236ed42b39 100644--- a/api/tests/unit_tests/services/test_installed_app_generation_adapters.py+++ b/api/tests/unit_tests/services/test_installed_app_generation_adapters.py@@ -1,8 +1,6 @@import jsonfrom collections.abc import Callable, Generator, Mappingfrom dataclasses import dataclass, field-from decimal import Decimal-from inspect import GEN_CLOSED, getgeneratorstatefrom typing import cast, overridefrom unittest.mock import MagicMockfrom uuid import uuid4@@ -25,14 +23,12 @@ from libs.broadcast_channel.redis.streams_channel import (_StreamsSubscriber,_StreamsSubscription,)-from models import Account, App, AppMode, AppModelConfig, Conversation, Message, Workflow+from models import Account, App, AppMode, AppModelConfig, Conversation, Workflowfrom models.enums import ConversationFromSourcefrom models.workflow import WorkflowTypefrom services.account_errors import AccountNotFoundErrorfrom services.app_definition_query_service import AppDefinitionUnavailableError-from services.errors.app import MoreLikeThisDisabledErrorfrom services.errors.conversation import ConversationNotExistsError-from services.errors.message import MessageNotExistsErrorfrom services.installed_app_generation_adapters import AppGenerateServiceRuntimefrom services.installed_app_generation_service import GenerationResponse@@ -94,7 +90,6 @@ def _patch_generation(generate: Callable[[Session], GenerationResponse | Generator[Mapping[str, object] | str]],*,streaming: bool,- more_like_this: bool = False,) -> None:def assert_context(*,@@ -132,43 +127,19 @@ def _patch_generation(session=session, app_model=app_model, user=user, invoke_from=invoke_from, streaming=streaming)- def legacy_generate_more_like_this(- *,- session: Session,- app_model: App,- user: Account,- message_id: str,- invoke_from: InvokeFrom,- streaming: bool,- ) -> GenerationResponse | Generator[Mapping[str, object] | str]:- assert message_id == _MESSAGE_ID- return assert_context(- session=session, app_model=app_model, user=user, invoke_from=invoke_from, streaming=streaming- )-expected_streaming = streaming- if more_like_this:- monkeypatch.setattr(- generation_module.AppGenerateService, "generate_more_like_this", legacy_generate_more_like_this- )- else:- monkeypatch.setattr(generation_module.AppGenerateService, "generate", legacy_generate)+ monkeypatch.setattr(generation_module.AppGenerateService, "generate", legacy_generate)def _invoke_generation(harness: _RuntimeHarness,*,streaming: bool,- more_like_this: bool,app_id: str | None = None,account_id: str | None = None,) -> GenerationResponse:app_id = app_id or harness.app_idaccount_id = account_id or harness.account_id- if more_like_this:- return harness.runtime.generate_more_like_this(- app_id=app_id, account_id=account_id, message_id=_MESSAGE_ID, streaming=streaming- )return harness.runtime.generate(app_id=app_id, account_id=account_id, args=_ARGS, streaming=streaming)@@ -187,12 +158,10 @@ def _rate_limited_stream(source: Generator[str], rate: _RateLimitExit) -> RateLireturn RateLimitGenerator(rate_limit=cast(RateLimit, rate), generator=source, request_id="request-1")[email protected]("more_like_this", [False, True])def test_runtime_loads_detached_entities_then_commits_work_and_returns_the_same_mapping(harness: _RuntimeHarness,monkeypatch: pytest.MonkeyPatch,sqlite_session_factory: sessionmaker[Session],- more_like_this: bool,) -> None:response: dict[str, object] = {"answer": "", "metadata": {"tokens": 0}}@@ -200,8 +169,8 @@ def test_runtime_loads_detached_entities_then_commits_work_and_returns_the_same_session.execute(update(App).where(App.id == harness.app_id).values(name="Generated app"))return response- _patch_generation(monkeypatch, harness, generate, streaming=False, more_like_this=more_like_this)- result = _invoke_generation(harness, streaming=False, more_like_this=more_like_this)+ _patch_generation(monkeypatch, harness, generate, streaming=False)+ result = _invoke_generation(harness, streaming=False)assert result is responseassert len(harness.closed_sessions) == 2@@ -256,55 +225,10 @@ def test_runtime_preserves_stream_identity_and_original_close_lifecycle(assert events == ["start", "close"][email protected]("finish", ["complete", "cancel", "error", "close_before_iteration"])-def test_more_like_this_serializes_raw_events_and_closes_source(- harness: _RuntimeHarness, monkeypatch: pytest.MonkeyPatch, finish: str-) -> None:- events: list[str] = []- failure = RuntimeError("more-like-this stream failed")-- def source() -> Generator[Mapping[str, object] | str]:- assert len(harness.closed_sessions) == 2- events.append("start")- try:- yield {"event": "message", "answer": "Hello"}- if finish == "error":- raise failure- yield "ping"- finally:- events.append("close")-- stream = source()- _patch_generation(monkeypatch, harness, lambda _session: stream, streaming=True, more_like_this=True)- result = _invoke_generation(harness, streaming=True, more_like_this=True)-- assert not isinstance(result, Mapping)- assert events == []- assert harness.committed_sessions == [harness.closed_sessions[1]]- if finish != "close_before_iteration":- assert next(result) == 'data: {"event":"message","answer":"Hello"}\n\n'- if finish == "complete":- assert list(result) == ["event: ping\n\n"]- elif finish == "error":- with pytest.raises(RuntimeError) as raised:- next(result)- assert raised.value is failure- else:- result.close()-- result.close()- result.close()- assert list(result) == []- assert getgeneratorstate(stream) == GEN_CLOSED- assert events == ([] if finish == "close_before_iteration" else ["start", "close"])--[email protected]("more_like_this", [False, True])def test_streaming_preparation_errors_raise_eagerly_and_rollback_runtime_writes(harness: _RuntimeHarness,monkeypatch: pytest.MonkeyPatch,sqlite_session_factory: sessionmaker[Session],- more_like_this: bool,) -> None:failure = ValueError("query must be a string")@@ -312,9 +236,9 @@ def test_streaming_preparation_errors_raise_eagerly_and_rollback_runtime_writes(session.execute(update(App).where(App.id == harness.app_id).values(name="Uncommitted app"))raise failure- _patch_generation(monkeypatch, harness, generate, streaming=True, more_like_this=more_like_this)+ _patch_generation(monkeypatch, harness, generate, streaming=True)with pytest.raises(ValueError, match="query must be a string") as raised:- _invoke_generation(harness, streaming=True, more_like_this=more_like_this)+ _invoke_generation(harness, streaming=True)assert raised.value is failureassert len(harness.closed_sessions) == 2@@ -326,21 +250,19 @@ def test_streaming_preparation_errors_raise_eagerly_and_rollback_runtime_writes(@pytest.mark.parametrize("missing", ["app", "account"])[email protected]("more_like_this", [False, True])def test_missing_runtime_entities_keep_precise_errors_and_do_not_enter_generation(- harness: _RuntimeHarness, monkeypatch: pytest.MonkeyPatch, missing: str, more_like_this: bool+ harness: _RuntimeHarness, monkeypatch: pytest.MonkeyPatch, missing: str) -> None:def unexpected_generation(**_kwargs: object) -> GenerationResponse:pytest.fail("Missing app or account must not reach generation")monkeypatch.setattr(generation_module.AppGenerateService, "generate", unexpected_generation)- monkeypatch.setattr(generation_module.AppGenerateService, "generate_more_like_this", unexpected_generation)app_id = str(uuid4()) if missing == "app" else harness.app_idaccount_id = str(uuid4()) if missing == "account" else harness.account_iderror_type = AppDefinitionUnavailableError if missing == "app" else AccountNotFoundErrorwith pytest.raises(error_type, match=app_id if missing == "app" else account_id):- _invoke_generation(harness, app_id=app_id, account_id=account_id, streaming=True, more_like_this=more_like_this)+ _invoke_generation(harness, app_id=app_id, account_id=account_id, streaming=True)assert len(harness.closed_sessions) == 1assert harness.committed_sessions == []@@ -348,14 +270,12 @@ def test_missing_runtime_entities_keep_precise_errors_and_do_not_enter_generatio@pytest.mark.parametrize("failure_phase", ["commit", "session_close"])@pytest.mark.parametrize("stream_close_fails", [False, True])[email protected]("more_like_this", [False, True])def test_failure_before_stream_handoff_closes_stream_without_masking_primary_error(harness: _RuntimeHarness,monkeypatch: pytest.MonkeyPatch,sqlite_session_factory: sessionmaker[Session],failure_phase: str,stream_close_fails: bool,- more_like_this: bool,) -> None:failure = RuntimeError(f"runtime {failure_phase} failed")rate = _RateLimitExit(failure=ValueError("stream close failed") if stream_close_fails else None)@@ -377,9 +297,9 @@ def test_failure_before_stream_handoff_closes_stream_without_masking_primary_errsession.info["close_failure"] = failurereturn stream- _patch_generation(monkeypatch, harness, generate, streaming=True, more_like_this=more_like_this)+ _patch_generation(monkeypatch, harness, generate, streaming=True)with pytest.raises(RuntimeError) as raised:- _invoke_generation(harness, streaming=True, more_like_this=more_like_this)+ _invoke_generation(harness, streaming=True)assert raised.value is failureassert stream.closed is True@@ -390,113 +310,6 @@ def test_failure_before_stream_handoff_closes_stream_without_masking_primary_errassert stored.name == ("Original app" if failure_phase == "commit" else "Generated app")-def _seed_more_like_this_message(harness: _RuntimeHarness, session_factory: sessionmaker[Session]) -> str:- with session_factory.begin() as session:- conversation = Conversation(- app_id=harness.app_id,- mode=AppMode.COMPLETION,- name="Earlier completion",- _inputs={},- from_source=ConversationFromSource.CONSOLE,- from_account_id=harness.account_id,- )- session.add(conversation)- session.flush()- message = Message(- app_id=harness.app_id,- conversation_id=conversation.id,- _inputs={"count": 0},- query="Earlier query",- message={},- answer="Earlier answer",- message_unit_price=Decimal(0),- answer_unit_price=Decimal(0),- currency="USD",- from_source=ConversationFromSource.CONSOLE,- from_account_id=harness.account_id,- )- session.add(message)- session.flush()- return message.id--[email protected]("inaccessible", ["missing", "other_app", "other_account", "api_source", "end_user"])-def test_more_like_this_checks_real_message_ownership_before_feature_config(- harness: _RuntimeHarness, sqlite_session_factory: sessionmaker[Session], inaccessible: str-) -> None:- message_id = _seed_more_like_this_message(harness, sqlite_session_factory)- with sqlite_session_factory.begin() as session:- message = session.get(Message, message_id)- assert message is not None- if inaccessible == "missing":- message_id = str(uuid4())- elif inaccessible == "other_app":- message.app_id = str(uuid4())- elif inaccessible == "other_account":- message.from_account_id = str(uuid4())- elif inaccessible == "api_source":- message.from_source = ConversationFromSource.API- else:- message.from_end_user_id = str(uuid4())-- with pytest.raises(MessageNotExistsError):- harness.runtime.generate_more_like_this(- app_id=harness.app_id, account_id=harness.account_id, message_id=message_id, streaming=True- )-- assert len(harness.closed_sessions) == 2- assert harness.committed_sessions == []--[email protected]("current_config", ["missing", "null", "empty", "disabled"])-def test_more_like_this_disabled_config_fails_eagerly_before_history_lookup(- harness: _RuntimeHarness, sqlite_session_factory: sessionmaker[Session], current_config: str-) -> None:- message_id = _seed_more_like_this_message(harness, sqlite_session_factory)- if current_config != "missing":- with sqlite_session_factory.begin() as session:- app = session.get(App, harness.app_id)- assert app is not None- feature_config = {"null": None, "empty": "{}", "disabled": '{"enabled":false}'}[current_config]- config = AppModelConfig(app_id=app.id, more_like_this=feature_config)- session.add(config)- app.app_model_config_id = config.id-- with pytest.raises(MoreLikeThisDisabledError):- harness.runtime.generate_more_like_this(- app_id=harness.app_id, account_id=harness.account_id, message_id=message_id, streaming=True- )-- assert len(harness.closed_sessions) == 2- assert harness.committed_sessions == []--[email protected]("missing_config_id", [None, "00000000-0000-0000-0000-000000000001"])-def test_more_like_this_requires_historical_config_even_when_current_config_is_enabled(- harness: _RuntimeHarness, sqlite_session_factory: sessionmaker[Session], missing_config_id: str | None-) -> None:- message_id = _seed_more_like_this_message(harness, sqlite_session_factory)- with sqlite_session_factory.begin() as session:- app = session.get(App, harness.app_id)- assert app is not None- config = AppModelConfig(app_id=app.id, more_like_this='{"enabled":true}')- session.add(config)- app.app_model_config_id = config.id- message = session.get(Message, message_id)- assert message is not None- conversation = session.get(Conversation, message.conversation_id)- assert conversation is not None- conversation.app_model_config_id = missing_config_id-- with pytest.raises(ValueError, match="Message app_model_config is None"):- harness.runtime.generate_more_like_this(- app_id=harness.app_id, account_id=harness.account_id, message_id=message_id, streaming=True- )-- assert len(harness.closed_sessions) == 2- assert harness.committed_sessions == []--@pytest.mark.parametrize("legacy_agent", [False, True])def test_runtime_keeps_shared_completion_and_legacy_agent_dispatch(harness: _RuntimeHarness,diff --git a/api/tests/unit_tests/services/test_message_more_like_this_generator.py b/api/tests/unit_tests/services/test_message_more_like_this_generator.pynew file mode 100644index 00000000000..77327078a7e--- /dev/null+++ b/api/tests/unit_tests/services/test_message_more_like_this_generator.py@@ -0,0 +1,383 @@+"""Real completion preparation, stored files and failure cleanup without provider stubs.++The worker/Redis and provider transport paths live in the container suite. These+cases use invalid persisted provider data to stop model preparation before I/O.+"""++import json+from collections.abc import Generator, Iterator, Mapping+from dataclasses import dataclass+from datetime import UTC, datetime+from decimal import Decimal+from uuid import uuid4++import pytest+from flask import Flask+from pydantic import JsonValue+from sqlalchemy import Connection, Engine, delete, event, func, 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, get_current_file_access_scope+from core.entities.provider_entities import ProviderQuotaType, QuotaUnit+from core.hosting_configuration import HostingProvider, TrialHostingQuota+from core.workflow.file_reference import resolve_file_record_id+from extensions import ext_hosting_provider+from extensions.ext_database import db+from extensions.storage.storage_type import StorageType+from graphon.file import File, FileTransferMethod, FileType+from graphon.file.constants import FILE_MODEL_IDENTITY+from graphon.model_runtime.entities.model_entities import ModelType+from models import App, AppMode, AppModelConfig, Conversation, EndUser, Message, MessageFile, UploadFile+from models.enums import ConversationFromSource, CreatorUserRole, EndUserType, MessageFileBelongsTo+from models.provider import Provider, ProviderModel, ProviderType+from repositories.message_repository import MessageRepository+from services.entities.message_entities import MessageEndUser+from services.message_more_like_this_generator import (+ MessageMoreLikeThisGenerator,+ _file_mapping,+ _MoreLikeThisEventStream,+ _restore_inputs,+)+from services.message_more_like_this_service import MessageMoreLikeThisService, MoreLikeThisFile, MoreLikeThisResponse+++@dataclass(frozen=True)+class _Runtime:+ app: Flask+ service: MessageMoreLikeThisService+ app_id: str+ tenant_id: str+ end_user_id: str+ message_id: str+ historical_config_id: str+ sessions: list[Session]++ def generate(self) -> MoreLikeThisResponse:+ with self.app.test_request_context("/messages/regenerate"):+ return self.service.generate(+ app_id=self.app_id,+ app_owner_tenant_id=self.tenant_id,+ actor=MessageEndUser(end_user_id=self.end_user_id),+ message_id=self.message_id,+ streaming=False,+ )+++def runtime(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]) -> Iterator[_Runtime]:+ tenant_id = str(uuid4())+ with sqlite_session_factory.begin() as session:+ app_record = App(+ tenant_id=tenant_id, name="Completion", mode=AppMode.COMPLETION, enable_site=True, enable_api=True+ )+ session.add(app_record)+ session.flush()+ end_user = EndUser(tenant_id=tenant_id, app_id=app_record.id, type=EndUserType.BROWSER, session_id=str(uuid4()))+ current = AppModelConfig(app_id=app_record.id, more_like_this='{"enabled":true}')+ historical = AppModelConfig(+ app_id=app_record.id,+ model=json.dumps(+ {"provider": "langgenius/openai/openai", "name": "test-model", "mode": "chat", "completion_params": {}}+ ),+ pre_prompt="Historical prompt",+ )+ session.add_all([end_user, current, historical])+ session.flush()+ app_record.app_model_config_id = current.id+ conversation = Conversation(+ app_id=app_record.id,+ app_model_config_id=historical.id,+ mode=AppMode.COMPLETION,+ name="Original completion",+ _inputs={},+ from_source=ConversationFromSource.API,+ from_end_user_id=end_user.id,+ )+ session.add(conversation)+ session.flush()+ message = Message(+ app_id=app_record.id,+ conversation_id=conversation.id,+ _inputs={},+ query="Original query",+ message={},+ answer="Original answer",+ message_unit_price=Decimal(0),+ answer_unit_price=Decimal(0),+ currency="USD",+ from_source=ConversationFromSource.API,+ from_end_user_id=end_user.id,+ )+ session.add_all([message, Provider(tenant_id=tenant_id, provider_name="invalid/provider", is_valid=True)])+ session.flush()++ factory = sessionmaker(bind=sqlite_engine)+ service = MessageMoreLikeThisService(+ repository=MessageRepository(session_factory=factory),+ generator=MessageMoreLikeThisGenerator(session_factory=factory),+ )+ app = Flask(__name__)+ app.config["SQLALCHEMY_DATABASE_URI"] = str(sqlite_engine.url)+ db.init_app(app)+ sessions: list[Session] = []++ def observe(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:+ sessions.append(session)++ event.listen(factory, "after_begin", observe)+ with app.app_context():+ event.listen(db.session.session_factory, "after_begin", observe)+ try:+ yield _Runtime(app, service, app_record.id, tenant_id, end_user.id, message.id, historical.id, sessions)+ finally:+ event.remove(db.session.session_factory, "after_begin", observe)+ db.session.remove()+ db.engine.dispose()+ event.remove(factory, "after_begin", observe)+++def test_real_model_preparation_failure_closes_queries_without_creating_records(+ runtime: _Runtime, sqlite_session_factory: sessionmaker[Session]+) -> None:+ with pytest.raises(ValueError, match="Invalid plugin id invalid/provider"):+ runtime.generate()+ assert runtime.sessions+ assert all(not session.in_transaction() and not session.identity_map for session in runtime.sessions)+ assert get_current_file_access_scope() is None+ with sqlite_session_factory() as session:+ assert session.scalar(select(func.count()).select_from(Message)) == 1+ assert session.scalar(select(func.count()).select_from(Conversation)) == 1+++def _attach_file(runtime: _Runtime, session_factory: sessionmaker[Session], *, limit: int = 2) -> UploadFile:+ upload = UploadFile(+ tenant_id=runtime.tenant_id,+ storage_type=StorageType.LOCAL,+ key="stored/image.png",+ name="image.png",+ size=123,+ extension="png",+ mime_type="image/png",+ created_by_role=CreatorUserRole.END_USER,+ created_by=runtime.end_user_id,+ created_at=datetime(2026, 1, 1, tzinfo=UTC),+ used=True,+ )+ with session_factory.begin() as session:+ config = session.get(AppModelConfig, runtime.historical_config_id)+ assert config is not None+ config.file_upload = json.dumps(+ {+ "enabled": True,+ "allowed_file_types": ["image"],+ "allowed_file_upload_methods": ["local_file"],+ "number_limits": limit,+ }+ )+ session.add(upload)+ session.add(+ MessageFile(+ message_id=runtime.message_id,+ type=FileType.IMAGE,+ transfer_method=FileTransferMethod.LOCAL_FILE,+ upload_file_id=upload.id,+ created_by_role=CreatorUserRole.END_USER,+ created_by=runtime.end_user_id,+ belongs_to=MessageFileBelongsTo.USER,+ )+ )+ return upload++[email protected]("failure", ["missing", "tenant", "owner"])+def test_file_restoration_rejects_missing_or_foreign_uploads_before_model_resolution(+ runtime: _Runtime, sqlite_session_factory: sessionmaker[Session], failure: str+) -> None:+ upload = _attach_file(runtime, sqlite_session_factory)+ with sqlite_session_factory.begin() as session:+ file = session.get(UploadFile, upload.id)+ assert file is not None+ if failure == "missing":+ session.delete(file)+ elif failure == "tenant":+ file.tenant_id = str(uuid4())+ else:+ file.created_by = str(uuid4())+ with pytest.raises(ValueError, match="Invalid upload file"):+ runtime.generate()+ assert all(not session.in_transaction() and not session.identity_map for session in runtime.sessions)+ assert get_current_file_access_scope() is None+++def test_attachment_count_limit_stops_generation(+ runtime: _Runtime, sqlite_session_factory: sessionmaker[Session]+) -> None:+ for _ in range(2):+ _attach_file(runtime, sqlite_session_factory, limit=1)+ with pytest.raises(ValueError, match="Number of image files exceeds"):+ runtime.generate()+ with sqlite_session_factory() as session:+ assert session.scalar(select(func.count()).select_from(Message)) == 1++[email protected]("as_list", [False, True])+def test_stored_input_restoration_reloads_metadata_using_the_admitted_tenant(+ runtime: _Runtime, sqlite_session_factory: sessionmaker[Session], as_list: bool+) -> None:+ uploaded = _attach_file(runtime, sqlite_session_factory)+ mapping: dict[str, JsonValue] = {+ "dify_model_identity": FILE_MODEL_IDENTITY,+ "type": "image",+ "transfer_method": "local_file",+ "related_id": uploaded.id,+ "tenant_id": str(uuid4()),+ "filename": "untrusted-name.png",+ }+ scope = FileAccessScope(+ tenant_id=runtime.tenant_id,+ user_id=runtime.end_user_id,+ user_from=UserFrom.END_USER,+ invoke_from=InvokeFrom.WEB_APP,+ )+ with bind_file_access_scope(scope):+ restored = _restore_inputs(+ {"file": [mapping] if as_list else mapping, "count": 0, "empty": "", "items": []},+ tenant_id=runtime.tenant_id,+ )+ file = restored["file"][0] if as_list else restored["file"]+ assert isinstance(file, File)+ assert file.filename == "image.png"+ assert resolve_file_record_id(file.reference) == uploaded.id+ assert restored["count"] == 0+ assert restored["empty"] == ""+ assert restored["items"] == []+ assert mapping["filename"] == "untrusted-name.png"+++def test_real_provider_initialization_commit_does_not_flush_the_callers_pending_session(+ runtime: _Runtime, sqlite_session_factory: sessionmaker[Session], monkeypatch: pytest.MonkeyPatch+) -> None:+ provider_name = "langgenius/openai/openai"+ with sqlite_session_factory.begin() as session:+ session.execute(delete(Provider).where(Provider.tenant_id == runtime.tenant_id))+ session.add(Provider(tenant_id=runtime.tenant_id, provider_name=provider_name, is_valid=True))+ # Model records are normalized after real hosting initialization commits.+ session.add(+ ProviderModel(+ tenant_id=runtime.tenant_id,+ provider_name="invalid/provider",+ model_name="broken",+ model_type=ModelType.LLM,+ is_valid=True,+ )+ )+ monkeypatch.setattr(+ ext_hosting_provider.hosting_configuration,+ "provider_map",+ {provider_name: HostingProvider(enabled=True, quota_unit=QuotaUnit.TIMES, quotas=[TrialHostingQuota()])},+ )+ caller = db.session()+ pending = caller.get(App, runtime.app_id)+ assert pending is not None+ pending.name = "Pending caller change"+ try:+ with pytest.raises(ValueError, match="Invalid plugin id invalid/provider"):+ runtime.generate()+ assert db.session() is caller+ assert caller.in_transaction()+ assert pending in caller.dirty+ with sqlite_session_factory() as session:+ trial = session.scalar(+ select(Provider).where(+ Provider.tenant_id == runtime.tenant_id,+ Provider.provider_type == ProviderType.SYSTEM,+ Provider.quota_type == ProviderQuotaType.TRIAL,+ )+ )+ assert trial is not None+ assert session.scalar(select(App.name).where(App.id == runtime.app_id)) == "Completion"+ finally:+ caller.rollback()+++ ("transfer_method", "url", "upload_file_id", "expected"),+ [+ (FileTransferMethod.LOCAL_FILE, None, None, "no upload_file_id"),+ (FileTransferMethod.REMOTE_URL, None, None, "no url"),+ (FileTransferMethod.TOOL_FILE, None, None, "no tool file reference"),+ (FileTransferMethod.DATASOURCE_FILE, None, "record", "invalid transfer_method"),+ ],+)+def test_invalid_stored_attachment_reports_the_message_file_id(+ transfer_method: FileTransferMethod, url: str | None, upload_file_id: str | None, expected: str+) -> None:+ file = MoreLikeThisFile("message-file-id", "image", transfer_method, url, upload_file_id)+ with pytest.raises(ValueError, match=f"MessageFile message-file-id .*{expected}"):+ _file_mapping(file)++[email protected]("record_id", [None, "explicit-file-id"])+def test_legacy_tool_reference_is_recovered_without_changing_the_stored_reference(record_id: str | None) -> None:+ file = MoreLikeThisFile(+ "message-file-id", "image", "tool_file", "https://example.com/tools/legacy-id.png", record_id+ )+ mapping = _file_mapping(file)+ assert mapping["tool_file_id"] == (record_id or "legacy-id")+ assert file.upload_file_id == record_id++[email protected]("termination", ["exhaust", "partial", "error"])+def test_event_stream_encodes_events_and_closes_its_source(termination: str) -> None:+ closed: list[bool] = []++ def source() -> Generator[Mapping[str, object] | str]:+ try:+ yield {"event": "message", "answer": "hello"}+ yield "ping"+ if termination == "error":+ # A real iterator failure tests this iterator wrapper's ownership.+ json.loads("{")+ finally:+ closed.append(True)++ stream = _MoreLikeThisEventStream(source())+ assert next(stream) == 'data: {"event":"message","answer":"hello"}\n\n'+ if termination == "partial":+ stream.close()+ else:+ assert next(stream) == "event: ping\n\n"+ with pytest.raises(json.JSONDecodeError if termination == "error" else StopIteration):+ next(stream)+ stream.close()+ assert closed == [True]++[email protected]("consume_all", [False, True])+def test_flask_response_close_releases_its_real_event_iterator(consume_all: bool) -> None:+ from libs.helper import compact_generate_response++ closed: list[bool] = []++ def events() -> Generator[Mapping[str, object] | str]:+ try:+ yield {"event": "message", "answer": "hello"}+ yield {"event": "message_end"}+ finally:+ closed.append(True)++ with Flask(__name__).test_request_context():+ response = compact_generate_response(_MoreLikeThisEventStream(events()))+ try:+ assert response.mimetype == "text/event-stream"+ if consume_all:+ assert response.get_data(as_text=True) == (+ 'data: {"event":"message","answer":"hello"}\n\ndata: {"event":"message_end"}\n\n'+ )+ else:+ assert next(iter(response.response)) == 'data: {"event":"message","answer":"hello"}\n\n'+ assert not closed+ finally:+ response.close()+ assert closed == [True]diff --git a/api/tests/unit_tests/services/test_message_more_like_this_service.py b/api/tests/unit_tests/services/test_message_more_like_this_service.pynew file mode 100644index 00000000000..b8698fa1da2--- /dev/null+++ b/api/tests/unit_tests/services/test_message_more_like_this_service.py@@ -0,0 +1,458 @@+"""Exercise regeneration policy and ownership through the real SQLite repository."""++import json+from collections.abc import Iterator+from dataclasses import dataclass+from decimal import Decimal+from uuid import uuid4++import pytest+from flask import Flask+from pydantic import JsonValue+from sqlalchemy import Connection, Engine, event, func, select+from sqlalchemy.orm import Session, SessionTransaction, sessionmaker++from extensions.ext_database import db+from graphon.file import FileTransferMethod, FileType+from models import Account, App, AppMode, AppModelConfig, Conversation, EndUser, Message, MessageFile+from models.enums import ConversationFromSource, CreatorUserRole, EndUserType, MessageFileBelongsTo+from models.provider import Provider+from repositories.message_repository import MessageRepository+from services.app_definition_query_service import AppDefinitionUnavailableError+from services.entities.message_entities import MessageAccount, MessageActor, MessageEndUser+from services.errors.app import MoreLikeThisDisabledError+from services.errors.app_model_config import AppModelConfigBrokenError+from services.errors.conversation import ConversationNotExistsError+from services.errors.message import MessageActorNotFoundError, MessageNotExistsError+from services.message_more_like_this_generator import MessageMoreLikeThisGenerator+from services.message_more_like_this_service import (+ MessageMoreLikeThisService,+ MoreLikeThisConfigNotFoundError,+ MoreLikeThisNotCompletionError,+ MoreLikeThisResponse,+ MoreLikeThisSource,+)+++@dataclass+class _Harness:+ service: MessageMoreLikeThisService+ repository: MessageRepository+ app_id: str+ tenant_id: str+ actor: MessageActor+ message_id: str+ conversation_id: str+ current_config_id: str+ historical_config_id: str+ committed_sessions: list[Session]+ read_sessions: list[Session]+ scoped_sessions: list[Session]++ def assert_closed(self) -> None:+ assert all(+ not session.in_transaction() and not session.identity_map+ for session in self.read_sessions + self.scoped_sessions+ )++ def source(self) -> MoreLikeThisSource:+ return self.repository.get_more_like_this_source(+ app_id=self.app_id,+ app_owner_tenant_id=self.tenant_id,+ actor=self.actor,+ message_id=self.message_id,+ )++ def generate(self) -> MoreLikeThisResponse:+ return self.service.generate(+ app_id=self.app_id,+ app_owner_tenant_id=self.tenant_id,+ actor=self.actor,+ message_id=self.message_id,+ streaming=False,+ )++[email protected](params=["account", "end_user"])+def harness(+ request: pytest.FixtureRequest, sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]+) -> Iterator[_Harness]:+ tenant_id = str(uuid4())+ with sqlite_session_factory.begin() as session:+ app = App(tenant_id=tenant_id, name="Completion", mode=AppMode.COMPLETION, enable_site=True, enable_api=True)+ account = Account(name="Viewer", email="[email protected]")+ session.add_all([app, account])+ session.flush()+ end_user = EndUser(tenant_id=tenant_id, app_id=app.id, type=EndUserType.BROWSER, session_id=str(uuid4()))+ session.add(end_user)+ session.flush()+ current = AppModelConfig(+ app_id=app.id,+ more_like_this='{"enabled":true}',+ model='{"name":"current-model","completion_params":{"temperature":0.2}}',+ )+ historical = AppModelConfig(+ app_id=app.id,+ more_like_this='{"enabled":false}',+ model='{"provider":"langgenius/openai/openai","name":"historical-model","mode":"chat","completion_params":{"temperature":0.1,"top_p":0.8}}',+ pre_prompt="Historical prompt",+ )+ session.add_all(+ [current, historical, Provider(tenant_id=tenant_id, provider_name="invalid/provider", is_valid=True)]+ )+ app.app_model_config_id = current.id+ is_account = request.param == "account"+ actor: MessageActor = (+ MessageAccount(account_id=account.id) if is_account else MessageEndUser(end_user_id=end_user.id)+ )+ from_source = ConversationFromSource.CONSOLE if is_account else ConversationFromSource.API+ conversation = Conversation(+ app_id=app.id,+ app_model_config_id=historical.id,+ mode=AppMode.COMPLETION,+ name="Earlier completion",+ _inputs={},+ from_source=from_source,+ from_account_id=account.id if is_account else None,+ from_end_user_id=None if is_account else end_user.id,+ )+ session.add(conversation)+ session.flush()+ message = Message(+ app_id=app.id,+ conversation_id=conversation.id,+ _inputs={"count": 0, "empty": "", "items": [], "optional": None},+ query="Original query",+ message={},+ answer="Original answer",+ message_unit_price=Decimal(0),+ answer_unit_price=Decimal(0),+ currency="USD",+ from_source=from_source,+ from_account_id=account.id if is_account else None,+ from_end_user_id=None if is_account else end_user.id,+ )+ session.add(message)+ session.flush()++ read_sessions: list[Session] = []+ scoped_sessions: list[Session] = []+ committed_sessions: list[Session] = []+ factory = sessionmaker(bind=sqlite_engine, expire_on_commit=False)++ @event.listens_for(factory, "after_begin")+ def record_read(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:+ read_sessions.append(session)++ @event.listens_for(factory, "after_commit")+ def record_commit(session: Session) -> None:+ committed_sessions.append(session)++ flask_app = Flask(__name__)+ flask_app.config.update(TESTING=True, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))+ db.init_app(flask_app)++ def record_scoped(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:+ scoped_sessions.append(session)++ event.listen(db.session.session_factory, "after_begin", record_scoped)+ repository = MessageRepository(session_factory=factory)+ with flask_app.test_request_context("/more-like-this"):+ yield _Harness(+ service=MessageMoreLikeThisService(+ repository=repository, generator=MessageMoreLikeThisGenerator(session_factory=factory)+ ),+ repository=repository,+ app_id=app.id,+ tenant_id=tenant_id,+ actor=actor,+ message_id=message.id,+ conversation_id=conversation.id,+ current_config_id=current.id,+ historical_config_id=historical.id,+ committed_sessions=committed_sessions,+ read_sessions=read_sessions,+ scoped_sessions=scoped_sessions,+ )+ event.remove(db.session.session_factory, "after_begin", record_scoped)+ with flask_app.app_context():+ db.session.remove()+ db.engine.dispose()+++def test_model_preparation_failure_preserves_historical_config_and_inputs(+ harness: _Harness, sqlite_session_factory: sessionmaker[Session]+) -> None:+ source = harness.source()+ assert source.query == "Original query"+ assert source.inputs == {"count": 0, "empty": "", "items": [], "optional": None}+ assert source.historical_model_config_id == harness.historical_config_id+ config = harness.repository.get_more_like_this_model_config(+ app_id=harness.app_id, app_owner_tenant_id=harness.tenant_id, model_config_id=harness.historical_config_id+ )+ assert config is not None+ assert config["pre_prompt"] == "Historical prompt"+ with pytest.raises(ValueError, match="Invalid plugin id invalid/provider"):+ harness.generate()+ with sqlite_session_factory() as session:+ historical = session.get(AppModelConfig, harness.historical_config_id)+ assert historical is not None+ assert historical.model is not None+ assert json.loads(historical.model)["completion_params"]["temperature"] == 0.1+ assert session.scalar(select(func.count()).select_from(Message)) == 1+ assert session.scalar(select(func.count()).select_from(Conversation)) == 1+ assert harness.committed_sessions == []+ harness.assert_closed()+++def test_shared_repository_preserves_each_use_cases_deleted_conversation_policy(+ harness: _Harness, sqlite_session_factory: sessionmaker[Session]+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = session.get(Conversation, harness.conversation_id)+ assert conversation is not None+ conversation.is_deleted = True++ with sqlite_session_factory() as session:+ with pytest.raises(ConversationNotExistsError):+ harness.repository.get_suggested_questions_context(+ session=session,+ app_id=harness.app_id,+ app_owner_tenant_id=harness.tenant_id,+ expected_app_mode=AppMode.COMPLETION,+ actor=harness.actor,+ message_id=harness.message_id,+ )+ assert session.in_transaction()++ assert harness.source().historical_model_config_id == harness.historical_config_id+ with pytest.raises(ValueError, match="Invalid plugin id invalid/provider"):+ harness.generate()+ harness.assert_closed()++[email protected]("inaccessible", ["missing", "app", "source", "owner", "opposite_actor"])+def test_rejects_messages_outside_the_complete_actor_scope_before_feature_checks(+ harness: _Harness, sqlite_session_factory: sessionmaker[Session], inaccessible: str+) -> None:+ with sqlite_session_factory.begin() as session:+ current = session.get(AppModelConfig, harness.current_config_id)+ message = session.get(Message, harness.message_id)+ assert current is not None+ assert message is not None+ current.more_like_this = '{"enabled":false}'+ if inaccessible == "missing":+ harness.message_id = str(uuid4())+ elif inaccessible == "app":+ message.app_id = str(uuid4())+ elif inaccessible == "source":+ message.from_source = (+ ConversationFromSource.API+ if isinstance(harness.actor, MessageAccount)+ else ConversationFromSource.CONSOLE+ )+ elif inaccessible == "owner":+ if isinstance(harness.actor, MessageAccount):+ message.from_account_id = str(uuid4())+ else:+ message.from_end_user_id = str(uuid4())+ elif isinstance(harness.actor, MessageAccount):+ message.from_end_user_id = str(uuid4())+ else:+ message.from_account_id = str(uuid4())++ with pytest.raises(MessageNotExistsError):+ harness.generate()+ assert harness.scoped_sessions == []+ harness.assert_closed()++[email protected]("feature", [None, "", "{}", '{"enabled":false}'])+def test_disabled_current_feature_wins_over_malformed_historical_config(+ harness: _Harness, sqlite_session_factory: sessionmaker[Session], feature: str | None+) -> None:+ with sqlite_session_factory.begin() as session:+ current = session.get(AppModelConfig, harness.current_config_id)+ historical = session.get(AppModelConfig, harness.historical_config_id)+ assert current is not None+ assert historical is not None+ current.more_like_this = feature+ historical.model = "broken-json"++ with pytest.raises(MoreLikeThisDisabledError):+ harness.generate()+ assert len(harness.read_sessions) == 1+ assert harness.scoped_sessions == []+ harness.assert_closed()+++ ("current", "field", "value"),+ [+ (True, "more_like_this", '{"secret":"private-config-value"'),+ (True, "more_like_this", '["private-config-value"]'),+ (False, "model", '{"secret":"private-config-value"'),+ (False, "model", '["private-config-value"]'),+ (False, "model", '{"completion_params":["private-config-value"]}'),+ (False, "model", None),+ ],+ ids=["feature-json", "feature-shape", "model-json", "model-shape", "parameter-shape", "missing-model"],+)+def test_corrupt_persisted_configuration_has_context_without_echoing_values(+ harness: _Harness, sqlite_session_factory: sessionmaker[Session], current: bool, field: str, value: str | None+) -> None:+ """None represents a missing model payload in an existing configuration row."""+ config_id = harness.current_config_id if current else harness.historical_config_id+ with sqlite_session_factory.begin() as session:+ config = session.get(AppModelConfig, config_id)+ assert config is not None+ if field == "more_like_this":+ config.more_like_this = value+ else:+ config.model = value++ with pytest.raises(AppModelConfigBrokenError) as caught:+ harness.generate()++ description = str(caught.value)+ assert harness.app_id in description+ if current:+ assert harness.message_id in description+ else:+ assert harness.historical_config_id in description+ assert "private-config-value" not in description+ assert harness.scoped_sessions == []+ harness.assert_closed()++[email protected]("current_config", ["missing", "foreign"])+def test_missing_or_foreign_current_config_disables_feature(+ harness: _Harness, sqlite_session_factory: sessionmaker[Session], current_config: str+) -> None:+ with sqlite_session_factory.begin() as session:+ app = session.get(App, harness.app_id)+ current = session.get(AppModelConfig, harness.current_config_id)+ assert app is not None+ assert current is not None+ if current_config == "missing":+ app.app_model_config_id = None+ else:+ current.app_id = str(uuid4())+ with pytest.raises(MoreLikeThisDisabledError):+ harness.generate()+ assert harness.scoped_sessions == []+ harness.assert_closed()++[email protected]("enabled", [0, None, ""])+def test_keeps_legacy_enabled_flag_semantics(+ harness: _Harness, sqlite_session_factory: sessionmaker[Session], enabled: JsonValue+) -> None:+ with sqlite_session_factory.begin() as session:+ current = session.get(AppModelConfig, harness.current_config_id)+ assert current is not None+ current.more_like_this = json.dumps({"enabled": enabled})+ with pytest.raises(ValueError, match="Invalid plugin id invalid/provider"):+ harness.generate()+ assert len(harness.read_sessions) == 2+ harness.assert_closed()++[email protected]("inaccessible", ["missing_app", "tenant", "mode", "actor"])+def test_rechecks_app_and_actor_before_loading_message(+ harness: _Harness, sqlite_session_factory: sessionmaker[Session], inaccessible: str+) -> None:+ expected_error: type[Exception] = AppDefinitionUnavailableError+ if inaccessible == "missing_app":+ harness.app_id = str(uuid4())+ elif inaccessible == "tenant":+ harness.tenant_id = str(uuid4())+ elif inaccessible == "mode":+ with sqlite_session_factory.begin() as session:+ app = session.get(App, harness.app_id)+ assert app is not None+ app.mode = AppMode.CHAT+ expected_error = MoreLikeThisNotCompletionError+ else:+ harness.actor = (+ MessageAccount(account_id=str(uuid4()))+ if isinstance(harness.actor, MessageAccount)+ else MessageEndUser(end_user_id=str(uuid4()))+ )+ expected_error = MessageActorNotFoundError+ with pytest.raises(expected_error):+ harness.generate()+ assert harness.scoped_sessions == []+ harness.assert_closed()+++ "inaccessible", ["missing", "app", "source", "owner", "opposite_actor", "config", "null_config", "deleted_config"]+)+def test_rejects_historical_config_outside_the_message_owner_chain(+ harness: _Harness, sqlite_session_factory: sessionmaker[Session], inaccessible: str+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = session.get(Conversation, harness.conversation_id)+ assert conversation is not None+ if inaccessible == "missing":+ message = session.get(Message, harness.message_id)+ assert message is not None+ message.conversation_id = str(uuid4())+ elif inaccessible == "app":+ conversation.app_id = str(uuid4())+ elif inaccessible == "source":+ conversation.from_source = (+ ConversationFromSource.API+ if isinstance(harness.actor, MessageAccount)+ else ConversationFromSource.CONSOLE+ )+ elif inaccessible == "owner":+ if isinstance(harness.actor, MessageAccount):+ conversation.from_account_id = str(uuid4())+ else:+ conversation.from_end_user_id = str(uuid4())+ elif inaccessible == "opposite_actor":+ if isinstance(harness.actor, MessageAccount):+ conversation.from_end_user_id = str(uuid4())+ else:+ conversation.from_account_id = str(uuid4())+ elif inaccessible == "null_config":+ conversation.app_model_config_id = None+ elif inaccessible == "deleted_config":+ conversation.app_model_config_id = str(uuid4())+ else:+ historical = session.get(AppModelConfig, harness.historical_config_id)+ assert historical is not None+ historical.app_id = str(uuid4())++ with pytest.raises(MoreLikeThisConfigNotFoundError):+ harness.generate()+ assert harness.scoped_sessions == []+ harness.assert_closed()+++def test_reads_file_references_without_restoring_or_rewriting_them(+ harness: _Harness, sqlite_session_factory: sessionmaker[Session]+) -> None:+ with sqlite_session_factory.begin() as session:+ tool_file = MessageFile(+ message_id=harness.message_id,+ type=FileType.IMAGE,+ transfer_method=FileTransferMethod.TOOL_FILE,+ url="https://example.com/files/tools/legacy-id.png",+ created_by_role=CreatorUserRole.ACCOUNT,+ created_by=str(uuid4()),+ belongs_to=MessageFileBelongsTo.ASSISTANT,+ )+ session.add(tool_file)+ source = harness.source()+ assert len(source.files) == 1+ assert source.files[0].url == "https://example.com/files/tools/legacy-id.png"+ assert source.files[0].upload_file_id is None+ assert harness.committed_sessions == []+ harness.assert_closed()+ with sqlite_session_factory() as session:+ saved = session.get(MessageFile, tool_file.id)+ assert saved is not None+ assert saved.upload_file_id is Nonediff --git a/api/tests/unit_tests/services/test_message_suggested_questions_service.py b/api/tests/unit_tests/services/test_message_suggested_questions_service.pyindex a350c5e97da..8f4f70c678d 100644--- a/api/tests/unit_tests/services/test_message_suggested_questions_service.py+++ b/api/tests/unit_tests/services/test_message_suggested_questions_service.py@@ -184,7 +184,9 @@ def harness(scoped_sessions.append(session)event.listen(db.session.session_factory, "after_begin", track_scoped)- queries = SuggestedQuestionsQuery(session_factory=read_factory, repository_factory=MessageRepository)+ queries = SuggestedQuestionsQuery(+ session_factory=read_factory, repository=MessageRepository(session_factory=read_factory)+ )with flask_app.app_context():yield _Harness(flask_app,diff --git a/packages/contracts/generated/api/web/errors.gen.ts b/packages/contracts/generated/api/web/errors.gen.tsindex c1e64b12d77..f8f8be7a441 100644--- a/packages/contracts/generated/api/web/errors.gen.ts+++ b/packages/contracts/generated/api/web/errors.gen.ts@@ -526,6 +526,7 @@ export const post16Errors = {export const get4Errors = {app_more_like_this_disabled: { status: 403, data: zAppMoreLikeThisDisabledError },+ app_unavailable: { status: 400, data: zAppUnavailableError },completion_request_error: { status: 400, data: zCompletionRequestError },model_currently_not_support: { status: 400, data: zModelCurrentlyNotSupportError },not_completion_app: { status: 400, data: zNotCompletionAppError },diff --git a/packages/contracts/generated/api/web/orpc.gen.ts b/packages/contracts/generated/api/web/orpc.gen.tsindex baed17c3901..c8a28383efd 100644--- a/packages/contracts/generated/api/web/orpc.gen.ts+++ b/packages/contracts/generated/api/web/orpc.gen.ts@@ -830,6 +830,7 @@ export const get4 = oc.output(zGetMessagesByMessageIdMoreLikeThisResponse).errors({app_more_like_this_disabled: { status: 403, data: zAppMoreLikeThisDisabledError },+ app_unavailable: { status: 400, data: zAppUnavailableError },completion_request_error: { status: 400, data: zCompletionRequestError },model_currently_not_support: { status: 400, data: zModelCurrentlyNotSupportError },not_completion_app: { status: 400, data: zNotCompletionAppError },diff --git a/packages/contracts/generated/api/web/types.gen.ts b/packages/contracts/generated/api/web/types.gen.tsindex ec7272063aa..349c98900a0 100644--- a/packages/contracts/generated/api/web/types.gen.ts+++ b/packages/contracts/generated/api/web/types.gen.ts@@ -2003,6 +2003,7 @@ export type GetMessagesByMessageIdMoreLikeThisData = {export type GetMessagesByMessageIdMoreLikeThisErrors = {400:+ | AppUnavailableError| CompletionRequestError| ModelCurrentlyNotSupportError| NotCompletionAppError