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): isolate installed app conversations (#41971)
非法操作53aa73e4168e
diff --git a/api/.importlinter b/api/.importlinterindex dfc2451770f..f1fb5726f27 100644--- a/api/.importlinter+++ b/api/.importlinter@@ -224,6 +224,32 @@ forbidden_modules =sqlalchemywerkzeug+[importlinter:contract:installed-app-conversation-boundary]+name = Installed app conversation service is framework and persistence neutral+type = forbidden+source_modules =+ services.installed_app_conversation_service+forbidden_modules =+ controllers+ extensions+ flask+ models+ repositories+ sqlalchemy+ werkzeug++[importlinter:contract:conversation-persistence-boundary]+name = Conversation persistence does not call legacy conversation or workspace services+type = forbidden+source_modules =+ repositories.installed_app_conversation_repository+ repositories.conversation_lifecycle+ repositories.agent_workspace_repository+forbidden_modules =+ services.conversation_service+ services.agent.workspace_service+allow_indirect_imports = True+[importlinter:contract:installed-app-generation-boundary]name = Installed app generation service is framework and persistence neutraltype = forbiddendiff --git a/api/controllers/console/explore/completion.py b/api/controllers/console/explore/completion.pyindex 733db9ea5f2..2f6c2c59948 100644--- a/api/controllers/console/explore/completion.py+++ b/api/controllers/console/explore/completion.py@@ -147,10 +147,7 @@ class CompletionStopApi(Resource):def post(self, request_context: RequestContext, installed_app: InstalledAppRef, task_id: str) -> tuple[dict[str, object], int]:- try:- app_mode = application_services().app_definitions.get_mode(installed_app.app_id)- except AppDefinitionUnavailableError:- raise AppUnavailableError() from None+ app_mode = installed_app.app_modeif app_mode != AppMode.COMPLETION:raise NotCompletionAppError()@@ -232,11 +229,7 @@ class ChatStopApi(Resource):def post(self, request_context: RequestContext, installed_app: InstalledAppRef, task_id: str) -> tuple[dict[str, object], int]:- try:- mode = application_services().app_definitions.get_mode(installed_app.app_id)- except AppDefinitionUnavailableError:- raise AppUnavailableError() from None- app_mode = AppMode.value_of(mode)+ app_mode = AppMode.value_of(installed_app.app_mode)if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:raise NotChatAppError()diff --git a/api/controllers/console/explore/conversation.py b/api/controllers/console/explore/conversation.pyindex 90b0d97e488..8a537e78522 100644--- a/api/controllers/console/explore/conversation.py+++ b/api/controllers/console/explore/conversation.py@@ -1,33 +1,34 @@-from typing import Any+"""HTTP admission and response contracts for installed-app conversations."""++from collections.abc import Callable+from functools import wrapsfrom uuid import UUID-from flask import request-from pydantic import BaseModel, Field, TypeAdapter-from sqlalchemy.orm import sessionmaker-from werkzeug.exceptions import NotFound+from flask_restx import Resource+from pydantic import BaseModel, Field, field_validatorfrom controllers.common.controller_schemas import ConversationRenamePayloadfrom controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_models-from controllers.console.app.error import AppUnavailableError-from controllers.console.explore.error import NotChatAppError-from controllers.console.explore.wraps import InstalledAppResource-from controllers.console.wraps import model_validate, with_current_user-from core.app.entities.app_invoke_entities import InvokeFrom-from extensions.ext_database import db-from fields.conversation_fields import (- ConversationInfiniteScrollPagination,- ConversationResponseSource,- ResultResponse,- SimpleConversation,+from controllers.console import console_ns+from controllers.console.explore.error import (+ ConversationCursorNotFoundHTTPError,+ ConversationFirstMessageNotFoundHTTPError,+ ConversationNameRequiredHTTPError,+ ConversationNotFoundHTTPError,+ InstalledAppNotFoundHTTPError,+ NotChatAppError,)-from libs.helper import UUIDStrOrEmpty-from models import Account-from models.model import AppMode, InstalledApp-from services.conversation_service import ConversationService+from controllers.console.explore.installed_app_admission import get_installed_app+from controllers.console.flask_admission import console_account_admission+from controllers.console.wraps import model_validate+from extensions.ext_application_services import application_services+from fields.conversation_fields import ConversationInfiniteScrollPagination, ResultResponse, SimpleConversation+from libs.helper import UUIDStrOrEmpty, dump_response+from machinery.context import RequestContextfrom services.errors.conversation import ConversationNotExistsError, LastConversationNotExistsError-from services.web_conversation_service import WebConversationService--from .. import console_ns+from services.errors.message import MessageNotExistsError+from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppRef+from services.installed_app_conversation_service import ConversationNameRequiredError, ConversationNotChatAppErrorclass ConversationListQuery(BaseModel):@@ -35,93 +36,84 @@ class ConversationListQuery(BaseModel):limit: int = Field(default=20, ge=1, le=100)pinned: bool | None = None+ @field_validator("limit", mode="before")+ @classmethod+ def parse_limit(cls, value: object) -> object:+ # Preserve request.args.get(..., default=20, type=int) coercion.+ if isinstance(value, str):+ try:+ return int(value)+ except ValueError:+ return 20+ return value++ @field_validator("pinned", mode="before")+ @classmethod+ def parse_pinned(cls, value: object) -> object:+ # Existing callers use the literal query string "true" for pinned items.+ return value == "true" if isinstance(value, str) else value+register_schema_models(console_ns, ConversationListQuery, ConversationRenamePayload)-register_response_schema_models(- console_ns,- ConversationInfiniteScrollPagination,- ResultResponse,- SimpleConversation,-)+register_response_schema_models(console_ns, ConversationInfiniteScrollPagination, ResultResponse, SimpleConversation)-@console_ns.route(- "/installed-apps/<uuid:installed_app_id>/conversations",- endpoint="installed_app_conversations",-)-class ConversationListApi(InstalledAppResource):- @console_ns.doc(params=query_params_from_model(ConversationListQuery))- @console_ns.response(200, "Success", console_ns.models[ConversationInfiniteScrollPagination.__name__])- @with_current_user- def get(self, current_user: Account, installed_app: InstalledApp):- app_model = installed_app.app_with_session(session=db.session())- if app_model is None:- raise AppUnavailableError()- app_mode = AppMode.value_of(app_model.mode)- if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:- raise NotChatAppError()-- raw_args: dict[str, Any] = {- "last_id": request.args.get("last_id"),- "limit": request.args.get("limit", default=20, type=int),- "pinned": request.args.get("pinned"),- }- if raw_args["last_id"] is None:- raw_args["last_id"] = None- pinned_value = raw_args["pinned"]- if isinstance(pinned_value, str):- raw_args["pinned"] = pinned_value == "true"- args = ConversationListQuery.model_validate(raw_args)+def _conversation_errors[**P, R](view: Callable[P, R]) -> Callable[P, R]:+ """Translate the shared conversation use-case errors at the Console boundary."""+ @wraps(view)+ def decorated(*args: P.args, **kwargs: P.kwargs) -> R:try:- with sessionmaker(db.engine).begin() as session:- pagination = WebConversationService.pagination_by_last_id(- session=session,- app_model=app_model,- user=current_user,- last_id=args.last_id or None,- limit=args.limit,- invoke_from=InvokeFrom.EXPLORE,- pinned=args.pinned,- )- adapter = TypeAdapter(SimpleConversation)- conversations = [- adapter.validate_python(- ConversationResponseSource(item, session=session),- from_attributes=True,- )- for item in pagination.data- ]- return ConversationInfiniteScrollPagination(- limit=pagination.limit,- has_more=pagination.has_more,- data=conversations,- ).model_dump(mode="json")- except LastConversationNotExistsError:- raise NotFound("Last Conversation Not Exists.")+ return view(*args, **kwargs)+ except InstalledAppNotFoundError as error:+ raise InstalledAppNotFoundHTTPError() from error+ except ConversationNotChatAppError as error:+ raise NotChatAppError() from error+ except ConversationNotExistsError as error:+ raise ConversationNotFoundHTTPError() from error+ except LastConversationNotExistsError as error:+ raise ConversationCursorNotFoundHTTPError() from error+ except MessageNotExistsError as error:+ raise ConversationFirstMessageNotFoundHTTPError() from error+ except ConversationNameRequiredError as error:+ raise ConversationNameRequiredHTTPError() from error++ return decorated+++@console_ns.route("/installed-apps/<uuid:installed_app_id>/conversations", endpoint="installed_app_conversations")+class ConversationListApi(Resource):+ @console_ns.doc(params=query_params_from_model(ConversationListQuery))+ @console_ns.response(200, "Success", console_ns.models[ConversationInfiniteScrollPagination.__name__])+ @console_account_admission()+ @get_installed_app+ @model_validate(ConversationListQuery)+ @_conversation_errors+ def get(+ self, query: ConversationListQuery, request_context: RequestContext, installed_app: InstalledAppRef+ ) -> dict[str, object]:+ page = application_services().installed_app_conversations.get_page(+ installed_app=installed_app,+ account_id=request_context.account_id,+ last_id=query.last_id or None,+ limit=query.limit,+ pinned=query.pinned,+ )+ return dump_response(ConversationInfiniteScrollPagination, page)@console_ns.route(- "/installed-apps/<uuid:installed_app_id>/conversations/<uuid:c_id>",- endpoint="installed_app_conversation",+ "/installed-apps/<uuid:installed_app_id>/conversations/<uuid:c_id>", endpoint="installed_app_conversation")-class ConversationApi(InstalledAppResource):+class ConversationApi(Resource):@console_ns.response(204, "Conversation deleted successfully")- @with_current_user- def delete(self, current_user: Account, installed_app: InstalledApp, c_id: UUID):- app_model = installed_app.app_with_session(session=db.session())- if app_model is None:- raise AppUnavailableError()- app_mode = AppMode.value_of(app_model.mode)- if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:- raise NotChatAppError()-- conversation_id = str(c_id)- try:- ConversationService.delete(app_model, conversation_id, current_user, session=db.session())- except ConversationNotExistsError:- raise NotFound("Conversation Not Exists.")-+ @console_account_admission()+ @get_installed_app+ @_conversation_errors+ def delete(self, request_context: RequestContext, installed_app: InstalledAppRef, c_id: UUID) -> tuple[str, int]:+ application_services().installed_app_conversations.delete(+ installed_app=installed_app, account_id=request_context.account_id, conversation_id=str(c_id)+ )return "", 204@@ -129,76 +121,62 @@ class ConversationApi(InstalledAppResource):"/installed-apps/<uuid:installed_app_id>/conversations/<uuid:c_id>/name",endpoint="installed_app_conversation_rename",)-class ConversationRenameApi(InstalledAppResource):+class ConversationRenameApi(Resource):@console_ns.expect(console_ns.models[ConversationRenamePayload.__name__])@console_ns.response(200, "Conversation renamed successfully", console_ns.models[SimpleConversation.__name__])- @with_current_user+ @console_account_admission()+ @get_installed_app@model_validate(ConversationRenamePayload)- def post(self, req_data: ConversationRenamePayload, current_user: Account, installed_app: InstalledApp, c_id: UUID):- app_model = installed_app.app_with_session(session=db.session())- if app_model is None:- raise AppUnavailableError()- app_mode = AppMode.value_of(app_model.mode)- if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:- raise NotChatAppError()-- conversation_id = str(c_id)-- try:- session = db.session()- conversation = ConversationService.rename(- app_model, conversation_id, current_user, req_data.name, req_data.auto_generate, session=session- )- return (- TypeAdapter(SimpleConversation)- .validate_python(ConversationResponseSource(conversation, session=session), from_attributes=True)- .model_dump(mode="json")- )- except ConversationNotExistsError:- raise NotFound("Conversation Not Exists.")+ @_conversation_errors+ def post(+ self,+ payload: ConversationRenamePayload,+ request_context: RequestContext,+ installed_app: InstalledAppRef,+ c_id: UUID,+ ) -> dict[str, object]:+ conversation = application_services().installed_app_conversations.rename(+ installed_app=installed_app,+ account_id=request_context.account_id,+ conversation_id=str(c_id),+ name=payload.name,+ auto_generate=payload.auto_generate,+ )+ return dump_response(SimpleConversation, conversation)@console_ns.route(- "/installed-apps/<uuid:installed_app_id>/conversations/<uuid:c_id>/pin",- endpoint="installed_app_conversation_pin",+ "/installed-apps/<uuid:installed_app_id>/conversations/<uuid:c_id>/pin", endpoint="installed_app_conversation_pin")-class ConversationPinApi(InstalledAppResource):+class ConversationPinApi(Resource):@console_ns.response(200, "Success", console_ns.models[ResultResponse.__name__])- @with_current_user- def patch(self, current_user: Account, installed_app: InstalledApp, c_id: UUID):- app_model = installed_app.app_with_session(session=db.session())- if app_model is None:- raise AppUnavailableError()- app_mode = AppMode.value_of(app_model.mode)- if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:- raise NotChatAppError()-- conversation_id = str(c_id)-- try:- WebConversationService.pin(app_model, conversation_id, current_user, db.session())- except ConversationNotExistsError:- raise NotFound("Conversation Not Exists.")-- return ResultResponse(result="success").model_dump(mode="json")+ @console_account_admission()+ @get_installed_app+ @_conversation_errors+ def patch(self, request_context: RequestContext, installed_app: InstalledAppRef, c_id: UUID) -> dict[str, object]:+ application_services().installed_app_conversations.set_pinned(+ installed_app=installed_app,+ account_id=request_context.account_id,+ conversation_id=str(c_id),+ is_pinned=True,+ )+ return dump_response(ResultResponse, {"result": "success"})@console_ns.route("/installed-apps/<uuid:installed_app_id>/conversations/<uuid:c_id>/unpin",endpoint="installed_app_conversation_unpin",)-class ConversationUnPinApi(InstalledAppResource):+class ConversationUnPinApi(Resource):@console_ns.response(200, "Success", console_ns.models[ResultResponse.__name__])- @with_current_user- def patch(self, current_user: Account, installed_app: InstalledApp, c_id: UUID):- app_model = installed_app.app_with_session(session=db.session())- if app_model is None:- raise AppUnavailableError()- app_mode = AppMode.value_of(app_model.mode)- if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:- raise NotChatAppError()-- conversation_id = str(c_id)- WebConversationService.unpin(app_model, conversation_id, current_user, db.session())-- return ResultResponse(result="success").model_dump(mode="json")+ @console_account_admission()+ @get_installed_app+ @_conversation_errors+ def patch(self, request_context: RequestContext, installed_app: InstalledAppRef, c_id: UUID) -> dict[str, object]:+ application_services().installed_app_conversations.set_pinned(+ installed_app=installed_app,+ account_id=request_context.account_id,+ conversation_id=str(c_id),+ is_pinned=False,+ )+ return dump_response(ResultResponse, {"result": "success"})diff --git a/api/controllers/console/explore/error.py b/api/controllers/console/explore/error.pyindex d33e301e175..e0489463cdc 100644--- a/api/controllers/console/explore/error.py+++ b/api/controllers/console/explore/error.py@@ -35,6 +35,30 @@ class WebAppAccessUnavailableHTTPError(InstalledAppHTTPError):code = 503+class ConversationNotFoundHTTPError(InstalledAppHTTPError):+ error_code = "conversation_not_found"+ description = "The conversation was not found for this account and app."+ code = 404+++class ConversationCursorNotFoundHTTPError(InstalledAppHTTPError):+ error_code = "conversation_cursor_not_found"+ description = "The conversation cursor is not in the current list. Refresh the list and try again."+ code = 404+++class ConversationFirstMessageNotFoundHTTPError(InstalledAppHTTPError):+ error_code = "conversation_first_message_not_found"+ description = "The conversation has no message from which to generate a name."+ code = 404+++class ConversationNameRequiredHTTPError(InstalledAppHTTPError):+ error_code = "conversation_name_required"+ description = "A name is required when automatic naming is disabled."+ code = 400++class NotCompletionAppError(BaseHTTPException):error_code = "not_completion_app"description = "Not Completion App"diff --git a/api/controllers/console/explore/saved_message.py b/api/controllers/console/explore/saved_message.pyindex fe6ab013a02..514bded999e 100644--- a/api/controllers/console/explore/saved_message.py+++ b/api/controllers/console/explore/saved_message.py@@ -6,7 +6,6 @@ from werkzeug.exceptions import NotFoundfrom controllers.common.controller_schemas import SavedMessageCreatePayload, SavedMessageListQueryfrom controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_modelsfrom controllers.console import console_ns-from controllers.console.app.error import AppUnavailableErrorfrom controllers.console.explore.error import NotCompletionAppErrorfrom controllers.console.explore.installed_app_admission import get_installed_appfrom controllers.console.flask_admission import console_account_admission@@ -16,7 +15,6 @@ from fields.conversation_fields import ResultResponsefrom fields.message_fields import SavedMessageInfiniteScrollPaginationfrom libs.helper import dump_responsefrom machinery.context import RequestContext-from services.app_definition_query_service import AppDefinitionUnavailableErrorfrom services.errors.message import MessageNotExistsErrorfrom services.installed_app_access_service import InstalledAppReffrom services.saved_message_service import SavedMessageActor@@ -26,15 +24,9 @@ register_response_schema_models(console_ns, ResultResponse, SavedMessageInfinitedef _require_completion_app(installed_app: InstalledAppRef) -> str:- app_id = installed_app.app_id- try:- mode = application_services().app_definitions.get_mode(app_id)- except AppDefinitionUnavailableError:- raise AppUnavailableError() from None-- if mode != "completion":+ if installed_app.app_mode != "completion":raise NotCompletionAppError()- return app_id+ return installed_app.app_id@console_ns.route("/installed-apps/<uuid:installed_app_id>/saved-messages", endpoint="installed_app_saved_messages")diff --git a/api/controllers/console/explore/workflow.py b/api/controllers/console/explore/workflow.pyindex 4200ae798d7..74515faaf20 100644--- a/api/controllers/console/explore/workflow.py+++ b/api/controllers/console/explore/workflow.py@@ -96,11 +96,7 @@ class InstalledAppWorkflowTaskStopApi(Resource):"""Stop workflow task"""- try:- app_mode = application_services().app_definitions.get_mode(installed_app.app_id)- except AppDefinitionUnavailableError:- raise NotWorkflowAppError() from None- if app_mode != "workflow":+ if installed_app.app_mode != "workflow":raise NotWorkflowAppError()application_services().app_tasks.stop_workflow_task_no_user_check(task_id=task_id)diff --git a/api/core/agent/workspace.py b/api/core/agent/workspace.pynew file mode 100644index 00000000000..6ed3f35eeba--- /dev/null+++ b/api/core/agent/workspace.py@@ -0,0 +1,26 @@+"""Shared owner identity and errors for Agent Workspace lifecycle operations."""++from dataclasses import dataclass++from models.agent import AgentWorkspaceOwnerType+++class AgentWorkspaceError(RuntimeError):+ pass+++class AgentWorkspaceNotFoundError(AgentWorkspaceError):+ pass+++class AgentWorkspaceBindingGenerationMismatchError(AgentWorkspaceError):+ pass+++@dataclass(frozen=True, slots=True)+class WorkspaceOwnerScope:+ tenant_id: str+ app_id: str+ owner_type: AgentWorkspaceOwnerType+ owner_id: str+ owner_scope_key: str = "root"diff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.pyindex 10bbcad023b..e4fab175f77 100644--- a/api/extensions/ext_application_services.py+++ b/api/extensions/ext_application_services.py@@ -56,6 +56,7 @@ from repositories.factory import DifyAPIRepositoryFactoryfrom repositories.file_grant_repository import FileGrantRepositoryfrom repositories.human_input_file_upload_repository import SQLAlchemyHumanInputFileUploadRepositoryfrom repositories.installation_state_repository import InstallationStateRepository+from repositories.installed_app_conversation_repository import SQLAlchemyInstalledAppConversationRepositoryfrom repositories.installed_app_repository import SQLAlchemyInstalledAppRepositoryfrom repositories.message_file_preview_repository import MessageFilePreviewQueryRepositoryfrom repositories.oauth_access_token_repository import SQLAlchemyOAuthAccessTokenRepository@@ -168,6 +169,7 @@ from services.auth.data_source_api_key_auth_service import DataSourceApiKeyAuthSfrom services.billing_portal_service import BillingPortalServicefrom services.billing_service import BillingServicefrom services.compliance_download_service import ComplianceDownloadService+from services.conversation_service import ConversationServicefrom services.data_source_oauth_service import DataSourceOAuthService, InvalidDataSourceOAuthProviderErrorfrom services.enterprise.enterprise_service import EnterpriseServicefrom services.entities.file_grant_entities import FileGrantLimits@@ -182,6 +184,7 @@ from services.human_input_file_upload_service import HumanInputFileUploadServicefrom services.init_validation_service import InitValidationServicefrom services.inner_mail_service import InnerMailServicefrom services.installed_app_access_service import InstalledAppAccessService+from services.installed_app_conversation_service import InstalledAppConversationServicefrom services.installed_app_generation_adapters import AppGenerateServiceRuntime as InstalledAppGenerateServiceRuntimefrom services.installed_app_generation_service import InstalledAppGenerationServicefrom services.installed_app_service import InstalledAppService@@ -259,6 +262,18 @@ logger = logging.getLogger(__name__)_EXTENSION_KEY = "application_services"+def _generate_installed_app_conversation_name(+ *, tenant_id: str, app_id: str, conversation_id: str, query: str, app_mode: str+) -> str:+ # Legacy provider and tracing lookups use db.session. Give them their own+ # scope so teardown releases it before the conversation write transaction,+ # without removing a session owned by the surrounding request.+ with current_app.app_context():+ return ConversationService.generate_name(+ tenant_id=tenant_id, app_id=app_id, conversation_id=conversation_id, query=query, app_mode=app_mode+ )++# TODO: Normalize EnterpriseService.WebAppAuth result/error contracts in the SDK,# migrate its callers, then inject its methods directly and remove these adapters.# Define SDK errors for timeouts, transport failures, upstream status and invalid@@ -373,6 +388,7 @@ class ApplicationServices:oauth_device: OAuthDeviceApplicationServiceinit_validation: InitValidationServiceinstalled_app_access: InstalledAppAccessService+ installed_app_conversations: InstalledAppConversationServiceinstalled_app_generation: InstalledAppGenerationServiceinstalled_apps: InstalledAppServicenotifications: NotificationService@@ -805,8 +821,12 @@ def build_application_services(),webapp_access=webapp_access,installed_app_access=installed_app_access,+ installed_app_conversations=InstalledAppConversationService(+ conversations=SQLAlchemyInstalledAppConversationRepository(session_factory=database_client),+ generate_name=_generate_installed_app_conversation_name,+ enqueue_delete_cleanup=ConversationService.enqueue_delete_cleanup,+ ),installed_app_generation=InstalledAppGenerationService(- app_definitions=app_definitions,usage=installed_apps,runtime=InstalledAppGenerateServiceRuntime(session_factory=database_client),),diff --git a/api/repositories/agent_workspace_repository.py b/api/repositories/agent_workspace_repository.pynew file mode 100644index 00000000000..60012a483ed--- /dev/null+++ b/api/repositories/agent_workspace_repository.py@@ -0,0 +1,90 @@+"""Agent Workspace persistence within a caller-owned session and transaction."""++from sqlalchemy import select+from sqlalchemy.orm import Session++from core.agent.workspace import WorkspaceOwnerScope+from libs.datetime_utils import naive_utc_now+from models.agent import AgentWorkingResourceStatus, AgentWorkspace, AgentWorkspaceBinding, AgentWorkspaceOwnerType+++class AgentWorkspaceRepository:+ """Borrow a session without committing, rolling back, or closing it."""++ def __init__(self, *, session: Session) -> None:+ self._session: Session = session++ def get_active_binding(+ self,+ *,+ tenant_id: str,+ binding_id: str,+ expected_owner_scope: WorkspaceOwnerScope,+ ) -> AgentWorkspaceBinding | None:+ """Return the active binding in the exact owner scope, or None if unavailable."""+ return self._session.scalar(+ select(AgentWorkspaceBinding)+ .join(+ AgentWorkspace,+ (AgentWorkspace.tenant_id == AgentWorkspaceBinding.tenant_id)+ & (AgentWorkspace.id == AgentWorkspaceBinding.workspace_id),+ )+ .where(+ AgentWorkspaceBinding.id == binding_id,+ AgentWorkspaceBinding.tenant_id == tenant_id,+ AgentWorkspaceBinding.status == AgentWorkingResourceStatus.ACTIVE,+ AgentWorkspace.tenant_id == expected_owner_scope.tenant_id,+ AgentWorkspace.app_id == expected_owner_scope.app_id,+ AgentWorkspace.owner_type == expected_owner_scope.owner_type,+ AgentWorkspace.owner_id == expected_owner_scope.owner_id,+ AgentWorkspace.owner_scope_key == expected_owner_scope.owner_scope_key,+ AgentWorkspace.status == AgentWorkingResourceStatus.ACTIVE,+ )+ )++ def retire_workspace(self, *, tenant_id: str, workspace_id: str) -> str | None:+ """Retire a workspace and its active bindings; return None if it is not active or not found."""+ workspace = self._session.scalar(+ select(AgentWorkspace)+ .where(+ AgentWorkspace.id == workspace_id,+ AgentWorkspace.tenant_id == tenant_id,+ AgentWorkspace.status == AgentWorkingResourceStatus.ACTIVE,+ )+ .with_for_update()+ )+ if workspace is None:+ return None+ now = naive_utc_now()+ workspace.status = AgentWorkingResourceStatus.RETIRED+ workspace.active_guard = None+ workspace.retired_at = now+ bindings = self._session.scalars(+ select(AgentWorkspaceBinding).where(+ AgentWorkspaceBinding.tenant_id == tenant_id,+ AgentWorkspaceBinding.workspace_id == workspace.id,+ AgentWorkspaceBinding.status == AgentWorkingResourceStatus.ACTIVE,+ )+ ).all()+ for binding in bindings:+ binding.status = AgentWorkingResourceStatus.RETIRED+ binding.retired_at = now+ return workspace.id++ def retire_all_for_conversation(self, *, tenant_id: str, app_id: str, conversation_id: str) -> list[str]:+ """Retire all active workspaces owned by the conversation, including Chatflow nodes."""+ workspaces = self._session.scalars(+ select(AgentWorkspace).where(+ AgentWorkspace.tenant_id == tenant_id,+ AgentWorkspace.app_id == app_id,+ AgentWorkspace.owner_type == AgentWorkspaceOwnerType.CONVERSATION,+ AgentWorkspace.owner_id == conversation_id,+ AgentWorkspace.status == AgentWorkingResourceStatus.ACTIVE,+ )+ ).all()+ retired: list[str] = []+ for workspace in workspaces:+ workspace_id = self.retire_workspace(tenant_id=tenant_id, workspace_id=workspace.id)+ if workspace_id is not None:+ retired.append(workspace_id)+ return retireddiff --git a/api/repositories/conversation_lifecycle.py b/api/repositories/conversation_lifecycle.pynew file mode 100644index 00000000000..fd45a1a44f2--- /dev/null+++ b/api/repositories/conversation_lifecycle.py@@ -0,0 +1,50 @@+"""Shared conversation lifecycle mutations within a caller-owned transaction."""++import logging++from sqlalchemy.orm import Session++from core.agent.workspace import AgentWorkspaceNotFoundError, WorkspaceOwnerScope+from models.agent import AgentWorkspaceOwnerType+from models.model import App, Conversation+from repositories.agent_workspace_repository import AgentWorkspaceRepository++logger = logging.getLogger(__name__)+++def retire_conversation(*, app_model: App, conversation: Conversation, session: Session) -> tuple[str, ...]:+ """Retire a conversation and all its workspaces in the caller's transaction.++ The caller must validate conversation ownership before calling, commit+ all lifecycle changes together, then enqueue cleanup after that commit.+ This function neither commits nor dispatches background tasks.+ """+ workspaces = AgentWorkspaceRepository(session=session)+ binding_id = conversation.agent_workspace_binding_id+ if binding_id is not None:+ owner_scope = WorkspaceOwnerScope(+ tenant_id=app_model.tenant_id,+ app_id=app_model.id,+ owner_type=AgentWorkspaceOwnerType.CONVERSATION,+ owner_id=conversation.id,+ )+ binding = workspaces.get_active_binding(+ tenant_id=app_model.tenant_id,+ binding_id=binding_id,+ expected_owner_scope=owner_scope,+ )+ if binding is None:+ raise AgentWorkspaceNotFoundError("Conversation participant Binding is unavailable")++ logger.info(+ "Initiating conversation deletion for app_name %s, conversation_id: %s",+ app_model.name,+ conversation.id,+ )+ retired_workspace_ids = workspaces.retire_all_for_conversation(+ tenant_id=app_model.tenant_id,+ app_id=app_model.id,+ conversation_id=conversation.id,+ )+ conversation.is_deleted = True+ return tuple(retired_workspace_ids)diff --git a/api/repositories/installed_app_conversation_repository.py b/api/repositories/installed_app_conversation_repository.pynew file mode 100644index 00000000000..69a54d05e11--- /dev/null+++ b/api/repositories/installed_app_conversation_repository.py@@ -0,0 +1,222 @@+"""Persist an account's conversations within its admitted installation."""++from dataclasses import replace+from datetime import datetime+from typing import cast, override++from sqlalchemy import Select, exists, or_, select+from sqlalchemy.orm import Session, sessionmaker++from core.app.entities.app_invoke_entities import InvokeFrom+from models.enums import ConversationFromSource, CreatorUserRole+from models.model import App, Conversation, InstalledApp, Message+from models.web import PinnedConversation+from repositories.conversation_lifecycle import retire_conversation+from services.errors.conversation import ConversationNotExistsError, LastConversationNotExistsError+from services.errors.message import MessageNotExistsError+from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppRef+from services.installed_app_conversation_service import (+ ConversationDeletion,+ ConversationInputValue,+ ConversationNameSource,+ ConversationPage,+ ConversationRecord,+ InstalledAppConversationStore,+)+++class SQLAlchemyInstalledAppConversationRepository(InstalledAppConversationStore):+ def __init__(self, *, session_factory: sessionmaker[Session]) -> None:+ self._session_factory: sessionmaker[Session] = session_factory++ @override+ def get(self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str) -> ConversationRecord:+ with self._session_factory() 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+ )+ return self._to_record(conversation=conversation, session=session)++ @override+ def get_page(+ self, *, installed_app: InstalledAppRef, account_id: str, last_id: str | None, limit: int, pinned: bool | None+ ) -> ConversationPage:+ with self._session_factory() as session:+ app = self._get_app(session=session, installed_app=installed_app)+ statement = self._conversation_statement(app_id=app.id, account_id=account_id).where(+ or_(Conversation.invoke_from.is_(None), Conversation.invoke_from == InvokeFrom.EXPLORE)+ )+ if pinned is not None:+ pinned_ids = session.scalars(+ select(PinnedConversation.conversation_id).where(+ PinnedConversation.app_id == app.id,+ PinnedConversation.created_by_role == CreatorUserRole.ACCOUNT,+ PinnedConversation.created_by == account_id,+ )+ ).all()+ if pinned:+ if not pinned_ids:+ return ConversationPage(limit=limit, has_more=False, data=())+ statement = statement.where(Conversation.id.in_(pinned_ids))+ elif pinned_ids:+ statement = statement.where(Conversation.id.not_in(pinned_ids))++ if last_id:+ last_conversation = session.scalar(statement.where(Conversation.id == last_id))+ if last_conversation is None:+ raise LastConversationNotExistsError("The last_id cursor does not belong to these conversations.")+ statement = statement.where(Conversation.updated_at < last_conversation.updated_at)++ conversations = session.scalars(statement.order_by(Conversation.updated_at.desc()).limit(limit)).all()+ # Keep the existing strict timestamp cursor, including tied timestamps.+ has_more = len(conversations) == limit and bool(+ session.scalar(select(exists(statement.where(Conversation.updated_at < conversations[-1].updated_at))))+ )+ return ConversationPage(+ limit=limit,+ has_more=has_more,+ data=tuple(+ self._to_record(conversation=conversation, session=session) for conversation in conversations+ ),+ )++ @override+ def get_name_source(+ self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str+ ) -> ConversationNameSource:+ with self._session_factory() 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+ )+ message = session.scalar(+ select(Message)+ .where(Message.app_id == app.id, Message.conversation_id == conversation.id)+ .order_by(Message.created_at.asc())+ .limit(1)+ )+ if message is None:+ raise MessageNotExistsError(f"Conversation {conversation_id} has no message to generate a name from.")+ return ConversationNameSource(+ tenant_id=app.tenant_id,+ query=message.query,+ )++ @override+ def rename(+ self,+ *,+ installed_app: InstalledAppRef,+ account_id: str,+ conversation_id: str,+ name: str,+ updated_at: datetime | None,+ ) -> ConversationRecord:+ 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+ )+ record = self._to_record(conversation=conversation, session=session)+ conversation.name = name+ if updated_at is not None:+ conversation.updated_at = updated_at+ session.flush()+ renamed = replace(record, name=conversation.name, updated_at=conversation.updated_at)+ return renamed++ @override+ def delete(self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str) -> 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+ )+ retired_workspace_ids = retire_conversation(app_model=app, conversation=conversation, session=session)+ return ConversationDeletion(+ tenant_id=app.tenant_id,+ conversation_id=conversation.id,+ retired_workspace_ids=retired_workspace_ids,+ )++ @override+ def set_pinned(+ self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str, is_pinned: bool+ ) -> None:+ with self._session_factory.begin() as session:+ app = self._get_app(session=session, installed_app=installed_app)+ pin = 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,+ )+ .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+ )+ session.add(+ PinnedConversation(+ app_id=app.id,+ conversation_id=conversation.id,+ created_by_role=CreatorUserRole.ACCOUNT,+ created_by=account_id,+ )+ )+ elif pin is not None:+ session.delete(pin)++ @staticmethod+ def _get_app(*, session: Session, installed_app: InstalledAppRef) -> App:+ app = session.scalar(+ select(App)+ .join(InstalledApp, InstalledApp.app_id == App.id)+ .where(+ InstalledApp.id == installed_app.id,+ InstalledApp.tenant_id == installed_app.tenant_id,+ InstalledApp.app_id == installed_app.app_id,+ )+ )+ if app is None:+ raise InstalledAppNotFoundError(f"Installed app {installed_app.id} no longer exists")+ return app++ @staticmethod+ def _conversation_statement(*, app_id: str, account_id: str) -> Select[tuple[Conversation]]:+ return select(Conversation).where(+ Conversation.app_id == app_id,+ Conversation.from_source == ConversationFromSource.CONSOLE,+ Conversation.from_account_id == account_id,+ Conversation.from_end_user_id.is_(None),+ Conversation.is_deleted.is_(False),+ )++ @classmethod+ def _get_conversation(cls, *, session: Session, app_id: str, account_id: str, conversation_id: str) -> Conversation:+ conversation = session.scalar(+ cls._conversation_statement(app_id=app_id, account_id=account_id).where(Conversation.id == conversation_id)+ )+ if conversation is None:+ raise ConversationNotExistsError(f"Conversation {conversation_id} does not belong to this account and app.")+ return conversation++ @staticmethod+ def _to_record(*, conversation: Conversation, session: Session) -> ConversationRecord:+ # Reuse the model's input/file restoration until that legacy I/O boundary+ # is migrated; do not duplicate its reconstruction logic in this repository.+ return ConversationRecord(+ id=conversation.id,+ name=conversation.name,+ inputs=cast(dict[str, ConversationInputValue], conversation.inputs_with_session(session=session)),+ status=conversation.status,+ introduction=conversation.introduction,+ created_at=conversation.created_at,+ updated_at=conversation.updated_at,+ )diff --git a/api/repositories/installed_app_repository.py b/api/repositories/installed_app_repository.pyindex eba9af7f13a..da345827be2 100644--- a/api/repositories/installed_app_repository.py+++ b/api/repositories/installed_app_repository.py@@ -104,13 +104,15 @@ class SQLAlchemyInstalledAppRepository(InstalledAppAccessStore, InstalledAppUsag# An installed public app can belong to another workspace. Admission# preserves the existence check; publication policy belongs to its callers.- app_id = session.scalar(select(App.id).where(App.id == installed_app.app_id).limit(1))- if app_id is None:+ app = session.execute(select(App.id, App.mode).where(App.id == installed_app.app_id).limit(1)).first()+ if app is None:session.delete(installed_app)session.commit()return None- return InstalledAppRef(id=installed_app.id, app_id=app_id, tenant_id=installed_app.tenant_id)+ return InstalledAppRef(+ id=installed_app.id, app_id=app.id, tenant_id=installed_app.tenant_id, app_mode=app.mode.value+ )@overridedef record(self, *, installed_app: InstalledAppRef, used_at: datetime) -> None:diff --git a/api/services/agent/workspace_service.py b/api/services/agent/workspace_service.pyindex fee8348b66f..344f6b38905 100644--- a/api/services/agent/workspace_service.py+++ b/api/services/agent/workspace_service.py@@ -9,7 +9,6 @@ and deletes ledger rows only after idempotent physical cleanup succeeds.from __future__ import annotationsimport logging-from dataclasses import dataclassfrom dify_agent.client import Clientfrom dify_agent.protocol import CreateExecutionBindingRequest, DestroyExecutionBindingRequest@@ -18,6 +17,12 @@ from sqlalchemy.orm import Sessionfrom clients.agent_backend.factory import create_agent_backend_clientfrom configs import dify_config+from core.agent.workspace import (+ AgentWorkspaceBindingGenerationMismatchError,+ AgentWorkspaceError,+ AgentWorkspaceNotFoundError,+ WorkspaceOwnerScope,+)from core.db.session_factory import session_factoryfrom libs.datetime_utils import naive_utc_nowfrom libs.uuid_utils import uuidv7@@ -27,33 +32,12 @@ from models.agent import (AgentWorkingResourceStatus,AgentWorkspace,AgentWorkspaceBinding,- AgentWorkspaceOwnerType,)+from repositories.agent_workspace_repository import AgentWorkspaceRepositorylogger = logging.getLogger(__name__)-class AgentWorkspaceError(RuntimeError):- pass---class AgentWorkspaceNotFoundError(AgentWorkspaceError):- pass---class AgentWorkspaceBindingGenerationMismatchError(AgentWorkspaceError):- pass---@dataclass(frozen=True, slots=True)-class WorkspaceOwnerScope:- tenant_id: str- app_id: str- owner_type: AgentWorkspaceOwnerType- owner_id: str- owner_scope_key: str = "root"--class AgentWorkspaceService:"""Allocate and manage working-environment resources.@@ -84,24 +68,8 @@ class AgentWorkspaceService:binding_id: str,expected_owner_scope: WorkspaceOwnerScope,) -> AgentWorkspaceBinding | None:- return session.scalar(- select(AgentWorkspaceBinding)- .join(- AgentWorkspace,- (AgentWorkspace.tenant_id == AgentWorkspaceBinding.tenant_id)- & (AgentWorkspace.id == AgentWorkspaceBinding.workspace_id),- )- .where(- AgentWorkspaceBinding.id == binding_id,- AgentWorkspaceBinding.tenant_id == tenant_id,- AgentWorkspaceBinding.status == AgentWorkingResourceStatus.ACTIVE,- AgentWorkspace.tenant_id == expected_owner_scope.tenant_id,- AgentWorkspace.app_id == expected_owner_scope.app_id,- AgentWorkspace.owner_type == expected_owner_scope.owner_type,- AgentWorkspace.owner_id == expected_owner_scope.owner_id,- AgentWorkspace.owner_scope_key == expected_owner_scope.owner_scope_key,- AgentWorkspace.status == AgentWorkingResourceStatus.ACTIVE,- )+ return AgentWorkspaceRepository(session=session).get_active_binding(+ tenant_id=tenant_id, binding_id=binding_id, expected_owner_scope=expected_owner_scope)@classmethod@@ -281,32 +249,9 @@ class AgentWorkspaceService:@classmethoddef retire_workspace(cls, *, session: Session, tenant_id: str, workspace_id: str) -> str | None:- workspace = session.scalar(- select(AgentWorkspace)- .where(- AgentWorkspace.id == workspace_id,- AgentWorkspace.tenant_id == tenant_id,- AgentWorkspace.status == AgentWorkingResourceStatus.ACTIVE,- )- .with_for_update()+ return AgentWorkspaceRepository(session=session).retire_workspace(+ tenant_id=tenant_id, workspace_id=workspace_id)- if workspace is None:- return None- now = naive_utc_now()- workspace.status = AgentWorkingResourceStatus.RETIRED- workspace.active_guard = None- workspace.retired_at = now- bindings = session.scalars(- select(AgentWorkspaceBinding).where(- AgentWorkspaceBinding.tenant_id == tenant_id,- AgentWorkspaceBinding.workspace_id == workspace.id,- AgentWorkspaceBinding.status == AgentWorkingResourceStatus.ACTIVE,- )- ).all()- for binding in bindings:- binding.status = AgentWorkingResourceStatus.RETIRED- binding.retired_at = now- return workspace.id@classmethoddef retire_all_for_app(cls, *, session: Session, tenant_id: str, app_id: str) -> list[str]:@@ -340,26 +285,9 @@ class AgentWorkspaceService:conversation_id: str,) -> list[str]:"""Retire all ACTIVE conversation-owned Workspaces for one Chatflow conversation."""-- workspaces = session.scalars(- select(AgentWorkspace).where(- AgentWorkspace.tenant_id == tenant_id,- AgentWorkspace.app_id == app_id,- AgentWorkspace.owner_type == AgentWorkspaceOwnerType.CONVERSATION,- AgentWorkspace.owner_id == conversation_id,- AgentWorkspace.status == AgentWorkingResourceStatus.ACTIVE,- )- ).all()- retired: list[str] = []- for workspace in workspaces:- workspace_id = cls.retire_workspace(- session=session,- tenant_id=tenant_id,- workspace_id=workspace.id,- )- if workspace_id is not None:- retired.append(workspace_id)- return retired+ return AgentWorkspaceRepository(session=session).retire_all_for_conversation(+ tenant_id=tenant_id, app_id=app_id, conversation_id=conversation_id+ )@classmethoddef collect_retired_binding(cls, *, tenant_id: str, binding_id: str) -> None:diff --git a/api/services/conversation_service.py b/api/services/conversation_service.pyindex de73a7cf32f..fda23414051 100644--- a/api/services/conversation_service.py+++ b/api/services/conversation_service.py@@ -15,9 +15,8 @@ from graphon.variables.types import SegmentTypefrom libs.datetime_utils import naive_utc_nowfrom libs.infinite_scroll_pagination import InfiniteScrollPaginationfrom models import Account, ConversationVariable-from models.agent import AgentWorkspaceOwnerTypefrom models.model import App, Conversation, EndUser, Message-from services.agent.workspace_service import AgentWorkspaceNotFoundError, AgentWorkspaceService, WorkspaceOwnerScope+from repositories.conversation_lifecycle import retire_conversationfrom services.errors.conversation import (ConversationNotExistsError,ConversationVariableNotExistsError,@@ -140,7 +139,7 @@ class ConversationService:return conversation@classmethod- def auto_generate_name(cls, app_model: App, conversation: Conversation, *, session: Session):+ def auto_generate_name(cls, app_model: App, conversation: Conversation, *, session: Session) -> Conversation:# get conversation first messagemessage = session.scalar(select(Message)@@ -153,19 +152,25 @@ class ConversationService:raise MessageNotExistsError()# generate conversation name- with (- contextlib.suppress(Exception),- use_credit_usage_metadata({"app_type": get_credit_usage_app_type(app_model.mode)}),- ):- name = LLMGenerator.generate_conversation_name(- app_model.tenant_id, message.query, conversation.id, app_model.id+ with contextlib.suppress(Exception):+ conversation.name = cls.generate_name(+ tenant_id=app_model.tenant_id,+ app_id=app_model.id,+ conversation_id=conversation.id,+ query=message.query,+ app_mode=app_model.mode,)- conversation.name = namesession.commit()return conversation+ @staticmethod+ def generate_name(*, tenant_id: str, app_id: str, conversation_id: str, query: str, app_mode: str) -> str:+ """Generate a conversation title with the appropriate credit usage metadata."""+ with use_credit_usage_metadata({"app_type": get_credit_usage_app_type(app_mode)}):+ return LLMGenerator.generate_conversation_name(tenant_id, query, conversation_id, app_id)+@classmethoddef get_conversation(cls, app_model: App, conversation_id: str, user: Account | EndUser | None, *, session: Session@@ -189,7 +194,7 @@ class ConversationService:return conversation@classmethod- def delete(cls, app_model: App, conversation_id: str, user: Account | EndUser | None, *, session: Session):+ def delete(cls, app_model: App, conversation_id: str, user: Account | EndUser | None, *, session: Session) -> None:"""Delete a conversation only if it belongs to the given user and app context.@@ -200,51 +205,33 @@ class ConversationService:ConversationNotExistsError: When the conversation is not visible to the current user."""conversation = cls.get_conversation(app_model, conversation_id, user, session=session)- binding_id = conversation.agent_workspace_binding_id- if binding_id is not None:- owner_scope = WorkspaceOwnerScope(- tenant_id=app_model.tenant_id,- app_id=app_model.id,- owner_type=AgentWorkspaceOwnerType.CONVERSATION,- owner_id=conversation.id,- )- binding = AgentWorkspaceService.get_active_binding(- session=session,- tenant_id=app_model.tenant_id,- binding_id=binding_id,- expected_owner_scope=owner_scope,- )- if binding is None:- raise AgentWorkspaceNotFoundError("Conversation participant Binding is unavailable")-+ tenant_id = app_model.tenant_idtry:- logger.info(- "Initiating conversation deletion for app_name %s, conversation_id: %s",- app_model.name,- conversation_id,- )- retired_workspace_ids = AgentWorkspaceService.retire_all_for_conversation(- session=session,- tenant_id=app_model.tenant_id,- app_id=app_model.id,- conversation_id=conversation.id,- )- conversation.is_deleted = True+ retired_workspace_ids = retire_conversation(app_model=app_model, conversation=conversation, session=session)session.commit()except Exception:session.rollback()raise+ cls.enqueue_delete_cleanup(+ tenant_id=tenant_id,+ conversation_id=conversation_id,+ retired_workspace_ids=retired_workspace_ids,+ )++ @staticmethod+ def enqueue_delete_cleanup(*, tenant_id: str, conversation_id: str, retired_workspace_ids: tuple[str, ...]) -> None:+ """Dispatch resource collection only after the lifecycle transaction commits."""if retired_workspace_ids:enqueue_agent_resource_collection(- tenant_id=app_model.tenant_id,+ tenant_id=tenant_id,workspace_ids=retired_workspace_ids,)try:- delete_conversation_related_data.delay(conversation.id)+ delete_conversation_related_data.delay(conversation_id)except Exception:# The soft-deleted row is a durable cleanup marker picked up by the# periodic sweeper, so a broker outage must not resurrect or expose it.- logger.exception("Failed to enqueue cleanup for conversation %s", conversation.id)+ logger.exception("Failed to enqueue cleanup for conversation %s", conversation_id)@classmethoddef get_conversational_variable(diff --git a/api/services/installed_app_access_service.py b/api/services/installed_app_access_service.pyindex 3f01b0dd1f7..c686eababd2 100644--- a/api/services/installed_app_access_service.py+++ b/api/services/installed_app_access_service.py@@ -10,9 +10,12 @@ from services.webapp_access_query_service import WebAppAccessModesQuery, WebAppU@dataclass(frozen=True, slots=True)class InstalledAppRef:+ """Installation identity and app mode captured during request admission."""+id: strapp_id: strtenant_id: str+ app_mode: strclass InstalledAppAccessStore(Protocol):diff --git a/api/services/installed_app_conversation_service.py b/api/services/installed_app_conversation_service.pynew file mode 100644index 00000000000..6e2677861e3--- /dev/null+++ b/api/services/installed_app_conversation_service.py@@ -0,0 +1,196 @@+"""Manage an account's conversations in an admitted installation."""++import logging+from dataclasses import dataclass+from datetime import datetime+from typing import Protocol++from pydantic import JsonValue++from graphon.file import File+from libs.datetime_utils import naive_utc_now+from services.installed_app_access_service import InstalledAppRef++logger = logging.getLogger(__name__)++type ConversationInputValue = JsonValue | File | list[File]+++@dataclass(frozen=True, slots=True)+class ConversationRecord:+ id: str+ name: str+ inputs: dict[str, ConversationInputValue]+ status: str+ introduction: str | None+ created_at: datetime | None+ updated_at: datetime | None+++@dataclass(frozen=True, slots=True)+class ConversationPage:+ limit: int+ has_more: bool+ data: tuple[ConversationRecord, ...]+++@dataclass(frozen=True, slots=True)+class ConversationNameSource:+ tenant_id: str+ query: str+++@dataclass(frozen=True, slots=True)+class ConversationDeletion:+ tenant_id: str+ conversation_id: str+ retired_workspace_ids: tuple[str, ...]+++class ConversationNotChatAppError(ValueError):+ """The installed app does not support conversation management."""+++class ConversationNameRequiredError(ValueError):+ """A manual rename must provide a name."""+++class InstalledAppConversationStore(Protocol):+ def get(self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str) -> ConversationRecord: ...++ def get_page(+ self, *, installed_app: InstalledAppRef, account_id: str, last_id: str | None, limit: int, pinned: bool | None+ ) -> ConversationPage: ...++ def get_name_source(+ self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str+ ) -> ConversationNameSource: ...++ def rename(+ self,+ *,+ installed_app: InstalledAppRef,+ account_id: str,+ conversation_id: str,+ name: str,+ updated_at: datetime | None,+ ) -> ConversationRecord: ...++ 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 ConversationNameGenerator(Protocol):+ def __call__(self, *, tenant_id: str, app_id: str, conversation_id: str, query: str, app_mode: str) -> str: ...+++class ConversationCleanup(Protocol):+ def __call__(self, *, tenant_id: str, conversation_id: str, retired_workspace_ids: tuple[str, ...]) -> None: ...+++class InstalledAppConversationService:+ def __init__(+ self,+ *,+ conversations: InstalledAppConversationStore,+ generate_name: ConversationNameGenerator,+ enqueue_delete_cleanup: ConversationCleanup,+ ) -> None:+ self._conversations: InstalledAppConversationStore = conversations+ self._generate_name: ConversationNameGenerator = generate_name+ self._enqueue_delete_cleanup: ConversationCleanup = enqueue_delete_cleanup++ def get_page(+ self, *, installed_app: InstalledAppRef, account_id: str, last_id: str | None, limit: int, pinned: bool | None+ ) -> ConversationPage:+ self._get_chat_mode(installed_app)+ return self._conversations.get_page(+ installed_app=installed_app, account_id=account_id, last_id=last_id, limit=limit, pinned=pinned+ )++ def rename(+ self,+ *,+ installed_app: InstalledAppRef,+ account_id: str,+ conversation_id: str,+ name: str | None,+ auto_generate: bool,+ ) -> ConversationRecord:+ """Rename a conversation manually or generate its name.++ When auto_generate is False, name is required and cannot be None.+ When auto_generate is True, name is ignored.+ """+ app_mode = self._get_chat_mode(installed_app)+ if not auto_generate:+ if name is None:+ raise ConversationNameRequiredError("name is required when auto_generate is false")+ return self._conversations.rename(+ installed_app=installed_app,+ account_id=account_id,+ conversation_id=conversation_id,+ name=name,+ updated_at=naive_utc_now(),+ )++ source = self._conversations.get_name_source(+ installed_app=installed_app, account_id=account_id, conversation_id=conversation_id+ )+ # The read transaction is closed before entering the model provider.+ try:+ generated_name = self._generate_name(+ tenant_id=source.tenant_id,+ app_id=installed_app.app_id,+ conversation_id=conversation_id,+ query=source.query,+ app_mode=app_mode,+ )+ except Exception:+ # Automatic naming is best-effort; preserve the existing name on failure.+ logger.exception(+ "Failed to generate a name for app %s conversation %s", installed_app.app_id, conversation_id+ )+ return self._conversations.get(+ installed_app=installed_app, account_id=account_id, conversation_id=conversation_id+ )+ # Recheck ownership and deletion state in the write transaction.+ return self._conversations.rename(+ installed_app=installed_app,+ account_id=account_id,+ conversation_id=conversation_id,+ name=generated_name,+ updated_at=None,+ )++ 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,+ )++ 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+ )++ @staticmethod+ def _get_chat_mode(installed_app: InstalledAppRef) -> str:+ mode = installed_app.app_mode+ if mode not in {"chat", "agent-chat", "advanced-chat"}:+ raise ConversationNotChatAppError(f"App {installed_app.app_id} is not a chat app")+ return modediff --git a/api/services/installed_app_generation_service.py b/api/services/installed_app_generation_service.pyindex 381a4a57228..708e777ee9c 100644--- a/api/services/installed_app_generation_service.py+++ b/api/services/installed_app_generation_service.py@@ -5,7 +5,6 @@ from datetime import datetimefrom typing import Protocolfrom libs.datetime_utils import naive_utc_now-from services.app_definition_query_service import AppDefinitionQueryServicefrom services.installed_app_access_service import InstalledAppRef@@ -51,18 +50,16 @@ class InstalledAppGenerationService:def __init__(self,*,- app_definitions: AppDefinitionQueryService,usage: InstalledAppUsageRecorder,runtime: InstalledAppGenerationRuntime,) -> None:- self._app_definitions: AppDefinitionQueryService = app_definitionsself._usage: InstalledAppUsageRecorder = usageself._runtime: InstalledAppGenerationRuntime = runtimedef generate_completion(self, *, installed_app: InstalledAppRef, account_id: str, args: Mapping[str, object]) -> GenerationResponse:- if self._app_definitions.get_mode(installed_app.app_id) != "completion":+ if installed_app.app_mode != "completion":raise InstalledAppNotCompletionError(f"App {installed_app.app_id} is not a completion app")return self._generate(@@ -75,7 +72,7 @@ class InstalledAppGenerationService:def generate_chat(self, *, installed_app: InstalledAppRef, account_id: str, args: Mapping[str, object]) -> GenerationResponse:- if self._app_definitions.get_mode(installed_app.app_id) not in {"chat", "agent-chat", "advanced-chat"}:+ if installed_app.app_mode not in {"chat", "agent-chat", "advanced-chat"}:raise InstalledAppNotChatError(f"App {installed_app.app_id} is not a chat app")return self._generate(installed_app=installed_app, account_id=account_id, args=args, streaming=True)@@ -83,7 +80,7 @@ class InstalledAppGenerationService:def generate_workflow(self, *, installed_app: InstalledAppRef, account_id: str, args: Mapping[str, object]) -> GenerationResponse:- if self._app_definitions.get_mode(installed_app.app_id) != "workflow":+ if installed_app.app_mode != "workflow":raise InstalledAppNotWorkflowError(f"App {installed_app.app_id} is not a workflow app")# Workflow runs do not update installation usage or add chat naming options.diff --git a/api/tests/test_containers_integration_tests/controllers/console/explore/test_conversation.py b/api/tests/test_containers_integration_tests/controllers/console/explore/test_conversation.pydeleted file mode 100644index d6efdb9a1c4..00000000000--- a/api/tests/test_containers_integration_tests/controllers/console/explore/test_conversation.py+++ /dev/null@@ -1,272 +0,0 @@-"""Testcontainers integration tests for controllers.console.explore.conversation endpoints."""--from __future__ import annotations--from dataclasses import dataclass-from inspect import unwrap-from typing import cast-from unittest.mock import patch--import pytest-from flask import Flask-from sqlalchemy.orm import Session-from werkzeug.exceptions import NotFound--import controllers.console.explore.conversation as conversation_module-from controllers.console.explore.error import NotChatAppError-from libs.infinite_scroll_pagination import InfiniteScrollPagination-from models import Account-from models.enums import ConversationFromSource, ConversationStatus-from models.model import App, AppMode, Conversation, InstalledApp-from services.errors.conversation import (- ConversationNotExistsError,- LastConversationNotExistsError,-)---@dataclass-class InstalledAppCarrier:- app: App | None-- def app_with_session(self, *, session: Session) -> App | None:- del session- return self.app---def chat_app() -> InstalledApp:- app_model = App(- tenant_id="tenant-1",- name="Chat App",- mode=AppMode.CHAT,- enable_site=True,- enable_api=False,- )- app_model.id = "app-id"- return cast(InstalledApp, InstalledAppCarrier(app=app_model))---def non_chat_app() -> InstalledApp:- app_model = App(- tenant_id="tenant-1",- name="Completion App",- mode=AppMode.COMPLETION,- enable_site=True,- enable_api=False,- )- app_model.id = "app-id"- return cast(InstalledApp, InstalledAppCarrier(app=app_model))---def make_conversation(*, id: str) -> Conversation:- conversation = Conversation(- app_id="app-id",- mode=AppMode.CHAT,- name="test",- from_source=ConversationFromSource.API,- )- conversation.id = id- conversation.inputs = {}- conversation.status = ConversationStatus.NORMAL- conversation.introduction = ""- return conversation---def user() -> Account:- user = Account(name="User", email="user.com")- user.id = "uid"- return user---class TestConversationListApi:- @pytest.fixture- def app(self, flask_app_with_containers: Flask) -> Flask:- return flask_app_with_containers-- def test_get_success(self, app: Flask, chat_app: InstalledApp, user: Account) -> None:- api = conversation_module.ConversationListApi()- method = unwrap(api.get)-- pagination = InfiniteScrollPagination(- data=[make_conversation(id="c1"), make_conversation(id="c2")],- limit=20,- has_more=False,- )-- with (- app.test_request_context("/?limit=20"),- patch.object(- conversation_module.WebConversationService,- "pagination_by_last_id",- return_value=pagination,- ),- ):- result = method(api, user, chat_app)-- assert result["limit"] == 20- assert result["has_more"] is False- assert len(result["data"]) == 2-- def test_last_conversation_not_exists(self, app: Flask, chat_app: InstalledApp, user: Account) -> None:- api = conversation_module.ConversationListApi()- method = unwrap(api.get)-- with (- app.test_request_context("/"),- patch.object(- conversation_module.WebConversationService,- "pagination_by_last_id",- side_effect=LastConversationNotExistsError(),- ),- ):- with pytest.raises(NotFound):- method(api, user, chat_app)-- def test_wrong_app_mode(self, app: Flask, non_chat_app: InstalledApp, user: Account) -> None:- api = conversation_module.ConversationListApi()- method = unwrap(api.get)-- with app.test_request_context("/"):- with pytest.raises(NotChatAppError):- method(api, user, non_chat_app)---class TestConversationApi:- @pytest.fixture- def app(self, flask_app_with_containers: Flask) -> Flask:- return flask_app_with_containers-- def test_delete_success(self, app: Flask, chat_app: InstalledApp, user: Account) -> None:- api = conversation_module.ConversationApi()- method = unwrap(api.delete)-- with (- app.test_request_context("/"),- patch.object(- conversation_module.ConversationService,- "delete",- ),- ):- result = method(api, user, chat_app, "cid")-- body, status = result- assert status == 204- assert body == ""-- def test_delete_not_found(self, app: Flask, chat_app: InstalledApp, user: Account) -> None:- api = conversation_module.ConversationApi()- method = unwrap(api.delete)-- with (- app.test_request_context("/"),- patch.object(- conversation_module.ConversationService,- "delete",- side_effect=ConversationNotExistsError(),- ),- ):- with pytest.raises(NotFound):- method(api, user, chat_app, "cid")-- def test_delete_wrong_app_mode(self, app: Flask, non_chat_app: InstalledApp, user: Account) -> None:- api = conversation_module.ConversationApi()- method = unwrap(api.delete)-- with app.test_request_context("/"):- with pytest.raises(NotChatAppError):- method(api, user, non_chat_app, "cid")---class TestConversationRenameApi:- @pytest.fixture- def app(self, flask_app_with_containers: Flask) -> Flask:- return flask_app_with_containers-- def test_rename_success(self, app: Flask, chat_app: InstalledApp, user: Account) -> None:- api = conversation_module.ConversationRenameApi()- method = unwrap(api.post)-- conversation = make_conversation(id="cid")-- with (- app.test_request_context("/", json={"name": "new"}),- patch.object(- conversation_module.ConversationService,- "rename",- return_value=conversation,- ),- ):- result = method(- api,- conversation_module.ConversationRenamePayload.model_validate({"name": "new"}),- user,- chat_app,- "cid",- )-- assert result["id"] == "cid"-- def test_rename_not_found(self, app: Flask, chat_app: InstalledApp, user: Account) -> None:- api = conversation_module.ConversationRenameApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"name": "new"}),- patch.object(- conversation_module.ConversationService,- "rename",- side_effect=ConversationNotExistsError(),- ),- ):- with pytest.raises(NotFound):- method(- api,- conversation_module.ConversationRenamePayload.model_validate({"name": "new"}),- user,- chat_app,- "cid",- )---class TestConversationPinApi:- @pytest.fixture- def app(self, flask_app_with_containers: Flask) -> Flask:- return flask_app_with_containers-- def test_pin_success(self, app: Flask, chat_app: InstalledApp, user: Account) -> None:- api = conversation_module.ConversationPinApi()- method = unwrap(api.patch)-- with (- app.test_request_context("/"),- patch.object(- conversation_module.WebConversationService,- "pin",- ),- ):- result = method(api, user, chat_app, "cid")-- assert result == {"result": "success"}---class TestConversationUnPinApi:- @pytest.fixture- def app(self, flask_app_with_containers: Flask) -> Flask:- return flask_app_with_containers-- def test_unpin_success(self, app: Flask, chat_app: InstalledApp, user: Account) -> None:- api = conversation_module.ConversationUnPinApi()- method = unwrap(api.patch)-- with (- app.test_request_context("/"),- patch.object(- conversation_module.WebConversationService,- "unpin",- ),- ):- result = method(api, user, chat_app, "cid")-- assert result == {"result": "success"}diff --git a/api/tests/unit_tests/controllers/console/explore/test_completion.py b/api/tests/unit_tests/controllers/console/explore/test_completion.pyindex 7860c8127ac..40385c027f7 100644--- a/api/tests/unit_tests/controllers/console/explore/test_completion.py+++ b/api/tests/unit_tests/controllers/console/explore/test_completion.py@@ -9,10 +9,8 @@ import controllers.console.explore.completion as completion_modulefrom core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededErrorfrom graphon.model_runtime.errors.invoke import InvokeErrorfrom models import AppMode, Conversation, Tenant-from repositories.app_definition_query_repository import AppDefinitionQueryRepositoryfrom repositories.installed_app_repository import SQLAlchemyInstalledAppRepositoryfrom services.account_errors import AccountNotFoundError-from services.app_definition_query_service import AppDefinitionQueryServicefrom services.app_generate_service import AppGenerateServicefrom services.errors.app_model_config import AppModelConfigBrokenErrorfrom services.errors.conversation import ConversationCompletedError, ConversationNotExistsError@@ -281,6 +279,21 @@ def test_chat_rejects_other_modes_before_recording_usage(assert _last_used_at(harness, sqlite_session_factory) is None+def test_chat_uses_the_mode_captured_at_admission(+ harness: _Harness,+ chat_runtime: _Runtime,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ harness.state.permission_action = lambda: _set_app_mode(harness, sqlite_session_factory, AppMode.COMPLETION)++ response = harness.app.test_client().post(_url(harness), json={"inputs": {}, "query": "Hi"})++ assert response.status_code == 200+ assert len(chat_runtime.calls) == 1+ assert chat_runtime.calls[0].streaming is True+ assert _last_used_at(harness, sqlite_session_factory) == _USED_AT++@pytest.mark.parametrize("rejection", ["permission", "tenant"])def test_chat_enforces_admission_before_payload_validation(harness: _Harness,@@ -341,10 +354,6 @@ def test_chat_conversation_preflight_returns_404_before_starting_generation_and_services = _Services(installed_app_generation=InstalledAppGenerationService(- app_definitions=AppDefinitionQueryService(- definitions=AppDefinitionQueryRepository(session_factory=sqlite_session_factory),- builtin_icon_url_prefix="/tools/icons",- ),usage=SQLAlchemyInstalledAppRepository(session_factory=sqlite_session_factory),runtime=AppGenerateServiceRuntime(session_factory=sqlite_session_factory),)diff --git a/api/tests/unit_tests/controllers/console/explore/test_conversation.py b/api/tests/unit_tests/controllers/console/explore/test_conversation.pynew file mode 100644index 00000000000..2577de5ed4e--- /dev/null+++ b/api/tests/unit_tests/controllers/console/explore/test_conversation.py@@ -0,0 +1,495 @@+"""Explore conversation HTTP contracts through real admission, services and SQLite."""++from collections.abc import Callable+from dataclasses import dataclass, field+from datetime import datetime, timedelta+from decimal import Decimal+from typing import Literal+from uuid import uuid4++import pytest+from sqlalchemy import Connection, event, select+from sqlalchemy.orm import Session, SessionTransaction, sessionmaker+from werkzeug.test import TestResponse++import controllers.console.explore.conversation as module+from core.app.entities.app_invoke_entities import InvokeFrom+from models.enums import ConversationFromSource, ConversationStatus, CreatorUserRole+from models.model import App, AppMode, Conversation, Message+from models.web import PinnedConversation+from repositories.installed_app_conversation_repository import SQLAlchemyInstalledAppConversationRepository+from services.installed_app_conversation_service import InstalledAppConversationService+from tests.unit_tests.controllers.console.explore.test_installed_app_admission import (+ _assert_json_response,+ _Harness,+ harness,+)++__all__ = ["harness"]++_CREATED_AT = datetime(2024, 1, 1)+_CREATED_TIMESTAMP = int(_CREATED_AT.timestamp())+type _Operation = Literal["list", "delete", "rename", "pin", "unpin"]+_OPERATIONS: tuple[_Operation, ...] = ("list", "delete", "rename", "pin", "unpin")+++@dataclass(frozen=True)+class _Services:+ installed_app_conversations: InstalledAppConversationService+++@dataclass+class _Conversations:+ harness: _Harness+ factory: sessionmaker[Session]+ sessions: list[Session] = field(default_factory=list)+ generation_calls: list[tuple[str, str, str, str, str]] = field(default_factory=list)+ cleanup_calls: list[tuple[str, str, tuple[str, ...]]] = field(default_factory=list)+ generation_error: Exception | None = None+ generation_action: Callable[[], None] | None = None++ def assert_sessions_closed(self) -> None:+ assert all(not session.in_transaction() and not session.identity_map for session in self.sessions)++ def generate_name(self, *, tenant_id: str, app_id: str, conversation_id: str, query: str, app_mode: str) -> str:+ self.assert_sessions_closed()+ self.generation_calls.append((tenant_id, app_id, conversation_id, query, app_mode))+ if self.generation_error is not None:+ raise self.generation_error+ if self.generation_action is not None:+ self.generation_action()+ return "Generated title"++ def enqueue_cleanup(self, *, tenant_id: str, conversation_id: str, retired_workspace_ids: tuple[str, ...]) -> None:+ self.assert_sessions_closed()+ with self.factory() as session:+ conversation = session.get(Conversation, conversation_id)+ assert conversation is not None+ assert conversation.is_deleted+ self.cleanup_calls.append((tenant_id, conversation_id, retired_workspace_ids))++ def request(+ self,+ operation: _Operation,+ *,+ conversation_id: str | None = None,+ installed_app_id: str | None = None,+ query: str = "",+ body: dict[str, object] | None = None,+ ) -> TestResponse:+ url = f"/installed-apps/{installed_app_id or self.harness.installed_app.id}/conversations"+ method = "GET"+ if operation != "list":+ url += f"/{conversation_id or uuid4()}"+ if operation == "delete":+ method = "DELETE"+ else:+ method = "POST" if operation == "rename" else "PATCH"+ url += "/name" if operation == "rename" else f"/{operation}"+ if query:+ url += f"?{query}"+ if operation == "rename" and body is None:+ body = {"name": "Renamed"}+ return self.harness.app.test_client().open(url, method=method, json=body)+++def conversations(+ harness: _Harness, monkeypatch: pytest.MonkeyPatch, sqlite_session_factory: sessionmaker[Session]+) -> _Conversations:+ factory = sessionmaker(bind=sqlite_session_factory.kw["bind"], expire_on_commit=False)+ with factory.begin() as session:+ app = session.get(App, harness.target_app.id)+ assert app is not None+ app.mode = AppMode.CHAT+ state = _Conversations(harness=harness, factory=factory)++ @event.listens_for(factory, "after_begin")+ def track_session(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:+ state.sessions.append(session)++ services = _Services(+ InstalledAppConversationService(+ conversations=SQLAlchemyInstalledAppConversationRepository(session_factory=factory),+ generate_name=state.generate_name,+ enqueue_delete_cleanup=state.enqueue_cleanup,+ )+ )+ monkeypatch.setattr(module, "application_services", lambda: services)+ routes = (+ (module.ConversationListApi, ""),+ (module.ConversationApi, "/<uuid:c_id>"),+ (module.ConversationRenameApi, "/<uuid:c_id>/name"),+ (module.ConversationPinApi, "/<uuid:c_id>/pin"),+ (module.ConversationUnPinApi, "/<uuid:c_id>/unpin"),+ )+ for resource, suffix in routes:+ harness.api.add_resource(resource, f"/installed-apps/<uuid:installed_app_id>/conversations{suffix}")+ return state+++def _conversation(+ state: _Conversations,+ *,+ age: int = 0,+ app_id: str | None = None,+ account_id: str | None = None,+ source: ConversationFromSource = ConversationFromSource.CONSOLE,+ end_user_id: str | None = None,+ invoke_from: InvokeFrom | None = InvokeFrom.EXPLORE,+ is_deleted: bool = False,+) -> Conversation:+ conversation = Conversation(+ app_id=app_id or state.harness.target_app.id,+ mode=AppMode.CHAT,+ name="Original title",+ status=ConversationStatus.NORMAL,+ _inputs={"text": "hello", "count": 0, "enabled": False, "optional": None, "items": []},+ introduction=None,+ from_source=source,+ from_account_id=account_id or state.harness.account.id,+ from_end_user_id=end_user_id,+ invoke_from=invoke_from,+ is_deleted=is_deleted,+ created_at=_CREATED_AT,+ updated_at=_CREATED_AT - timedelta(minutes=age),+ )+ with state.factory.begin() as session:+ session.add(conversation)+ return conversation+++def _message(state: _Conversations, conversation: Conversation, *, query: str = "First question", age: int = 0) -> None:+ with state.factory.begin() as session:+ session.add(+ Message(+ app_id=conversation.app_id,+ conversation_id=conversation.id,+ _inputs={},+ query=query,+ message={},+ answer="answer",+ message_unit_price=Decimal(0),+ answer_unit_price=Decimal(0),+ currency="USD",+ from_source=ConversationFromSource.CONSOLE,+ from_account_id=state.harness.account.id,+ created_at=_CREATED_AT + timedelta(minutes=age),+ )+ )+++def _pin(state: _Conversations, conversation: Conversation, *, account_id: str | None = None) -> None:+ with state.factory.begin() as session:+ session.add(+ PinnedConversation(+ app_id=conversation.app_id,+ conversation_id=conversation.id,+ created_by_role=CreatorUserRole.ACCOUNT,+ created_by=account_id or state.harness.account.id,+ )+ )+++def _error(response: TestResponse, *, status: int, code: str) -> None:+ assert response.status_code == status+ body = response.get_json()+ assert body["code"] == code+ assert body["status"] == status+ assert isinstance(body["message"], str)+ assert body["message"]+ assert response.headers["Content-Type"] == "application/json"+++def test_list_preserves_response_fields_values_and_timestamp_pagination(conversations: _Conversations) -> None:+ first = _conversation(conversations)+ second = _conversation(conversations, age=1)+ response = conversations.request("list", query="limit=1")+ _assert_json_response(+ response,+ status=200,+ body={+ "limit": 1,+ "has_more": True,+ "data": [+ {+ "id": first.id,+ "name": "Original title",+ "inputs": {"text": "hello", "count": 0, "enabled": False, "optional": None, "items": []},+ "status": "normal",+ "introduction": None,+ "created_at": _CREATED_TIMESTAMP,+ "updated_at": _CREATED_TIMESTAMP,+ }+ ],+ },+ )+ response = conversations.request("list", query=f"limit=1&last_id={first.id}")+ assert response.status_code == 200+ assert response.get_json()["has_more"] is False+ assert [item["id"] for item in response.get_json()["data"]] == [second.id]+ conversations.assert_sessions_closed()++[email protected](("query", "limit"), [("", 20), ("limit=invalid", 20), ("limit=", 20), ("limit=100", 100)])+def test_list_retains_default_and_invalid_string_limit_fallback(+ conversations: _Conversations, query: str, limit: int+) -> None:+ _assert_json_response(+ conversations.request("list", query=query), status=200, body={"limit": limit, "has_more": False, "data": []}+ )++[email protected]("query", ["limit=0", "limit=-1", "limit=101", "last_id=invalid"])+def test_invalid_query_uses_shared_validation_error(conversations: _Conversations, query: str) -> None:+ _error(conversations.request("list", query=query), status=422, code="unprocessable_entity")++[email protected]("pinned", ["true", "false", "TRUE", "1", ""])+def test_list_preserves_literal_true_pinned_filter(conversations: _Conversations, pinned: str) -> None:+ pinned_conversation = _conversation(conversations)+ unpinned = _conversation(conversations, age=1)+ _pin(conversations, pinned_conversation)+ response = conversations.request("list", query=f"pinned={pinned}")+ assert response.status_code == 200+ expected = pinned_conversation.id if pinned == "true" else unpinned.id+ assert [item["id"] for item in response.get_json()["data"]] == [expected]+++def test_list_hides_other_account_app_source_end_user_deleted_and_debugger_conversations(+ conversations: _Conversations,+) -> None:+ visible = _conversation(conversations)+ legacy = _conversation(conversations, age=1, invoke_from=None)+ _conversation(conversations, app_id=str(uuid4()))+ _conversation(conversations, account_id=str(uuid4()))+ _conversation(conversations, source=ConversationFromSource.API)+ _conversation(conversations, end_user_id=str(uuid4()))+ _conversation(conversations, is_deleted=True)+ _conversation(conversations, invoke_from=InvokeFrom.DEBUGGER)+ response = conversations.request("list")+ assert response.status_code == 200+ assert [item["id"] for item in response.get_json()["data"]] == [visible.id, legacy.id]+++def test_cursor_not_in_current_conversations_has_specific_error(conversations: _Conversations) -> None:+ foreign = _conversation(conversations, account_id=str(uuid4()))+ _error(+ conversations.request("list", query=f"last_id={foreign.id}"), status=404, code="conversation_cursor_not_found"+ )+++def test_manual_rename_keeps_inputs_and_persists_name(conversations: _Conversations) -> None:+ conversation = _conversation(conversations)+ response = conversations.request("rename", conversation_id=conversation.id, body={"name": " User title "})+ assert response.status_code == 200+ assert response.get_json()["id"] == conversation.id+ assert response.get_json()["name"] == " User title "+ assert response.get_json()["inputs"] == conversation._inputs+ assert response.get_json()["created_at"] == _CREATED_TIMESTAMP+ assert response.get_json()["updated_at"] >= _CREATED_TIMESTAMP+ with conversations.factory() as session:+ persisted = session.get(Conversation, conversation.id)+ assert persisted is not None+ assert persisted.name == " User title "+ assert conversations.generation_calls == []++[email protected]("body", [{}, {"name": " "}, {"name": 123}, {"auto_generate": "invalid"}])+def test_invalid_rename_uses_shared_validation_error(conversations: _Conversations, body: dict[str, object]) -> None:+ conversation = _conversation(conversations)+ _error(+ conversations.request("rename", conversation_id=conversation.id, body=body),+ status=422,+ code="unprocessable_entity",+ )++[email protected]("fail_generation", [False, True])+def test_auto_rename_uses_first_message_after_sessions_close_and_preserves_name_on_failure(+ conversations: _Conversations, fail_generation: bool+) -> None:+ conversation = _conversation(conversations)+ _message(conversations, conversation)+ _message(conversations, conversation, query="Later question", age=1)+ if fail_generation:+ conversations.generation_error = RuntimeError("provider unavailable")+ response = conversations.request("rename", conversation_id=conversation.id, body={"auto_generate": True})+ assert response.status_code == 200+ assert response.get_json()["name"] == ("Original title" if fail_generation else "Generated title")+ assert response.get_json()["inputs"] == conversation._inputs+ assert conversations.generation_calls == [+ (conversations.harness.target_app.tenant_id, conversation.app_id, conversation.id, "First question", "chat")+ ]+ conversations.assert_sessions_closed()+++def test_auto_rename_without_messages_returns_specific_error(conversations: _Conversations) -> None:+ conversation = _conversation(conversations)+ _error(+ conversations.request("rename", conversation_id=conversation.id, body={"auto_generate": True}),+ status=404,+ code="conversation_first_message_not_found",+ )+ assert conversations.generation_calls == []+++def test_delete_returns_empty_204_after_commit_and_closed_sessions(conversations: _Conversations) -> None:+ conversation = _conversation(conversations)+ response = conversations.request("delete", conversation_id=conversation.id)+ assert response.status_code == 204+ assert response.data == b""+ assert response.headers["Content-Type"] == "application/json"+ assert "Content-Length" not in response.headers+ assert conversations.cleanup_calls == [(conversations.harness.target_app.tenant_id, conversation.id, ())]+ conversations.assert_sessions_closed()+ _error(conversations.request("delete", conversation_id=conversation.id), status=404, code="conversation_not_found")+ assert len(conversations.cleanup_calls) == 1+++def test_pin_and_unpin_are_idempotent_and_preserve_other_accounts_pin(conversations: _Conversations) -> None:+ conversation = _conversation(conversations)+ other_account_id = str(uuid4())+ _pin(conversations, conversation, account_id=other_account_id)+ for operation in ("pin", "pin", "unpin", "unpin"):+ _assert_json_response(+ conversations.request(operation, conversation_id=conversation.id), status=200, body={"result": "success"}+ )+ _assert_json_response(+ conversations.request("unpin", conversation_id=str(uuid4())), status=200, body={"result": "success"}+ )+ with conversations.factory() as session:+ pins = session.scalars(select(PinnedConversation)).all()+ assert [(pin.conversation_id, pin.created_by) for pin in pins] == [(conversation.id, other_account_id)]++[email protected]("operation", ["delete", "rename", "pin"])[email protected]("owner", ["app", "account", "source", "end_user", "deleted", "missing"])+def test_conversation_mutations_reject_other_owner_and_missing_rows(+ conversations: _Conversations, operation: _Operation, owner: str+) -> None:+ conversation = _conversation(+ conversations,+ app_id=str(uuid4()) if owner == "app" else None,+ account_id=str(uuid4()) if owner == "account" else None,+ source=ConversationFromSource.API if owner == "source" else ConversationFromSource.CONSOLE,+ end_user_id=str(uuid4()) if owner == "end_user" else None,+ is_deleted=owner == "deleted",+ )+ _error(+ conversations.request(operation, conversation_id=str(uuid4()) if owner == "missing" else conversation.id),+ status=404,+ code="conversation_not_found",+ )+ assert conversations.cleanup_calls == conversations.generation_calls == []++[email protected]("operation", _OPERATIONS)[email protected]("admission", ["missing", "denied", "mode"])+def test_all_conversation_handlers_apply_installed_app_admission_and_chat_mode(+ conversations: _Conversations, operation: _Operation, admission: str+) -> None:+ conversation = _conversation(conversations)+ installed_app_id: str | None = None+ if admission == "missing":+ installed_app_id = str(uuid4())+ elif admission == "denied":+ conversations.harness.state.allowed = False+ else:+ with conversations.factory.begin() as session:+ app = session.get(App, conversations.harness.target_app.id)+ assert app is not None+ app.mode = AppMode.COMPLETION+ status, code = {+ "missing": (404, "installed_app_not_found"),+ "denied": (403, "access_denied"),+ "mode": (400, "not_chat_app"),+ }[admission]+ _error(+ conversations.request(operation, conversation_id=conversation.id, installed_app_id=installed_app_id),+ status=status,+ code=code,+ )+ assert conversations.cleanup_calls == conversations.generation_calls == []++[email protected]("operation", _OPERATIONS)+def test_app_removed_after_admission_reports_missing_installation(+ conversations: _Conversations, operation: _Operation+) -> None:+ conversation = _conversation(conversations)++ def remove_app() -> None:+ with conversations.factory.begin() as session:+ app = session.get(App, conversations.harness.target_app.id)+ assert app is not None+ session.delete(app)++ conversations.harness.state.permission_action = remove_app+ _error(+ conversations.request(operation, conversation_id=conversation.id), status=404, code="installed_app_not_found"+ )+ assert conversations.cleanup_calls == conversations.generation_calls == []+++def test_auto_rename_uses_mode_captured_before_permission_check(conversations: _Conversations) -> None:+ conversation = _conversation(conversations)+ _message(conversations, conversation)++ def change_mode() -> None:+ with conversations.factory.begin() as session:+ app = session.get(App, conversations.harness.target_app.id)+ assert app is not None+ app.mode = AppMode.ADVANCED_CHAT++ conversations.harness.state.permission_action = change_mode+ response = conversations.request("rename", conversation_id=conversation.id, body={"auto_generate": True})++ assert response.status_code == 200+ assert response.get_json()["name"] == "Generated title"+ assert conversations.generation_calls == [+ (conversations.harness.target_app.tenant_id, conversation.app_id, conversation.id, "First question", "chat")+ ]+++def test_delete_commit_failure_rolls_back_and_does_not_enqueue(conversations: _Conversations) -> None:+ conversation = _conversation(conversations)+ conversations.harness.app.config["PROPAGATE_EXCEPTIONS"] = False++ @event.listens_for(conversations.factory, "before_commit", once=True)+ def fail_commit(session: Session) -> None:+ session.flush()+ raise RuntimeError("commit failed")++ response = conversations.request("delete", conversation_id=conversation.id)+ assert response.status_code == 500+ assert conversations.cleanup_calls == []+ conversations.assert_sessions_closed()+ with conversations.factory() as session:+ persisted = session.get(Conversation, conversation.id)+ assert persisted is not None+ assert persisted.is_deleted is False+++def test_conversation_deleted_during_generation_is_not_renamed_or_resurrected(conversations: _Conversations) -> None:+ conversation = _conversation(conversations)+ _message(conversations, conversation)++ def delete_during_generation() -> None:+ with conversations.factory.begin() as session:+ persisted = session.get(Conversation, conversation.id)+ assert persisted is not None+ persisted.is_deleted = True++ conversations.generation_action = delete_during_generation+ _error(+ conversations.request("rename", conversation_id=conversation.id, body={"auto_generate": True}),+ status=404,+ code="conversation_not_found",+ )+ with conversations.factory() as session:+ persisted = session.get(Conversation, conversation.id)+ assert persisted is not None+ assert persisted.is_deleted is True+ assert persisted.name == "Original title"+ conversations.assert_sessions_closed()diff --git a/api/tests/unit_tests/controllers/console/explore/test_installed_app_admission.py b/api/tests/unit_tests/controllers/console/explore/test_installed_app_admission.pyindex 371efba6780..d9aeb4a55dc 100644--- a/api/tests/unit_tests/controllers/console/explore/test_installed_app_admission.py+++ b/api/tests/unit_tests/controllers/console/explore/test_installed_app_admission.py@@ -32,9 +32,7 @@ from libs.external_api import ExternalApifrom machinery.context import RequestContextfrom models import Account, App, AppMode, InstalledApp, Tenantfrom models.account import AccountStatus-from repositories.app_definition_query_repository import AppDefinitionQueryRepositoryfrom repositories.installed_app_repository import SQLAlchemyInstalledAppRepository-from services.app_definition_query_service import AppDefinitionQueryServicefrom services.app_task_service import AppTaskControlServicefrom services.installed_app_access_service import InstalledAppAccessService, InstalledAppReffrom services.saved_message_service import SavedMessageActor, SavedMessagePage, SavedMessageRecord, SavedMessageService@@ -441,10 +439,6 @@ class _AppDefinitions:app_id: strparameters: dict[str, object]- def get_mode(self, app_id: str) -> str:- assert app_id == self.app_id- return "completion"-def get_parameters(self, app_id: str) -> dict[str, object]:assert app_id == self.app_idreturn self.parameters@@ -549,7 +543,6 @@ def test_migrated_saved_message_and_parameter_handlers_dispatch_through_full_adm@dataclass(frozen=True)class _StopServices:- app_definitions: AppDefinitionQueryServiceapp_tasks: AppTaskControlService@@ -576,15 +569,10 @@ def _stop_global_redis(monkeypatch: pytest.MonkeyPatch) -> Generator[_StopRedis]def stop_redis(harness: _Harness,monkeypatch: pytest.MonkeyPatch,- sqlite_session_factory: sessionmaker[Session],_stop_global_redis: _StopRedis,) -> _StopRedis:redis = _StopRedis(values={f"generate_task_belong:{_TASK_ID}": f"account-{harness.account.id}".encode()})services = _StopServices(- app_definitions=AppDefinitionQueryService(- definitions=AppDefinitionQueryRepository(session_factory=sqlite_session_factory),- builtin_icon_url_prefix="/tools/icons",- ),app_tasks=AppTaskControlService(redis_client=redis),)monkeypatch.setattr(completion_module, "application_services", lambda: services)@@ -708,13 +696,18 @@ def test_stop_handlers_reject_wrong_modes_without_sending_commands(assert f"generate_task_stopped:{_TASK_ID}" not in stop_redis.values[email protected]("message_kind", ["completion", "chat"])-def test_stop_handlers_reject_app_removed_after_admission_before_sending_commands(+ ("message_kind", "mode"), [("completion", AppMode.COMPLETION), ("chat", AppMode.ADVANCED_CHAT)]+)+def test_stop_handlers_use_admitted_mode_when_app_is_removed(harness: _Harness,stop_redis: _StopRedis,sqlite_session_factory: sessionmaker[Session],message_kind: str,+ mode: AppMode,) -> None:+ _set_app_mode(harness, sqlite_session_factory, mode)+def remove_app() -> None:with sqlite_session_factory.begin() as session:app = session.get(App, harness.target_app.id)@@ -725,18 +718,13 @@ def test_stop_handlers_reject_app_removed_after_admission_before_sending_commandresponse = harness.app.test_client().post(_stop_url(harness, message_kind))- _assert_json_response(- response,- status=400,- body={- "code": "app_unavailable",- "message": "App unavailable, please check your app configurations.",- "status": 400,- },- )+ _assert_json_response(response, status=200, body={"result": "success"})assert harness.state.permission_calls == [(harness.account.id, harness.target_app.id)]- assert stop_redis.reads == []- assert stop_redis.commands == {}+ assert stop_redis.reads == [f"generate_task_belong:{_TASK_ID}"]+ assert stop_redis.values[f"generate_task_stopped:{_TASK_ID}"] == b"1"+ assert stop_redis.operations == (+ ["legacy_flag", "graph_command"] if mode == AppMode.ADVANCED_CHAT else ["legacy_flag"]+ )@pytest.mark.parametrize("message_kind", ["completion", "chat"])diff --git a/api/tests/unit_tests/controllers/console/explore/test_installed_app_completion.py b/api/tests/unit_tests/controllers/console/explore/test_installed_app_completion.pyindex d59bc90605f..bd5d5783144 100644--- a/api/tests/unit_tests/controllers/console/explore/test_installed_app_completion.py+++ b/api/tests/unit_tests/controllers/console/explore/test_installed_app_completion.py@@ -11,16 +11,17 @@ import services.installed_app_generation_service as completion_service_modulefrom core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededErrorfrom graphon.model_runtime.errors.invoke import InvokeErrorfrom models import App, AppMode, InstalledApp, Tenant-from repositories.app_definition_query_repository import AppDefinitionQueryRepositoryfrom repositories.installed_app_repository import SQLAlchemyInstalledAppRepositoryfrom services.account_errors import AccountNotFoundError-from services.app_definition_query_service import AppDefinitionQueryService+from services.app_generate_service import AppGenerateServicefrom services.errors.app_model_config import AppModelConfigBrokenErrorfrom services.errors.conversation import ConversationCompletedError, ConversationNotExistsError+from services.installed_app_generation_adapters import AppGenerateServiceRuntimefrom services.installed_app_generation_service import GenerationResponse, InstalledAppGenerationServicefrom tests.unit_tests.controllers.console.explore.test_installed_app_admission import (_assert_json_response,_Harness,+ _set_app_mode,harness,)@@ -74,10 +75,6 @@ def runtime() -> _Runtime:runtime = _Runtime(sqlite_session_factory, harness.installed_app.id)service = InstalledAppGenerationService(- app_definitions=AppDefinitionQueryService(- definitions=AppDefinitionQueryRepository(session_factory=sqlite_session_factory),- builtin_icon_url_prefix="/tools/icons",- ),usage=SQLAlchemyInstalledAppRepository(session_factory=sqlite_session_factory),runtime=runtime,)@@ -323,6 +320,21 @@ def test_wrong_mode_does_not_record_usage_or_start_runtime(assert _last_used_at(harness, sqlite_session_factory) is None+def test_completion_uses_the_mode_captured_at_admission(+ harness: _Harness,+ runtime: _Runtime,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ harness.state.permission_action = lambda: _set_app_mode(harness, sqlite_session_factory, AppMode.CHAT)++ response = harness.app.test_client().post(_url(harness), json={"inputs": {}})++ assert response.status_code == 200+ assert response.get_json() == _BLOCKING_RESPONSE+ assert len(runtime.calls) == 1+ assert _last_used_at(harness, sqlite_session_factory) == _USED_AT++@pytest.mark.parametrize("rejection", ["permission", "missing", "tenant"])def test_completion_requires_installed_app_admission_before_payload_validation(harness: _Harness,@@ -363,10 +375,11 @@ def test_completion_requires_installed_app_admission_before_payload_validation(@pytest.mark.parametrize("deleted_resource", ["app", "installation"])-def test_resource_removed_after_admission_does_not_start_runtime([email protected]("runtime")+def test_resource_removed_after_admission_is_revalidated_before_generation(harness: _Harness,- runtime: _Runtime,sqlite_session_factory: sessionmaker[Session],+ monkeypatch: pytest.MonkeyPatch,deleted_resource: str,) -> None:def delete_resource() -> None:@@ -379,6 +392,18 @@ def test_resource_removed_after_admission_does_not_start_runtime(session.delete(resource)harness.state.permission_action = delete_resource+ services = _Services(+ installed_app_generation=InstalledAppGenerationService(+ usage=SQLAlchemyInstalledAppRepository(session_factory=sqlite_session_factory),+ runtime=AppGenerateServiceRuntime(session_factory=sqlite_session_factory),+ )+ )+ monkeypatch.setattr(completion_module, "application_services", lambda: services)++ def generate(**_kwargs: object) -> GenerationResponse:+ pytest.fail("Removed app or installation must be rejected before generation")++ monkeypatch.setattr(AppGenerateService, "generate", generate)response = harness.app.test_client().post(_url(harness), json={"inputs": {}})@@ -392,11 +417,10 @@ def test_resource_removed_after_admission_does_not_start_runtime("status": 400,},)- assert _last_used_at(harness, sqlite_session_factory) is None+ assert _last_used_at(harness, sqlite_session_factory) == _USED_ATelse:_assert_json_response(response,status=404,body={"code": "not_found", "message": "Installed app not found", "status": 404},)- assert runtime.calls == []diff --git a/api/tests/unit_tests/controllers/console/explore/test_parameter.py b/api/tests/unit_tests/controllers/console/explore/test_parameter.pyindex 24eaf51e185..30cdd70045f 100644--- a/api/tests/unit_tests/controllers/console/explore/test_parameter.py+++ b/api/tests/unit_tests/controllers/console/explore/test_parameter.py@@ -16,7 +16,7 @@ _REQUEST_CONTEXT = RequestContext(def _installed_app() -> InstalledAppRef:- return InstalledAppRef(id="installed-1", tenant_id="viewer-tenant", app_id="app-1")+ return InstalledAppRef(id="installed-1", tenant_id="viewer-tenant", app_id="app-1", app_mode="completion")def _application_services() -> tuple[SimpleNamespace, MagicMock]:diff --git a/api/tests/unit_tests/controllers/console/explore/test_saved_message.py b/api/tests/unit_tests/controllers/console/explore/test_saved_message.pyindex 62fc3c99fab..be49ddfa02f 100644--- a/api/tests/unit_tests/controllers/console/explore/test_saved_message.py+++ b/api/tests/unit_tests/controllers/console/explore/test_saved_message.py@@ -10,7 +10,6 @@ from flask import Flaskfrom werkzeug.exceptions import NotFoundimport controllers.console.explore.saved_message as module-from controllers.console.app.error import AppUnavailableErrorfrom controllers.console.explore.error import NotCompletionAppErrorfrom graphon.file import File, FileTransferMethod, FileTypefrom libs.external_api import ExternalApi@@ -34,7 +33,6 @@ _WORKSPACE_ID = "22222222-2222-4222-8222-222222222222"@dataclass(frozen=True)class _ApplicationServiceMocks:- app_definitions: MagicMockinstalled_app_access: MagicMocksaved_messages: MagicMock@@ -44,11 +42,12 @@ _REQUEST_CONTEXT = RequestContext()-def _installed_app() -> InstalledAppRef:+def _installed_app(*, app_mode: str = "completion") -> InstalledAppRef:return InstalledAppRef(id="99999999-9999-4999-8999-999999999999",tenant_id=_WORKSPACE_ID,app_id="33333333-3333-4333-8333-333333333333",+ app_mode=app_mode,)@@ -129,11 +128,9 @@ def _expected_record() -> dict[str, object]:@pytest.fixturedef services() -> Generator[_ApplicationServiceMocks]:service_mocks = _ApplicationServiceMocks(- app_definitions=MagicMock(),installed_app_access=MagicMock(),saved_messages=MagicMock(),)- service_mocks.app_definitions.get_mode.return_value = "completion"service_mocks.installed_app_access.get_access.return_value = _installed_app()with patch.object(module,@@ -163,7 +160,6 @@ class TestSavedMessageListApi:installed_app,)- services.app_definitions.get_mode.assert_called_once_with(installed_app.app_id)services.saved_messages.pagination_by_last_id.assert_called_once_with(app_id=installed_app.app_id,actor=SavedMessageActor.account(_ACCOUNT_ID),@@ -220,7 +216,6 @@ class TestSavedMessageListApi:tenant_id=_WORKSPACE_ID,account_id=_ACCOUNT_ID,)- services.app_definitions.get_mode.assert_not_called()services.saved_messages.pagination_by_last_id.assert_not_called()def test_get_preserves_invalid_last_id_context(self, app: Flask, services: _ApplicationServiceMocks) -> None:@@ -242,27 +237,15 @@ class TestSavedMessageListApi:assert raised.value.description == description- def test_get_rejects_missing_app(self, app: Flask, services: _ApplicationServiceMocks) -> None:- services.app_definitions.get_mode.side_effect = module.AppDefinitionUnavailableError-- with app.test_request_context("/"), pytest.raises(AppUnavailableError):- unwrap(module.SavedMessageListApi().get)(- module.SavedMessageListApi(),- module.SavedMessageListQuery.model_validate({}),- _REQUEST_CONTEXT,- _installed_app(),- )-def test_get_rejects_non_completion_app(self, app: Flask, services: _ApplicationServiceMocks) -> None:- services.app_definitions.get_mode.return_value = "chat"-with app.test_request_context("/"), pytest.raises(NotCompletionAppError):unwrap(module.SavedMessageListApi().get)(module.SavedMessageListApi(),module.SavedMessageListQuery.model_validate({}),_REQUEST_CONTEXT,- _installed_app(),+ _installed_app(app_mode="chat"),)+ services.saved_messages.pagination_by_last_id.assert_not_called()def test_post_success(self, services: _ApplicationServiceMocks) -> None:installed_app = _installed_app()@@ -282,6 +265,16 @@ class TestSavedMessageListApi:)assert result == {"result": "success"}+ def test_post_rejects_non_completion_app(self, services: _ApplicationServiceMocks) -> None:+ with pytest.raises(NotCompletionAppError):+ unwrap(module.SavedMessageListApi().post)(+ module.SavedMessageListApi(),+ module.SavedMessageCreatePayload.model_validate({"message_id": str(uuid4())}),+ _REQUEST_CONTEXT,+ _installed_app(app_mode="chat"),+ )+ services.saved_messages.save.assert_not_called()+def test_post_maps_missing_message_to_not_found(self, services: _ApplicationServiceMocks) -> None:services.saved_messages.save.side_effect = MessageNotExistsError()@@ -314,12 +307,11 @@ class TestSavedMessageApi:assert result == ("", 204)def test_delete_rejects_non_completion_app(self, services: _ApplicationServiceMocks) -> None:- services.app_definitions.get_mode.return_value = "chat"-with pytest.raises(NotCompletionAppError):unwrap(module.SavedMessageApi().delete)(module.SavedMessageApi(),_REQUEST_CONTEXT,- _installed_app(),+ _installed_app(app_mode="chat"),uuid4(),)+ services.saved_messages.delete.assert_not_called()diff --git a/api/tests/unit_tests/controllers/console/explore/test_workflow.py b/api/tests/unit_tests/controllers/console/explore/test_workflow.pyindex c967556193e..3c93a4d0261 100644--- a/api/tests/unit_tests/controllers/console/explore/test_workflow.py+++ b/api/tests/unit_tests/controllers/console/explore/test_workflow.py@@ -12,12 +12,13 @@ import controllers.console.explore.workflow as workflow_modulefrom core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededErrorfrom graphon.model_runtime.errors.invoke import InvokeErrorfrom models import App, AppMode, InstalledApp, Tenant-from repositories.app_definition_query_repository import AppDefinitionQueryRepositoryfrom repositories.installed_app_repository import SQLAlchemyInstalledAppRepositoryfrom services.account_errors import AccountNotFoundError-from services.app_definition_query_service import AppDefinitionQueryService, AppDefinitionUnavailableError+from services.app_definition_query_service import AppDefinitionUnavailableError+from services.app_generate_service import AppGenerateServicefrom services.app_task_service import AppTaskControlServicefrom services.errors.llm import InvokeRateLimitError+from services.installed_app_generation_adapters import AppGenerateServiceRuntimefrom services.installed_app_generation_service import GenerationResponse, InstalledAppGenerationServicefrom tests.unit_tests.controllers.console.explore.test_installed_app_admission import (_assert_json_response,@@ -74,7 +75,6 @@ class _Runtime:@dataclass(frozen=True)class _Services:installed_app_generation: InstalledAppGenerationService- app_definitions: AppDefinitionQueryServiceapp_tasks: AppTaskControlService@@ -91,17 +91,11 @@ def runtime(assert installation is not Noneinstallation.last_used_at = _LAST_USED_ATruntime = _Runtime(sqlite_session_factory, harness.installed_app.id)- definitions = AppDefinitionQueryService(- definitions=AppDefinitionQueryRepository(session_factory=sqlite_session_factory),- builtin_icon_url_prefix="/tools/icons",- )services = _Services(installed_app_generation=InstalledAppGenerationService(- app_definitions=definitions,usage=SQLAlchemyInstalledAppRepository(session_factory=sqlite_session_factory),runtime=runtime,),- app_definitions=definitions,app_tasks=AppTaskControlService(redis_client=stop_redis),)monkeypatch.setattr(workflow_module, "application_services", lambda: services)@@ -314,6 +308,24 @@ def test_workflow_handlers_reject_other_modes_without_side_effects(runtime.assert_usage_unchanged()[email protected]("action", ["run", "stop"])+def test_workflow_handlers_use_the_mode_captured_at_admission(+ harness: _Harness,+ runtime: _Runtime,+ stop_redis: _StopRedis,+ sqlite_session_factory: sessionmaker[Session],+ action: str,+) -> None:+ harness.state.permission_action = lambda: _set_app_mode(harness, sqlite_session_factory, AppMode.CHAT)++ response = harness.app.test_client().post(_url(harness, action), json={"inputs": {}})++ assert response.status_code == 200+ assert len(runtime.calls) == (1 if action == "run" else 0)+ assert stop_redis.operations == (["legacy_flag", "graph_command"] if action == "stop" else [])+ runtime.assert_usage_unchanged()++@pytest.mark.parametrize("action", ["run", "stop"])@pytest.mark.parametrize("rejection", ["permission", "tenant", "missing"])def test_workflow_handlers_require_admission_before_payload_or_task_actions(@@ -357,11 +369,12 @@ def test_workflow_handlers_require_admission_before_payload_or_task_actions(@pytest.mark.parametrize("action", ["run", "stop"])-def test_workflow_handlers_preserve_not_workflow_error_when_app_disappears_after_admission(+def test_workflow_run_revalidates_app_while_stop_uses_admission_snapshot(harness: _Harness,runtime: _Runtime,stop_redis: _StopRedis,sqlite_session_factory: sessionmaker[Session],+ monkeypatch: pytest.MonkeyPatch,action: str,) -> None:def remove_app() -> None:@@ -371,14 +384,32 @@ def test_workflow_handlers_preserve_not_workflow_error_when_app_disappears_aftersession.delete(app)harness.state.permission_action = remove_app+ services = _Services(+ installed_app_generation=InstalledAppGenerationService(+ usage=SQLAlchemyInstalledAppRepository(session_factory=sqlite_session_factory),+ runtime=AppGenerateServiceRuntime(session_factory=sqlite_session_factory),+ ),+ app_tasks=AppTaskControlService(redis_client=stop_redis),+ )+ monkeypatch.setattr(workflow_module, "application_services", lambda: services)++ def generate(**_kwargs: object) -> GenerationResponse:+ pytest.fail("A removed workflow app must be rejected before generation")++ monkeypatch.setattr(AppGenerateService, "generate", generate)response = harness.app.test_client().post(_url(harness, action), json={"inputs": {}})- _assert_json_response(- response, status=400, body={"code": "not_workflow_app", "message": "Only support workflow app.", "status": 400}- )+ if action == "run":+ _assert_json_response(+ response,+ status=400,+ body={"code": "not_workflow_app", "message": "Only support workflow app.", "status": 400},+ )+ else:+ _assert_json_response(response, status=200, body={"result": "success"})assert runtime.calls == []- assert stop_redis.operations == []+ assert stop_redis.operations == (["legacy_flag", "graph_command"] if action == "stop" else [])runtime.assert_usage_unchanged()diff --git a/api/tests/unit_tests/extensions/test_ext_application_services.py b/api/tests/unit_tests/extensions/test_ext_application_services.pyindex 8460a941f57..a3b01cc84f5 100644--- a/api/tests/unit_tests/extensions/test_ext_application_services.py+++ b/api/tests/unit_tests/extensions/test_ext_application_services.py@@ -3,6 +3,7 @@import jsonimport loggingfrom collections.abc import Mapping+from decimal import Decimalfrom io import BytesIOfrom types import SimpleNamespacefrom typing import cast@@ -15,14 +16,29 @@ from flask import Flaskfrom sqlalchemy import event, selectfrom sqlalchemy.orm import Session, sessionmaker+from core.credit_usage import CreditUsageAppType+from core.llm_generator.llm_generator import LLMGenerator+from core.model_context import get_credit_usage_metadata, use_credit_usage_metadatafrom core.tools.tool_file_manager import ToolFileManagerfrom enums import DeploymentEdition, WebAppAccessModefrom extensions import ext_application_services+from extensions.ext_database import dbfrom extensions.ext_redis import RedisClientWrapperfrom machinery.context import RequestContextfrom models.account import Account, Tenant, TenantAccountJoin, TenantAccountRolefrom models.enums import CustomizeTokenStrategy-from models.model import AccountTrialAppRecord, App, AppMode, AppModelConfig, DifySetup, InstalledApp, Site, TrialApp+from models.model import (+ AccountTrialAppRecord,+ App,+ AppMode,+ AppModelConfig,+ Conversation,+ DifySetup,+ InstalledApp,+ Message,+ Site,+ TrialApp,+)from repositories.account_activation_repository import SQLAlchemyAccountActivationRepositoryfrom repositories.account_integration_repository import SQLAlchemyAccountIntegrationRepositoryfrom repositories.account_oauth_repository import (@@ -103,6 +119,7 @@ from services.webapp_access_query_service import WebAppAccessQueryService, WebApfrom services.workflow_app_log_query_service import WorkflowAppLogQueryServicefrom services.workflow_run_service import WorkflowRunServicefrom services.workflow_statistic_query_service import WorkflowStatisticQueryService+from tasks.delete_conversation_task import delete_conversation_related_datafrom tests.unit_tests.config_override import apply_config_overridesfrom tests.unit_tests.services.test_app_task_service import _StopRedis@@ -204,7 +221,6 @@ def test_build_application_services_preserves_composed_boundaries(installed_apps = services.installed_app_access._installed_appsassert isinstance(installed_apps, SQLAlchemyInstalledAppRepository)assert services.installed_app_generation._usage is installed_apps- assert services.installed_app_generation._app_definitions is services.app_definitionsruntime = services.installed_app_generation._runtimeassert isinstance(runtime, InstalledAppGenerateServiceRuntime)assert runtime._session_factory is sqlite_session_factory@@ -794,7 +810,9 @@ def installed_app_ref(sqlite_session_factory: sessionmaker[Session]) -> Installe)session.add(installed_app)session.flush()- result = InstalledAppRef(id=installed_app.id, app_id=app.id, tenant_id=installed_app.tenant_id)+ result = InstalledAppRef(+ id=installed_app.id, app_id=app.id, tenant_id=installed_app.tenant_id, app_mode=app.mode.value+ )return result@@ -1353,6 +1371,133 @@ def test_installed_app_management_composition_reads_real_installations_and_curreenterprise_request.assert_not_called()[email protected]("naming_fails", [False, True])+def test_installed_app_conversations_wire_real_persistence_naming_and_cleanup(+ sqlite_session_factory: sessionmaker[Session],+ installed_app_ref: InstalledAppRef,+ monkeypatch: pytest.MonkeyPatch,+ naming_fails: bool,+) -> None:+ account_id = str(uuid4())+ with sqlite_session_factory.begin() as session:+ app = session.get(App, installed_app_ref.app_id)+ assert app is not None+ app.mode = AppMode.CHAT+ owner_tenant_id = app.tenant_id+ conversation = Conversation(+ app_id=app.id,+ mode=AppMode.CHAT,+ name="Original",+ inputs={"enabled": False},+ from_source="console",+ from_account_id=account_id,+ from_end_user_id=None,+ invoke_from="explore",+ )+ session.add(conversation)+ session.flush()+ conversation_id = conversation.id+ session.add(+ Message(+ app_id=app.id,+ conversation_id=conversation.id,+ inputs={},+ query="First question",+ message={},+ message_unit_price=Decimal(0),+ answer="Answer",+ answer_unit_price=Decimal(0),+ currency="USD",+ from_source="console",+ from_account_id=account_id,+ )+ )++ active_connections = 0++ @event.listens_for(sqlite_session_factory.kw["bind"], "checkout")+ def connection_checked_out(_connection: object, _record: object, _proxy: object) -> None:+ nonlocal active_connections+ active_connections += 1++ @event.listens_for(sqlite_session_factory.kw["bind"], "checkin")+ def connection_checked_in(_connection: object, _record: object) -> None:+ nonlocal active_connections+ active_connections -= 1++ naming_sessions: list[Session] = []++ def generate_name(tenant_id: str, query: str, c_id: str, app_id: str) -> str:+ assert active_connections == 0+ assert get_credit_usage_metadata() == {"app_type": CreditUsageAppType.CHATBOT, "request_id": "naming-request"}+ assert (tenant_id, query, c_id, app_id) == (+ owner_tenant_id,+ "First question",+ conversation_id,+ installed_app_ref.app_id,+ )+ # Provider/tracing code still uses the Flask-scoped session. Exercise+ # that lifecycle rather than letting a pure callback hide a leaked read.+ naming_session = db.session()+ naming_session.scalar(select(1))+ naming_sessions.append(naming_session)+ if naming_fails:+ raise RuntimeError("Provider unavailable")+ return "Generated name"++ queued: list[str] = []++ def enqueue_cleanup(c_id: str) -> None:+ assert active_connections == 0+ assert all(not session.in_transaction() for session in naming_sessions)+ with sqlite_session_factory() as session:+ stored = session.get(Conversation, c_id)+ assert stored is not None+ assert stored.is_deleted+ queued.append(c_id)++ monkeypatch.setattr(LLMGenerator, "generate_conversation_name", generate_name)+ monkeypatch.setattr(delete_conversation_related_data, "delay", enqueue_cleanup)+ services = ext_application_services.build_application_services(+ database_client=sqlite_session_factory,+ deployment_edition=DeploymentEdition.COMMUNITY,+ initialization_password="",+ redis=MagicMock(spec=RedisClientWrapper),+ )+ naming_app = Flask(__name__)+ admitted_app = services.installed_app_access.get_access(+ installed_app_id=installed_app_ref.id,+ tenant_id=installed_app_ref.tenant_id,+ account_id=account_id,+ )+ assert admitted_app.app_mode == "chat"+ naming_app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite://"+ db.init_app(naming_app)+ previous_metadata = get_credit_usage_metadata()+ with naming_app.app_context(), use_credit_usage_metadata({"request_id": "naming-request"}):+ outer_session = db.session()+ renamed = services.installed_app_conversations.rename(+ installed_app=admitted_app,+ account_id=account_id,+ conversation_id=conversation_id,+ name=None,+ auto_generate=True,+ )+ assert get_credit_usage_metadata() == {"request_id": "naming-request"}+ assert renamed.name == ("Original" if naming_fails else "Generated name")+ assert renamed.inputs == {"enabled": False}+ assert len(naming_sessions) == 1+ assert naming_sessions[0] is not outer_session+ assert not naming_sessions[0].in_transaction()+ assert db.session() is outer_session+ services.installed_app_conversations.delete(+ installed_app=admitted_app, account_id=account_id, conversation_id=conversation_id+ )+ assert get_credit_usage_metadata() == previous_metadata+ assert queued == [conversation_id]+ assert active_connections == 0++def test_installed_app_visibility_batches_settings_before_permissions_and_preserves_truthiness_filter(sqlite_session_factory: sessionmaker[Session],) -> None:diff --git a/api/tests/unit_tests/repositories/test_agent_workspace_repository.py b/api/tests/unit_tests/repositories/test_agent_workspace_repository.pynew file mode 100644index 00000000000..e8c99d79b32--- /dev/null+++ b/api/tests/unit_tests/repositories/test_agent_workspace_repository.py@@ -0,0 +1,256 @@+from dataclasses import replace+from datetime import datetime+from typing import Literal++import pytest+from sqlalchemy.orm import Session++from core.agent.workspace import WorkspaceOwnerScope+from models.agent import (+ AgentConfigVersionKind,+ AgentWorkingResourceStatus,+ AgentWorkspace,+ AgentWorkspaceBinding,+ AgentWorkspaceOwnerType,+)+from repositories.agent_workspace_repository import AgentWorkspaceRepository++_SCOPE = WorkspaceOwnerScope(+ tenant_id="tenant-1",+ app_id="app-1",+ owner_type=AgentWorkspaceOwnerType.CONVERSATION,+ owner_id="conversation-1",+)+_RETIRED_AT = datetime(2026, 9, 1)+++def _workspace(workspace_id: str, scope: WorkspaceOwnerScope) -> AgentWorkspace:+ return AgentWorkspace(+ id=workspace_id,+ tenant_id=scope.tenant_id,+ app_id=scope.app_id,+ owner_type=scope.owner_type,+ owner_id=scope.owner_id,+ owner_scope_key=scope.owner_scope_key,+ backend_workspace_ref=f"{workspace_id}-ref",+ status=AgentWorkingResourceStatus.ACTIVE,+ active_guard=1,+ )+++def _binding(binding_id: str, workspace: AgentWorkspace) -> AgentWorkspaceBinding:+ return AgentWorkspaceBinding(+ id=binding_id,+ tenant_id=workspace.tenant_id,+ app_id=workspace.app_id,+ workspace_id=workspace.id,+ agent_id="agent-1",+ agent_config_version_id="config-1",+ agent_config_version_kind=AgentConfigVersionKind.SNAPSHOT,+ backend_binding_ref=f"{binding_id}-ref",+ status=AgentWorkingResourceStatus.ACTIVE,+ )+++def workspace_binding(sqlite_session: Session) -> tuple[AgentWorkspace, AgentWorkspaceBinding]:+ workspace = _workspace("workspace-1", _SCOPE)+ binding = _binding("binding-1", workspace)+ sqlite_session.add_all([workspace, binding])+ sqlite_session.commit()+ return workspace, binding+++ "scope",+ [+ _SCOPE,+ replace(_SCOPE, tenant_id="other-tenant"),+ replace(_SCOPE, app_id="other-app"),+ replace(_SCOPE, owner_type=AgentWorkspaceOwnerType.BUILD_DRAFT),+ replace(_SCOPE, owner_id="other-conversation"),+ replace(_SCOPE, owner_scope_key="node-1:binding-1"),+ ],+ ids=["matching", "tenant", "app", "owner-type", "owner-id", "owner-scope-key"],+)+def test_get_active_binding_requires_complete_owner_scope(+ sqlite_session: Session,+ workspace_binding: tuple[AgentWorkspace, AgentWorkspaceBinding],+ scope: WorkspaceOwnerScope,+) -> None:+ _workspace_row, binding = workspace_binding+ resolved = AgentWorkspaceRepository(session=sqlite_session).get_active_binding(+ tenant_id=_SCOPE.tenant_id,+ binding_id=binding.id,+ expected_owner_scope=scope,+ )++ assert resolved is (binding if scope == _SCOPE else None)+++ ("tenant_id", "binding_id"),+ [("other-tenant", "binding-1"), ("tenant-1", "missing-binding")],+)[email protected]("workspace_binding")+def test_get_active_binding_requires_requested_tenant_and_binding(+ sqlite_session: Session,+ tenant_id: str,+ binding_id: str,+) -> None:+ assert (+ AgentWorkspaceRepository(session=sqlite_session).get_active_binding(+ tenant_id=tenant_id,+ binding_id=binding_id,+ expected_owner_scope=_SCOPE,+ )+ is None+ )++[email protected]("mismatch", ["binding-tenant", "workspace-id", "retired-binding", "retired-workspace"])+def test_get_active_binding_requires_active_binding_joined_to_its_active_workspace(+ sqlite_session: Session,+ workspace_binding: tuple[AgentWorkspace, AgentWorkspaceBinding],+ mismatch: str,+) -> None:+ workspace, binding = workspace_binding+ if mismatch == "binding-tenant":+ binding.tenant_id = "other-tenant"+ elif mismatch == "workspace-id":+ binding.workspace_id = "missing-workspace"+ elif mismatch == "retired-binding":+ binding.status = AgentWorkingResourceStatus.RETIRED+ else:+ workspace.status = AgentWorkingResourceStatus.RETIRED+ sqlite_session.commit()++ assert (+ AgentWorkspaceRepository(session=sqlite_session).get_active_binding(+ tenant_id=binding.tenant_id,+ binding_id=binding.id,+ expected_owner_scope=_SCOPE,+ )+ is None+ )+++def test_retire_all_for_conversation_scopes_workspaces_and_active_bindings(sqlite_session: Session) -> None:+ matching = [+ _workspace("root", _SCOPE),+ _workspace("node", replace(_SCOPE, owner_scope_key="node-1:binding-1")),+ ]+ excluded = [+ _workspace("other-tenant", replace(_SCOPE, tenant_id="other-tenant")),+ _workspace("other-app", replace(_SCOPE, app_id="other-app", owner_scope_key="other-app")),+ _workspace("other-conversation", replace(_SCOPE, owner_id="other-conversation")),+ _workspace("workflow-run", replace(_SCOPE, owner_type=AgentWorkspaceOwnerType.WORKFLOW_RUN)),+ _workspace("already-retired", replace(_SCOPE, owner_scope_key="already-retired")),+ ]+ active_bindings = [_binding(f"{workspace.id}-binding", workspace) for workspace in matching]+ active_bindings.append(_binding("second-root-binding", matching[0]))+ excluded_bindings = [_binding(f"{workspace.id}-binding", workspace) for workspace in excluded]+ foreign_binding = _binding("foreign-binding", matching[0])+ foreign_binding.tenant_id = "other-tenant"+ retired_binding = _binding("retired-root-binding", matching[0])+ sqlite_session.add_all(+ [*matching, *excluded, *active_bindings, *excluded_bindings, foreign_binding, retired_binding]+ )+ sqlite_session.flush()+ excluded[-1].status = AgentWorkingResourceStatus.RETIRED+ excluded[-1].active_guard = None+ excluded[-1].retired_at = _RETIRED_AT+ retired_binding.status = AgentWorkingResourceStatus.RETIRED+ retired_binding.retired_at = _RETIRED_AT+ sqlite_session.commit()+ repository = AgentWorkspaceRepository(session=sqlite_session)++ retired_ids = repository.retire_all_for_conversation(+ tenant_id=_SCOPE.tenant_id,+ app_id=_SCOPE.app_id,+ conversation_id=_SCOPE.owner_id,+ )+ sqlite_session.commit()+ sqlite_session.expire_all()++ assert set(retired_ids) == {workspace.id for workspace in matching}+ for workspace in matching:+ assert workspace.status is AgentWorkingResourceStatus.RETIRED+ assert workspace.active_guard is None+ assert workspace.retired_at is not None+ for binding in active_bindings:+ assert binding.status is AgentWorkingResourceStatus.RETIRED+ workspace = next(workspace for workspace in matching if workspace.id == binding.workspace_id)+ assert binding.retired_at == workspace.retired_at+ for workspace in excluded[:-1]:+ assert workspace.status is AgentWorkingResourceStatus.ACTIVE+ assert workspace.active_guard == 1+ assert workspace.retired_at is None+ for binding in [*excluded_bindings, foreign_binding]:+ assert binding.status is AgentWorkingResourceStatus.ACTIVE+ assert binding.retired_at is None+ assert excluded[-1].retired_at == _RETIRED_AT+ assert retired_binding.retired_at == _RETIRED_AT+ assert (+ repository.retire_all_for_conversation(+ tenant_id=_SCOPE.tenant_id,+ app_id=_SCOPE.app_id,+ conversation_id=_SCOPE.owner_id,+ )+ == []+ )++[email protected]("operation", ["workspace", "conversation"])+def test_caller_rollback_restores_workspace_and_bindings(+ sqlite_session: Session,+ workspace_binding: tuple[AgentWorkspace, AgentWorkspaceBinding],+ operation: Literal["workspace", "conversation"],+) -> None:+ workspace, binding = workspace_binding+ workspace_id, binding_id = workspace.id, binding.id+ repository = AgentWorkspaceRepository(session=sqlite_session)+ with sqlite_session.begin() as transaction:+ if operation == "workspace":+ assert repository.retire_workspace(tenant_id=_SCOPE.tenant_id, workspace_id=workspace.id) == workspace.id+ else:+ assert repository.retire_all_for_conversation(+ tenant_id=_SCOPE.tenant_id,+ app_id=_SCOPE.app_id,+ conversation_id=_SCOPE.owner_id,+ ) == [workspace.id]+ sqlite_session.flush()+ assert workspace.status is AgentWorkingResourceStatus.RETIRED+ assert workspace.active_guard is None+ assert binding.status is AgentWorkingResourceStatus.RETIRED+ assert binding.retired_at == workspace.retired_at+ transaction.rollback()++ stored_workspace = sqlite_session.get(AgentWorkspace, workspace_id)+ stored_binding = sqlite_session.get(AgentWorkspaceBinding, binding_id)+ assert stored_workspace is not None+ assert stored_binding is not None+ assert stored_workspace.status is AgentWorkingResourceStatus.ACTIVE+ assert stored_workspace.active_guard == 1+ assert stored_workspace.retired_at is None+ assert stored_binding.status is AgentWorkingResourceStatus.ACTIVE+ assert stored_binding.retired_at is None++[email protected]("tenant_id", ["tenant-1", "other-tenant"])+def test_retire_workspace_ignores_missing_or_foreign_workspace(+ sqlite_session: Session,+ workspace_binding: tuple[AgentWorkspace, AgentWorkspaceBinding],+ tenant_id: str,+) -> None:+ workspace, binding = workspace_binding+ workspace_id = "missing-workspace" if tenant_id == _SCOPE.tenant_id else workspace.id++ assert (+ AgentWorkspaceRepository(session=sqlite_session).retire_workspace(+ tenant_id=tenant_id, workspace_id=workspace_id+ )+ is None+ )+ assert workspace.status is AgentWorkingResourceStatus.ACTIVE+ assert binding.status is AgentWorkingResourceStatus.ACTIVEdiff --git a/api/tests/unit_tests/repositories/test_installed_app_conversation_repository.py b/api/tests/unit_tests/repositories/test_installed_app_conversation_repository.pynew file mode 100644index 00000000000..2571f2e7814--- /dev/null+++ b/api/tests/unit_tests/repositories/test_installed_app_conversation_repository.py@@ -0,0 +1,517 @@+from dataclasses import replace+from datetime import datetime, timedelta+from decimal import Decimal+from typing import Literal+from uuid import uuid4++import pytest+from sqlalchemy import Engine, event, inspect, select, update+from sqlalchemy.orm import Session, sessionmaker++from core.app.entities.app_invoke_entities import InvokeFrom+from models.agent import AgentWorkingResourceStatus, AgentWorkspace, AgentWorkspaceOwnerType+from models.enums import ConversationFromSource, CreatorUserRole+from models.model import App, AppMode, Conversation, InstalledApp, Message+from models.web import PinnedConversation+from repositories.installed_app_conversation_repository import SQLAlchemyInstalledAppConversationRepository+from services.errors.conversation import ConversationNotExistsError, LastConversationNotExistsError+from services.errors.message import MessageNotExistsError+from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppRef+from services.installed_app_conversation_service import ConversationPage++_ACCOUNT_ID = "11111111-1111-4111-8111-111111111111"+_OWNER_TENANT_ID = "22222222-2222-4222-8222-222222222222"+_TIME = datetime(2026, 9, 8, 12, 30)+++def installation(sqlite_session_factory: sessionmaker[Session]) -> InstalledAppRef:+ with sqlite_session_factory.begin() as session:+ app = App(tenant_id=_OWNER_TENANT_ID, name="Shared chat", mode=AppMode.CHAT, enable_site=True, enable_api=True)+ session.add(app)+ session.flush()+ installed_app = InstalledApp(+ tenant_id=str(uuid4()), app_id=app.id, app_owner_tenant_id=app.tenant_id, position=0, is_pinned=False+ )+ session.add(installed_app)+ session.flush()+ return InstalledAppRef(+ id=installed_app.id, tenant_id=installed_app.tenant_id, app_id=app.id, app_mode=app.mode.value+ )+++def _conversation(+ session: Session,+ installation: InstalledAppRef,+ *,+ updated_at: datetime = _TIME,+ invoke_from: InvokeFrom | None = InvokeFrom.EXPLORE,+) -> Conversation:+ conversation = Conversation(+ app_id=installation.app_id,+ mode=AppMode.CHAT,+ name="Original name",+ inputs={"empty": "", "list": [], "zero": 0, "flag": False, "none": None},+ introduction=None,+ from_source=ConversationFromSource.CONSOLE,+ from_account_id=_ACCOUNT_ID,+ from_end_user_id=None,+ created_at=_TIME - timedelta(days=1),+ updated_at=updated_at,+ invoke_from=invoke_from,+ is_deleted=False,+ )+ session.add(conversation)+ session.flush()+ return conversation+++def _message(session: Session, conversation: Conversation, *, query: str, created_at: datetime) -> None:+ session.add(+ Message(+ app_id=conversation.app_id,+ conversation_id=conversation.id,+ inputs={},+ query=query,+ message={},+ message_unit_price=Decimal(0),+ answer="",+ answer_unit_price=Decimal(0),+ currency="USD",+ from_source=ConversationFromSource.CONSOLE,+ from_account_id=_ACCOUNT_ID,+ created_at=created_at,+ )+ )+++def _pin(+ session: Session,+ installation: InstalledAppRef,+ conversation_id: str,+ *,+ role: CreatorUserRole = CreatorUserRole.ACCOUNT,+ account_id: str = _ACCOUNT_ID,+) -> None:+ session.add(+ PinnedConversation(+ app_id=installation.app_id,+ conversation_id=conversation_id,+ created_by_role=role,+ created_by=account_id,+ )+ )+++def test_page_preserves_empty_result_and_pinned_empty_short_circuit(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef+) -> None:+ repository = SQLAlchemyInstalledAppConversationRepository(session_factory=sqlite_session_factory)+ assert repository.get_page(+ installed_app=installation, account_id=_ACCOUNT_ID, last_id=None, limit=20, pinned=None+ ) == ConversationPage(limit=20, has_more=False, data=())+ assert repository.get_page(+ installed_app=installation, account_id=_ACCOUNT_ID, last_id=str(uuid4()), limit=20, pinned=True+ ) == ConversationPage(limit=20, has_more=False, data=())+ with pytest.raises(LastConversationNotExistsError):+ repository.get_page(+ installed_app=installation, account_id=_ACCOUNT_ID, last_id=str(uuid4()), limit=20, pinned=None+ )+++def test_page_keeps_updated_order_cursor_and_detached_inputs(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef+) -> None:+ with sqlite_session_factory.begin() as session:+ old = _conversation(session, installation, updated_at=_TIME - timedelta(hours=1))+ newest = _conversation(session, installation, updated_at=_TIME + timedelta(hours=1))+ middle = _conversation(session, installation)+ repository = SQLAlchemyInstalledAppConversationRepository(session_factory=sqlite_session_factory)++ first_page = repository.get_page(+ installed_app=installation, account_id=_ACCOUNT_ID, last_id=None, limit=2, pinned=None+ )+ final_page = repository.get_page(+ installed_app=installation, account_id=_ACCOUNT_ID, last_id=middle.id, limit=1, pinned=None+ )++ assert [item.id for item in first_page.data] == [newest.id, middle.id]+ assert first_page.limit == 2+ assert first_page.has_more is True+ assert [item.id for item in final_page.data] == [old.id]+ assert final_page.has_more is False+ record = first_page.data[0]+ assert inspect(record, raiseerr=False) is None+ assert record.inputs == {"empty": "", "list": [], "zero": 0, "flag": False, "none": None}+ assert record.name == "Original name"+ assert record.status == "normal"+ assert record.introduction is None+ assert record.created_at == _TIME - timedelta(days=1)+ assert record.updated_at == newest.updated_at+++def test_page_keeps_existing_strict_timestamp_behavior_for_ties(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef+) -> None:+ with sqlite_session_factory.begin() as session:+ _conversation(session, installation)+ _conversation(session, installation)+ repository = SQLAlchemyInstalledAppConversationRepository(session_factory=sqlite_session_factory)+ page = repository.get_page(installed_app=installation, account_id=_ACCOUNT_ID, last_id=None, limit=1, pinned=None)+ assert len(page.data) == 1+ assert page.has_more is False+ assert (+ repository.get_page(+ installed_app=installation, account_id=_ACCOUNT_ID, last_id=page.data[0].id, limit=1, pinned=None+ ).data+ == ()+ )+++def test_page_filters_invoke_source_and_scopes_pins_to_account_role_and_owner(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef+) -> None:+ with sqlite_session_factory.begin() as session:+ legacy = _conversation(session, installation, invoke_from=None, updated_at=_TIME + timedelta(hours=1))+ explore = _conversation(session, installation)+ debugging = _conversation(session, installation, invoke_from=InvokeFrom.DEBUGGER)+ _pin(session, installation, legacy.id)+ _pin(session, installation, explore.id, role=CreatorUserRole.END_USER)+ _pin(session, installation, explore.id, account_id=str(uuid4()))+ _pin(session, replace(installation, app_id=str(uuid4())), explore.id)+ repository = SQLAlchemyInstalledAppConversationRepository(session_factory=sqlite_session_factory)++ for pinned, expected in [(None, [legacy.id, explore.id]), (True, [legacy.id]), (False, [explore.id])]:+ page = repository.get_page(+ installed_app=installation, account_id=_ACCOUNT_ID, last_id=None, limit=20, pinned=pinned+ )+ assert [item.id for item in page.data] == expected+ assert page.has_more is False+ for cursor, pinned in [(debugging.id, None), (explore.id, True), (legacy.id, False)]:+ with pytest.raises(LastConversationNotExistsError):+ repository.get_page(+ installed_app=installation, account_id=_ACCOUNT_ID, last_id=cursor, limit=20, pinned=pinned+ )++[email protected]("mismatch", ["app_id", "from_account_id", "from_source", "from_end_user_id", "is_deleted"])+def test_every_conversation_ownership_predicate_protects_reads_and_mutations(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef, mismatch: str+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ value: str | bool = True if mismatch == "is_deleted" else str(uuid4())+ if mismatch == "from_source":+ value = ConversationFromSource.API+ session.execute(update(Conversation).where(Conversation.id == conversation.id).values({mismatch: value}))+ conversation_id = conversation.id+ repository = SQLAlchemyInstalledAppConversationRepository(session_factory=sqlite_session_factory)++ assert (+ repository.get_page(+ installed_app=installation, account_id=_ACCOUNT_ID, last_id=None, limit=20, pinned=None+ ).data+ == ()+ )+ with pytest.raises(LastConversationNotExistsError):+ repository.get_page(+ installed_app=installation, account_id=_ACCOUNT_ID, last_id=conversation_id, limit=20, pinned=None+ )+ with pytest.raises(ConversationNotExistsError):+ repository.get(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation_id)+ with pytest.raises(ConversationNotExistsError):+ repository.get_name_source(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation_id)+ with pytest.raises(ConversationNotExistsError):+ repository.rename(+ installed_app=installation,+ account_id=_ACCOUNT_ID,+ conversation_id=conversation_id,+ name="Unauthorized",+ updated_at=_TIME,+ )+ with pytest.raises(ConversationNotExistsError):+ repository.delete(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+ )+ with sqlite_session_factory() as session:+ stored = session.get(Conversation, conversation_id)+ assert stored is not None+ assert stored.name == "Original name"+ assert stored.is_deleted is (mismatch == "is_deleted")+ assert session.scalars(select(PinnedConversation)).all() == []++[email protected]("mismatch", ["id", "tenant_id", "app_id", "deleted_app", "deleted_installation"])+def test_all_operations_revalidate_complete_installation_and_actual_app(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef, mismatch: str+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ if mismatch == "deleted_app":+ app = session.get(App, installation.app_id)+ assert app is not None+ session.delete(app)+ elif mismatch == "deleted_installation":+ installed_app = session.get(InstalledApp, installation.id)+ assert installed_app is not None+ session.delete(installed_app)+ else:+ installation = replace(installation, **{mismatch: str(uuid4())})+ repository = SQLAlchemyInstalledAppConversationRepository(session_factory=sqlite_session_factory)++ with pytest.raises(InstalledAppNotFoundError):+ repository.get_page(installed_app=installation, account_id=_ACCOUNT_ID, last_id=None, limit=20, pinned=True)+ with pytest.raises(InstalledAppNotFoundError):+ repository.get_name_source(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id)+ with pytest.raises(InstalledAppNotFoundError):+ repository.rename(+ installed_app=installation,+ account_id=_ACCOUNT_ID,+ conversation_id=conversation.id,+ name="Unauthorized",+ updated_at=_TIME,+ )+ with pytest.raises(InstalledAppNotFoundError):+ repository.delete(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+ )+++def test_name_source_uses_first_message_and_real_app_owner_tenant(+ sqlite_session_factory: sessionmaker[Session], sqlite_engine: Engine, installation: InstalledAppRef+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ _message(session, conversation, query="Later", created_at=_TIME)+ _message(session, conversation, query="First", created_at=_TIME - timedelta(hours=1))+ repository = SQLAlchemyInstalledAppConversationRepository(session_factory=sqlite_session_factory)+ connection_events: list[str] = []++ @event.listens_for(sqlite_engine, "checkout")+ def track_checkout(_connection: object, _record: object, _proxy: object) -> None:+ connection_events.append("checkout")++ @event.listens_for(sqlite_engine, "checkin")+ def track_checkin(_connection: object, _record: object) -> None:+ connection_events.append("checkin")++ result = repository.get_name_source(+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id+ )+ assert connection_events == ["checkout", "checkin"]+ assert result.tenant_id == _OWNER_TENANT_ID != installation.tenant_id+ assert result.query == "First"+ record = repository.get(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id)+ assert record.name == "Original name"+ assert inspect(record, raiseerr=False) is None+ assert connection_events == ["checkout", "checkin", "checkout", "checkin"]+++def test_name_source_rejects_missing_message_and_message_from_other_app(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ _message(session, conversation, query="Wrong app", created_at=_TIME)+ session.flush()+ session.execute(update(Message).values(app_id=str(uuid4())))+ repository = SQLAlchemyInstalledAppConversationRepository(session_factory=sqlite_session_factory)+ with pytest.raises(MessageNotExistsError, match=conversation.id):+ repository.get_name_source(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id)++[email protected]("updated_at", [None, _TIME + timedelta(hours=1)])+def test_rename_commits_and_materializes_automatic_or_explicit_updated_at(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef, updated_at: datetime | None+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ repository = SQLAlchemyInstalledAppConversationRepository(session_factory=sqlite_session_factory)+ result = repository.rename(+ installed_app=installation,+ account_id=_ACCOUNT_ID,+ conversation_id=conversation.id,+ name="",+ updated_at=updated_at,+ )++ with sqlite_session_factory() as session:+ stored = session.get(Conversation, conversation.id)+ assert stored is not None+ assert stored.name == result.name == ""+ assert stored.updated_at == result.updated_at+ if updated_at is not None:+ assert result.updated_at == updated_at+ else:+ # The model's existing onupdate default still runs for automatic names.+ assert result.updated_at != _TIME+ assert result.inputs["flag"] is False+++def test_rename_materializes_inputs_before_mutation(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef, monkeypatch: pytest.MonkeyPatch+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ materialization_state: list[tuple[str, bool]] = []+ original_inputs_with_session = Conversation.inputs_with_session++ def track_materialization(self: Conversation, *, session: Session) -> dict[str, object]:+ materialization_state.append((self.name, self in session.dirty))+ return original_inputs_with_session(self, session=session)++ monkeypatch.setattr(Conversation, "inputs_with_session", track_materialization)+ repository = SQLAlchemyInstalledAppConversationRepository(session_factory=sqlite_session_factory)++ repository.rename(+ installed_app=installation,+ account_id=_ACCOUNT_ID,+ conversation_id=conversation.id,+ name="Renamed",+ updated_at=_TIME + timedelta(hours=1),+ )++ assert materialization_state == [("Original name", False)]+++def test_pin_and_unpin_are_idempotent_and_preserve_other_owners(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ _pin(session, installation, conversation.id, role=CreatorUserRole.END_USER)+ _pin(session, installation, conversation.id, account_id=str(uuid4()))+ _pin(session, replace(installation, app_id=str(uuid4())), conversation.id)+ repository = SQLAlchemyInstalledAppConversationRepository(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+ )+ with sqlite_session_factory() as session:+ assert len(session.scalars(select(PinnedConversation)).all()) == 4++ for _ in range(2):+ repository.set_pinned(+ 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+ )+ with sqlite_session_factory() as session:+ remaining = session.scalars(select(PinnedConversation)).all()+ assert len(remaining) == 3+ assert all(+ pin.created_by_role != CreatorUserRole.ACCOUNT+ or pin.created_by != _ACCOUNT_ID+ or pin.app_id != installation.app_id+ for pin in remaining+ )+++def test_existing_pin_and_unpin_do_not_require_live_conversation(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef+) -> None:+ missing_id = str(uuid4())+ with sqlite_session_factory.begin() as session:+ _pin(session, installation, missing_id)+ repository = SQLAlchemyInstalledAppConversationRepository(session_factory=sqlite_session_factory)+ repository.set_pinned(+ 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+ )+ with sqlite_session_factory() as session:+ assert session.scalars(select(PinnedConversation)).all() == []++[email protected]("workspace_count", [0, 2])+def test_delete_commits_soft_deletion_and_returns_owner_tenant_for_cleanup(+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef, workspace_count: int+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ workspaces = [+ AgentWorkspace(+ id=str(uuid4()),+ tenant_id=_OWNER_TENANT_ID,+ app_id=conversation.app_id,+ owner_type=AgentWorkspaceOwnerType.CONVERSATION,+ owner_id=conversation.id,+ owner_scope_key=f"node-{index}:workflow-binding-{index}",+ backend_workspace_ref=f"backend-workspace-{index}",+ status=AgentWorkingResourceStatus.ACTIVE,+ active_guard=1,+ )+ for index in range(workspace_count)+ ]+ session.add_all(workspaces)+ repository = SQLAlchemyInstalledAppConversationRepository(session_factory=sqlite_session_factory)+ deleted = repository.delete(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id)++ assert deleted.tenant_id == _OWNER_TENANT_ID+ assert deleted.conversation_id == conversation.id+ assert set(deleted.retired_workspace_ids) == {workspace.id for workspace in workspaces}+ with sqlite_session_factory() as session:+ stored = session.get(Conversation, conversation.id)+ assert stored is not None+ assert stored.is_deleted is True+ for workspace in workspaces:+ stored_workspace = session.get(AgentWorkspace, workspace.id)+ assert stored_workspace is not None+ assert stored_workspace.status == AgentWorkingResourceStatus.RETIRED+ assert stored_workspace.retired_at is not None+ assert stored_workspace.active_guard is None+ with pytest.raises(ConversationNotExistsError):+ repository.delete(installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id)++[email protected]("operation", ["rename", "delete", "pin"])+def test_failed_commit_rolls_back_mutations_and_propagates_original_error(+ sqlite_session_factory: sessionmaker[Session],+ sqlite_engine: Engine,+ installation: InstalledAppRef,+ operation: Literal["rename", "delete", "pin"],+) -> None:+ with sqlite_session_factory.begin() as session:+ conversation = _conversation(session, installation)+ failing_factory = sessionmaker(bind=sqlite_engine)+ failure = RuntimeError("database commit unavailable")++ @event.listens_for(failing_factory, "before_commit")+ def fail_commit(_session: Session) -> None:+ raise failure++ repository = SQLAlchemyInstalledAppConversationRepository(session_factory=failing_factory)++ def mutate() -> None:+ if operation == "rename":+ repository.rename(+ installed_app=installation,+ account_id=_ACCOUNT_ID,+ conversation_id=conversation.id,+ name="Discarded",+ updated_at=_TIME + timedelta(hours=1),+ )+ elif operation == "delete":+ repository.delete(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+ )++ with pytest.raises(RuntimeError) as error:+ mutate()+ assert error.value is failure+ with sqlite_session_factory() as session:+ stored = session.get(Conversation, conversation.id)+ assert stored is not None+ assert stored.name == "Original name"+ assert stored.updated_at == _TIME+ assert stored.is_deleted is False+ assert session.scalars(select(PinnedConversation)).all() == []diff --git a/api/tests/unit_tests/repositories/test_installed_app_repository.py b/api/tests/unit_tests/repositories/test_installed_app_repository.pyindex c0fd7fd7035..eefe5424d81 100644--- a/api/tests/unit_tests/repositories/test_installed_app_repository.py+++ b/api/tests/unit_tests/repositories/test_installed_app_repository.py@@ -4,7 +4,7 @@ from uuid import uuid4import pytestfrom sqlalchemy import event, inspect-from sqlalchemy.orm import Session, sessionmaker+from sqlalchemy.orm import ORMExecuteState, Session, sessionmakerfrom models.model import App, AppMode, AppModelConfig, IconType, InstalledAppfrom models.workflow import Workflow, WorkflowKind, WorkflowType@@ -28,15 +28,17 @@ def _installation(*, app_id: str) -> InstalledApp:)[email protected]("app_mode", list(AppMode))def test_resolve_returns_pure_reference_to_cross_workspace_app(sqlite_session_factory: sessionmaker[Session],+ app_mode: AppMode,) -> None:with sqlite_session_factory.begin() as session:# Admission must not add public, published, or app-mode constraints.app = App(tenant_id=_OWNER_TENANT_ID,name="Installed app",- mode=AppMode.AGENT,+ mode=app_mode,is_public=False,enable_site=True,enable_api=True,@@ -50,9 +52,21 @@ def test_resolve_returns_pure_reference_to_cross_workspace_app(app_id = app.idrepository = SQLAlchemyInstalledAppRepository(session_factory=sqlite_session_factory)+ select_count = 0++ @event.listens_for(sqlite_session_factory, "do_orm_execute")+ def count_selects(state: ORMExecuteState) -> None:+ nonlocal select_count+ if state.is_select:+ select_count += 1+result = repository.resolve(installed_app_id=installed_app_id, tenant_id=_VIEWER_TENANT_ID)- assert result == InstalledAppRef(id=installed_app_id, app_id=app_id, tenant_id=_VIEWER_TENANT_ID)+ assert result == InstalledAppRef(+ id=installed_app_id, app_id=app_id, tenant_id=_VIEWER_TENANT_ID, app_mode=app_mode.value+ )+ # The app existence read also supplies its mode; no separate mode query.+ assert select_count == 2assert inspect(result, raiseerr=False) is Nonewith sqlite_session_factory() as session:assert session.get(InstalledApp, installed_app_id) is not None@@ -126,7 +140,9 @@ def installed_app(sqlite_session_factory: sessionmaker[Session]) -> InstalledAppdef _reference(installation: InstalledApp) -> InstalledAppRef:- return InstalledAppRef(id=installation.id, app_id=installation.app_id, tenant_id=installation.tenant_id)+ return InstalledAppRef(+ id=installation.id, app_id=installation.app_id, tenant_id=installation.tenant_id, app_mode="completion"+ )def test_record_commits_usage_for_cross_workspace_app_without_changing_installation_settings(diff --git a/api/tests/unit_tests/services/test_conversation_service.py b/api/tests/unit_tests/services/test_conversation_service.pyindex 43868748761..0331b02498e 100644--- a/api/tests/unit_tests/services/test_conversation_service.py+++ b/api/tests/unit_tests/services/test_conversation_service.py@@ -8,6 +8,8 @@ in-memory SQLite sessions with persisted ORM rows."""import json+from dataclasses import replace+from decimal import Decimalfrom unittest.mock import MagicMockimport pytest@@ -15,18 +17,24 @@ from sqlalchemy import asc, desc, eventfrom sqlalchemy.orm import Sessionfrom core.app.entities.app_invoke_entities import InvokeFrom+from core.credit_usage import CreditUsageAppType+from core.model_context import get_credit_usage_metadata, use_credit_usage_metadatafrom libs.datetime_utils import naive_utc_nowfrom models import Account, ConversationVariablefrom models.agent import (AgentConfigVersionKind,AgentWorkingResourceStatus,+ AgentWorkspace,AgentWorkspaceBinding,+ AgentWorkspaceOwnerType,)from models.enums import AppStatus, ConversationFromSource, ConversationStatus-from models.model import App, AppMode, Conversation+from models.model import App, AppMode, Conversation, Message+from repositories.conversation_lifecycle import retire_conversationfrom services import conversation_service-from services.agent.workspace_service import AgentWorkspaceService+from services.agent.workspace_service import AgentWorkspaceNotFoundError, WorkspaceOwnerScopefrom services.conversation_service import ConversationService+from services.errors.message import MessageNotExistsErrorTENANT_ID = "11111111-1111-1111-1111-111111111111"APP_ID = "22222222-2222-2222-2222-222222222222"@@ -170,91 +178,286 @@ class ConversationServiceTestDataFactory:return conversation-def test_delete_retires_then_commits_before_enqueue(monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> None:+def conversation_workspace(sqlite_session: Session) -> tuple[AgentWorkspace, AgentWorkspaceBinding]:+ workspace = AgentWorkspace(+ id="workspace-1",+ tenant_id=TENANT_ID,+ app_id=APP_ID,+ owner_type=AgentWorkspaceOwnerType.CONVERSATION,+ owner_id=CONVERSATION_ID,+ owner_scope_key="root",+ backend_workspace_ref="backend-workspace-1",+ status=AgentWorkingResourceStatus.ACTIVE,+ active_guard=1,+ )+ binding = _workspace_binding("binding-1")+ sqlite_session.add_all([workspace, binding])+ sqlite_session.flush()+ return workspace, binding++[email protected]("has_root_binding", [False, True])+def test_delete_retires_then_commits_before_enqueue(+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session: Session,+ conversation_workspace: tuple[AgentWorkspace, AgentWorkspaceBinding],+ has_root_binding: bool,+) -> None:+ workspace, binding = conversation_workspaceapp = ConversationServiceTestDataFactory.create_app()+ account = ConversationServiceTestDataFactory.create_account()conversation = ConversationServiceTestDataFactory.create_conversation()- conversation.agent_workspace_binding_id = "conversation-binding-1"- sqlite_session.add(conversation)- sqlite_session.flush()+ conversation.agent_workspace_binding_id = binding.id if has_root_binding else None+ node_workspace = AgentWorkspace(+ id="workspace-node",+ tenant_id=TENANT_ID,+ app_id=APP_ID,+ owner_type=AgentWorkspaceOwnerType.CONVERSATION,+ owner_id=conversation.id,+ owner_scope_key="node-1:workflow-binding-1",+ backend_workspace_ref="backend-workspace-node",+ status=AgentWorkingResourceStatus.ACTIVE,+ active_guard=1,+ )+ sqlite_session.add_all([conversation, node_workspace])+ sqlite_session.commit()events: list[str] = []- get_binding = MagicMock(return_value=_workspace_binding("conversation-binding-1"))- retire_conversation = MagicMock(side_effect=lambda **_kwargs: events.append("retire") or ["workspace-1"])- monkeypatch.setattr(ConversationService, "get_conversation", MagicMock(return_value=conversation))- monkeypatch.setattr(AgentWorkspaceService, "get_active_binding", get_binding)- monkeypatch.setattr(AgentWorkspaceService, "retire_all_for_conversation", retire_conversation)event.listen(sqlite_session, "after_commit", lambda _session: events.append("commit"))- monkeypatch.setattr(- conversation_service,- "enqueue_agent_resource_collection",- MagicMock(side_effect=lambda **_kwargs: events.append("enqueue")),- )- delete_related = MagicMock()++ def enqueue(*, tenant_id: str, workspace_ids: tuple[str, ...]) -> None:+ assert tenant_id == TENANT_ID+ assert set(workspace_ids) == {workspace.id, node_workspace.id}+ assert not sqlite_session.in_transaction()+ assert conversation.is_deleted is True+ assert binding.status == workspace.status == AgentWorkingResourceStatus.RETIRED+ assert binding.retired_at is not None+ assert workspace.retired_at is not None+ assert workspace.active_guard is None+ assert node_workspace.status == AgentWorkingResourceStatus.RETIRED+ assert node_workspace.retired_at is not None+ assert node_workspace.active_guard is None+ events.append("agent cleanup")++ monkeypatch.setattr(conversation_service, "enqueue_agent_resource_collection", enqueue)+ delete_related = MagicMock(side_effect=lambda _conversation_id: events.append("conversation cleanup"))monkeypatch.setattr(conversation_service.delete_conversation_related_data, "delay", delete_related)- ConversationService.delete(app, conversation.id, None, session=sqlite_session)+ ConversationService.delete(app, conversation.id, account, session=sqlite_session)- assert events == ["retire", "commit", "enqueue"]- assert conversation.is_deleted is True- assert get_binding.call_args.kwargs["binding_id"] == "conversation-binding-1"- assert retire_conversation.call_args.kwargs["conversation_id"] == conversation.id+ assert events == ["commit", "agent cleanup", "conversation cleanup"]delete_related.assert_called_once_with(conversation.id)-def test_delete_commit_failure_does_not_enqueue(monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> None:+def test_delete_commit_failure_rolls_back_all_lifecycle_changes_without_enqueue(+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session: Session,+ conversation_workspace: tuple[AgentWorkspace, AgentWorkspaceBinding],+) -> None:+ workspace, binding = conversation_workspaceapp = ConversationServiceTestDataFactory.create_app()+ account = ConversationServiceTestDataFactory.create_account()conversation = ConversationServiceTestDataFactory.create_conversation()- conversation.agent_workspace_binding_id = "binding-1"+ conversation.agent_workspace_binding_id = binding.idsqlite_session.add(conversation)sqlite_session.commit()- rollback_events: list[str] = []- event.listen(sqlite_session, "after_rollback", lambda _session: rollback_events.append("rollback"))- def fail_commit(_session: Session) -> None:+ def fail_commit(session: Session) -> None:+ session.flush()raise RuntimeError("commit failed")event.listen(sqlite_session, "before_commit", fail_commit, once=True)- monkeypatch.setattr(ConversationService, "get_conversation", MagicMock(return_value=conversation))- monkeypatch.setattr(- AgentWorkspaceService,- "get_active_binding",- MagicMock(return_value=_workspace_binding("binding-1")),- )- monkeypatch.setattr(AgentWorkspaceService, "retire_all_for_conversation", MagicMock(return_value=["workspace-1"]))enqueue_collection = MagicMock()delete_related = MagicMock()monkeypatch.setattr(conversation_service, "enqueue_agent_resource_collection", enqueue_collection)monkeypatch.setattr(conversation_service.delete_conversation_related_data, "delay", delete_related)with pytest.raises(RuntimeError, match="commit failed"):- ConversationService.delete(app, conversation.id, None, session=sqlite_session)+ ConversationService.delete(app, conversation.id, account, session=sqlite_session)- assert rollback_events == ["rollback"]assert conversation.is_deleted is False+ assert binding.status == workspace.status == AgentWorkingResourceStatus.ACTIVE+ assert binding.retired_at is None+ assert workspace.retired_at is None+ assert workspace.active_guard == 1+ enqueue_collection.assert_not_called()+ delete_related.assert_not_called()+++def test_retire_leaves_commit_and_cleanup_to_the_caller(+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session: Session,+ conversation_workspace: tuple[AgentWorkspace, AgentWorkspaceBinding],+) -> None:+ workspace, binding = conversation_workspace+ app = ConversationServiceTestDataFactory.create_app()+ conversation = ConversationServiceTestDataFactory.create_conversation()+ conversation.agent_workspace_binding_id = binding.id+ sqlite_session.add(conversation)+ sqlite_session.commit()+ enqueue_collection = MagicMock()+ delete_related = MagicMock()+ monkeypatch.setattr(conversation_service, "enqueue_agent_resource_collection", enqueue_collection)+ monkeypatch.setattr(conversation_service.delete_conversation_related_data, "delay", delete_related)++ retired_workspace_ids = retire_conversation(app_model=app, conversation=conversation, session=sqlite_session)+ sqlite_session.flush()++ assert retired_workspace_ids == (workspace.id,)+ assert conversation.is_deleted is True+ assert binding.status == workspace.status == AgentWorkingResourceStatus.RETIREDenqueue_collection.assert_not_called()delete_related.assert_not_called()+ sqlite_session.rollback()+ restored = sqlite_session.get(Conversation, CONVERSATION_ID)+ assert restored is not None+ assert restored.is_deleted is False+ assert binding.status == workspace.status == AgentWorkingResourceStatus.ACTIVE+++_CONVERSATION_OWNER = WorkspaceOwnerScope(+ tenant_id=TENANT_ID,+ app_id=APP_ID,+ owner_type=AgentWorkspaceOwnerType.CONVERSATION,+ owner_id=CONVERSATION_ID,+)+++ "scope",+ [+ replace(_CONVERSATION_OWNER, tenant_id="bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"),+ replace(_CONVERSATION_OWNER, app_id=OTHER_APP_ID),+ replace(_CONVERSATION_OWNER, owner_type=AgentWorkspaceOwnerType.WORKFLOW_RUN),+ replace(_CONVERSATION_OWNER, owner_id=OTHER_CONVERSATION_ID),+ replace(_CONVERSATION_OWNER, owner_scope_key="other"),+ ],+ ids=["tenant", "app", "owner type", "owner id", "owner scope"],+)+def test_retire_rejects_participants_owned_by_another_scope(+ scope: WorkspaceOwnerScope,+ sqlite_session: Session,+ conversation_workspace: tuple[AgentWorkspace, AgentWorkspaceBinding],+) -> None:+ workspace, binding = conversation_workspace+ workspace.tenant_id = scope.tenant_id+ workspace.app_id = scope.app_id+ workspace.owner_type = scope.owner_type+ workspace.owner_id = scope.owner_id+ workspace.owner_scope_key = scope.owner_scope_key+ app = ConversationServiceTestDataFactory.create_app()+ conversation = ConversationServiceTestDataFactory.create_conversation()+ conversation.agent_workspace_binding_id = binding.id+ sqlite_session.add(conversation)+ sqlite_session.commit()++ with pytest.raises(AgentWorkspaceNotFoundError, match="participant Binding is unavailable"):+ retire_conversation(app_model=app, conversation=conversation, session=sqlite_session)++ assert conversation.is_deleted is False+ assert binding.status == workspace.status == AgentWorkingResourceStatus.ACTIVEdef test_delete_keeps_soft_deleted_marker_when_dispatch_fails(monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> None:app = ConversationServiceTestDataFactory.create_app()+ account = ConversationServiceTestDataFactory.create_account()conversation = ConversationServiceTestDataFactory.create_conversation()sqlite_session.add(conversation)sqlite_session.flush()- monkeypatch.setattr(ConversationService, "get_conversation", MagicMock(return_value=conversation))monkeypatch.setattr(conversation_service.delete_conversation_related_data,"delay",MagicMock(side_effect=RuntimeError("broker unavailable")),)- ConversationService.delete(app, conversation.id, None, session=sqlite_session)+ ConversationService.delete(app, conversation.id, account, session=sqlite_session)persisted = sqlite_session.get(Conversation, conversation.id)assert persisted is not Noneassert persisted.is_deleted is True+def test_cleanup_propagates_agent_enqueue_failure_before_conversation_enqueue(monkeypatch: pytest.MonkeyPatch) -> None:+ monkeypatch.setattr(+ conversation_service, "enqueue_agent_resource_collection", MagicMock(side_effect=RuntimeError("unavailable"))+ )+ delete_related = MagicMock()+ monkeypatch.setattr(conversation_service.delete_conversation_related_data, "delay", delete_related)++ with pytest.raises(RuntimeError, match="unavailable"):+ ConversationService.enqueue_delete_cleanup(+ tenant_id=TENANT_ID, conversation_id=CONVERSATION_ID, retired_workspace_ids=("workspace-1",)+ )++ delete_related.assert_not_called()++[email protected]("naming_fails", [False, True])+def test_legacy_auto_generate_name_preserves_metadata_and_persists_success_or_original_title(+ monkeypatch: pytest.MonkeyPatch, sqlite_session: Session, naming_fails: bool+) -> None:+ app = ConversationServiceTestDataFactory.create_app(mode=AppMode.ADVANCED_CHAT)+ conversation = ConversationServiceTestDataFactory.create_conversation(mode=AppMode.ADVANCED_CHAT)+ message = Message(+ app_id=APP_ID,+ conversation_id=CONVERSATION_ID,+ _inputs={},+ query="First query",+ message={},+ answer="Answer",+ message_unit_price=Decimal(0),+ answer_unit_price=Decimal(0),+ currency="USD",+ from_source=ConversationFromSource.CONSOLE,+ from_account_id=ACCOUNT_ID,+ )+ sqlite_session.add_all([app, conversation, message])+ sqlite_session.commit()+ calls: list[tuple[str, str, str, str, dict[str, object]]] = []++ def generate(tenant_id: str, query: str, conversation_id: str, app_id: str) -> str:+ calls.append((tenant_id, query, conversation_id, app_id, dict(get_credit_usage_metadata() or {})))+ if naming_fails:+ raise RuntimeError("Provider unavailable")+ return "Generated title"++ monkeypatch.setattr(conversation_service.LLMGenerator, "generate_conversation_name", generate)+ previous_metadata = get_credit_usage_metadata()+ with use_credit_usage_metadata({"request_id": "legacy-name-request"}):+ inherited_metadata = dict(get_credit_usage_metadata() or {})+ result = ConversationService.auto_generate_name(app, conversation, session=sqlite_session)+ assert get_credit_usage_metadata() == inherited_metadata+ assert get_credit_usage_metadata() == previous_metadata+ # Assert outside the best-effort naming call so its exception suppression+ # cannot hide failed assertions inside the external provider callback.+ assert calls == [+ (+ TENANT_ID,+ "First query",+ CONVERSATION_ID,+ APP_ID,+ {"app_type": CreditUsageAppType.CHATFLOW, **inherited_metadata},+ )+ ]+ assert result is conversation+ sqlite_session.refresh(result)+ assert result.name == ("Test Conversation" if naming_fails else "Generated title")+++def test_legacy_auto_generate_name_reports_missing_first_message(sqlite_session: Session) -> None:+ app = ConversationServiceTestDataFactory.create_app()+ conversation = ConversationServiceTestDataFactory.create_conversation()+ sqlite_session.add(conversation)+ sqlite_session.commit()++ with pytest.raises(MessageNotExistsError):+ ConversationService.auto_generate_name(app, conversation, session=sqlite_session)++ assert conversation.name == "Test Conversation"++class TestConversationServicePagination:"""Test conversation pagination operations."""diff --git a/api/tests/unit_tests/services/test_installed_app_access_service.py b/api/tests/unit_tests/services/test_installed_app_access_service.pyindex eabb473b1a9..f5817925403 100644--- a/api/tests/unit_tests/services/test_installed_app_access_service.py+++ b/api/tests/unit_tests/services/test_installed_app_access_service.py@@ -11,7 +11,7 @@ from services.installed_app_access_service import (InstalledAppRef,)-_REF = InstalledAppRef(id="installation-1", app_id="app-1", tenant_id="workspace-1")+_REF = InstalledAppRef(id="installation-1", app_id="app-1", tenant_id="workspace-1", app_mode="completion")class _Store: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.pynew file mode 100644index 00000000000..97c20f764a5--- /dev/null+++ b/api/tests/unit_tests/services/test_installed_app_conversation_service.py@@ -0,0 +1,231 @@+"""Conversation orchestration over a stateful persistence fake."""++from collections.abc import Callable+from dataclasses import dataclass, field, replace+from datetime import datetime++import pytest++from services.errors.conversation import ConversationNotExistsError+from services.installed_app_access_service import InstalledAppRef+from services.installed_app_conversation_service import (+ ConversationDeletion,+ ConversationNameRequiredError,+ ConversationNameSource,+ ConversationNotChatAppError,+ ConversationPage,+ ConversationRecord,+ InstalledAppConversationService,+)++_REF = InstalledAppRef(+ id="11111111-1111-4111-8111-111111111111",+ app_id="22222222-2222-4222-8222-222222222222",+ tenant_id="33333333-3333-4333-8333-333333333333",+ app_mode="chat",+)+_ACCOUNT_ID = "44444444-4444-4444-8444-444444444444"+_CONVERSATION_ID = "55555555-5555-4555-8555-555555555555"+_OWNER_TENANT_ID = "66666666-6666-4666-8666-666666666666"+_UPDATED_AT = datetime(2024, 1, 1)+++@dataclass+class _Store:+ conversation: ConversationRecord | None = field(+ default_factory=lambda: ConversationRecord(+ id=_CONVERSATION_ID,+ name="Original title",+ inputs={"count": 0},+ status="normal",+ introduction=None,+ created_at=_UPDATED_AT,+ updated_at=_UPDATED_AT,+ )+ )+ events: list[str] = field(default_factory=list)+ delete_error: Exception | None = None++ def get(self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str) -> ConversationRecord:+ self.events.append("read conversation")+ assert (installed_app, account_id, conversation_id) == (_REF, _ACCOUNT_ID, _CONVERSATION_ID)+ if self.conversation is None:+ raise ConversationNotExistsError()+ return self.conversation++ def get_page(+ self, *, installed_app: InstalledAppRef, account_id: str, last_id: str | None, limit: int, pinned: bool | None+ ) -> ConversationPage:+ raise AssertionError(f"Unexpected listing: {installed_app=}, {account_id=}, {last_id=}, {limit=}, {pinned=}")++ def get_name_source(+ self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str+ ) -> ConversationNameSource:+ self.events.append("read source")+ assert (installed_app, account_id, conversation_id) == (_REF, _ACCOUNT_ID, _CONVERSATION_ID)+ if self.conversation is None:+ raise ConversationNotExistsError()+ return ConversationNameSource(tenant_id=_OWNER_TENANT_ID, query="First query")++ def rename(+ self,+ *,+ installed_app: InstalledAppRef,+ account_id: str,+ conversation_id: str,+ name: str,+ updated_at: datetime | None,+ ) -> ConversationRecord:+ self.events.append("rename")+ assert (installed_app, account_id, conversation_id) == (_REF, _ACCOUNT_ID, _CONVERSATION_ID)+ if self.conversation is None:+ raise ConversationNotExistsError()+ self.conversation = replace(+ self.conversation,+ name=name,+ updated_at=updated_at if updated_at is not None else self.conversation.updated_at,+ )+ return self.conversation++ def delete(self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str) -> ConversationDeletion:+ assert (installed_app, account_id, conversation_id) == (_REF, _ACCOUNT_ID, _CONVERSATION_ID)+ if self.delete_error is not None:+ raise self.delete_error+ self.conversation = None+ self.events.append("delete committed")+ return ConversationDeletion(+ tenant_id=_OWNER_TENANT_ID,+ conversation_id=conversation_id,+ retired_workspace_ids=("retired-workspace-1", "retired-workspace-2"),+ )++ def set_pinned(+ self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str, is_pinned: bool+ ) -> None:+ raise AssertionError(f"Unexpected pin: {installed_app=}, {account_id=}, {conversation_id=}, {is_pinned=}")+++@dataclass+class _Orchestration:+ store: _Store+ service: InstalledAppConversationService | None = None+ generation_error: Exception | None = None+ generation_action: Callable[[], None] | None = None+ cleanup_calls: list[tuple[str, str, tuple[str, ...]]] = field(default_factory=list)++ def generate_name(self, *, tenant_id: str, app_id: str, conversation_id: str, query: str, app_mode: str) -> str:+ self.store.events.append("generate")+ assert (tenant_id, app_id, conversation_id, query, app_mode) == (+ _OWNER_TENANT_ID,+ _REF.app_id,+ _CONVERSATION_ID,+ "First query",+ "chat",+ )+ if self.generation_error is not None:+ raise self.generation_error+ if self.generation_action is not None:+ self.generation_action()+ return "Generated title"++ def cleanup(self, *, tenant_id: str, conversation_id: str, retired_workspace_ids: tuple[str, ...]) -> None:+ assert self.store.conversation is None+ self.store.events.append("enqueue")+ self.cleanup_calls.append((tenant_id, conversation_id, retired_workspace_ids))++ def rename(self, *, name: str | None = None, auto_generate: bool = True) -> ConversationRecord:+ assert self.service is not None+ return self.service.rename(+ installed_app=_REF,+ account_id=_ACCOUNT_ID,+ conversation_id=_CONVERSATION_ID,+ name=name,+ auto_generate=auto_generate,+ )++ def delete(self) -> None:+ assert self.service is not None+ self.service.delete(installed_app=_REF, account_id=_ACCOUNT_ID, conversation_id=_CONVERSATION_ID)+++def orchestration() -> _Orchestration:+ state = _Orchestration(store=_Store())+ state.service = InstalledAppConversationService(+ conversations=state.store,+ generate_name=state.generate_name,+ enqueue_delete_cleanup=state.cleanup,+ )+ return state+++def test_auto_rename_reads_then_generates_then_writes_without_changing_manual_timestamp(+ orchestration: _Orchestration,+) -> None:+ result = orchestration.rename()+ assert result.name == "Generated title"+ assert result.inputs == {"count": 0}+ assert result.updated_at == _UPDATED_AT+ assert orchestration.store.events == ["read source", "generate", "rename"]+++def test_generation_failure_returns_original_record_without_writing(orchestration: _Orchestration) -> None:+ original = orchestration.store.conversation+ orchestration.generation_error = RuntimeError("provider unavailable")+ assert orchestration.rename() is original+ assert orchestration.store.conversation is original+ assert orchestration.store.events == ["read source", "generate", "read conversation"]+++def test_conversation_deleted_during_generation_is_not_recreated(orchestration: _Orchestration) -> None:+ def remove_conversation() -> None:+ orchestration.store.conversation = None++ orchestration.generation_action = remove_conversation+ with pytest.raises(ConversationNotExistsError):+ orchestration.rename()+ assert orchestration.store.conversation is None+ assert orchestration.store.events == ["read source", "generate", "rename"]+++def test_manual_rename_updates_timestamp_without_generating(orchestration: _Orchestration) -> None:+ result = orchestration.rename(name="User title", auto_generate=False)+ assert result.name == "User title"+ assert result.updated_at is not None+ assert result.updated_at > _UPDATED_AT+ assert orchestration.store.events == ["rename"]+++def test_manual_rename_requires_name_before_writing(orchestration: _Orchestration) -> None:+ with pytest.raises(ConversationNameRequiredError):+ orchestration.rename(auto_generate=False)+ assert orchestration.store.events == []+++def test_cleanup_uses_deleted_app_owner_and_retired_workspaces_after_commit(orchestration: _Orchestration) -> None:+ orchestration.delete()+ assert orchestration.store.events == ["delete committed", "enqueue"]+ assert orchestration.cleanup_calls == [+ (_OWNER_TENANT_ID, _CONVERSATION_ID, ("retired-workspace-1", "retired-workspace-2"))+ ]+++def test_delete_transaction_failure_does_not_enqueue_cleanup(orchestration: _Orchestration) -> None:+ original = orchestration.store.conversation+ orchestration.store.delete_error = RuntimeError("commit failed")+ with pytest.raises(RuntimeError, match="commit failed"):+ orchestration.delete()+ assert orchestration.store.conversation is original+ assert orchestration.cleanup_calls == []++[email protected]("mode", ["completion", "workflow", "agent", "unknown"])+def test_non_chat_admission_snapshot_is_rejected_before_persistence(orchestration: _Orchestration, mode: str) -> None:+ assert orchestration.service is not None+ with pytest.raises(ConversationNotChatAppError):+ orchestration.service.delete(+ installed_app=replace(_REF, app_mode=mode), account_id=_ACCOUNT_ID, conversation_id=_CONVERSATION_ID+ )+ assert orchestration.store.events == []+ assert orchestration.store.conversation is not None+ assert orchestration.cleanup_calls == []