Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
refactor(api): share conversation deletion and pin commands (#43992)
非法操作55b5265424b9
diff --git a/api/.importlinter b/api/.importlinterindex 9545ecbb7f9..9c3cdb6aa8e 100644--- a/api/.importlinter+++ b/api/.importlinter@@ -1040,10 +1040,11 @@ forbidden_modules =werkzeug[importlinter:contract:conversation-name-boundary]-name = Conversation naming policy is framework and persistence neutral+name = Conversation naming and commands are framework and persistence neutraltype = forbiddensource_modules =services.conversation_name_service+ services.conversation_command_serviceforbidden_modules =controllersextensionsdiff --git a/api/controllers/service_api/app/conversation.py b/api/controllers/service_api/app/conversation.pyindex 27d5a47c854..3f6cc2bd051 100644--- a/api/controllers/service_api/app/conversation.py+++ b/api/controllers/service_api/app/conversation.py@@ -233,42 +233,41 @@ class ConversationApi(Resource):@service_api_ns.route("/conversations/<uuid:conversation_id>")class ConversationDetailApi(Resource):- @error_responses(NotChatAppError)+ @error_responses(NotChatAppError, ConversationNotFoundHTTPError)@service_api_ns.doc(summary="Delete Conversation",description="Delete a conversation.",tags=["Conversations"],responses={- 204: "Conversation deleted successfully.",- 400: "`not_chat_app` : App mode does not match the API route.",- 404: "`not_found` : Conversation does not exist.",+ HTTPStatus.NO_CONTENT: "Conversation deleted successfully.",+ HTTPStatus.BAD_REQUEST: "Invalid app selection or app mode does not match the API route.",+ HTTPStatus.UNAUTHORIZED: "Invalid API credentials.",+ HTTPStatus.FORBIDDEN: "API credential, app or workspace access is unavailable.",+ HTTPStatus.NOT_FOUND: "`conversation_not_found`: Conversation does not exist for this user and app.",},)@expect_user_json(service_api_ns)@service_api_ns.doc("delete_conversation")- @service_api_ns.doc(description="Delete a specific conversation")@service_api_ns.doc(params={"conversation_id": "Conversation ID."})- @service_api_ns.doc(- responses={- 204: "Conversation deleted successfully",- 401: "Unauthorized - invalid API token",- 404: "Conversation not found",- }- )- @validate_app_token(fetch_user_arg=FetchUserArg(fetch_from=WhereisUserArg.JSON))- def delete(self, app_model: App, end_user: EndUser, conversation_id: UUID):+ @service_api_end_user_admission(fetch_user_arg=FetchUserArg(fetch_from=WhereisUserArg.JSON))+ def delete(self, context: ServiceApiEndUserContext, conversation_id: UUID) -> tuple[str, HTTPStatus]:"""Delete a specific conversation."""- app_mode = AppMode.value_of(app_model.mode)+ app_mode = AppMode.value_of(context.app_mode)if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}:raise NotChatAppError()- conversation_id_str = str(conversation_id)-try:- ConversationService.delete(app_model, conversation_id_str, end_user, session=db.session())- except services.errors.conversation.ConversationNotExistsError as caught_error:- raise NotFound("Conversation Not Exists.") from caught_error- return "", 204+ application_services().conversation_commands.delete(+ ref=EndUserConversationRef(+ app_id=context.app_id,+ tenant_id=context.tenant_id,+ end_user_id=context.end_user_id,+ conversation_id=str(conversation_id),+ )+ )+ except services.errors.conversation.ConversationNotExistsError as error:+ raise ConversationNotFoundHTTPError() from error+ return "", HTTPStatus.NO_CONTENT@service_api_ns.route("/conversations/<uuid:conversation_id>/name")diff --git a/api/controllers/web/conversation.py b/api/controllers/web/conversation.pyindex f84b0782673..4e373ec4b42 100644--- a/api/controllers/web/conversation.py+++ b/api/controllers/web/conversation.py@@ -26,7 +26,6 @@ from fields.conversation_fields import (from libs.external_api import error_responsesfrom libs.helper import dump_response, uuid_valuefrom models.model import App, AppMode, EndUser-from services.conversation_service import ConversationServicefrom services.entities.conversation_entities import EndUserConversationReffrom services.errors.conversation import ConversationNotExistsError, LastConversationNotExistsErrorfrom services.errors.message import MessageNotExistsError@@ -106,30 +105,37 @@ class ConversationListApi(WebApiResource):@web_ns.route("/conversations/<uuid:c_id>")class ConversationApi(WebApiResource):- @error_responses(NotChatAppError)+ @error_responses(NotChatAppError, ConversationNotFoundHTTPError)@web_ns.doc("Delete Conversation")@web_ns.doc(description="Delete a specific conversation.")@web_ns.doc(params={"c_id": {"description": "Conversation UUID", "type": "string", "required": True}})@web_ns.doc(responses={- 204: "Conversation deleted successfully",- 400: "Bad Request",- 401: "Unauthorized",- 404: "Conversation Not Found or Not a Chat App",- 500: "Internal Server Error",+ HTTPStatus.NO_CONTENT: "Conversation deleted successfully",+ HTTPStatus.BAD_REQUEST: "Bad Request",+ HTTPStatus.UNAUTHORIZED: "Unauthorized",+ HTTPStatus.NOT_FOUND: "`conversation_not_found`: Conversation does not exist for this user and app.",+ HTTPStatus.INTERNAL_SERVER_ERROR: "Internal Server Error",})- def delete(self, app_model: App, end_user: EndUser, c_id: UUID):+ def delete(self, app_model: App, end_user: EndUser, c_id: UUID) -> tuple[str, HTTPStatus]:app_mode = AppMode.value_of(app_model.mode)if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}:raise NotChatAppError()conversation_id = str(c_id)try:- ConversationService.delete(app_model, conversation_id, end_user, session=db.session())- except ConversationNotExistsError as caught_error:- raise NotFound("Conversation Not Exists.") from caught_error- return "", 204+ application_services().conversation_commands.delete(+ ref=EndUserConversationRef(+ app_id=app_model.id,+ tenant_id=app_model.tenant_id,+ end_user_id=end_user.id,+ conversation_id=conversation_id,+ )+ )+ except ConversationNotExistsError as error:+ raise ConversationNotFoundHTTPError() from error+ return "", HTTPStatus.NO_CONTENT@web_ns.route("/conversations/<uuid:c_id>/name")@@ -195,21 +201,21 @@ class ConversationRenameApi(WebApiResource):@web_ns.route("/conversations/<uuid:c_id>/pin")class ConversationPinApi(WebApiResource):- @error_responses(NotChatAppError)+ @error_responses(NotChatAppError, ConversationNotFoundHTTPError)@web_ns.doc("Pin Conversation")@web_ns.doc(description="Pin a specific conversation to keep it at the top of the list.")@web_ns.doc(params={"c_id": {"description": "Conversation UUID", "type": "string", "required": True}})@web_ns.doc(responses={- 200: "Conversation pinned successfully",- 400: "Bad Request",- 401: "Unauthorized",- 404: "Conversation Not Found or Not a Chat App",- 500: "Internal Server Error",+ HTTPStatus.OK: "Conversation pinned successfully",+ HTTPStatus.BAD_REQUEST: "Bad Request",+ HTTPStatus.UNAUTHORIZED: "Unauthorized",+ HTTPStatus.NOT_FOUND: "`conversation_not_found`: Conversation does not exist for this user and app.",+ HTTPStatus.INTERNAL_SERVER_ERROR: "Internal Server Error",})- @web_ns.response(200, "Conversation pinned successfully", web_ns.models[ResultResponse.__name__])- def patch(self, app_model: App, end_user: EndUser, c_id: UUID):+ @web_ns.response(HTTPStatus.OK, "Conversation pinned successfully", web_ns.models[ResultResponse.__name__])+ def patch(self, app_model: App, end_user: EndUser, c_id: UUID) -> dict[str, object]:app_mode = AppMode.value_of(app_model.mode)if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}:raise NotChatAppError()@@ -217,35 +223,54 @@ class ConversationPinApi(WebApiResource):conversation_id = str(c_id)try:- WebConversationService.pin(app_model, conversation_id, end_user, db.session())- except ConversationNotExistsError as caught_error:- raise NotFound("Conversation Not Exists.") from caught_error+ application_services().conversation_commands.set_pinned(+ ref=EndUserConversationRef(+ app_id=app_model.id,+ tenant_id=app_model.tenant_id,+ end_user_id=end_user.id,+ conversation_id=conversation_id,+ ),+ is_pinned=True,+ )+ except ConversationNotExistsError as error:+ raise ConversationNotFoundHTTPError() from errorreturn ResultResponse(result="success").model_dump(mode="json")@web_ns.route("/conversations/<uuid:c_id>/unpin")class ConversationUnPinApi(WebApiResource):- @error_responses(NotChatAppError)+ @error_responses(NotChatAppError, ConversationNotFoundHTTPError)@web_ns.doc("Unpin Conversation")- @web_ns.doc(description="Unpin a specific conversation to remove it from the top of the list.")+ @web_ns.doc(description="Remove the current user's pin. Succeeds when the conversation is already unpinned.")@web_ns.doc(params={"c_id": {"description": "Conversation UUID", "type": "string", "required": True}})@web_ns.doc(responses={- 200: "Conversation unpinned successfully",- 400: "Bad Request",- 401: "Unauthorized",- 404: "Conversation Not Found or Not a Chat App",- 500: "Internal Server Error",+ HTTPStatus.OK: "Conversation unpinned successfully",+ HTTPStatus.BAD_REQUEST: "Bad Request",+ HTTPStatus.UNAUTHORIZED: "Unauthorized",+ HTTPStatus.NOT_FOUND: "`conversation_not_found`: The app or user is no longer available.",+ HTTPStatus.INTERNAL_SERVER_ERROR: "Internal Server Error",})- @web_ns.response(200, "Conversation unpinned successfully", web_ns.models[ResultResponse.__name__])- def patch(self, app_model: App, end_user: EndUser, c_id: UUID):+ @web_ns.response(HTTPStatus.OK, "Conversation unpinned successfully", web_ns.models[ResultResponse.__name__])+ def patch(self, app_model: App, end_user: EndUser, c_id: UUID) -> dict[str, object]:app_mode = AppMode.value_of(app_model.mode)if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}:raise NotChatAppError()conversation_id = str(c_id)- WebConversationService.unpin(app_model, conversation_id, end_user, db.session())+ try:+ application_services().conversation_commands.set_pinned(+ ref=EndUserConversationRef(+ app_id=app_model.id,+ tenant_id=app_model.tenant_id,+ end_user_id=end_user.id,+ conversation_id=conversation_id,+ ),+ is_pinned=False,+ )+ except ConversationNotExistsError as error:+ raise ConversationNotFoundHTTPError() from errorreturn ResultResponse(result="success").model_dump(mode="json")diff --git a/api/extensions/application_services/installed_app.py b/api/extensions/application_services/installed_app.pyindex c729e676fbc..96a7e2ebf69 100644--- a/api/extensions/application_services/installed_app.py+++ b/api/extensions/application_services/installed_app.py@@ -5,8 +5,8 @@ from dataclasses import dataclassfrom sqlalchemy.orm import Session, sessionmakerfrom repositories.installed_app_repository import SQLAlchemyInstalledAppRepository+from services.conversation_command_service import ConversationCommandServicefrom services.conversation_name_service import ConversationNameService-from services.conversation_service import ConversationServicefrom services.installed_app_access_service import InstalledAppAccessServicefrom services.installed_app_conversation_service import InstalledAppConversationService, InstalledAppConversationStorefrom services.installed_app_generation_adapters import AppGenerateServiceRuntime@@ -28,6 +28,7 @@ def build_installed_app_services(database_client: sessionmaker[Session],conversations: InstalledAppConversationStore,conversation_names: ConversationNameService,+ conversation_commands: ConversationCommandService,webapp_access: WebAppAccessQueryService,get_workspace_role: WorkspaceRoleLookup,webapp_auth_enabled: bool,@@ -53,6 +54,6 @@ def build_installed_app_services(conversations=InstalledAppConversationService(conversations=conversations,names=conversation_names,- enqueue_delete_cleanup=ConversationService.enqueue_delete_cleanup,+ commands=conversation_commands,),)diff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.pyindex a31ccbe8da6..607de199039 100644--- a/api/extensions/ext_application_services.py+++ b/api/extensions/ext_application_services.py@@ -136,8 +136,10 @@ from services.app_tracing_config_service import AppTracingConfigServicefrom services.billing_portal_service import BillingPortalServicefrom services.billing_service import BillingServicefrom services.compliance_download_service import ComplianceDownloadService+from services.conversation_command_service import ConversationCommandServicefrom services.conversation_name_generator import generate_conversation_namefrom services.conversation_name_service import ConversationNameService+from services.conversation_service import ConversationServicefrom services.conversation_variable_query import ConversationVariableQueryfrom services.credentials.query import CredentialQueryfrom services.enterprise.enterprise_service import EnterpriseService@@ -314,6 +316,7 @@ class ApplicationServices:billing_portal: BillingPortalServicecompliance_downloads: ComplianceDownloadServiceconversation_names: ConversationNameService+ conversation_commands: ConversationCommandServicedata_sources: DataSourceServicesknowledge: KnowledgeServicesapp_scoped_end_users: AppScopedEndUserServices@@ -577,6 +580,9 @@ def build_application_services()conversations = ConversationRepository(session_factory=database_client)conversation_names = ConversationNameService(conversations=conversations, generate_name=generate_conversation_name)+ conversation_commands = ConversationCommandService(+ conversations=conversations, enqueue_delete_cleanup=ConversationService.enqueue_delete_cleanup+ )annotations = AnnotationRepository(session_factory=database_client)messages = MessageRepository(session_factory=database_client)suggested_questions = SuggestedQuestionsQuery(@@ -613,6 +619,7 @@ def build_application_services(),rbac=rbac,conversation_names=conversation_names,+ conversation_commands=conversation_commands,accounts=account_services,apps=apps,credential_queries=CredentialQueryRepository(session_factory=database_client),@@ -688,6 +695,7 @@ def build_application_services(installed_apps=build_installed_app_services(conversations=conversations,conversation_names=conversation_names,+ conversation_commands=conversation_commands,database_client=database_client,webapp_access=webapp_access,get_workspace_role=workspace_repository.get_account_role,diff --git a/api/openapi/markdown/service-openapi.md b/api/openapi/markdown/service-openapi.mdindex 5f5dc794428..d45868ada8e 100644--- a/api/openapi/markdown/service-openapi.md+++ b/api/openapi/markdown/service-openapi.md@@ -2315,10 +2315,10 @@ Delete a conversation.| Code | Description | Schema || ---- | ----------- | ------ || 204 | Conversation deleted successfully. | |-| 400 | `not_chat_app` : App mode does not match the API route. | **application/json**: [NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> |-| 401 | Unauthorized - invalid API token | **application/json**: [ErrorResponse](#errorresponse)<br> |-| 403 | Forbidden - token scope, app, dataset, or workspace access denied | **application/json**: [ErrorResponse](#errorresponse)<br> |-| 404 | `not_found` : Conversation does not exist. | **application/json**: [ErrorResponse](#errorresponse)<br> |+| 400 | Invalid app selection or app mode does not match the API route. | **application/json**: [NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> |+| 401 | Invalid API credentials. | **application/json**: [ErrorResponse](#errorresponse)<br> |+| 403 | API credential, app or workspace access is unavailable. | **application/json**: [AppAbnormalStatusError](#appabnormalstatuserror)<br>[AppApiDisabledError](#appapidisablederror)<br>[AppNotFoundError](#appnotfounderror)<br>[ForbiddenError](#forbiddenerror)<br>[WorkspaceArchivedError](#workspacearchivederror)<br>[WorkspaceNotFoundError](#workspacenotfounderror)<br>[ErrorResponse](#errorresponse)<br> |+| 404 | `conversation_not_found`: Conversation does not exist for this user and app. | **application/json**: [ConversationNotFoundError](#conversationnotfounderror)<br>[ErrorResponse](#errorresponse)<br> || default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |### [POST] /conversations/{conversation_id}/namediff --git a/api/openapi/markdown/web-openapi.md b/api/openapi/markdown/web-openapi.mdindex e93ab4ff1a4..a83031fba6b 100644--- a/api/openapi/markdown/web-openapi.md+++ b/api/openapi/markdown/web-openapi.md@@ -149,7 +149,7 @@ Delete a specific conversation.| 204 | Conversation deleted successfully | || 400 | Bad Request | **application/json**: [NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> || 401 | Unauthorized | **application/json**: [ErrorResponse](#errorresponse)<br> |-| 404 | Conversation Not Found or Not a Chat App | **application/json**: [ErrorResponse](#errorresponse)<br> |+| 404 | `conversation_not_found`: Conversation does not exist for this user and app. | **application/json**: [ConversationNotFoundError](#conversationnotfounderror)<br>[ErrorResponse](#errorresponse)<br> || 500 | Internal Server Error | **application/json**: [ErrorResponse](#errorresponse)<br> || default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |@@ -198,12 +198,12 @@ Pin a specific conversation to keep it at the top of the list.| 200 | Conversation pinned successfully | **application/json**: [ResultResponse](#resultresponse)<br> || 400 | Bad Request | **application/json**: [NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> || 401 | Unauthorized | **application/json**: [ErrorResponse](#errorresponse)<br> |-| 404 | Conversation Not Found or Not a Chat App | **application/json**: [ErrorResponse](#errorresponse)<br> |+| 404 | `conversation_not_found`: Conversation does not exist for this user and app. | **application/json**: [ConversationNotFoundError](#conversationnotfounderror)<br>[ErrorResponse](#errorresponse)<br> || 500 | Internal Server Error | **application/json**: [ErrorResponse](#errorresponse)<br> || default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |### [PATCH] /conversations/{c_id}/unpin-Unpin a specific conversation to remove it from the top of the list.+Remove the current user's pin. Succeeds when the conversation is already unpinned.#### Parameters@@ -218,7 +218,7 @@ Unpin a specific conversation to remove it from the top of the list.| 200 | Conversation unpinned successfully | **application/json**: [ResultResponse](#resultresponse)<br> || 400 | Bad Request | **application/json**: [NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> || 401 | Unauthorized | **application/json**: [ErrorResponse](#errorresponse)<br> |-| 404 | Conversation Not Found or Not a Chat App | **application/json**: [ErrorResponse](#errorresponse)<br> |+| 404 | `conversation_not_found`: The app or user is no longer available. | **application/json**: [ConversationNotFoundError](#conversationnotfounderror)<br>[ErrorResponse](#errorresponse)<br> || 500 | Internal Server Error | **application/json**: [ErrorResponse](#errorresponse)<br> || default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |diff --git a/api/repositories/conversation_repository.py b/api/repositories/conversation_repository.pyindex a036d7c4394..b6c95ee836d 100644--- a/api/repositories/conversation_repository.py+++ b/api/repositories/conversation_repository.py@@ -104,12 +104,9 @@ class ConversationRepository:renamed = replace(record, name=conversation.name, updated_at=conversation.updated_at)return renamed- def delete(self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str) -> ConversationDeletion:+ def delete(self, *, ref: ConversationRef) -> ConversationDeletion:with self._session_factory.begin() as session:- app = self._get_app(session=session, installed_app=installed_app)- conversation = self._get_conversation(- session=session, app_id=app.id, account_id=account_id, conversation_id=conversation_id- )+ app, conversation = self._resolve(session=session, ref=ref)retired_workspace_ids = retire_conversation(app_model=app, conversation=conversation, session=session)return ConversationDeletion(tenant_id=app.tenant_id,@@ -117,36 +114,53 @@ class ConversationRepository:retired_workspace_ids=retired_workspace_ids,)- def set_pinned(- self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str, is_pinned: bool- ) -> None:+ def set_pinned(self, *, ref: ConversationRef, is_pinned: bool) -> None:with self._session_factory.begin() as session:- app = self._get_app(session=session, installed_app=installed_app)+ if isinstance(ref, InstalledAppConversationRef):+ app = self._get_app(session=session, installed_app=ref.installed_app)+ role = CreatorUserRole.ACCOUNT+ actor_id = ref.account_id+ else:+ app = session.scalar(+ select(App)+ .join(EndUser, EndUser.app_id == App.id)+ .where(+ App.id == ref.app_id,+ App.tenant_id == ref.tenant_id,+ EndUser.id == ref.end_user_id,+ EndUser.tenant_id == App.tenant_id,+ )+ )+ if app is None:+ raise ConversationNotExistsError(+ f"Conversation {ref.conversation_id} is unavailable for this end user and app."+ )+ role = CreatorUserRole.END_USER+ actor_id = ref.end_user_idpin = session.scalar(select(PinnedConversation).where(PinnedConversation.app_id == app.id,- PinnedConversation.conversation_id == conversation_id,- PinnedConversation.created_by_role == CreatorUserRole.ACCOUNT,- PinnedConversation.created_by == account_id,+ PinnedConversation.conversation_id == ref.conversation_id,+ PinnedConversation.created_by_role == role,+ PinnedConversation.created_by == actor_id,).limit(1))if is_pinned:if pin is not None:return- conversation = self._get_conversation(- session=session, app_id=app.id, account_id=account_id, conversation_id=conversation_id- )+ _, conversation = self._resolve(session=session, ref=ref)session.add(PinnedConversation(app_id=app.id,conversation_id=conversation.id,- created_by_role=CreatorUserRole.ACCOUNT,- created_by=account_id,+ created_by_role=role,+ created_by=actor_id,))elif pin is not None:+ # Unpin remains idempotent even after its conversation is deleted.session.delete(pin)@classmethoddiff --git a/api/services/conversation_command_service.py b/api/services/conversation_command_service.pynew file mode 100644index 00000000000..e3f8f935183--- /dev/null+++ b/api/services/conversation_command_service.py@@ -0,0 +1,37 @@+"""Mutate owned conversations and dispatch cleanup after persistence commits."""++from typing import Protocol++from services.entities.conversation_entities import ConversationDeletion, ConversationRef+++class ConversationCommandStore(Protocol):+ def delete(self, *, ref: ConversationRef) -> ConversationDeletion:+ """Commit soft deletion and workspace retirement before returning cleanup data."""+ ...++ def set_pinned(self, *, ref: ConversationRef, is_pinned: bool) -> None:+ """Set the caller's pin; removing an absent pin succeeds."""+ ...+++class ConversationCleanup(Protocol):+ def __call__(self, *, tenant_id: str, conversation_id: str, retired_workspace_ids: tuple[str, ...]) -> None: ...+++class ConversationCommandService:+ def __init__(self, *, conversations: ConversationCommandStore, enqueue_delete_cleanup: ConversationCleanup) -> None:+ self._conversations: ConversationCommandStore = conversations+ self._enqueue_delete_cleanup: ConversationCleanup = enqueue_delete_cleanup++ def delete(self, *, ref: ConversationRef) -> None:+ deleted = self._conversations.delete(ref=ref)+ # The retirement and soft-delete commit must precede physical cleanup.+ self._enqueue_delete_cleanup(+ tenant_id=deleted.tenant_id,+ conversation_id=deleted.conversation_id,+ retired_workspace_ids=deleted.retired_workspace_ids,+ )++ def set_pinned(self, *, ref: ConversationRef, is_pinned: bool) -> None:+ self._conversations.set_pinned(ref=ref, is_pinned=is_pinned)diff --git a/api/services/installed_app_conversation_service.py b/api/services/installed_app_conversation_service.pyindex 10fd969f038..cd741185b3b 100644--- a/api/services/installed_app_conversation_service.py+++ b/api/services/installed_app_conversation_service.py@@ -2,9 +2,9 @@from typing import Protocol+from services.conversation_command_service import ConversationCommandServicefrom services.conversation_name_service import ConversationNameServicefrom services.entities.conversation_entities import (- ConversationDeletion,ConversationPage,ConversationRecord,InstalledAppConversationRef,@@ -21,18 +21,6 @@ class InstalledAppConversationStore(Protocol):self, *, installed_app: InstalledAppRef, account_id: str, last_id: str | None, limit: int, pinned: bool | None) -> ConversationPage: ...- def delete(- self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str- ) -> ConversationDeletion: ...-- def set_pinned(- self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str, is_pinned: bool- ) -> None: ...---class ConversationCleanup(Protocol):- def __call__(self, *, tenant_id: str, conversation_id: str, retired_workspace_ids: tuple[str, ...]) -> None: ...-class InstalledAppConversationService:def __init__(@@ -40,11 +28,11 @@ class InstalledAppConversationService:*,conversations: InstalledAppConversationStore,names: ConversationNameService,- enqueue_delete_cleanup: ConversationCleanup,+ commands: ConversationCommandService,) -> None:self._conversations: InstalledAppConversationStore = conversationsself._names = names- self._enqueue_delete_cleanup: ConversationCleanup = enqueue_delete_cleanup+ self._commands = commandsdef get_page(self, *, installed_app: InstalledAppRef, account_id: str, last_id: str | None, limit: int, pinned: bool | None@@ -80,22 +68,21 @@ class InstalledAppConversationService:def delete(self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str) -> None:self._get_chat_mode(installed_app)- deleted = self._conversations.delete(- installed_app=installed_app, account_id=account_id, conversation_id=conversation_id- )- # The retirement and soft-delete commit must precede physical cleanup.- self._enqueue_delete_cleanup(- tenant_id=deleted.tenant_id,- conversation_id=deleted.conversation_id,- retired_workspace_ids=deleted.retired_workspace_ids,+ self._commands.delete(+ ref=InstalledAppConversationRef(+ installed_app=installed_app, account_id=account_id, conversation_id=conversation_id+ ))def set_pinned(self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str, is_pinned: bool) -> None:self._get_chat_mode(installed_app)- self._conversations.set_pinned(- installed_app=installed_app, account_id=account_id, conversation_id=conversation_id, is_pinned=is_pinned+ self._commands.set_pinned(+ ref=InstalledAppConversationRef(+ installed_app=installed_app, account_id=account_id, conversation_id=conversation_id+ ),+ is_pinned=is_pinned,)@staticmethoddiff --git a/api/services/web_conversation_service.py b/api/services/web_conversation_service.pyindex 96d95d5f5ac..d6d5cda594c 100644--- a/api/services/web_conversation_service.py+++ b/api/services/web_conversation_service.py@@ -4,7 +4,6 @@ from sqlalchemy.orm import Sessionfrom core.app.entities.app_invoke_entities import InvokeFromfrom libs.infinite_scroll_pagination import InfiniteScrollPaginationfrom models import Account-from models.enums import CreatorUserRolefrom models.model import App, EndUserfrom models.web import PinnedConversationfrom services.conversation_service import ConversationService@@ -56,56 +55,3 @@ class WebConversationService:exclude_ids=exclude_ids,sort_by=sort_by,)-- @classmethod- def pin(cls, app_model: App, conversation_id: str, user: Account | EndUser | None, session: Session):- if not user:- return- pinned_conversation = session.scalar(- select(PinnedConversation)- .where(- PinnedConversation.app_id == app_model.id,- PinnedConversation.conversation_id == conversation_id,- PinnedConversation.created_by_role == ("account" if isinstance(user, Account) else "end_user"),- PinnedConversation.created_by == user.id,- )- .limit(1)- )-- if pinned_conversation:- return-- conversation = ConversationService.get_conversation(- app_model=app_model, conversation_id=conversation_id, user=user, session=session- )-- pinned_conversation = PinnedConversation(- app_id=app_model.id,- conversation_id=conversation.id,- created_by_role=CreatorUserRole.ACCOUNT if isinstance(user, Account) else CreatorUserRole.END_USER,- created_by=user.id,- )-- session.add(pinned_conversation)- session.commit()-- @classmethod- def unpin(cls, app_model: App, conversation_id: str, user: Account | EndUser | None, session: Session):- if not user:- return- pinned_conversation = session.scalar(- select(PinnedConversation)- .where(- PinnedConversation.app_id == app_model.id,- PinnedConversation.conversation_id == conversation_id,- PinnedConversation.created_by_role == ("account" if isinstance(user, Account) else "end_user"),- PinnedConversation.created_by == user.id,- )- .limit(1)- )-- if not pinned_conversation:- return-- session.delete(pinned_conversation)- session.commit()diff --git a/api/tests/e2e_tests/containers/controllers/web/test_conversation.py b/api/tests/e2e_tests/containers/controllers/web/test_conversation.pyindex 177b29aa50b..aa199e179ff 100644--- a/api/tests/e2e_tests/containers/controllers/web/test_conversation.py+++ b/api/tests/e2e_tests/containers/controllers/web/test_conversation.py@@ -8,16 +8,9 @@ from uuid import uuid4import pytestfrom flask import Flask-from werkzeug.exceptions import NotFound--from controllers.web.conversation import (- ConversationApi,- ConversationListApi,- ConversationPinApi,- ConversationUnPinApi,-)++from controllers.web.conversation import ConversationListApifrom controllers.web.error import NotChatAppError-from services.errors.conversation import ConversationNotExistsErrordef _chat_app() -> SimpleNamespace:@@ -61,75 +54,3 @@ class TestConversationListApi:assert result["limit"] == 20assert result["has_more"] is False---class TestConversationApi:- @pytest.fixture- def app(self, flask_app_with_containers: Flask):- return flask_app_with_containers-- def test_non_chat_mode_raises(self, app: Flask) -> None:- with app.test_request_context(f"/conversations/{uuid4()}"):- with pytest.raises(NotChatAppError):- ConversationApi().delete(_completion_app(), _end_user(), uuid4())-- @patch("controllers.web.conversation.ConversationService.delete")- def test_delete_success(self, mock_delete: MagicMock, app: Flask) -> None:- c_id = uuid4()- with app.test_request_context(f"/conversations/{c_id}"):- result, status = ConversationApi().delete(_chat_app(), _end_user(), c_id)-- assert status == 204- assert result == ""-- @patch("controllers.web.conversation.ConversationService.delete", side_effect=ConversationNotExistsError())- def test_delete_not_found(self, mock_delete: MagicMock, app: Flask) -> None:- c_id = uuid4()- with app.test_request_context(f"/conversations/{c_id}"):- with pytest.raises(NotFound, match="Conversation Not Exists"):- ConversationApi().delete(_chat_app(), _end_user(), c_id)---class TestConversationPinApi:- @pytest.fixture- def app(self, flask_app_with_containers: Flask):- return flask_app_with_containers-- def test_non_chat_mode_raises(self, app: Flask) -> None:- with app.test_request_context(f"/conversations/{uuid4()}/pin", method="PATCH"):- with pytest.raises(NotChatAppError):- ConversationPinApi().patch(_completion_app(), _end_user(), uuid4())-- @patch("controllers.web.conversation.WebConversationService.pin")- def test_pin_success(self, mock_pin: MagicMock, app: Flask) -> None:- c_id = uuid4()- with app.test_request_context(f"/conversations/{c_id}/pin", method="PATCH"):- result = ConversationPinApi().patch(_chat_app(), _end_user(), c_id)-- assert result["result"] == "success"-- @patch("controllers.web.conversation.WebConversationService.pin", side_effect=ConversationNotExistsError())- def test_pin_not_found(self, mock_pin: MagicMock, app: Flask) -> None:- c_id = uuid4()- with app.test_request_context(f"/conversations/{c_id}/pin", method="PATCH"):- with pytest.raises(NotFound):- ConversationPinApi().patch(_chat_app(), _end_user(), c_id)---class TestConversationUnPinApi:- @pytest.fixture- def app(self, flask_app_with_containers: Flask):- return flask_app_with_containers-- def test_non_chat_mode_raises(self, app: Flask) -> None:- with app.test_request_context(f"/conversations/{uuid4()}/unpin", method="PATCH"):- with pytest.raises(NotChatAppError):- ConversationUnPinApi().patch(_completion_app(), _end_user(), uuid4())-- @patch("controllers.web.conversation.WebConversationService.unpin")- def test_unpin_success(self, mock_unpin: MagicMock, app: Flask) -> None:- c_id = uuid4()- with app.test_request_context(f"/conversations/{c_id}/unpin", method="PATCH"):- result = ConversationUnPinApi().patch(_chat_app(), _end_user(), c_id)-- assert result["result"] == "success"diff --git a/api/tests/e2e_tests/containers/services/test_web_conversation_service.py b/api/tests/e2e_tests/containers/services/test_web_conversation_service.pyindex 928fa6344d0..28aa37324a6 100644--- a/api/tests/e2e_tests/containers/services/test_web_conversation_service.py+++ b/api/tests/e2e_tests/containers/services/test_web_conversation_service.py@@ -2,7 +2,6 @@ from unittest.mock import patchimport pytestfrom faker import Faker-from sqlalchemy import selectfrom sqlalchemy.orm import Sessionfrom core.app.entities.app_invoke_entities import InvokeFrom@@ -299,181 +298,6 @@ class TestWebConversationService:expected_unpinned_ids = [conv.id for conv in conversations[1:]]assert set(returned_ids) == set(expected_unpinned_ids)- def test_pin_conversation_success(self, db_session_with_containers: Session, mock_external_service_dependencies):- """- Test successful pinning of a conversation.- """- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Create a conversation- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)-- # Pin the conversation- WebConversationService.pin(app, conversation.id, account, db_session_with_containers)-- # Verify the conversation was pinned-- pinned_conversation = (- db_session_with_containers.query(PinnedConversation)- .where(- PinnedConversation.app_id == app.id,- PinnedConversation.conversation_id == conversation.id,- PinnedConversation.created_by_role == "account",- PinnedConversation.created_by == account.id,- )- .first()- )-- assert pinned_conversation is not None- assert pinned_conversation.app_id == app.id- assert pinned_conversation.conversation_id == conversation.id- assert pinned_conversation.created_by_role == "account"- assert pinned_conversation.created_by == account.id-- def test_pin_conversation_already_pinned(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test pinning a conversation that is already pinned (should not create duplicate).- """- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Create a conversation- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)-- # Pin the conversation first time- WebConversationService.pin(app, conversation.id, account, db_session_with_containers)-- # Pin the conversation again- WebConversationService.pin(app, conversation.id, account, db_session_with_containers)-- # Verify only one pinned conversation record exists-- pinned_conversations = db_session_with_containers.scalars(- select(PinnedConversation).where(- PinnedConversation.app_id == app.id,- PinnedConversation.conversation_id == conversation.id,- PinnedConversation.created_by_role == "account",- PinnedConversation.created_by == account.id,- )- ).all()-- assert len(pinned_conversations) == 1-- def test_pin_conversation_with_end_user(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test pinning a conversation with an end user.- """- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Create an end user- end_user = self._create_test_end_user(db_session_with_containers, app)-- # Create a conversation for the end user- conversation = self._create_test_conversation(db_session_with_containers, app, end_user, fake)-- # Pin the conversation- WebConversationService.pin(app, conversation.id, end_user, db_session_with_containers)-- # Verify the conversation was pinned-- pinned_conversation = (- db_session_with_containers.query(PinnedConversation)- .where(- PinnedConversation.app_id == app.id,- PinnedConversation.conversation_id == conversation.id,- PinnedConversation.created_by_role == "end_user",- PinnedConversation.created_by == end_user.id,- )- .first()- )-- assert pinned_conversation is not None- assert pinned_conversation.app_id == app.id- assert pinned_conversation.conversation_id == conversation.id- assert pinned_conversation.created_by_role == "end_user"- assert pinned_conversation.created_by == end_user.id-- def test_unpin_conversation_success(self, db_session_with_containers: Session, mock_external_service_dependencies):- """- Test successful unpinning of a conversation.- """- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Create a conversation- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)-- # Pin the conversation first- WebConversationService.pin(app, conversation.id, account, db_session_with_containers)-- # Verify it was pinned-- pinned_conversation = (- db_session_with_containers.query(PinnedConversation)- .where(- PinnedConversation.app_id == app.id,- PinnedConversation.conversation_id == conversation.id,- PinnedConversation.created_by_role == "account",- PinnedConversation.created_by == account.id,- )- .first()- )-- assert pinned_conversation is not None-- # Unpin the conversation- WebConversationService.unpin(app, conversation.id, account, db_session_with_containers)-- # Verify it was unpinned- pinned_conversation = (- db_session_with_containers.query(PinnedConversation)- .where(- PinnedConversation.app_id == app.id,- PinnedConversation.conversation_id == conversation.id,- PinnedConversation.created_by_role == "account",- PinnedConversation.created_by == account.id,- )- .first()- )-- assert pinned_conversation is None-- def test_unpin_conversation_not_pinned(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test unpinning a conversation that is not pinned (should not cause error).- """- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Create a conversation- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)-- # Try to unpin a conversation that was never pinned- WebConversationService.unpin(app, conversation.id, account, db_session_with_containers)-- # Verify no pinned conversation record exists-- pinned_conversation = (- db_session_with_containers.query(PinnedConversation)- .where(- PinnedConversation.app_id == app.id,- PinnedConversation.conversation_id == conversation.id,- PinnedConversation.created_by_role == "account",- PinnedConversation.created_by == account.id,- )- .first()- )-- assert pinned_conversation is None-def test_pagination_by_last_id_user_required_error(self, db_session_with_containers: Session, mock_external_service_dependencies):@@ -495,76 +319,3 @@ class TestWebConversationService:pinned=None,sort_by="-updated_at",)-- def test_pin_conversation_user_none(self, db_session_with_containers: Session, mock_external_service_dependencies):- """- Test that pin method returns early when user is None.- """- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Create a conversation- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)-- # Try to pin with None user- WebConversationService.pin(app, conversation.id, None, db_session_with_containers)-- # Verify no pinned conversation was created-- pinned_conversation = (- db_session_with_containers.query(PinnedConversation)- .where(- PinnedConversation.app_id == app.id,- PinnedConversation.conversation_id == conversation.id,- )- .first()- )-- assert pinned_conversation is None-- def test_unpin_conversation_user_none(- self, db_session_with_containers: Session, mock_external_service_dependencies- ):- """- Test that unpin method returns early when user is None.- """- fake = Faker()- app, account = self._create_test_app_and_account(db_session_with_containers, mock_external_service_dependencies)-- # Create a conversation- conversation = self._create_test_conversation(db_session_with_containers, app, account, fake)-- # Pin the conversation first- WebConversationService.pin(app, conversation.id, account, db_session_with_containers)-- # Verify it was pinned-- pinned_conversation = (- db_session_with_containers.query(PinnedConversation)- .where(- PinnedConversation.app_id == app.id,- PinnedConversation.conversation_id == conversation.id,- PinnedConversation.created_by_role == "account",- PinnedConversation.created_by == account.id,- )- .first()- )-- assert pinned_conversation is not None-- # Try to unpin with None user- WebConversationService.unpin(app, conversation.id, None, db_session_with_containers)-- # Verify the conversation is still pinned- pinned_conversation = (- db_session_with_containers.query(PinnedConversation)- .where(- PinnedConversation.app_id == app.id,- PinnedConversation.conversation_id == conversation.id,- PinnedConversation.created_by_role == "account",- PinnedConversation.created_by == account.id,- )- .first()- )-- assert pinned_conversation is not Nonediff --git a/api/tests/e2e_tests/contracts/controllers/service_api/app/test_conversation_commands.py b/api/tests/e2e_tests/contracts/controllers/service_api/app/test_conversation_commands.pynew file mode 100644index 00000000000..bc1a86b73b3--- /dev/null+++ b/api/tests/e2e_tests/contracts/controllers/service_api/app/test_conversation_commands.py@@ -0,0 +1,298 @@+"""Delete contracts using real API tokens, EndUser admission, and SQLite writes."""++from dataclasses import dataclass+from http import HTTPStatus+from uuid import uuid4++import pytest+from sqlalchemy import event, select, update+from sqlalchemy.orm import Session, SessionTransaction+from werkzeug.test import TestResponse++from constants.resource_access_token import ResourceAccessTokenResourceType+from controllers.service_api.app.conversation import ConversationDetailApi+from machinery.context import RequestContext+from models import Tenant, TenantStatus+from models.enums import ConversationFromSource+from models.model import App, AppMode, Conversation, EndUser+from models.resource_access_token import ResourceAccessToken+from repositories.conversation_repository import ConversationRepository+from services.auth.resource_access_token_contracts import ResourceAccessTokenResource+from services.conversation_command_service import ConversationCommandService+from tests.e2e_tests.contracts.controllers.service_api.app import test_conversation_rename as rename_tests+from tests.e2e_tests.contracts.controllers.service_api.app.test_conversation_rename import _Harness as RenameHarness+from tests.e2e_tests.contracts.controllers.service_api.app.test_conversation_rename import _Services as RenameServices+from tests.helpers.unit.model_factories import make_app++rename_harness = rename_tests.harness+++@dataclass(frozen=True)+class _Services(RenameServices):+ conversation_commands: ConversationCommandService+++@dataclass(frozen=True)+class _Harness:+ source: RenameHarness+ cleanups: list[tuple[str, str, tuple[str, ...]]]++ def delete(+ self,+ *,+ conversation_id: str | None = None,+ user: str | None = "alice",+ authorization: str | None = "Bearer rename-token",+ requested_app_id: str | None = None,+ ) -> TestResponse:+ headers = {"Authorization": authorization} if authorization is not None else {}+ if requested_app_id is not None:+ headers["X-Dify-App-ID"] = requested_app_id+ return self.source.app.test_client().delete(+ f"/conversations/{conversation_id or self.source.conversation.id}",+ json={"user": user} if user is not None else {},+ headers=headers,+ )++ def assert_not_deleted(self) -> None:+ with self.source.factory() as session:+ stored = session.get(Conversation, self.source.conversation.id)+ assert stored is not None+ assert not stored.is_deleted+ assert self.cleanups == []+++def harness(rename_harness: RenameHarness) -> _Harness:+ cleanups: list[tuple[str, str, tuple[str, ...]]] = []++ def enqueue_cleanup(*, tenant_id: str, conversation_id: str, retired_workspace_ids: tuple[str, ...]) -> None:+ rename_harness.assert_closed()+ with rename_harness.factory() as session:+ stored = session.get(Conversation, conversation_id)+ assert stored is not None+ assert stored.is_deleted+ cleanups.append((tenant_id, conversation_id, retired_workspace_ids))++ original = rename_harness.app.extensions["application_services"]+ assert isinstance(original, RenameServices)+ rename_harness.app.extensions["application_services"] = _Services(+ app_definitions=original.app_definitions,+ app_scoped_end_users=original.app_scoped_end_users,+ conversation_names=original.conversation_names,+ resource_access_tokens=original.resource_access_tokens,+ conversation_commands=ConversationCommandService(+ conversations=ConversationRepository(session_factory=rename_harness.repository_factory),+ enqueue_delete_cleanup=enqueue_cleanup,+ ),+ )+ rename_harness.api.add_resource(ConversationDetailApi, "/conversations/<uuid:conversation_id>")+ return _Harness(rename_harness, cleanups)++[email protected]("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT])+def test_delete_commits_before_cleanup_after_admission_connections_close(harness: _Harness, mode: AppMode) -> None:+ source = harness.source+ with source.factory.begin() as session:+ session.execute(update(App).where(App.id == source.target.id).values(mode=mode))++ response = harness.delete()++ assert response.status_code == HTTPStatus.NO_CONTENT+ assert response.data == b""+ assert response.headers["Content-Type"] == "application/json"+ assert harness.cleanups == [(source.tenant.id, source.conversation.id, ())]+ assert source.admissions+ assert source.provisions+ assert source.queries+ assert source.scoped_sessions == []+ source.assert_closed()++ repeated = harness.delete()+ assert repeated.status_code == HTTPStatus.NOT_FOUND+ assert repeated.json is not None+ assert repeated.json["code"] == "conversation_not_found"+ assert len(harness.cleanups) == 1+ source.assert_closed()++[email protected]("field", ["app_id", "from_end_user_id", "from_source", "from_account_id", "is_deleted"])+def test_delete_rejects_conversation_outside_end_user_scope(harness: _Harness, field: str) -> None:+ source = harness.source+ value: str | bool+ if field == "is_deleted":+ value = True+ elif field == "from_source":+ value = ConversationFromSource.CONSOLE+ elif field == "from_account_id":+ value = source.end_user.id+ else:+ value = str(uuid4())+ with source.factory.begin() as session:+ session.execute(update(Conversation).where(Conversation.id == source.conversation.id).values({field: value}))++ response = harness.delete()++ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.json is not None+ assert response.json == {+ "code": "conversation_not_found",+ "message": "The conversation was not found for this user and app.",+ "status": HTTPStatus.NOT_FOUND,+ }+ assert harness.cleanups == []+ with source.factory() as session:+ stored = session.get(Conversation, source.conversation.id)+ assert stored is not None+ assert stored.is_deleted is (field == "is_deleted")+ source.assert_closed()++[email protected]("change_app_too", [False, True], ids=["end-user-workspace", "app-workspace"])+def test_workspace_change_after_admission_prevents_delete(harness: _Harness, change_app_too: bool) -> None:+ source = harness.source++ def change_owner(_session: Session, _transaction: SessionTransaction) -> None:+ with source.factory.begin() as session:+ end_user = session.get(EndUser, source.end_user.id)+ assert end_user is not None+ end_user.tenant_id = str(uuid4())+ if change_app_too:+ target = session.get(App, source.target.id)+ assert target is not None+ target.tenant_id = end_user.tenant_id++ event.listen(source.provision_factory, "after_transaction_end", change_owner, once=True)+ try:+ response = harness.delete()+ finally:+ event.remove(source.provision_factory, "after_transaction_end", change_owner)+ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.json is not None+ assert response.json["code"] == "conversation_not_found"+ harness.assert_not_deleted()+ source.assert_closed()+++def test_unknown_conversation_cannot_delete_existing_decoy(harness: _Harness) -> None:+ response = harness.delete(conversation_id=str(uuid4()))+ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.json is not None+ assert response.json["code"] == "conversation_not_found"+ harness.assert_not_deleted()+ harness.source.assert_closed()++[email protected]("user", [None, ""])+def test_anonymous_user_cannot_delete_identified_users_conversation(harness: _Harness, user: str | None) -> None:+ response = harness.delete(user=user)+ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.json is not None+ assert response.json["code"] == "conversation_not_found"+ with harness.source.factory() as session:+ end_users = session.scalars(select(EndUser)).all()+ assert len(end_users) == 2+ assert len([user for user in end_users if user.id != harness.source.end_user.id]) == 1+ harness.assert_not_deleted()+ harness.source.assert_closed()++[email protected]("authorization", [None, "Basic rename-token", "Bearer invalid-token"])+def test_invalid_token_is_rejected_before_admission(harness: _Harness, authorization: str | None) -> None:+ source = harness.source+ response = harness.delete(authorization=authorization)+ assert response.status_code == HTTPStatus.UNAUTHORIZED+ assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'+ assert response.json is not None+ assert response.json["code"] == "unauthorized"+ assert source.admissions == source.provisions == source.queries == []+ harness.assert_not_deleted()+ source.assert_closed()++[email protected]("mode", [AppMode.COMPLETION, AppMode.WORKFLOW])+def test_non_chat_mode_is_rejected_before_delete(harness: _Harness, mode: AppMode) -> None:+ source = harness.source+ with source.factory.begin() as session:+ session.execute(update(App).where(App.id == source.target.id).values(mode=mode))+ response = harness.delete()+ assert response.status_code == HTTPStatus.BAD_REQUEST+ assert response.json is not None+ assert response.json["code"] == "not_chat_app"+ assert source.queries == []+ harness.assert_not_deleted()+ source.assert_closed()+++ ("failure", "code"), [("disabled_api", "app_api_disabled"), ("archived_workspace", "workspace_archived")]+)+def test_disabled_app_or_workspace_is_rejected_before_provisioning(harness: _Harness, failure: str, code: str) -> None:+ source = harness.source+ with source.factory.begin() as session:+ if failure == "disabled_api":+ session.execute(update(App).where(App.id == source.target.id).values(enable_api=False))+ else:+ session.execute(update(Tenant).where(Tenant.id == source.tenant.id).values(status=TenantStatus.ARCHIVE))+ response = harness.delete(user="new-user")+ assert response.status_code == HTTPStatus.FORBIDDEN+ assert response.json is not None+ assert response.json["code"] == code+ assert source.provisions == source.queries == []+ with source.factory() as session:+ assert session.scalars(select(EndUser.id)).all() == [source.end_user.id]+ harness.assert_not_deleted()+ source.assert_closed()++[email protected]("multiple_apps", [False, True], ids=["implicit-single-app", "explicit-multiple-apps"])+def test_resource_token_deletes_bound_app_and_records_usage(harness: _Harness, multiple_apps: bool) -> None:+ source = harness.source+ app_ids = (source.target.id,)+ if multiple_apps:+ other = make_app(app_id=str(uuid4()), tenant_id=source.tenant.id)+ with source.factory.begin() as session:+ session.add(other)+ app_ids = (other.id, source.target.id)+ services = source.app.extensions["application_services"]+ assert isinstance(services, _Services)+ token = services.resource_access_tokens.create(+ RequestContext(+ request_id="delete-resource-token",+ trace_id=None,+ account_id=str(uuid4()),+ active_workspace_id=source.tenant.id,+ ),+ name="Delete app token",+ resources=tuple(ResourceAccessTokenResource(ResourceAccessTokenResourceType.APP, app_id) for app_id in app_ids),+ )++ response = harness.delete(+ authorization=f"Bearer {token.token}",+ requested_app_id=source.target.id if multiple_apps else None,+ )++ assert response.status_code == HTTPStatus.NO_CONTENT+ assert response.data == b""+ assert harness.cleanups == [(source.tenant.id, source.conversation.id, ())]+ source.assert_closed()+ with source.factory() as session:+ stored_token = session.get(ResourceAccessToken, token.token_id)+ assert stored_token is not None+ assert stored_token.last_used_at is not None+ assert session.scalars(select(EndUser.id)).all() == [source.end_user.id]+++def test_failed_delete_commit_rolls_back_without_publishing_cleanup(harness: _Harness) -> None:+ def reject_commit(_session: Session) -> None:+ raise RuntimeError("Database commit failed")++ source = harness.source+ event.listen(source.repository_factory, "before_commit", reject_commit)+ try:+ response = harness.delete()+ finally:+ event.remove(source.repository_factory, "before_commit", reject_commit)+ assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR+ harness.assert_not_deleted()+ source.assert_closed()diff --git a/api/tests/e2e_tests/contracts/controllers/service_api/app/test_conversation_rename.py b/api/tests/e2e_tests/contracts/controllers/service_api/app/test_conversation_rename.pyindex 9aeb6c83968..e38470ef8c5 100644--- a/api/tests/e2e_tests/contracts/controllers/service_api/app/test_conversation_rename.py+++ b/api/tests/e2e_tests/contracts/controllers/service_api/app/test_conversation_rename.py@@ -62,6 +62,8 @@ class _Harness:end_user: EndUserconversation: Conversationfactory: sessionmaker[Session]+ repository_factory: sessionmaker[Session]+ api: ExternalApiprovision_factory: sessionmaker[Session]admissions: list[Session]provisions: list[Session]@@ -185,6 +187,8 @@ def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]end_user,conversation,sqlite_session_factory,+ query_factory,+ api,provision_factory,admissions,provisions,diff --git a/api/tests/e2e_tests/contracts/controllers/web/test_conversation_commands.py b/api/tests/e2e_tests/contracts/controllers/web/test_conversation_commands.pynew file mode 100644index 00000000000..419f467045f--- /dev/null+++ b/api/tests/e2e_tests/contracts/controllers/web/test_conversation_commands.py@@ -0,0 +1,257 @@+"""Conversation commands through real Web admission and SQLite transactions."""++from dataclasses import dataclass+from http import HTTPStatus+from typing import Literal+from uuid import uuid4++import pytest+from sqlalchemy import event, select, update+from sqlalchemy.orm import Session+from werkzeug.test import TestResponse++from constants import HEADER_NAME_APP_CODE, HEADER_NAME_PASSPORT+from controllers.web.conversation import ConversationApi, ConversationPinApi, ConversationUnPinApi+from models.agent import AgentWorkingResourceStatus, AgentWorkspace, AgentWorkspaceOwnerType+from models.enums import ConversationFromSource, CreatorUserRole+from models.model import AppMode, Conversation, EndUser+from models.web import PinnedConversation+from repositories.conversation_repository import ConversationRepository+from services.conversation_command_service import ConversationCommandService+from tests.e2e_tests.contracts.controllers.web import test_conversation_rename as rename_tests+from tests.e2e_tests.contracts.controllers.web.test_conversation_rename import _Harness as RenameHarness++rename_harness = rename_tests.harness+++@dataclass(frozen=True)+class _Services:+ conversation_commands: ConversationCommandService+++@dataclass(frozen=True)+class _Harness:+ source: RenameHarness+ cleanups: list[tuple[str, str, tuple[str, ...]]]++ def request(self, action: str, *, conversation_id: str | None = None) -> TestResponse:+ path = f"/conversations/{conversation_id or self.source.conversation.id}"+ return self.source.app.test_client().open(+ path if action == "delete" else f"{path}/{action}",+ method="DELETE" if action == "delete" else "PATCH",+ headers={HEADER_NAME_APP_CODE: "public-app", HEADER_NAME_PASSPORT: self.source.passport},+ )++ def assert_not_deleted(self) -> None:+ with self.source.factory() as session:+ stored = session.get(Conversation, self.source.conversation.id)+ assert stored is not None+ assert not stored.is_deleted+ assert self.cleanups == []+++def harness(rename_harness: RenameHarness) -> _Harness:+ cleanups: list[tuple[str, str, tuple[str, ...]]] = []++ def enqueue_cleanup(*, tenant_id: str, conversation_id: str, retired_workspace_ids: tuple[str, ...]) -> None:+ # Observe the real external boundary: committed state must be visible on+ # another connection, with neither admission nor command transactions open.+ rename_harness.assert_closed()+ with rename_harness.factory() as session:+ stored = session.get(Conversation, conversation_id)+ assert stored is not None+ assert stored.is_deleted+ for workspace_id in retired_workspace_ids:+ workspace = session.get(AgentWorkspace, workspace_id)+ assert workspace is not None+ assert workspace.status == AgentWorkingResourceStatus.RETIRED+ assert workspace.active_guard is None+ assert workspace.retired_at is not None+ cleanups.append((tenant_id, conversation_id, retired_workspace_ids))++ rename_harness.app.extensions["application_services"] = _Services(+ conversation_commands=ConversationCommandService(+ conversations=ConversationRepository(session_factory=rename_harness.repository_factory),+ enqueue_delete_cleanup=enqueue_cleanup,+ )+ )+ rename_harness.api.add_resource(ConversationApi, "/conversations/<uuid:c_id>")+ rename_harness.api.add_resource(ConversationPinApi, "/conversations/<uuid:c_id>/pin")+ rename_harness.api.add_resource(ConversationUnPinApi, "/conversations/<uuid:c_id>/unpin")+ return _Harness(rename_harness, cleanups)++[email protected]("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT])+def test_delete_commits_retirement_before_cleanup_and_returns_empty_204(harness: _Harness, mode: AppMode) -> None:+ source = harness.source+ rename_tests._publish_mode(source, mode)+ with source.factory.begin() as session:+ workspace = AgentWorkspace(+ id=str(uuid4()),+ tenant_id=source.target.tenant_id,+ app_id=source.target.id,+ owner_type=AgentWorkspaceOwnerType.CONVERSATION,+ owner_id=source.conversation.id,+ owner_scope_key="chatflow-node",+ backend_workspace_ref="backend-workspace",+ status=AgentWorkingResourceStatus.ACTIVE,+ active_guard=1,+ )+ session.add(workspace)++ response = harness.request("delete")++ assert response.status_code == HTTPStatus.NO_CONTENT+ assert response.data == b""+ assert response.headers["Content-Type"] == "application/json"+ assert harness.cleanups == [(source.target.tenant_id, source.conversation.id, (workspace.id,))]+ assert source.repository_sessions+ source.assert_closed()++ repeated = harness.request("delete")+ assert repeated.status_code == HTTPStatus.NOT_FOUND+ assert repeated.json is not None+ assert repeated.json["code"] == "conversation_not_found"+ assert len(harness.cleanups) == 1+ source.assert_closed()++[email protected]("action", ["delete", "pin"])[email protected]("field", ["app_id", "from_end_user_id", "from_source", "from_account_id", "is_deleted"])+def test_commands_cannot_target_conversations_outside_end_user_scope(+ harness: _Harness, action: str, field: str+) -> None:+ source = harness.source+ value: str | bool+ if field == "is_deleted":+ value = True+ elif field == "from_source":+ value = ConversationFromSource.CONSOLE+ elif field == "from_account_id":+ # Account and EndUser IDs are independent namespaces, even if equal.+ value = source.end_user.id+ else:+ value = str(uuid4())+ with source.factory.begin() as session:+ session.execute(update(Conversation).where(Conversation.id == source.conversation.id).values({field: value}))++ response = harness.request(action)++ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.json is not None+ assert response.json["code"] == "conversation_not_found"+ assert harness.cleanups == []+ with source.factory() as session:+ stored = session.get(Conversation, source.conversation.id)+ assert stored is not None+ assert stored.is_deleted is (field == "is_deleted")+ assert session.scalars(select(PinnedConversation)).all() == []+ source.assert_closed()++[email protected]("action", ["delete", "pin", "unpin"])[email protected]("field", ["tenant_id", "app_id"])+def test_commands_reject_end_user_outside_app_owner_scope(+ harness: _Harness, action: str, field: Literal["tenant_id", "app_id"]+) -> None:+ source = harness.source+ with source.factory.begin() as session:+ session.execute(update(EndUser).where(EndUser.id == source.end_user.id).values({field: str(uuid4())}))+ response = harness.request(action)+ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.json is not None+ assert response.json["code"] == "not_found"+ harness.assert_not_deleted()+ source.assert_closed()+++def test_pin_and_unpin_are_idempotent_and_isolate_actor_role(harness: _Harness) -> None:+ source = harness.source+ with source.factory.begin() as session:+ other_pins = [+ PinnedConversation(+ app_id=source.target.id,+ conversation_id=source.conversation.id,+ created_by_role=role,+ created_by=actor_id,+ )+ for role, actor_id in [+ (CreatorUserRole.ACCOUNT, source.end_user.id),+ (CreatorUserRole.END_USER, str(uuid4())),+ ]+ ]+ session.add_all(other_pins)++ for _ in range(2):+ response = harness.request("pin")+ assert response.status_code == HTTPStatus.OK+ assert response.headers["Content-Type"] == "application/json"+ assert response.json is not None+ assert response.json == {"result": "success"}+ source.assert_closed()+ with source.factory() as session:+ pins = session.scalars(select(PinnedConversation)).all()+ own_pins = [+ pin+ for pin in pins+ if pin.created_by_role == CreatorUserRole.END_USER and pin.created_by == source.end_user.id+ ]+ assert len(pins) == 3+ assert len(own_pins) == 1+ assert own_pins[0].app_id == source.target.id+ assert own_pins[0].conversation_id == source.conversation.id++ for _ in range(2):+ response = harness.request("unpin")+ assert response.status_code == HTTPStatus.OK+ assert response.json is not None+ assert response.json == {"result": "success"}+ source.assert_closed()+ with source.factory() as session:+ assert set(session.scalars(select(PinnedConversation.id))) == {pin.id for pin in other_pins}+ harness.assert_not_deleted()++[email protected]("action", ["delete", "pin", "unpin"])+def test_unknown_conversation_preserves_existing_decoy(harness: _Harness, action: str) -> None:+ response = harness.request(action, conversation_id=str(uuid4()))+ if action == "unpin":+ assert response.status_code == HTTPStatus.OK+ assert response.json is not None+ assert response.json == {"result": "success"}+ else:+ assert response.status_code == HTTPStatus.NOT_FOUND+ assert response.json is not None+ assert response.json["code"] == "conversation_not_found"+ harness.assert_not_deleted()+ harness.source.assert_closed()++[email protected]("action", ["delete", "pin", "unpin"])[email protected]("mode", [AppMode.COMPLETION, AppMode.WORKFLOW])+def test_non_chat_mode_is_rejected_before_command_transaction(harness: _Harness, action: str, mode: AppMode) -> None:+ source = harness.source+ rename_tests._publish_mode(source, mode)+ response = harness.request(action)+ assert response.status_code == HTTPStatus.BAD_REQUEST+ assert response.json is not None+ assert response.json["code"] == "not_chat_app"+ assert source.repository_sessions == []+ harness.assert_not_deleted()+ source.assert_closed()+++def test_failed_delete_commit_rolls_back_without_publishing_cleanup(harness: _Harness) -> None:+ def reject_commit(_session: Session) -> None:+ raise RuntimeError("Database commit failed")++ source = harness.source+ event.listen(source.repository_factory, "before_commit", reject_commit)+ try:+ response = harness.request("delete")+ finally:+ event.remove(source.repository_factory, "before_commit", reject_commit)+ assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR+ harness.assert_not_deleted()+ source.assert_closed()diff --git a/api/tests/e2e_tests/contracts/controllers/web/test_conversation_rename.py b/api/tests/e2e_tests/contracts/controllers/web/test_conversation_rename.pyindex b8c01d6f258..fd097de70d0 100644--- a/api/tests/e2e_tests/contracts/controllers/web/test_conversation_rename.py+++ b/api/tests/e2e_tests/contracts/controllers/web/test_conversation_rename.py@@ -57,6 +57,8 @@ class _Harness:end_user: EndUserconversation: Conversationfactory: sessionmaker[Session]+ repository_factory: sessionmaker[Session]+ api: ExternalApipassport: stradmission_sessions: list[Session]repository_sessions: list[Session]@@ -166,6 +168,8 @@ def harness(end_user,conversation,sqlite_session_factory,+ repository_factory,+ api,passport,admission_sessions,repository_sessions,diff --git a/api/tests/unit_tests/controllers/console/explore/test_conversation.py b/api/tests/unit_tests/controllers/console/explore/test_conversation.pyindex 5f2f5802183..948bcc984ec 100644--- a/api/tests/unit_tests/controllers/console/explore/test_conversation.py+++ b/api/tests/unit_tests/controllers/console/explore/test_conversation.py@@ -19,6 +19,7 @@ from models.enums import InvokeFrom as ModelInvokeFromfrom models.model import App, AppMode, Conversation, Messagefrom models.web import PinnedConversationfrom repositories.conversation_repository import ConversationRepository+from services.conversation_command_service import ConversationCommandServicefrom services.conversation_name_service import ConversationNameServicefrom services.installed_app_conversation_service import InstalledAppConversationServicefrom tests.unit_tests.controllers.console.explore.test_installed_app_admission import (@@ -122,7 +123,10 @@ def conversations(names=ConversationNameService(conversations=ConversationRepository(session_factory=factory), generate_name=state.generate_name),- enqueue_delete_cleanup=state.enqueue_cleanup,+ commands=ConversationCommandService(+ conversations=ConversationRepository(session_factory=factory),+ enqueue_delete_cleanup=state.enqueue_cleanup,+ ),)))diff --git a/api/tests/unit_tests/controllers/service_api/app/test_conversation.py b/api/tests/unit_tests/controllers/service_api/app/test_conversation.pyindex 3f767872a02..08825d53d45 100644--- a/api/tests/unit_tests/controllers/service_api/app/test_conversation.py+++ b/api/tests/unit_tests/controllers/service_api/app/test_conversation.py@@ -16,7 +16,6 @@ import servicesfrom controllers.console.explore.conversation import ConversationRenamePayload as ConsolePayloadfrom controllers.service_api.app.conversation import (ConversationApi,- ConversationDetailApi,ConversationListQuery,ConversationRenamePayload,ConversationVariableDetailApi,@@ -595,43 +594,6 @@ class TestConversationCases:end_user=end_user,)- class TestConversationDetailApiController:- def test_delete_not_chat(self, app: Flask) -> None:- api = ConversationDetailApi()- handler = unwrap(api.delete)- app_model = _app(mode=AppMode.COMPLETION)- end_user = _end_user()-- with app.test_request_context("/conversations/1", method="DELETE"):- with pytest.raises(NotChatAppError):- handler(- api,- app_model=app_model,- end_user=end_user,- conversation_id="00000000-0000-0000-0000-000000000001",- )-- def test_delete_not_found(self, app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:- monkeypatch.setattr(- ConversationService,- "delete",- lambda *_args, **_kwargs: (_ for _ in ()).throw(ConversationNotExistsError()),- )-- api = ConversationDetailApi()- handler = unwrap(api.delete)- app_model = _app()- end_user = _end_user()-- with app.test_request_context("/conversations/1", method="DELETE"):- with pytest.raises(NotFound):- handler(- api,- app_model=app_model,- end_user=end_user,- conversation_id="00000000-0000-0000-0000-000000000001",- )-class TestConversationVariablesApiController:def test_not_chat(self, app: Flask) -> None:api = ConversationVariablesApi()diff --git a/api/tests/unit_tests/repositories/test_conversation_repository.py b/api/tests/unit_tests/repositories/test_conversation_repository.pyindex 734635e6545..80c4be6f6e5 100644--- a/api/tests/unit_tests/repositories/test_conversation_repository.py+++ b/api/tests/unit_tests/repositories/test_conversation_repository.py@@ -246,10 +246,17 @@ def test_every_conversation_ownership_predicate_protects_reads_and_mutations(updated_at=_TIME,)with pytest.raises(ConversationNotExistsError):- repository.delete(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation_id)+ repository.delete(+ ref=InstalledAppConversationRef(+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation_id+ )+ )with pytest.raises(ConversationNotExistsError):repository.set_pinned(- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation_id, is_pinned=True+ ref=InstalledAppConversationRef(+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation_id+ ),+ is_pinned=True,)with sqlite_session_factory() as session:stored = session.get(Conversation, conversation_id)@@ -294,11 +301,18 @@ def test_all_operations_revalidate_complete_installation_and_actual_app(updated_at=_TIME,)with pytest.raises(InstalledAppNotFoundError):- repository.delete(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id)+ repository.delete(+ ref=InstalledAppConversationRef(+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id+ )+ )for is_pinned in (True, False):with pytest.raises(InstalledAppNotFoundError):repository.set_pinned(- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id, is_pinned=is_pinned+ ref=InstalledAppConversationRef(+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id+ ),+ is_pinned=is_pinned,)@@ -394,17 +408,26 @@ def test_pin_and_unpin_are_idempotent_and_preserve_other_owners(repository = ConversationRepository(session_factory=sqlite_session_factory)for _ in range(2):repository.set_pinned(- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id, is_pinned=True+ ref=InstalledAppConversationRef(+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id+ ),+ is_pinned=True,)with sqlite_session_factory() as session:assert len(session.scalars(select(PinnedConversation)).all()) == 4for _ in range(2):repository.set_pinned(- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id, is_pinned=False+ ref=InstalledAppConversationRef(+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id+ ),+ is_pinned=False,)repository.set_pinned(- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=str(uuid4()), is_pinned=False+ ref=InstalledAppConversationRef(+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=str(uuid4())+ ),+ is_pinned=False,)with sqlite_session_factory() as session:remaining = session.scalars(select(PinnedConversation)).all()@@ -425,10 +448,12 @@ def test_existing_pin_and_unpin_do_not_require_live_conversation(_pin(session, installation, missing_id)repository = ConversationRepository(session_factory=sqlite_session_factory)repository.set_pinned(- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=missing_id, is_pinned=True+ ref=InstalledAppConversationRef(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=missing_id),+ is_pinned=True,)repository.set_pinned(- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=missing_id, is_pinned=False+ ref=InstalledAppConversationRef(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=missing_id),+ is_pinned=False,)with sqlite_session_factory() as session:assert session.scalars(select(PinnedConversation)).all() == []@@ -456,7 +481,11 @@ def test_delete_commits_soft_deletion_and_returns_owner_tenant_for_cleanup(]session.add_all(workspaces)repository = ConversationRepository(session_factory=sqlite_session_factory)- deleted = repository.delete(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id)+ deleted = repository.delete(+ ref=InstalledAppConversationRef(+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id+ )+ )assert deleted.tenant_id == _OWNER_TENANT_IDassert deleted.conversation_id == conversation.id@@ -472,7 +501,11 @@ def test_delete_commits_soft_deletion_and_returns_owner_tenant_for_cleanup(assert stored_workspace.retired_at is not Noneassert stored_workspace.active_guard is Nonewith pytest.raises(ConversationNotExistsError):- repository.delete(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id)+ repository.delete(+ ref=InstalledAppConversationRef(+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id+ )+ )@pytest.mark.parametrize("operation", ["rename", "delete", "pin"])@@ -503,10 +536,17 @@ def test_failed_commit_rolls_back_mutations_and_propagates_original_error(updated_at=_TIME + timedelta(hours=1),)elif operation == "delete":- repository.delete(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id)+ repository.delete(+ ref=InstalledAppConversationRef(+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id+ )+ )else:repository.set_pinned(- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id, is_pinned=True+ ref=InstalledAppConversationRef(+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id+ ),+ is_pinned=True,)with pytest.raises(RuntimeError) as error:@@ -574,5 +614,9 @@ def test_end_user_and_installed_account_refs_never_cross_owner_domains(repository.get_name_source(ref=foreign_ref)with pytest.raises(ConversationNotExistsError):repository.rename(ref=foreign_ref, name="Forbidden", updated_at=_TIME)+ with pytest.raises(ConversationNotExistsError):+ repository.delete(ref=foreign_ref)+ with pytest.raises(ConversationNotExistsError):+ repository.set_pinned(ref=foreign_ref, is_pinned=True)assert repository.get(ref=account_ref).name == "Original name"assert repository.get(ref=end_user_ref).name == "End-user conversation"diff --git a/api/tests/unit_tests/services/test_conversation_command_service.py b/api/tests/unit_tests/services/test_conversation_command_service.pynew file mode 100644index 00000000000..0c0bd3cf393--- /dev/null+++ b/api/tests/unit_tests/services/test_conversation_command_service.py@@ -0,0 +1,287 @@+"""Conversation commands exercise persistence, ownership and cleanup ordering."""++from dataclasses import replace+from uuid import uuid4++import pytest+from sqlalchemy import Engine, delete, event, select, update+from sqlalchemy.orm import Session, sessionmaker++from models.agent import AgentWorkingResourceStatus, AgentWorkspace, AgentWorkspaceOwnerType+from models.enums import ConversationFromSource, CreatorUserRole, EndUserType+from models.model import App, AppMode, Conversation, EndUser+from models.web import PinnedConversation+from repositories.conversation_repository import ConversationRepository+from services.conversation_command_service import ConversationCleanup, ConversationCommandService+from services.entities.conversation_entities import EndUserConversationRef+from services.errors.conversation import ConversationNotExistsError+++def end_user_ref(sqlite_session_factory: sessionmaker[Session]) -> EndUserConversationRef:+ with sqlite_session_factory.begin() as session:+ app = App(tenant_id=str(uuid4()), name="Chat", mode=AppMode.CHAT, enable_site=True, enable_api=True)+ session.add(app)+ session.flush()+ end_user = EndUser(+ tenant_id=app.tenant_id,+ app_id=app.id,+ type=EndUserType.BROWSER,+ session_id=str(uuid4()),+ )+ session.add(end_user)+ session.flush()+ conversation = Conversation(+ app_id=app.id,+ mode=AppMode.CHAT,+ name="Original",+ _inputs={},+ from_source=ConversationFromSource.API,+ from_end_user_id=end_user.id,+ from_account_id=None,+ is_deleted=False,+ )+ session.add(conversation)+ session.flush()+ return EndUserConversationRef(+ app_id=app.id,+ tenant_id=app.tenant_id,+ end_user_id=end_user.id,+ conversation_id=conversation.id,+ )+++def _unexpected_cleanup(**_kwargs: object) -> None:+ raise AssertionError("No cleanup should be dispatched")+++def _service(+ factory: sessionmaker[Session], *, cleanup: ConversationCleanup = _unexpected_cleanup+) -> ConversationCommandService:+ return ConversationCommandService(+ conversations=ConversationRepository(session_factory=factory), enqueue_delete_cleanup=cleanup+ )+++def test_delete_commits_and_returns_connection_before_dispatching_workspace_cleanup(+ sqlite_session_factory: sessionmaker[Session], sqlite_engine: Engine, end_user_ref: EndUserConversationRef+) -> None:+ with sqlite_session_factory.begin() as session:+ workspace = AgentWorkspace(+ id=str(uuid4()),+ tenant_id=end_user_ref.tenant_id,+ app_id=end_user_ref.app_id,+ owner_type=AgentWorkspaceOwnerType.CONVERSATION,+ owner_id=end_user_ref.conversation_id,+ owner_scope_key="conversation-binding",+ backend_workspace_ref="backend-workspace",+ status=AgentWorkingResourceStatus.ACTIVE,+ active_guard=1,+ )+ session.add(workspace)+ events: list[str] = []++ @event.listens_for(sqlite_engine, "checkout")+ def checkout(_connection: object, _record: object, _proxy: object) -> None:+ events.append("checkout")++ @event.listens_for(sqlite_engine, "checkin")+ def checkin(_connection: object, _record: object) -> None:+ events.append("checkin")++ def cleanup(*, tenant_id: str, conversation_id: str, retired_workspace_ids: tuple[str, ...]) -> None:+ assert events == ["checkout", "checkin"]+ assert (tenant_id, conversation_id) == (end_user_ref.tenant_id, end_user_ref.conversation_id)+ assert retired_workspace_ids == (workspace.id,)+ events.append("cleanup")+ with sqlite_session_factory() as session:+ assert session.scalar(select(Conversation.is_deleted).where(Conversation.id == conversation_id)) is True+ stored_workspace = session.get(AgentWorkspace, workspace.id)+ assert stored_workspace is not None+ assert stored_workspace.status == AgentWorkingResourceStatus.RETIRED+ assert stored_workspace.active_guard is None+ assert stored_workspace.retired_at is not None++ service = _service(sqlite_session_factory, cleanup=cleanup)+ service.delete(ref=end_user_ref)+ assert events == ["checkout", "checkin", "cleanup", "checkout", "checkin"]+ with pytest.raises(ConversationNotExistsError):+ service.delete(ref=end_user_ref)+ assert events.count("cleanup") == 1+++def test_failed_delete_commit_preserves_conversation_and_workspace_without_cleanup(+ sqlite_session_factory: sessionmaker[Session], sqlite_engine: Engine, end_user_ref: EndUserConversationRef+) -> None:+ with sqlite_session_factory.begin() as session:+ workspace = AgentWorkspace(+ id=str(uuid4()),+ tenant_id=end_user_ref.tenant_id,+ app_id=end_user_ref.app_id,+ owner_type=AgentWorkspaceOwnerType.CONVERSATION,+ owner_id=end_user_ref.conversation_id,+ owner_scope_key="conversation-binding",+ backend_workspace_ref="backend-workspace",+ status=AgentWorkingResourceStatus.ACTIVE,+ active_guard=1,+ )+ session.add(workspace)+ factory = sessionmaker(bind=sqlite_engine)+ failure = RuntimeError("Database commit failed")++ @event.listens_for(factory, "before_commit")+ def fail_commit(_session: Session) -> None:+ raise failure++ with pytest.raises(RuntimeError) as error:+ _service(factory).delete(ref=end_user_ref)+ assert error.value is failure+ with sqlite_session_factory() as session:+ assert (+ session.scalar(select(Conversation.is_deleted).where(Conversation.id == end_user_ref.conversation_id))+ is False+ )+ stored_workspace = session.get(AgentWorkspace, workspace.id)+ assert stored_workspace is not None+ assert stored_workspace.status == AgentWorkingResourceStatus.ACTIVE+ assert stored_workspace.active_guard == 1+ assert stored_workspace.retired_at is None++[email protected]("operation", ["delete", "pin"])+ "mismatch", ["app_id", "from_source", "from_account_id", "from_end_user_id", "is_deleted", "missing"]+)+def test_end_user_commands_reject_every_conversation_owner_mismatch(+ sqlite_session_factory: sessionmaker[Session],+ end_user_ref: EndUserConversationRef,+ operation: str,+ mismatch: str,+) -> None:+ with sqlite_session_factory.begin() as session:+ if mismatch == "missing":+ session.execute(delete(Conversation).where(Conversation.id == end_user_ref.conversation_id))+ else:+ value: str | bool = True if mismatch == "is_deleted" else str(uuid4())+ if mismatch == "from_source":+ value = ConversationFromSource.CONSOLE+ session.execute(+ update(Conversation).where(Conversation.id == end_user_ref.conversation_id).values({mismatch: value})+ )+ service = _service(sqlite_session_factory)+ if operation == "delete":+ with pytest.raises(ConversationNotExistsError):+ service.delete(ref=end_user_ref)+ else:+ with pytest.raises(ConversationNotExistsError):+ service.set_pinned(ref=end_user_ref, is_pinned=True)+ with sqlite_session_factory() as session:+ assert session.scalars(select(PinnedConversation)).all() == []+ stored = session.get(Conversation, end_user_ref.conversation_id)+ if mismatch == "missing":+ assert stored is None+ else:+ assert stored is not None+ assert stored.is_deleted is (mismatch == "is_deleted")++[email protected]("operation", ["delete", "pin", "unpin"])+ "mismatch", ["app_tenant", "end_user_tenant", "end_user_app", "app_missing", "end_user_missing"]+)+def test_end_user_commands_revalidate_app_and_end_user_owner_chain(+ sqlite_session_factory: sessionmaker[Session],+ end_user_ref: EndUserConversationRef,+ operation: str,+ mismatch: str,+) -> None:+ with sqlite_session_factory.begin() as session:+ pin = PinnedConversation(+ app_id=end_user_ref.app_id,+ conversation_id=end_user_ref.conversation_id,+ created_by_role=CreatorUserRole.END_USER,+ created_by=end_user_ref.end_user_id,+ )+ session.add(pin)+ if mismatch == "app_tenant":+ session.execute(update(App).where(App.id == end_user_ref.app_id).values(tenant_id=str(uuid4())))+ elif mismatch == "end_user_tenant":+ session.execute(+ update(EndUser).where(EndUser.id == end_user_ref.end_user_id).values(tenant_id=str(uuid4()))+ )+ elif mismatch == "end_user_app":+ session.execute(update(EndUser).where(EndUser.id == end_user_ref.end_user_id).values(app_id=str(uuid4())))+ elif mismatch == "app_missing":+ session.execute(delete(App).where(App.id == end_user_ref.app_id))+ else:+ session.execute(delete(EndUser).where(EndUser.id == end_user_ref.end_user_id))+ service = _service(sqlite_session_factory)+ if operation == "delete":+ with pytest.raises(ConversationNotExistsError):+ service.delete(ref=end_user_ref)+ else:+ with pytest.raises(ConversationNotExistsError):+ service.set_pinned(ref=end_user_ref, is_pinned=operation == "pin")+ with sqlite_session_factory() as session:+ assert (+ session.scalar(select(Conversation.is_deleted).where(Conversation.id == end_user_ref.conversation_id))+ is False+ )+ assert session.get(PinnedConversation, pin.id) is not None+++def test_end_user_pin_and_unpin_are_idempotent_and_preserve_other_roles_and_owners(+ sqlite_session_factory: sessionmaker[Session], end_user_ref: EndUserConversationRef+) -> None:+ with sqlite_session_factory.begin() as session:+ other_pins = [+ PinnedConversation(+ app_id=app_id,+ conversation_id=end_user_ref.conversation_id,+ created_by_role=role,+ created_by=actor_id,+ )+ for app_id, role, actor_id in [+ (end_user_ref.app_id, CreatorUserRole.ACCOUNT, end_user_ref.end_user_id),+ (end_user_ref.app_id, CreatorUserRole.END_USER, str(uuid4())),+ (str(uuid4()), CreatorUserRole.END_USER, end_user_ref.end_user_id),+ ]+ ]+ session.add_all(other_pins)+ service = _service(sqlite_session_factory)+ for _ in range(2):+ service.set_pinned(ref=end_user_ref, is_pinned=True)+ with sqlite_session_factory() as session:+ assert len(session.scalars(select(PinnedConversation)).all()) == 4+ for _ in range(2):+ service.set_pinned(ref=end_user_ref, is_pinned=False)+ service.set_pinned(ref=replace(end_user_ref, conversation_id=str(uuid4())), is_pinned=False)+ with sqlite_session_factory() as session:+ assert {pin.id for pin in session.scalars(select(PinnedConversation))} == {pin.id for pin in other_pins}++[email protected]("state", ["deleted", "missing"])+def test_end_user_existing_pin_and_unpin_do_not_require_live_conversation(+ sqlite_session_factory: sessionmaker[Session], end_user_ref: EndUserConversationRef, state: str+) -> None:+ with sqlite_session_factory.begin() as session:+ session.add(+ PinnedConversation(+ app_id=end_user_ref.app_id,+ conversation_id=end_user_ref.conversation_id,+ created_by_role=CreatorUserRole.END_USER,+ created_by=end_user_ref.end_user_id,+ )+ )+ if state == "deleted":+ session.execute(+ update(Conversation).where(Conversation.id == end_user_ref.conversation_id).values(is_deleted=True)+ )+ else:+ session.execute(delete(Conversation).where(Conversation.id == end_user_ref.conversation_id))+ service = _service(sqlite_session_factory)+ service.set_pinned(ref=end_user_ref, is_pinned=True)+ service.set_pinned(ref=end_user_ref, is_pinned=False)+ service.set_pinned(ref=end_user_ref, is_pinned=False)+ with sqlite_session_factory() as session:+ assert session.scalars(select(PinnedConversation)).all() == []diff --git a/api/tests/unit_tests/services/test_installed_app_conversation_service.py b/api/tests/unit_tests/services/test_installed_app_conversation_service.pyindex 7b91472f902..f5010633dad 100644--- a/api/tests/unit_tests/services/test_installed_app_conversation_service.py+++ b/api/tests/unit_tests/services/test_installed_app_conversation_service.py@@ -12,6 +12,7 @@ from sqlalchemy.orm import Session, sessionmakerfrom models.enums import ConversationFromSourcefrom models.model import App, AppMode, Conversation, InstalledApp, Messagefrom repositories.conversation_repository import ConversationRepository+from services.conversation_command_service import ConversationCleanup, ConversationCommandServicefrom services.conversation_name_service import (ConversationNameGenerator,ConversationNameRequiredError,@@ -21,7 +22,6 @@ from services.entities.conversation_entities import InstalledAppConversationReffrom services.errors.conversation import ConversationNotExistsErrorfrom services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppReffrom services.installed_app_conversation_service import (- ConversationCleanup,ConversationNotChatAppError,InstalledAppConversationService,)@@ -97,7 +97,7 @@ def _service(return InstalledAppConversationService(conversations=repository,names=ConversationNameService(conversations=repository, generate_name=generate_name),- enqueue_delete_cleanup=cleanup,+ commands=ConversationCommandService(conversations=repository, enqueue_delete_cleanup=cleanup),)diff --git a/packages/contracts/generated/api/service/errors.gen.ts b/packages/contracts/generated/api/service/errors.gen.tsindex ef467e76f6f..6a63831bf55 100644--- a/packages/contracts/generated/api/service/errors.gen.ts+++ b/packages/contracts/generated/api/service/errors.gen.ts@@ -565,7 +565,16 @@ export const put2Errors = { not_chat_app: { status: 400, data: zNotChatAppErrorexport const get5Errors = { not_chat_app: { status: 400, data: zNotChatAppError } }-export const delete2Errors = { not_chat_app: { status: 400, data: zNotChatAppError } }+export const delete2Errors = {+ app_abnormal_status: { status: 403, data: zAppAbnormalStatusError },+ app_api_disabled: { status: 403, data: zAppApiDisabledError },+ app_not_found: { status: 403, data: zAppNotFoundError },+ conversation_not_found: { status: 404, data: zConversationNotFoundError },+ forbidden: { status: 403, data: zForbiddenError },+ not_chat_app: { status: 400, data: zNotChatAppError },+ workspace_archived: { status: 403, data: zWorkspaceArchivedError },+ workspace_not_found: { status: 403, data: zWorkspaceNotFoundError },+}export const get6Errors = { not_chat_app: { status: 400, data: zNotChatAppError } }diff --git a/packages/contracts/generated/api/service/orpc.gen.ts b/packages/contracts/generated/api/service/orpc.gen.tsindex 512754c6fa6..aaf85135abb 100644--- a/packages/contracts/generated/api/service/orpc.gen.ts+++ b/packages/contracts/generated/api/service/orpc.gen.ts@@ -1016,7 +1016,16 @@ export const delete2 = oc}),).output(zDeleteConversationsByConversationIdResponse)- .errors({ not_chat_app: { status: 400, data: zNotChatAppError } })+ .errors({+ app_abnormal_status: { status: 403, data: zAppAbnormalStatusError },+ app_api_disabled: { status: 403, data: zAppApiDisabledError },+ app_not_found: { status: 403, data: zAppNotFoundError },+ conversation_not_found: { status: 404, data: zConversationNotFoundError },+ forbidden: { status: 403, data: zForbiddenError },+ not_chat_app: { status: 400, data: zNotChatAppError },+ workspace_archived: { status: 403, data: zWorkspaceArchivedError },+ workspace_not_found: { status: 403, data: zWorkspaceNotFoundError },+ })export const byConversationId = {delete: delete2,diff --git a/packages/contracts/generated/api/service/types.gen.ts b/packages/contracts/generated/api/service/types.gen.tsindex f9c583dee3f..d375781fdc9 100644--- a/packages/contracts/generated/api/service/types.gen.ts+++ b/packages/contracts/generated/api/service/types.gen.ts@@ -5008,8 +5008,15 @@ export type DeleteConversationsByConversationIdData = {export type DeleteConversationsByConversationIdErrors = {400: NotChatAppError | ErrorResponse401: ErrorResponse- 403: ErrorResponse- 404: ErrorResponse+ 403:+ | AppAbnormalStatusError+ | AppApiDisabledError+ | AppNotFoundError+ | ForbiddenError+ | WorkspaceArchivedError+ | WorkspaceNotFoundError+ | ErrorResponse+ 404: ConversationNotFoundError | ErrorResponsedefault: ErrorResponse}diff --git a/packages/contracts/generated/api/web/errors.gen.ts b/packages/contracts/generated/api/web/errors.gen.tsindex 1b4ffd442d8..7648c520cd0 100644--- a/packages/contracts/generated/api/web/errors.gen.ts+++ b/packages/contracts/generated/api/web/errors.gen.ts@@ -464,11 +464,20 @@ export const post6Errors = {not_chat_app: { status: 400, data: zNotChatAppError },}-export const patchErrors = { not_chat_app: { status: 400, data: zNotChatAppError } }+export const patchErrors = {+ conversation_not_found: { status: 404, data: zConversationNotFoundError },+ not_chat_app: { status: 400, data: zNotChatAppError },+}-export const patch2Errors = { not_chat_app: { status: 400, data: zNotChatAppError } }+export const patch2Errors = {+ conversation_not_found: { status: 404, data: zConversationNotFoundError },+ not_chat_app: { status: 400, data: zNotChatAppError },+}-export const delete_Errors = { not_chat_app: { status: 400, data: zNotChatAppError } }+export const delete_Errors = {+ conversation_not_found: { status: 404, data: zConversationNotFoundError },+ not_chat_app: { status: 400, data: zNotChatAppError },+}export const getErrors = { not_chat_app: { status: 400, data: zNotChatAppError } }diff --git a/packages/contracts/generated/api/web/orpc.gen.ts b/packages/contracts/generated/api/web/orpc.gen.tsindex e2f99672747..be955cc6272 100644--- a/packages/contracts/generated/api/web/orpc.gen.ts+++ b/packages/contracts/generated/api/web/orpc.gen.ts@@ -332,18 +332,22 @@ export const patch = oc}).input(z.object({ params: zPatchConversationsByCIdPinPath })).output(zPatchConversationsByCIdPinResponse)- .errors({ not_chat_app: { status: 400, data: zNotChatAppError } })+ .errors({+ conversation_not_found: { status: 404, data: zConversationNotFoundError },+ not_chat_app: { status: 400, data: zNotChatAppError },+ })export const pin = {patch,}/**- * Unpin a specific conversation to remove it from the top of the list.+ * Remove the current user's pin. Succeeds when the conversation is already unpinned.*/export const patch2 = oc.route({- description: 'Unpin a specific conversation to remove it from the top of the list.',+ description:+ "Remove the current user's pin. Succeeds when the conversation is already unpinned.",inputStructure: 'detailed',method: 'PATCH',operationId: 'patchConversationsByCIdUnpin',@@ -352,7 +356,10 @@ export const patch2 = oc}).input(z.object({ params: zPatchConversationsByCIdUnpinPath })).output(zPatchConversationsByCIdUnpinResponse)- .errors({ not_chat_app: { status: 400, data: zNotChatAppError } })+ .errors({+ conversation_not_found: { status: 404, data: zConversationNotFoundError },+ not_chat_app: { status: 400, data: zNotChatAppError },+ })export const unpin = {patch: patch2,@@ -373,7 +380,10 @@ export const delete_ = oc}).input(z.object({ params: zDeleteConversationsByCIdPath })).output(zDeleteConversationsByCIdResponse)- .errors({ not_chat_app: { status: 400, data: zNotChatAppError } })+ .errors({+ conversation_not_found: { status: 404, data: zConversationNotFoundError },+ not_chat_app: { status: 400, data: zNotChatAppError },+ })export const byCId = {delete: delete_,diff --git a/packages/contracts/generated/api/web/types.gen.ts b/packages/contracts/generated/api/web/types.gen.tsindex 365b170ae5f..bd8492280c7 100644--- a/packages/contracts/generated/api/web/types.gen.ts+++ b/packages/contracts/generated/api/web/types.gen.ts@@ -1519,7 +1519,7 @@ export type DeleteConversationsByCIdData = {export type DeleteConversationsByCIdErrors = {400: NotChatAppError | ErrorResponse401: ErrorResponse- 404: ErrorResponse+ 404: ConversationNotFoundError | ErrorResponse500: ErrorResponsedefault: ErrorResponse}@@ -1577,7 +1577,7 @@ export type PatchConversationsByCIdPinData = {export type PatchConversationsByCIdPinErrors = {400: NotChatAppError | ErrorResponse401: ErrorResponse- 404: ErrorResponse+ 404: ConversationNotFoundError | ErrorResponse500: ErrorResponsedefault: ErrorResponse}@@ -1604,7 +1604,7 @@ export type PatchConversationsByCIdUnpinData = {export type PatchConversationsByCIdUnpinErrors = {400: NotChatAppError | ErrorResponse401: ErrorResponse- 404: ErrorResponse+ 404: ConversationNotFoundError | ErrorResponse500: ErrorResponsedefault: ErrorResponse}