Skip to content

armgit / dify

Public Imported from GitHub
0

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

refactor(api): isolate installed app conversations (#41971)

非法操作53aa73e4168e
diff --git a/api/.importlinter b/api/.importlinter
index dfc2451770f..f1fb5726f27 100644
--- a/api/.importlinter
+++ b/api/.importlinter
@@ -224,6 +224,32 @@ forbidden_modules =
sqlalchemy
werkzeug
+[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 neutral
type = forbidden
diff --git a/api/controllers/console/explore/completion.py b/api/controllers/console/explore/completion.py
index 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_mode
if 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.py
index 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 wraps
from 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_validator
from controllers.common.controller_schemas import ConversationRenamePayload
from 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 RequestContext
from 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, ConversationNotChatAppError
class 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.py
index 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.py
index 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 NotFound
from controllers.common.controller_schemas import SavedMessageCreatePayload, SavedMessageListQuery
from controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_models
from controllers.console import console_ns
-from controllers.console.app.error import AppUnavailableError
from controllers.console.explore.error import NotCompletionAppError
from controllers.console.explore.installed_app_admission import get_installed_app
from controllers.console.flask_admission import console_account_admission
@@ -16,7 +15,6 @@ from fields.conversation_fields import ResultResponse
from fields.message_fields import SavedMessageInfiniteScrollPagination
from libs.helper import dump_response
from machinery.context import RequestContext
-from services.app_definition_query_service import AppDefinitionUnavailableError
from services.errors.message import MessageNotExistsError
from services.installed_app_access_service import InstalledAppRef
from services.saved_message_service import SavedMessageActor
@@ -26,15 +24,9 @@ register_response_schema_models(console_ns, ResultResponse, SavedMessageInfinite
def _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.py
index 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.py
new file mode 100644
index 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.py
index 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 DifyAPIRepositoryFactory
from repositories.file_grant_repository import FileGrantRepository
from repositories.human_input_file_upload_repository import SQLAlchemyHumanInputFileUploadRepository
from repositories.installation_state_repository import InstallationStateRepository
+from repositories.installed_app_conversation_repository import SQLAlchemyInstalledAppConversationRepository
from repositories.installed_app_repository import SQLAlchemyInstalledAppRepository
from repositories.message_file_preview_repository import MessageFilePreviewQueryRepository
from repositories.oauth_access_token_repository import SQLAlchemyOAuthAccessTokenRepository
@@ -168,6 +169,7 @@ from services.auth.data_source_api_key_auth_service import DataSourceApiKeyAuthS
from services.billing_portal_service import BillingPortalService
from services.billing_service import BillingService
from services.compliance_download_service import ComplianceDownloadService
+from services.conversation_service import ConversationService
from services.data_source_oauth_service import DataSourceOAuthService, InvalidDataSourceOAuthProviderError
from services.enterprise.enterprise_service import EnterpriseService
from services.entities.file_grant_entities import FileGrantLimits
@@ -182,6 +184,7 @@ from services.human_input_file_upload_service import HumanInputFileUploadService
from services.init_validation_service import InitValidationService
from services.inner_mail_service import InnerMailService
from services.installed_app_access_service import InstalledAppAccessService
+from services.installed_app_conversation_service import InstalledAppConversationService
from services.installed_app_generation_adapters import AppGenerateServiceRuntime as InstalledAppGenerateServiceRuntime
from services.installed_app_generation_service import InstalledAppGenerationService
from 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: OAuthDeviceApplicationService
init_validation: InitValidationService
installed_app_access: InstalledAppAccessService
+ installed_app_conversations: InstalledAppConversationService
installed_app_generation: InstalledAppGenerationService
installed_apps: InstalledAppService
notifications: 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.py
new file mode 100644
index 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 retired
diff --git a/api/repositories/conversation_lifecycle.py b/api/repositories/conversation_lifecycle.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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
+ )
@override
def record(self, *, installed_app: InstalledAppRef, used_at: datetime) -> None:
diff --git a/api/services/agent/workspace_service.py b/api/services/agent/workspace_service.py
index 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 annotations
import logging
-from dataclasses import dataclass
from dify_agent.client import Client
from dify_agent.protocol import CreateExecutionBindingRequest, DestroyExecutionBindingRequest
@@ -18,6 +17,12 @@ from sqlalchemy.orm import Session
from clients.agent_backend.factory import create_agent_backend_client
from configs import dify_config
+from core.agent.workspace import (
+ AgentWorkspaceBindingGenerationMismatchError,
+ AgentWorkspaceError,
+ AgentWorkspaceNotFoundError,
+ WorkspaceOwnerScope,
+)
from core.db.session_factory import session_factory
from libs.datetime_utils import naive_utc_now
from libs.uuid_utils import uuidv7
@@ -27,33 +32,12 @@ from models.agent import (
AgentWorkingResourceStatus,
AgentWorkspace,
AgentWorkspaceBinding,
- AgentWorkspaceOwnerType,
)
+from repositories.agent_workspace_repository import AgentWorkspaceRepository
logger = 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:
@classmethod
def 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
@classmethod
def 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
+ )
@classmethod
def collect_retired_binding(cls, *, tenant_id: str, binding_id: str) -> None:
diff --git a/api/services/conversation_service.py b/api/services/conversation_service.py
index de73a7cf32f..fda23414051 100644
--- a/api/services/conversation_service.py
+++ b/api/services/conversation_service.py
@@ -15,9 +15,8 @@ from graphon.variables.types import SegmentType
from libs.datetime_utils import naive_utc_now
from libs.infinite_scroll_pagination import InfiniteScrollPagination
from models import Account, ConversationVariable
-from models.agent import AgentWorkspaceOwnerType
from models.model import App, Conversation, EndUser, Message
-from services.agent.workspace_service import AgentWorkspaceNotFoundError, AgentWorkspaceService, WorkspaceOwnerScope
+from repositories.conversation_lifecycle import retire_conversation
from 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 message
message = 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 = name
session.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)
+
@classmethod
def 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_id
try:
- 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)
@classmethod
def get_conversational_variable(
diff --git a/api/services/installed_app_access_service.py b/api/services/installed_app_access_service.py
index 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: str
app_id: str
tenant_id: str
+ app_mode: str
class InstalledAppAccessStore(Protocol):
diff --git a/api/services/installed_app_conversation_service.py b/api/services/installed_app_conversation_service.py
new file mode 100644
index 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 mode
diff --git a/api/services/installed_app_generation_service.py b/api/services/installed_app_generation_service.py
index 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 datetime
from typing import Protocol
from libs.datetime_utils import naive_utc_now
-from services.app_definition_query_service import AppDefinitionQueryService
from 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_definitions
self._usage: InstalledAppUsageRecorder = usage
self._runtime: InstalledAppGenerationRuntime = runtime
def 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.py
deleted file mode 100644
index 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.py
index 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_module
from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
from graphon.model_runtime.errors.invoke import InvokeError
from models import AppMode, Conversation, Tenant
-from repositories.app_definition_query_repository import AppDefinitionQueryRepository
from repositories.installed_app_repository import SQLAlchemyInstalledAppRepository
from services.account_errors import AccountNotFoundError
-from services.app_definition_query_service import AppDefinitionQueryService
from services.app_generate_service import AppGenerateService
from services.errors.app_model_config import AppModelConfigBrokenError
from 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.py
new file mode 100644
index 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.py
index 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 ExternalApi
from machinery.context import RequestContext
from models import Account, App, AppMode, InstalledApp, Tenant
from models.account import AccountStatus
-from repositories.app_definition_query_repository import AppDefinitionQueryRepository
from repositories.installed_app_repository import SQLAlchemyInstalledAppRepository
-from services.app_definition_query_service import AppDefinitionQueryService
from services.app_task_service import AppTaskControlService
from services.installed_app_access_service import InstalledAppAccessService, InstalledAppRef
from services.saved_message_service import SavedMessageActor, SavedMessagePage, SavedMessageRecord, SavedMessageService
@@ -441,10 +439,6 @@ class _AppDefinitions:
app_id: str
parameters: 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_id
return 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: AppDefinitionQueryService
app_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_command
response = 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.py
index 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_module
from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
from graphon.model_runtime.errors.invoke import InvokeError
from models import App, AppMode, InstalledApp, Tenant
-from repositories.app_definition_query_repository import AppDefinitionQueryRepository
from repositories.installed_app_repository import SQLAlchemyInstalledAppRepository
from services.account_errors import AccountNotFoundError
-from services.app_definition_query_service import AppDefinitionQueryService
+from services.app_generate_service import AppGenerateService
from services.errors.app_model_config import AppModelConfigBrokenError
from services.errors.conversation import ConversationCompletedError, ConversationNotExistsError
+from services.installed_app_generation_adapters import AppGenerateServiceRuntime
from services.installed_app_generation_service import GenerationResponse, InstalledAppGenerationService
from 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(
+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_AT
else:
_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.py
index 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.py
index 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 Flask
from werkzeug.exceptions import NotFound
import controllers.console.explore.saved_message as module
-from controllers.console.app.error import AppUnavailableError
from controllers.console.explore.error import NotCompletionAppError
from graphon.file import File, FileTransferMethod, FileType
from libs.external_api import ExternalApi
@@ -34,7 +33,6 @@ _WORKSPACE_ID = "22222222-2222-4222-8222-222222222222"
@dataclass(frozen=True)
class _ApplicationServiceMocks:
- app_definitions: MagicMock
installed_app_access: MagicMock
saved_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.fixture
def 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.py
index 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_module
from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
from graphon.model_runtime.errors.invoke import InvokeError
from models import App, AppMode, InstalledApp, Tenant
-from repositories.app_definition_query_repository import AppDefinitionQueryRepository
from repositories.installed_app_repository import SQLAlchemyInstalledAppRepository
from 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 AppGenerateService
from services.app_task_service import AppTaskControlService
from services.errors.llm import InvokeRateLimitError
+from services.installed_app_generation_adapters import AppGenerateServiceRuntime
from services.installed_app_generation_service import GenerationResponse, InstalledAppGenerationService
from 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: AppDefinitionQueryService
app_tasks: AppTaskControlService
@@ -91,17 +91,11 @@ def runtime(
assert installation is not None
installation.last_used_at = _LAST_USED_AT
runtime = _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_after
session.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.py
index 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 json
import logging
from collections.abc import Mapping
+from decimal import Decimal
from io import BytesIO
from types import SimpleNamespace
from typing import cast
@@ -15,14 +16,29 @@ from flask import Flask
from sqlalchemy import event, select
from 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_metadata
from core.tools.tool_file_manager import ToolFileManager
from enums import DeploymentEdition, WebAppAccessMode
from extensions import ext_application_services
+from extensions.ext_database import db
from extensions.ext_redis import RedisClientWrapper
from machinery.context import RequestContext
from models.account import Account, Tenant, TenantAccountJoin, TenantAccountRole
from 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 SQLAlchemyAccountActivationRepository
from repositories.account_integration_repository import SQLAlchemyAccountIntegrationRepository
from repositories.account_oauth_repository import (
@@ -103,6 +119,7 @@ from services.webapp_access_query_service import WebAppAccessQueryService, WebAp
from services.workflow_app_log_query_service import WorkflowAppLogQueryService
from services.workflow_run_service import WorkflowRunService
from services.workflow_statistic_query_service import WorkflowStatisticQueryService
+from tasks.delete_conversation_task import delete_conversation_related_data
from tests.unit_tests.config_override import apply_config_overrides
from 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_apps
assert isinstance(installed_apps, SQLAlchemyInstalledAppRepository)
assert services.installed_app_generation._usage is installed_apps
- assert services.installed_app_generation._app_definitions is services.app_definitions
runtime = services.installed_app_generation._runtime
assert 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_curre
enterprise_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.py
new file mode 100644
index 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.ACTIVE
diff --git a/api/tests/unit_tests/repositories/test_installed_app_conversation_repository.py b/api/tests/unit_tests/repositories/test_installed_app_conversation_repository.py
new file mode 100644
index 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.py
index 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 uuid4
import pytest
from sqlalchemy import event, inspect
-from sqlalchemy.orm import Session, sessionmaker
+from sqlalchemy.orm import ORMExecuteState, Session, sessionmaker
from models.model import App, AppMode, AppModelConfig, IconType, InstalledApp
from 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.id
repository = 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 == 2
assert inspect(result, raiseerr=False) is None
with 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]) -> InstalledApp
def _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.py
index 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 Decimal
from unittest.mock import MagicMock
import pytest
@@ -15,18 +17,24 @@ from sqlalchemy import asc, desc, event
from sqlalchemy.orm import Session
from 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_metadata
from libs.datetime_utils import naive_utc_now
from models import Account, ConversationVariable
from 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_conversation
from services import conversation_service
-from services.agent.workspace_service import AgentWorkspaceService
+from services.agent.workspace_service import AgentWorkspaceNotFoundError, WorkspaceOwnerScope
from services.conversation_service import ConversationService
+from services.errors.message import MessageNotExistsError
TENANT_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_workspace
app = 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_workspace
app = ConversationServiceTestDataFactory.create_app()
+ account = ConversationServiceTestDataFactory.create_account()
conversation = ConversationServiceTestDataFactory.create_conversation()
- conversation.agent_workspace_binding_id = "binding-1"
+ conversation.agent_workspace_binding_id = binding.id
sqlite_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.RETIRED
enqueue_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.ACTIVE
def 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 None
assert 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.py
index 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.py
new file mode 100644
index 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 == []