Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

refactor(api): unify more-like-this generation across Web and Explore (#43715)

非法操作173d52d46abe
diff --git a/api/.importlinter b/api/.importlinter
index 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_service
core.app.apps.chat.app_generator -> services.conversation_service
core.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.message
core.app.apps.message_based_app_generator -> services.errors.app_model_config
core.app.apps.message_based_app_generator -> services.errors.conversation
core.app.apps.message_based_app_generator -> services.errors.message
@@ -1038,6 +1036,20 @@ forbidden_modules =
services.agent.roster_service
allow_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 neutral
type = forbidden
diff --git a/api/controllers/console/explore/message.py b/api/controllers/console/explore/message.py
index 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 AccountNotFoundError
from services.app_definition_query_service import AppDefinitionUnavailableError
from services.entities.message_entities import MessageAccount
from services.errors.app import MoreLikeThisDisabledError
+from services.errors.app_model_config import AppModelConfigBrokenError
from services.errors.base import BaseServiceError
from services.errors.conversation import ConversationNotExistsError
from 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 InstalledAppNotCompletionError
from 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 error
except (AccountNotFoundError, MessageActorNotFoundError) as error:
raise UnauthorizedError("Account no longer exists.") from error
except MessageNotChatAppError as error:
raise NotChatAppError() from error
- except InstalledAppNotCompletionError as error:
+ except MoreLikeThisNotCompletionError as error:
raise NotCompletionAppError() from error
except 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.py
index b9b27b7cb26..7fa3c025874 100644
--- a/api/controllers/web/message.py
+++ b/api/controllers/web/message.py
@@ -3,14 +3,13 @@ from http import HTTPStatus
from typing import Literal
from uuid import UUID
+from flask import Response
from pydantic import BaseModel, Field, TypeAdapter
-from sqlalchemy.orm import Session
from controllers.common.controller_schemas import MessageFeedbackPayload, MessageListQuery
from controllers.common.errors import InternalServerError, NotFoundError
from controllers.common.fields import GeneratedAppResponse
from controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_models
-from controllers.console.app.wraps import with_session
from controllers.console.wraps import model_validate
from controllers.web import web_ns
from 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 InvokeFrom
from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
from extensions.ext_application_services import application_services
from extensions.ext_database import db
@@ -33,14 +31,15 @@ from fields.conversation_fields import MessageResponseSource, ResultResponse
from fields.message_fields import SuggestedQuestionsResponse, WebMessageInfiniteScrollPagination, WebMessageListItem
from graphon.model_runtime.errors.invoke import InvokeError
from libs import helper
+from libs.exception import BaseHTTPException
from libs.external_api import error_responses
from models.enums import FeedbackRating
from models.model import App, AppMode, EndUser
from services.agent.errors import AgentVersionNotFoundError
from services.app_definition_query_service import AppDefinitionUnavailableError
-from services.app_generate_service import AppGenerateService
from services.entities.message_entities import 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 (
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 MessageService
logger = 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_response
return 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 error
except MessageNotExistsError as caught_error:
raise NotFoundError("Message Not Exists.") from caught_error
except MoreLikeThisDisabledError as caught_error:
@@ -223,8 +230,8 @@ class MessageMoreLikeThisApi(WebApiResource):
raise ProviderModelCurrentlyNotSupportError() from caught_error
except InvokeError as e:
raise CompletionRequestError(e.description) from e
- except ValueError as e:
- raise e
+ except (BaseHTTPException, ValueError):
+ raise
except Exception as caught_error:
logger.exception("internal server error.")
raise InternalServerError() from caught_error
diff --git a/api/core/app/apps/agent_app/app_generator.py b/api/core/app/apps/agent_app/app_generator.py
index 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.py
index 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.py
index 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.py
index 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.py
index 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, overload
from flask import Flask, copy_current_request_context, current_app
from pydantic import ValidationError
-from sqlalchemy import select
-from sqlalchemy.orm import Session
+from sqlalchemy.orm import Session, sessionmaker
from configs import dify_config
from core.app.app_config.easy_ui_based_app.model_config.converter import ModelConfigConverter
@@ -21,16 +20,15 @@ from core.app.apps.exc import GenerateTaskStoppedError
from core.app.apps.message_based_app_generator import MessageBasedAppGenerator
from core.app.apps.message_based_app_queue_manager import MessageBasedAppQueueManager
from core.app.entities.app_invoke_entities import CompletionAppGenerateEntity, InvokeFrom
+from core.app.entities.task_entities import AppBlockingResponse, AppStreamResponse
from core.db.session_factory import session_factory
from core.helper.trace_id_helper import extract_trace_session_id_from_args
from core.ops.ops_trace_manager import TraceQueueManager
from extensions.ext_database import db
from factories import file_factory
from graphon.model_runtime.errors.invoke import InvokeAuthorizationError
-from models import Account, App, AppModelConfig, Conversation, EndUser, Message
+from models import Account, App, Conversation, EndUser, Message
from models.model import load_annotation_reply_config
-from services.errors.app import MoreLikeThisDisabledError
-from services.errors.message import MessageNotExistsError
logger = 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: ignore
application_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.py
index 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 db
from extensions.ext_redis import get_pubsub_broadcast_channel
from libs.broadcast_channel.channel import SupportsPreparedSubscription, Topic
from libs.datetime_utils import naive_utc_now
-from models import Account
from 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, MessageFile
from services.errors.app_model_config import AppModelConfigBrokenError
from services.errors.conversation import ConversationNotExistsError
from 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.py
index 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 DatasetApiKeyService
from services.knowledge_fs.builtin_tool.knowledge_fs.knowledge_fs import KnowledgeFSProvider
from services.knowledge_fs.workflow_runtime import build_knowledge_fs_node_dependencies
from services.message_file_preview_service import MessageFilePreviewService
+from services.message_more_like_this_generator import MessageMoreLikeThisGenerator
+from services.message_more_like_this_service import MessageMoreLikeThisService
from services.message_suggested_questions_generator import SuggestedQuestionsGenerator
from services.message_suggested_questions_queries import SuggestedQuestionsQuery
from services.message_suggested_questions_service import MessageSuggestedQuestions, MessageSuggestedQuestionsService
@@ -301,6 +303,7 @@ class ApplicationServices:
human_input_file_uploads: HumanInputFileUploadService
message_file_previews: MessageFilePreviewService
message_suggested_questions: MessageSuggestedQuestions
+ message_more_like_this: MessageMoreLikeThisService
plugin_file_uploads: PluginFileUploadService
tool_file_downloads: ToolFileDownloadService
upload_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.md
index 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.py
index 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 JsonValue
from sqlalchemy import select
-from sqlalchemy.orm import Session
+from sqlalchemy.orm import Session, sessionmaker
from 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_config
from services.app_definition_query_service import AppDefinitionUnavailableError
from services.entities.message_entities import MessageAccount, MessageActor
+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_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.py
index 94b0f108084..48e6d50ae1f 100644
--- a/api/services/app_generate_service.py
+++ b/api/services/app_generate_service.py
@@ -3,7 +3,7 @@ from __future__ import annotations
import logging
import threading
import uuid
-from collections.abc import Callable, Generator, Mapping
+from collections.abc import Callable, Mapping
from typing import TYPE_CHECKING, Any
from 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,
- )
-
@classmethod
def _get_workflow(
cls,
diff --git a/api/services/installed_app_generation_adapters.py b/api/services/installed_app_generation_adapters.py
index 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 override
from sqlalchemy.orm import Session, sessionmaker
-from core.app.apps.completion.app_generator import CompletionAppGenerator
from core.app.entities.app_invoke_entities import InvokeFrom
from models import Account, App
from services.account_errors import AccountNotFoundError
@@ -15,45 +14,12 @@ from services.app_generate_service import AppGenerateService
from services.conversation_service import ConversationService
from 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.py
index 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.py
new file mode 100644
index 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 restored
diff --git a/api/services/message_more_like_this_service.py b/api/services/message_more_like_this_service.py
new file mode 100644
index 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.py
index 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 Mapping
from copy import deepcopy
from types import MappingProxyType
@@ -31,23 +32,21 @@ from services.workflow_service import WorkflowService
class 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 = repository
def 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 None
features = 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_dict
def 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.py
index 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 generators
mock_completion_generator_instance = mock_completion_generator.return_value
mock_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 message
assert "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.py
new file mode 100644
index 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.py
index 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.py
new file mode 100644
index 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.data
diff --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.py
index 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.py
index 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.py
new file mode 100644
index 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.py
index 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"] = services
api = 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.py
new file mode 100644
index 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)) == 0
diff --git a/api/tests/unit_tests/controllers/console/explore/test_message.py b/api/tests/unit_tests/controllers/console/explore/test_message.py
index 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, Sequence
from dataclasses import dataclass, field
from datetime import datetime, timedelta
from decimal import Decimal
@@ -12,21 +12,14 @@ import pytest
from pydantic import JsonValue
from sqlalchemy import Connection, event, select, update
from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
-from werkzeug.exceptions import Forbidden
from werkzeug.test import TestResponse
import controllers.console.explore.message as module
from core.app.entities.app_invoke_entities import InvokeFrom
-from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
-from graphon.model_runtime.errors.invoke import InvokeError
from models import App, AppMode, InstalledApp
from models.enums import ConversationFromSource, ConversationStatus, FeedbackFromSource, FeedbackRating
from models.model import Conversation, Message, MessageFeedback
from repositories.installed_app_message_repository import SQLAlchemyInstalledAppMessageRepository
-from 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, InstalledAppGenerationService
from services.installed_app_message_service import InstalledAppMessageService, MessageFeedbackEvent
from 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 = None
def 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.content
self.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.py
index 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 MethodView
from controllers.common.controller_schemas import MessageFeedbackPayload, MessageListQuery
from 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 InvokeFrom
from core.entities.execution_extra_content import HumanInputContent
@@ -37,7 +31,6 @@ from models.model import (
MessageAgentThought,
MessageFeedback,
)
-from services.errors.app import MoreLikeThisDisabledError
from services.errors.message import MessageNotExistsError
from 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
- )
# ---------------------------------------------------------------------------
# MessageSuggestedQuestionApi
diff --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.py
index 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 deepcopy
from types import SimpleNamespace
import pytest
@@ -7,7 +8,8 @@ from sqlalchemy.orm import Session
import core.app.apps.completion.app_config_manager as module
from core.app.app_config.entities import EasyUIBasedAppModelConfigFrom
from 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, AppModelConfig
def _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.py
index 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 InvokeAuthorizationError
from models import Account
from models.enums import ConversationFromSource
from models.model import App, AppMode, AppModelConfig, Conversation, Message
-from services.errors.app import MoreLikeThisDisabledError
-from services.errors.message import MessageNotExistsError
TABLES = (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.py
index 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 GenerateTaskStoppedError
from core.app.apps.message_based_app_generator import MessageBasedAppGenerator
from core.app.entities.app_invoke_entities import ChatAppGenerateEntity, InvokeFrom
-from models.account import Account
from models.model import App, AppMode, Conversation, Message
from 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.py
index 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.py
index 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 json
from collections.abc import Callable, Generator, Mapping
from dataclasses import dataclass, field
-from decimal import Decimal
-from inspect import GEN_CLOSED, getgeneratorstate
from typing import cast, override
from unittest.mock import MagicMock
from 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, Workflow
from models.enums import ConversationFromSource
from models.workflow import WorkflowType
from services.account_errors import AccountNotFoundError
from services.app_definition_query_service import AppDefinitionUnavailableError
-from services.errors.app import MoreLikeThisDisabledError
from services.errors.conversation import ConversationNotExistsError
-from services.errors.message import MessageNotExistsError
from services.installed_app_generation_adapters import AppGenerateServiceRuntime
from 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_id
account_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) -> RateLi
return 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 response
assert 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 failure
assert 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_id
account_id = str(uuid4()) if missing == "account" else harness.account_id
error_type = AppDefinitionUnavailableError if missing == "app" else AccountNotFoundError
with 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) == 1
assert 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_err
session.info["close_failure"] = failure
return 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 failure
assert stream.closed is True
@@ -390,113 +310,6 @@ def test_failure_before_stream_handoff_closes_stream_without_masking_primary_err
assert 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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 None
diff --git a/api/tests/unit_tests/services/test_message_suggested_questions_service.py b/api/tests/unit_tests/services/test_message_suggested_questions_service.py
index 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.ts
index 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.ts
index 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.ts
index 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