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): share conversation rename service and repository (#43991)

非法操作55501cf62bfb
diff --git a/api/.importlinter b/api/.importlinter
index ef4c3cce922..9545ecbb7f9 100644
--- a/api/.importlinter
+++ b/api/.importlinter
@@ -416,7 +416,7 @@ forbidden_modules =
name = Conversation persistence does not call legacy conversation or workspace services
type = forbidden
source_modules =
- repositories.installed_app_conversation_repository
+ repositories.conversation_repository
repositories.conversation_lifecycle
repositories.agent_workspace_repository
forbidden_modules =
@@ -1039,6 +1039,21 @@ forbidden_modules =
sqlalchemy
werkzeug
+[importlinter:contract:conversation-name-boundary]
+name = Conversation naming policy is framework and persistence neutral
+type = forbidden
+source_modules =
+ services.conversation_name_service
+forbidden_modules =
+ controllers
+ extensions
+ flask
+ models
+ repositories
+ services.conversation_service
+ sqlalchemy
+ werkzeug
+
[importlinter:contract:billing-application-boundary]
name = Billing application services and ports are framework and infrastructure neutral
type = forbidden
diff --git a/api/controllers/common/errors.py b/api/controllers/common/errors.py
index a0ce8fc9e41..2985a625f42 100644
--- a/api/controllers/common/errors.py
+++ b/api/controllers/common/errors.py
@@ -93,6 +93,18 @@ class NotFoundError(BaseHTTPException):
code = 404
+class ConversationNotFoundHTTPError(BaseHTTPException):
+ error_code = "conversation_not_found"
+ description = "The conversation was not found for this user and app."
+ code = HTTPStatus.NOT_FOUND
+
+
+class ConversationFirstMessageNotFoundHTTPError(BaseHTTPException):
+ error_code = "conversation_first_message_not_found"
+ description = "The conversation has no message from which to generate a name."
+ code = HTTPStatus.NOT_FOUND
+
+
class MessageFeedbackRatingRequiredError(BaseHTTPException):
error_code = "message_feedback_rating_required"
description = "A rating is required when there is no existing feedback to remove."
diff --git a/api/controllers/console/explore/conversation.py b/api/controllers/console/explore/conversation.py
index 5899932bc96..7b62e3d3f73 100644
--- a/api/controllers/console/explore/conversation.py
+++ b/api/controllers/console/explore/conversation.py
@@ -27,10 +27,11 @@ from fields.conversation_fields import ConversationInfiniteScrollPagination, Res
from libs.external_api import error_responses
from libs.helper import UUIDStrOrEmpty, dump_response
from machinery.context import RequestContext
+from services.conversation_name_service import ConversationNameRequiredError
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 ConversationNameRequiredError, ConversationNotChatAppError
+from services.installed_app_conversation_service import ConversationNotChatAppError
class ConversationListQuery(BaseModel):
diff --git a/api/controllers/service_api/app/conversation.py b/api/controllers/service_api/app/conversation.py
index f1b7ffe6ed2..27d5a47c854 100644
--- a/api/controllers/service_api/app/conversation.py
+++ b/api/controllers/service_api/app/conversation.py
@@ -1,4 +1,5 @@
from datetime import datetime
+from http import HTTPStatus
from typing import Annotated, Any, Literal
from uuid import UUID
@@ -9,13 +10,16 @@ from werkzeug.exceptions import BadRequest, NotFound
import services
from controllers.common.controller_schemas import ConversationRenamePayload
+from controllers.common.errors import ConversationFirstMessageNotFoundHTTPError, ConversationNotFoundHTTPError
from controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_models
from controllers.console.wraps import model_validate
from controllers.service_api import service_api_ns
from controllers.service_api.app.error import NotChatAppError
+from controllers.service_api.flask_admission import service_api_end_user_admission
from controllers.service_api.schema import expect_user_json, expect_with_user
from controllers.service_api.wraps import FetchUserArg, WhereisUserArg, validate_app_token
from core.app.entities.app_invoke_entities import InvokeFrom
+from extensions.ext_application_services import application_services
from extensions.ext_database import db
from fields._value_type_serializer import serialize_value_type
from fields.base import ResponseModel
@@ -27,8 +31,11 @@ from fields.conversation_fields import (
from graphon.variables.types import SegmentType
from libs.external_api import error_responses
from libs.helper import UUIDStrOrEmpty, dump_response, to_timestamp
+from machinery.context import ServiceApiEndUserContext
from models.model import App, AppMode, EndUser
from services.conversation_service import ConversationService
+from services.entities.conversation_entities import EndUserConversationRef
+from services.errors.message import MessageNotExistsError
UUIDString = Annotated[str, WithJsonSchema({"format": "uuid", "type": "string"})]
Int64 = Annotated[int, WithJsonSchema({"format": "int64", "type": "integer"})]
@@ -266,7 +273,7 @@ class ConversationDetailApi(Resource):
@service_api_ns.route("/conversations/<uuid:conversation_id>/name")
class ConversationRenameApi(Resource):
- @error_responses(NotChatAppError)
+ @error_responses(NotChatAppError, ConversationNotFoundHTTPError, ConversationFirstMessageNotFoundHTTPError)
@service_api_ns.doc(
summary="Rename Conversation",
description=(
@@ -275,45 +282,55 @@ class ConversationRenameApi(Resource):
),
tags=["Conversations"],
responses={
- 200: "Conversation renamed successfully.",
- 400: "`not_chat_app` : App mode does not match the API route.",
- 404: "`not_found` : Conversation does not exist.",
+ HTTPStatus.OK: "Conversation renamed successfully; model failure preserves the existing name.",
+ HTTPStatus.BAD_REQUEST: "Invalid app selection or app mode does not match the API route.",
+ HTTPStatus.UNAUTHORIZED: "Invalid API credentials.",
+ HTTPStatus.FORBIDDEN: "API credential, app or workspace access is unavailable.",
+ HTTPStatus.NOT_FOUND: (
+ "`conversation_not_found`: Conversation does not exist. "
+ "`conversation_first_message_not_found`: No first message is available for automatic naming."
+ ),
+ HTTPStatus.UNPROCESSABLE_ENTITY: "Invalid conversation rename payload.",
},
)
@expect_with_user(service_api_ns, ConversationRenamePayload)
@service_api_ns.doc("rename_conversation")
@service_api_ns.doc(description="Rename a conversation or auto-generate a name")
@service_api_ns.doc(params={"conversation_id": "Conversation ID."})
- @service_api_ns.doc(
- responses={
- 200: "Conversation renamed successfully",
- 401: "Unauthorized - invalid API token",
- 404: "Conversation not found",
- }
- )
@service_api_ns.response(
- 200,
+ HTTPStatus.OK,
"Conversation renamed successfully",
service_api_ns.models[SimpleConversation.__name__],
)
- @validate_app_token(fetch_user_arg=FetchUserArg(fetch_from=WhereisUserArg.JSON))
+ @service_api_end_user_admission(fetch_user_arg=FetchUserArg(fetch_from=WhereisUserArg.JSON))
@model_validate(ConversationRenamePayload)
- def post(self, payload: ConversationRenamePayload, app_model: App, end_user: EndUser, conversation_id: UUID):
+ def post(
+ self, payload: ConversationRenamePayload, context: ServiceApiEndUserContext, conversation_id: UUID
+ ) -> dict[str, object]:
"""Rename a conversation or auto-generate a name."""
- app_mode = AppMode.value_of(app_model.mode)
+ app_mode = AppMode.value_of(context.app_mode)
if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}:
raise NotChatAppError()
conversation_id_str = str(conversation_id)
try:
- session = db.session()
- conversation = ConversationService.rename(
- app_model, conversation_id_str, end_user, payload.name, payload.auto_generate, session=session
+ conversation = application_services().conversation_names.rename(
+ ref=EndUserConversationRef(
+ app_id=context.app_id,
+ tenant_id=context.tenant_id,
+ end_user_id=context.end_user_id,
+ conversation_id=conversation_id_str,
+ ),
+ app_mode=context.app_mode,
+ name=payload.name,
+ auto_generate=payload.auto_generate,
)
- return dump_response(SimpleConversation, ConversationResponseSource(conversation, session=session))
- except services.errors.conversation.ConversationNotExistsError as caught_error:
- raise NotFound("Conversation Not Exists.") from caught_error
+ return dump_response(SimpleConversation, conversation)
+ except services.errors.conversation.ConversationNotExistsError as error:
+ raise ConversationNotFoundHTTPError() from error
+ except MessageNotExistsError as error:
+ raise ConversationFirstMessageNotFoundHTTPError() from error
@service_api_ns.route("/conversations/<uuid:conversation_id>/variables")
diff --git a/api/controllers/web/conversation.py b/api/controllers/web/conversation.py
index 774b299706b..f84b0782673 100644
--- a/api/controllers/web/conversation.py
+++ b/api/controllers/web/conversation.py
@@ -1,3 +1,4 @@
+from http import HTTPStatus
from typing import Literal
from uuid import UUID
@@ -7,12 +8,14 @@ from sqlalchemy.orm import sessionmaker
from werkzeug.exceptions import NotFound
from controllers.common.controller_schemas import ConversationRenamePayload
+from controllers.common.errors import ConversationFirstMessageNotFoundHTTPError, ConversationNotFoundHTTPError
from controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_models
from controllers.console.wraps import model_validate
from controllers.web import web_ns
from controllers.web.error import NotChatAppError
from controllers.web.wraps import WebApiResource
from core.app.entities.app_invoke_entities import InvokeFrom
+from extensions.ext_application_services import application_services
from extensions.ext_database import db
from fields.conversation_fields import (
ConversationInfiniteScrollPagination,
@@ -21,10 +24,12 @@ from fields.conversation_fields import (
SimpleConversation,
)
from libs.external_api import error_responses
-from libs.helper import uuid_value
+from libs.helper import dump_response, uuid_value
from models.model import App, AppMode, EndUser
from services.conversation_service import ConversationService
+from services.entities.conversation_entities import EndUserConversationRef
from services.errors.conversation import ConversationNotExistsError, LastConversationNotExistsError
+from services.errors.message import MessageNotExistsError
from services.web_conversation_service import WebConversationService
@@ -129,7 +134,7 @@ class ConversationApi(WebApiResource):
@web_ns.route("/conversations/<uuid:c_id>/name")
class ConversationRenameApi(WebApiResource):
- @error_responses(NotChatAppError)
+ @error_responses(NotChatAppError, ConversationNotFoundHTTPError, ConversationFirstMessageNotFoundHTTPError)
@web_ns.doc("Rename Conversation")
@web_ns.doc(description="Rename a specific conversation with a custom name or auto-generate one.")
@web_ns.doc(params={"c_id": {"description": "Conversation UUID", "type": "string", "required": True}})
@@ -146,17 +151,23 @@ class ConversationRenameApi(WebApiResource):
)
@web_ns.doc(
responses={
- 200: "Conversation renamed successfully",
- 400: "Bad Request",
- 401: "Unauthorized",
- 404: "Conversation Not Found or Not a Chat App",
- 500: "Internal Server Error",
+ HTTPStatus.OK: "Conversation renamed successfully; model failure preserves the existing name.",
+ HTTPStatus.BAD_REQUEST: "Bad Request",
+ HTTPStatus.UNAUTHORIZED: "Unauthorized",
+ HTTPStatus.NOT_FOUND: (
+ "`conversation_not_found`: Conversation does not exist. "
+ "`conversation_first_message_not_found`: No first message is available for automatic naming."
+ ),
+ HTTPStatus.UNPROCESSABLE_ENTITY: "Invalid conversation rename payload.",
+ HTTPStatus.INTERNAL_SERVER_ERROR: "Internal Server Error",
}
)
- @web_ns.response(200, "Conversation renamed successfully", web_ns.models[SimpleConversation.__name__])
+ @web_ns.response(HTTPStatus.OK, "Conversation renamed successfully", web_ns.models[SimpleConversation.__name__])
@web_ns.expect(web_ns.models[ConversationRenamePayload.__name__])
@model_validate(ConversationRenamePayload)
- def post(self, payload: ConversationRenamePayload, app_model: App, end_user: EndUser, c_id: UUID):
+ def post(
+ self, payload: ConversationRenamePayload, app_model: App, end_user: EndUser, c_id: UUID
+ ) -> dict[str, object]:
app_mode = AppMode.value_of(app_model.mode)
if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT}:
raise NotChatAppError()
@@ -164,17 +175,22 @@ class ConversationRenameApi(WebApiResource):
conversation_id = str(c_id)
try:
- session = db.session()
- conversation = ConversationService.rename(
- app_model, conversation_id, end_user, payload.name, payload.auto_generate, session=session
- )
- return (
- TypeAdapter(SimpleConversation)
- .validate_python(ConversationResponseSource(conversation, session=session), from_attributes=True)
- .model_dump(mode="json")
+ conversation = application_services().conversation_names.rename(
+ ref=EndUserConversationRef(
+ app_id=app_model.id,
+ tenant_id=app_model.tenant_id,
+ end_user_id=end_user.id,
+ conversation_id=conversation_id,
+ ),
+ app_mode=app_model.mode,
+ name=payload.name,
+ auto_generate=payload.auto_generate,
)
- except ConversationNotExistsError as caught_error:
- raise NotFound("Conversation Not Exists.") from caught_error
+ return dump_response(SimpleConversation, conversation)
+ except ConversationNotExistsError as error:
+ raise ConversationNotFoundHTTPError() from error
+ except MessageNotExistsError as error:
+ raise ConversationFirstMessageNotFoundHTTPError() from error
@web_ns.route("/conversations/<uuid:c_id>/pin")
diff --git a/api/core/llm_generator/llm_generator.py b/api/core/llm_generator/llm_generator.py
index 09758157e71..dcec1b65b54 100644
--- a/api/core/llm_generator/llm_generator.py
+++ b/api/core/llm_generator/llm_generator.py
@@ -23,7 +23,7 @@ from core.llm_generator.prompts import (
WORKFLOW_RULE_CONFIG_PROMPT_GENERATE_TEMPLATE,
)
from core.model_context import with_credit_usage_created_by
-from core.model_manager import ModelManager
+from core.model_manager import ModelInstance, ModelManager
from core.ops.entities.trace_entity import TraceTaskName
from core.ops.ops_trace_manager import TraceQueueManager, TraceTask
from core.ops.utils import measure_time
@@ -181,11 +181,18 @@ class LLMGenerator:
def generate_conversation_name(
cls,
tenant_id: str,
- query,
+ query: str,
conversation_id: str | None = None,
app_id: str | None = None,
message_id: str | None = None,
- ):
+ *,
+ model_instance: ModelInstance | None = None,
+ ) -> str:
+ """Generate with a resolved model, or resolve it for legacy background callers.
+
+ Passing a model lets the caller close its preparation session before invocation.
+ ``None`` retains inline resolution for the first-message naming worker.
+ """
prompt = CONVERSATION_TITLE_PROMPT
if len(query) > 2000:
@@ -195,11 +202,12 @@ class LLMGenerator:
prompt += query + "\n"
- model_manager = ModelManager.for_tenant(tenant_id=tenant_id)
- model_instance = model_manager.get_default_model_instance(
- tenant_id=tenant_id,
- model_type=ModelType.LLM,
- )
+ if model_instance is None:
+ model_manager = ModelManager.for_tenant(tenant_id=tenant_id)
+ model_instance = model_manager.get_default_model_instance(
+ tenant_id=tenant_id,
+ model_type=ModelType.LLM,
+ )
prompts: list[PromptMessage] = [UserPromptMessage(content=prompt)]
with measure_time() as timer:
diff --git a/api/extensions/application_services/installed_app.py b/api/extensions/application_services/installed_app.py
index 81654b40259..c729e676fbc 100644
--- a/api/extensions/application_services/installed_app.py
+++ b/api/extensions/application_services/installed_app.py
@@ -2,14 +2,13 @@
from dataclasses import dataclass
-from flask import current_app
from sqlalchemy.orm import Session, sessionmaker
-from repositories.installed_app_conversation_repository import SQLAlchemyInstalledAppConversationRepository
from repositories.installed_app_repository import SQLAlchemyInstalledAppRepository
+from services.conversation_name_service import ConversationNameService
from services.conversation_service import ConversationService
from services.installed_app_access_service import InstalledAppAccessService
-from services.installed_app_conversation_service import InstalledAppConversationService
+from services.installed_app_conversation_service import InstalledAppConversationService, InstalledAppConversationStore
from services.installed_app_generation_adapters import AppGenerateServiceRuntime
from services.installed_app_generation_service import InstalledAppGenerationService
from services.installed_app_service import InstalledAppService, WorkspaceRoleLookup
@@ -24,21 +23,11 @@ class InstalledAppServices:
conversations: InstalledAppConversationService
-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
- )
-
-
def build_installed_app_services(
*,
database_client: sessionmaker[Session],
+ conversations: InstalledAppConversationStore,
+ conversation_names: ConversationNameService,
webapp_access: WebAppAccessQueryService,
get_workspace_role: WorkspaceRoleLookup,
webapp_auth_enabled: bool,
@@ -62,8 +51,8 @@ def build_installed_app_services(
runtime=AppGenerateServiceRuntime(session_factory=database_client),
),
conversations=InstalledAppConversationService(
- conversations=SQLAlchemyInstalledAppConversationRepository(session_factory=database_client),
- generate_name=_generate_installed_app_conversation_name,
+ conversations=conversations,
+ names=conversation_names,
enqueue_delete_cleanup=ConversationService.enqueue_delete_cleanup,
),
)
diff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.py
index a22eb875aa2..a31ccbe8da6 100644
--- a/api/extensions/ext_application_services.py
+++ b/api/extensions/ext_application_services.py
@@ -67,6 +67,7 @@ from repositories.app_definition_query_repository import AppDefinitionQueryRepos
from repositories.app_preview_query_repository import AppPreviewQueryRepository
from repositories.app_scoped_end_user_repository import AppScopedEndUserRepo
from repositories.app_statistic_query_repository import AppStatisticQueryRepository
+from repositories.conversation_repository import ConversationRepository
from repositories.conversation_variable_query_repository import ConversationVariableQueryRepository
from repositories.credentials.query_repository import CredentialQueryRepository
from repositories.explore_banner_query_repository import ExploreBannerQueryRepository
@@ -135,6 +136,8 @@ from services.app_tracing_config_service import AppTracingConfigService
from services.billing_portal_service import BillingPortalService
from services.billing_service import BillingService
from services.compliance_download_service import ComplianceDownloadService
+from services.conversation_name_generator import generate_conversation_name
+from services.conversation_name_service import ConversationNameService
from services.conversation_variable_query import ConversationVariableQuery
from services.credentials.query import CredentialQuery
from services.enterprise.enterprise_service import EnterpriseService
@@ -310,6 +313,7 @@ class ApplicationServices:
agent_tracing_configs: AgentTracingConfigService
billing_portal: BillingPortalService
compliance_downloads: ComplianceDownloadService
+ conversation_names: ConversationNameService
data_sources: DataSourceServices
knowledge: KnowledgeServices
app_scoped_end_users: AppScopedEndUserServices
@@ -571,6 +575,8 @@ def build_application_services(
registration=account_services.lifecycle,
invitation_tokens=invitation_tokens,
)
+ conversations = ConversationRepository(session_factory=database_client)
+ conversation_names = ConversationNameService(conversations=conversations, generate_name=generate_conversation_name)
annotations = AnnotationRepository(session_factory=database_client)
messages = MessageRepository(session_factory=database_client)
suggested_questions = SuggestedQuestionsQuery(
@@ -606,6 +612,7 @@ def build_application_services(
disable_task=disable_annotation_reply_task.delay,
),
rbac=rbac,
+ conversation_names=conversation_names,
accounts=account_services,
apps=apps,
credential_queries=CredentialQueryRepository(session_factory=database_client),
@@ -679,6 +686,8 @@ def build_application_services(
private_app_access_enabled=deployment_edition == DeploymentEdition.ENTERPRISE,
),
installed_apps=build_installed_app_services(
+ conversations=conversations,
+ conversation_names=conversation_names,
database_client=database_client,
webapp_access=webapp_access,
get_workspace_role=workspace_repository.get_account_role,
diff --git a/api/openapi/markdown/service-openapi.md b/api/openapi/markdown/service-openapi.md
index e09a2203fab..5f5dc794428 100644
--- a/api/openapi/markdown/service-openapi.md
+++ b/api/openapi/markdown/service-openapi.md
@@ -2342,11 +2342,12 @@ Rename a conversation or auto-generate a name. The conversation name is used for
| Code | Description | Schema |
| ---- | ----------- | ------ |
-| 200 | Conversation renamed successfully. | **application/json**: [SimpleConversation](#simpleconversation)<br> |
-| 400 | `not_chat_app` : App mode does not match the API route. | **application/json**: [NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> |
-| 401 | Unauthorized - invalid API token | **application/json**: [ErrorResponse](#errorresponse)<br> |
-| 403 | Forbidden - token scope, app, dataset, or workspace access denied | **application/json**: [ErrorResponse](#errorresponse)<br> |
-| 404 | `not_found` : Conversation does not exist. | **application/json**: [ErrorResponse](#errorresponse)<br> |
+| 200 | Conversation renamed successfully; model failure preserves the existing name. | **application/json**: [SimpleConversation](#simpleconversation)<br> |
+| 400 | Invalid app selection or app mode does not match the API route. | **application/json**: [NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> |
+| 401 | Invalid API credentials. | **application/json**: [ErrorResponse](#errorresponse)<br> |
+| 403 | API credential, app or workspace access is unavailable. | **application/json**: [AppAbnormalStatusError](#appabnormalstatuserror)<br>[AppApiDisabledError](#appapidisablederror)<br>[AppNotFoundError](#appnotfounderror)<br>[ForbiddenError](#forbiddenerror)<br>[WorkspaceArchivedError](#workspacearchivederror)<br>[WorkspaceNotFoundError](#workspacenotfounderror)<br>[ErrorResponse](#errorresponse)<br> |
+| 404 | `conversation_not_found`: Conversation does not exist. `conversation_first_message_not_found`: No first message is available for automatic naming. | **application/json**: [ConversationFirstMessageNotFoundError](#conversationfirstmessagenotfounderror)<br>[ConversationNotFoundError](#conversationnotfounderror)<br>[ErrorResponse](#errorresponse)<br> |
+| 422 | Invalid conversation rename payload. | **application/json**: [ErrorResponse](#errorresponse)<br> |
| default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |
### [GET] /conversations/{conversation_id}/variables
@@ -4522,6 +4523,14 @@ Condition detail
| name | string | Metadata field name to compare against. | Yes |
| value | string<br>[ string ]<br>number | Value to compare against. Type depends on `comparison_operator`: string for most string operators, array of strings for `in` and `not in`, number for numeric operators, and omit or use `null` for `empty` and `not empty`. | No |
+#### ConversationFirstMessageNotFoundError
+
+The conversation has no message from which to generate a name.
+
+| Name | Type | Description | Required |
+| ---- | ---- | ----------- | -------- |
+| ConversationFirstMessageNotFoundError | | The conversation has no message from which to generate a name. | |
+
#### ConversationInfiniteScrollPagination
| Name | Type | Description | Required |
@@ -4538,6 +4547,14 @@ Condition detail
| limit | integer, <br>**Default:** 20 | Number of records to return. | No |
| sort_by | string, <br>**Available values:** "-created_at", "-updated_at", "created_at", "updated_at", <br>**Default:** -updated_at | Sorting field. Use the `-` prefix for descending order.<br>*Enum:* `"-created_at"`, `"-updated_at"`, `"created_at"`, `"updated_at"` | No |
+#### ConversationNotFoundError
+
+The conversation was not found for this user and app.
+
+| Name | Type | Description | Required |
+| ---- | ---- | ----------- | -------- |
+| ConversationNotFoundError | | The conversation was not found for this user and app. | |
+
#### ConversationRenamePayload
| Name | Type | Description | Required |
diff --git a/api/openapi/markdown/web-openapi.md b/api/openapi/markdown/web-openapi.md
index a2c81c92bc6..e93ab4ff1a4 100644
--- a/api/openapi/markdown/web-openapi.md
+++ b/api/openapi/markdown/web-openapi.md
@@ -174,10 +174,11 @@ Rename a specific conversation with a custom name or auto-generate one.
| Code | Description | Schema |
| ---- | ----------- | ------ |
-| 200 | Conversation renamed successfully | **application/json**: [SimpleConversation](#simpleconversation)<br> |
+| 200 | Conversation renamed successfully; model failure preserves the existing name. | **application/json**: [SimpleConversation](#simpleconversation)<br> |
| 400 | Bad Request | **application/json**: [NotChatAppError](#notchatapperror)<br>[ErrorResponse](#errorresponse)<br> |
| 401 | Unauthorized | **application/json**: [ErrorResponse](#errorresponse)<br> |
-| 404 | Conversation Not Found or Not a Chat App | **application/json**: [ErrorResponse](#errorresponse)<br> |
+| 404 | `conversation_not_found`: Conversation does not exist. `conversation_first_message_not_found`: No first message is available for automatic naming. | **application/json**: [ConversationFirstMessageNotFoundError](#conversationfirstmessagenotfounderror)<br>[ConversationNotFoundError](#conversationnotfounderror)<br>[ErrorResponse](#errorresponse)<br> |
+| 422 | Invalid conversation rename payload. | **application/json**: [ErrorResponse](#errorresponse)<br> |
| 500 | Internal Server Error | **application/json**: [ErrorResponse](#errorresponse)<br> |
| default | Error | **application/json**: [ErrorResponse](#errorresponse)<br> |
@@ -1160,6 +1161,14 @@ Completion request failed.
| ---- | ---- | ----------- | -------- |
| CompletionRequestError | | Completion request failed. | |
+#### ConversationFirstMessageNotFoundError
+
+The conversation has no message from which to generate a name.
+
+| Name | Type | Description | Required |
+| ---- | ---- | ----------- | -------- |
+| ConversationFirstMessageNotFoundError | | The conversation has no message from which to generate a name. | |
+
#### ConversationInfiniteScrollPagination
| Name | Type | Description | Required |
@@ -1177,6 +1186,14 @@ Completion request failed.
| pinned | boolean | | No |
| sort_by | string, <br>**Available values:** "-created_at", "-updated_at", "created_at", "updated_at", <br>**Default:** -updated_at | *Enum:* `"-created_at"`, `"-updated_at"`, `"created_at"`, `"updated_at"` | No |
+#### ConversationNotFoundError
+
+The conversation was not found for this user and app.
+
+| Name | Type | Description | Required |
+| ---- | ---- | ----------- | -------- |
+| ConversationNotFoundError | | The conversation was not found for this user and app. | |
+
#### ConversationRenamePayload
| Name | Type | Description | Required |
diff --git a/api/repositories/installed_app_conversation_repository.py b/api/repositories/conversation_repository.py
similarity index 75%
rename from api/repositories/installed_app_conversation_repository.py
rename to api/repositories/conversation_repository.py
index 69a54d05e11..a036d7c4394 100644
--- a/api/repositories/installed_app_conversation_repository.py
+++ b/api/repositories/conversation_repository.py
@@ -1,44 +1,41 @@
-"""Persist an account's conversations within its admitted installation."""
+"""Persist conversations within their end-user or installed-account owner chain."""
+from copy import deepcopy
from dataclasses import replace
from datetime import datetime
-from typing import cast, override
+from typing import cast
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.model import App, Conversation, EndUser, 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 (
+from services.entities.conversation_entities import (
ConversationDeletion,
ConversationInputValue,
ConversationNameSource,
ConversationPage,
ConversationRecord,
- InstalledAppConversationStore,
+ ConversationRef,
+ InstalledAppConversationRef,
)
+from services.errors.conversation import ConversationNotExistsError, LastConversationNotExistsError
+from services.errors.message import MessageNotExistsError
+from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppRef
-class SQLAlchemyInstalledAppConversationRepository(InstalledAppConversationStore):
+class ConversationRepository:
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:
+ def get(self, *, ref: ConversationRef) -> 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
- )
+ _, conversation = self._resolve(session=session, ref=ref)
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:
@@ -81,43 +78,24 @@ class SQLAlchemyInstalledAppConversationRepository(InstalledAppConversationStore
),
)
- @override
- def get_name_source(
- self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str
- ) -> ConversationNameSource:
+ def get_name_source(self, *, ref: ConversationRef) -> 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)
+ app, conversation = self._resolve(session=session, ref=ref)
+ query = session.scalar(
+ select(Message.query)
.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,
- )
+ if query is None:
+ raise MessageNotExistsError(
+ f"Conversation {ref.conversation_id} has no message to generate a name from."
+ )
+ return ConversationNameSource(tenant_id=app.tenant_id, query=query)
- @override
- def rename(
- self,
- *,
- installed_app: InstalledAppRef,
- account_id: str,
- conversation_id: str,
- name: str,
- updated_at: datetime | None,
- ) -> ConversationRecord:
+ def rename(self, *, ref: ConversationRef, 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
- )
+ _, conversation = self._resolve(session=session, ref=ref)
record = self._to_record(conversation=conversation, session=session)
conversation.name = name
if updated_at is not None:
@@ -126,7 +104,6 @@ class SQLAlchemyInstalledAppConversationRepository(InstalledAppConversationStore
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)
@@ -140,7 +117,6 @@ class SQLAlchemyInstalledAppConversationRepository(InstalledAppConversationStore
retired_workspace_ids=retired_workspace_ids,
)
- @override
def set_pinned(
self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str, is_pinned: bool
) -> None:
@@ -173,6 +149,38 @@ class SQLAlchemyInstalledAppConversationRepository(InstalledAppConversationStore
elif pin is not None:
session.delete(pin)
+ @classmethod
+ def _resolve(cls, *, session: Session, ref: ConversationRef) -> tuple[App, Conversation]:
+ if isinstance(ref, InstalledAppConversationRef):
+ app = cls._get_app(session=session, installed_app=ref.installed_app)
+ conversation = cls._get_conversation(
+ session=session, app_id=app.id, account_id=ref.account_id, conversation_id=ref.conversation_id
+ )
+ return app, conversation
+
+ result = session.execute(
+ select(App, Conversation)
+ .join(Conversation, Conversation.app_id == App.id)
+ .join(
+ EndUser,
+ (EndUser.id == ref.end_user_id) & (EndUser.app_id == App.id) & (EndUser.tenant_id == App.tenant_id),
+ )
+ .where(
+ App.id == ref.app_id,
+ App.tenant_id == ref.tenant_id,
+ Conversation.id == ref.conversation_id,
+ Conversation.from_source == ConversationFromSource.API,
+ Conversation.from_end_user_id == ref.end_user_id,
+ Conversation.from_account_id.is_(None),
+ Conversation.is_deleted.is_(False),
+ )
+ ).one_or_none()
+ if result is None:
+ raise ConversationNotExistsError(
+ f"Conversation {ref.conversation_id} does not belong to this end user and app."
+ )
+ return result[0], result[1]
+
@staticmethod
def _get_app(*, session: Session, installed_app: InstalledAppRef) -> App:
app = session.scalar(
@@ -214,7 +222,7 @@ class SQLAlchemyInstalledAppConversationRepository(InstalledAppConversationStore
return ConversationRecord(
id=conversation.id,
name=conversation.name,
- inputs=cast(dict[str, ConversationInputValue], conversation.inputs_with_session(session=session)),
+ inputs=deepcopy(cast(dict[str, ConversationInputValue], conversation.inputs_with_session(session=session))),
status=conversation.status,
introduction=conversation.introduction,
created_at=conversation.created_at,
diff --git a/api/services/conversation_name_generator.py b/api/services/conversation_name_generator.py
new file mode 100644
index 00000000000..441ceae8eaf
--- /dev/null
+++ b/api/services/conversation_name_generator.py
@@ -0,0 +1,33 @@
+"""Prepare a conversation-title model separately from its invocation."""
+
+from flask import current_app
+
+from core.app.entities.app_invoke_entities import get_credit_usage_app_type
+from core.credit_usage import CreditUsageCreatedBy
+from core.llm_generator.llm_generator import LLMGenerator
+from core.model_context import use_credit_usage_metadata
+from core.model_manager import ModelManager
+from extensions.ext_database import db
+from graphon.model_runtime.entities.model_entities import ModelType
+
+
+def generate_conversation_name(*, tenant_id: str, app_id: str, conversation_id: str, query: str, app_mode: str) -> str:
+ """Release model-preparation sessions before LLM I/O, preserving the caller's session."""
+ # Provider resolution may commit; own its scope so it cannot affect the caller.
+ with (
+ current_app.app_context(),
+ use_credit_usage_metadata(
+ {"app_type": get_credit_usage_app_type(app_mode), "created_by": CreditUsageCreatedBy.CONVERSATION_NAME}
+ ),
+ ):
+ model = ModelManager.for_tenant(tenant_id=tenant_id).get_default_model_instance(
+ tenant_id=tenant_id, model_type=ModelType.LLM
+ )
+ db.session.remove()
+ return LLMGenerator.generate_conversation_name(
+ tenant_id=tenant_id,
+ app_id=app_id,
+ conversation_id=conversation_id,
+ query=query,
+ model_instance=model,
+ )
diff --git a/api/services/conversation_name_service.py b/api/services/conversation_name_service.py
new file mode 100644
index 00000000000..58e43b5c9b0
--- /dev/null
+++ b/api/services/conversation_name_service.py
@@ -0,0 +1,65 @@
+"""Rename conversations with model work outside their read and write transactions."""
+
+import logging
+from datetime import datetime
+from typing import Protocol
+
+from libs.datetime_utils import naive_utc_now
+from services.entities.conversation_entities import ConversationNameSource, ConversationRecord, ConversationRef
+
+logger = logging.getLogger(__name__)
+
+
+class ConversationNameRequiredError(ValueError):
+ """A manual rename must provide a name."""
+
+
+class ConversationNameGenerator(Protocol):
+ def __call__(self, *, tenant_id: str, app_id: str, conversation_id: str, query: str, app_mode: str) -> str: ...
+
+
+class ConversationNameStore(Protocol):
+ def get(self, *, ref: ConversationRef) -> ConversationRecord: ...
+
+ def get_name_source(self, *, ref: ConversationRef) -> ConversationNameSource: ...
+
+ def rename(self, *, ref: ConversationRef, name: str, updated_at: datetime | None) -> ConversationRecord:
+ """None uses the database model's automatic update timestamp."""
+ ...
+
+
+class ConversationNameService:
+ def __init__(self, *, conversations: ConversationNameStore, generate_name: ConversationNameGenerator) -> None:
+ self._conversations = conversations
+ self._generate_name = generate_name
+
+ def rename(
+ self,
+ *,
+ ref: ConversationRef,
+ app_mode: str,
+ name: str | None,
+ auto_generate: bool,
+ ) -> ConversationRecord:
+ """Require name for manual renames; ignore it when generating automatically."""
+ if not auto_generate:
+ if name is None:
+ raise ConversationNameRequiredError("name is required when auto_generate is false")
+ return self._conversations.rename(ref=ref, name=name, updated_at=naive_utc_now())
+
+ source = self._conversations.get_name_source(ref=ref)
+ # The store closes its read transaction before entering the model provider.
+ try:
+ generated_name = self._generate_name(
+ tenant_id=source.tenant_id,
+ app_id=ref.app_id,
+ conversation_id=ref.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", ref.app_id, ref.conversation_id)
+ return self._conversations.get(ref=ref)
+ # The write transaction rechecks ownership and deletion state.
+ return self._conversations.rename(ref=ref, name=generated_name, updated_at=None)
diff --git a/api/services/conversation_service.py b/api/services/conversation_service.py
index a87cba2013b..345eed9c75a 100644
--- a/api/services/conversation_service.py
+++ b/api/services/conversation_service.py
@@ -1,4 +1,3 @@
-import contextlib
import logging
from collections.abc import Callable, Sequence
from typing import Any
@@ -7,15 +6,13 @@ from sqlalchemy import asc, desc, func, or_, select
from sqlalchemy.orm import Session
from configs import dify_config
-from core.app.entities.app_invoke_entities import InvokeFrom, get_credit_usage_app_type
-from core.llm_generator.llm_generator import LLMGenerator
-from core.model_context import use_credit_usage_metadata
+from core.app.entities.app_invoke_entities import InvokeFrom
from factories import variable_factory
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.model import App, Conversation, EndUser, Message
+from models.model import App, Conversation, EndUser
from repositories.conversation_lifecycle import retire_conversation
from services.errors.conversation import (
ConversationNotExistsError,
@@ -23,7 +20,6 @@ from services.errors.conversation import (
ConversationVariableTypeMismatchError,
LastConversationNotExistsError,
)
-from services.errors.message import MessageNotExistsError
from tasks.collect_agent_resources_task import enqueue_agent_resource_collection
from tasks.delete_conversation_task import delete_conversation_related_data
@@ -114,63 +110,6 @@ class ConversationService:
return getattr(Conversation, sort_field) > field_value
- @classmethod
- def rename(
- cls,
- app_model: App,
- conversation_id: str,
- user: Account | EndUser | None,
- name: str | None,
- auto_generate: bool,
- *,
- session: Session,
- ):
- conversation = cls.get_conversation(app_model, conversation_id, user, session=session)
-
- if auto_generate:
- return cls.auto_generate_name(app_model, conversation, session=session)
- else:
- if name is None:
- raise ValueError("name is required when auto_generate is false")
- conversation.name = name
- conversation.updated_at = naive_utc_now()
- session.commit()
-
- return conversation
-
- @classmethod
- def auto_generate_name(cls, app_model: App, conversation: Conversation, *, session: Session) -> Conversation:
- # get conversation first message
- message = session.scalar(
- select(Message)
- .where(Message.app_id == app_model.id, Message.conversation_id == conversation.id)
- .order_by(Message.created_at.asc())
- .limit(1)
- )
-
- if not message:
- raise MessageNotExistsError()
-
- # generate conversation name
- 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,
- )
-
- 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
diff --git a/api/services/entities/conversation_entities.py b/api/services/entities/conversation_entities.py
new file mode 100644
index 00000000000..9ce6948fc8c
--- /dev/null
+++ b/api/services/entities/conversation_entities.py
@@ -0,0 +1,65 @@
+"""Detached conversation records and explicit ownership references."""
+
+from dataclasses import dataclass
+from datetime import datetime
+
+from pydantic import JsonValue
+
+from graphon.file import File
+from services.installed_app_access_service import InstalledAppRef
+
+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 ConversationNameSource:
+ tenant_id: str
+ query: str
+
+
+@dataclass(frozen=True, slots=True)
+class EndUserConversationRef:
+ app_id: str
+ tenant_id: str
+ end_user_id: str
+ conversation_id: str
+
+
+@dataclass(frozen=True, slots=True)
+class InstalledAppConversationRef:
+ # An installation can belong to a different workspace than its underlying app.
+ installed_app: InstalledAppRef
+ account_id: str
+ conversation_id: str
+
+ @property
+ def app_id(self) -> str:
+ return self.installed_app.app_id
+
+
+type ConversationRef = EndUserConversationRef | InstalledAppConversationRef
+
+
+@dataclass(frozen=True, slots=True)
+class ConversationPage:
+ limit: int
+ has_more: bool
+ data: tuple[ConversationRecord, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class ConversationDeletion:
+ tenant_id: str
+ conversation_id: str
+ retired_workspace_ids: tuple[str, ...]
diff --git a/api/services/installed_app_conversation_service.py b/api/services/installed_app_conversation_service.py
index 6e2677861e3..10fd969f038 100644
--- a/api/services/installed_app_conversation_service.py
+++ b/api/services/installed_app_conversation_service.py
@@ -1,81 +1,26 @@
"""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.conversation_name_service import ConversationNameService
+from services.entities.conversation_entities import (
+ ConversationDeletion,
+ ConversationPage,
+ ConversationRecord,
+ InstalledAppConversationRef,
+)
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: ...
@@ -85,10 +30,6 @@ class InstalledAppConversationStore(Protocol):
) -> 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: ...
@@ -98,11 +39,11 @@ class InstalledAppConversationService:
self,
*,
conversations: InstalledAppConversationStore,
- generate_name: ConversationNameGenerator,
+ names: ConversationNameService,
enqueue_delete_cleanup: ConversationCleanup,
) -> None:
self._conversations: InstalledAppConversationStore = conversations
- self._generate_name: ConversationNameGenerator = generate_name
+ self._names = names
self._enqueue_delete_cleanup: ConversationCleanup = enqueue_delete_cleanup
def get_page(
@@ -128,44 +69,13 @@ class InstalledAppConversationService:
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(
+ return self._names.rename(
+ ref=InstalledAppConversationRef(
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,
+ ),
+ app_mode=app_mode,
+ name=name,
+ auto_generate=auto_generate,
)
def delete(self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str) -> None:
diff --git a/api/tests/e2e_tests/containers/controllers/web/test_conversation.py b/api/tests/e2e_tests/containers/controllers/web/test_conversation.py
index b35e01bdbfa..177b29aa50b 100644
--- a/api/tests/e2e_tests/containers/controllers/web/test_conversation.py
+++ b/api/tests/e2e_tests/containers/controllers/web/test_conversation.py
@@ -14,7 +14,6 @@ from controllers.web.conversation import (
ConversationApi,
ConversationListApi,
ConversationPinApi,
- ConversationRenameApi,
ConversationUnPinApi,
)
from controllers.web.error import NotChatAppError
@@ -91,47 +90,6 @@ class TestConversationApi:
ConversationApi().delete(_chat_app(), _end_user(), c_id)
-class TestConversationRenameApi:
- @pytest.fixture
- def app(self, flask_app_with_containers: Flask):
- return flask_app_with_containers
-
- def test_non_chat_mode_raises(self, app: Flask) -> None:
- with app.test_request_context(f"/conversations/{uuid4()}/name", method="POST", json={"name": "x"}):
- with pytest.raises(NotChatAppError):
- ConversationRenameApi().post(_completion_app(), _end_user(), uuid4())
-
- @patch("controllers.web.conversation.ConversationService.rename")
- def test_rename_success(self, mock_rename: MagicMock, app: Flask) -> None:
- c_id = uuid4()
- conv = SimpleNamespace(
- id=str(c_id),
- name="New Name",
- inputs={},
- status="normal",
- introduction="",
- created_at=1700000000,
- updated_at=1700000000,
- )
- mock_rename.return_value = conv
-
- with app.test_request_context(f"/conversations/{c_id}/name", method="POST", json={"name": "New Name"}):
- result = ConversationRenameApi().post(_chat_app(), _end_user(), c_id)
-
- assert result["name"] == "New Name"
-
- @patch(
- "controllers.web.conversation.ConversationService.rename",
- side_effect=ConversationNotExistsError(),
- )
- def test_rename_not_found(self, mock_rename: MagicMock, app: Flask) -> None:
- c_id = uuid4()
-
- with app.test_request_context(f"/conversations/{c_id}/name", method="POST", json={"name": "X"}):
- with pytest.raises(NotFound, match="Conversation Not Exists"):
- ConversationRenameApi().post(_chat_app(), _end_user(), c_id)
-
-
class TestConversationPinApi:
@pytest.fixture
def app(self, flask_app_with_containers: Flask):
diff --git a/api/tests/e2e_tests/containers/services/test_conversation_service.py b/api/tests/e2e_tests/containers/services/test_conversation_service.py
index 2ceeda1ad62..ead1419394d 100644
--- a/api/tests/e2e_tests/containers/services/test_conversation_service.py
+++ b/api/tests/e2e_tests/containers/services/test_conversation_service.py
@@ -16,7 +16,6 @@ from models.enums import ConversationFromSource, EndUserType
from models.model import App, Conversation, EndUser, Message
from services.conversation_service import ConversationService
from services.errors.conversation import ConversationNotExistsError
-from services.errors.message import MessageNotExistsError
class ConversationServiceIntegrationTestDataFactory:
@@ -308,179 +307,6 @@ class TestConversationServicePagination:
assert result.data[1].updated_at >= result.data[2].updated_at
-class TestConversationServiceSummarization:
- """
- Test conversation summarization (auto-generated names).
-
- Tests the auto_generate_name functionality that creates conversation
- titles based on the first message.
- """
-
- @patch("services.conversation_service.LLMGenerator.generate_conversation_name")
- def test_auto_generate_name_success(self, mock_llm_generator, db_session_with_containers: Session):
- """
- Test successful auto-generation of conversation name.
-
- The service uses an LLM to generate a descriptive name based on
- the first message in the conversation.
- """
- # Arrange
- app_model, user = ConversationServiceIntegrationTestDataFactory.create_app_and_account(
- db_session_with_containers
- )
- conversation = ConversationServiceIntegrationTestDataFactory.create_conversation(
- db_session_with_containers, app_model, user
- )
-
- # Create the first message that will be used to generate the name
- first_message = ConversationServiceIntegrationTestDataFactory.create_message(
- db_session_with_containers,
- app_model,
- conversation,
- user,
- query="What is machine learning?",
- created_at=datetime(2024, 1, 1, 12, 0, 0),
- )
- # Expected name from LLM
- generated_name = "Machine Learning Discussion"
-
- # Mock the LLM to return our expected name
- mock_llm_generator.return_value = generated_name
-
- # Act
- ConversationService.auto_generate_name(app_model, conversation, session=db_session_with_containers)
-
- # Assert
- assert conversation.name == generated_name # Name updated on conversation object
- # Verify LLM was called with correct parameters
- mock_llm_generator.assert_called_once_with(
- app_model.tenant_id, first_message.query, conversation.id, app_model.id
- )
-
- def test_auto_generate_name_raises_error_when_no_message(self, db_session_with_containers: Session):
- """
- Test that MessageNotExistsError is raised when conversation has no messages.
-
- When the conversation has no messages, the service should raise an error.
- """
- # Arrange
- app_model, user = ConversationServiceIntegrationTestDataFactory.create_app_and_account(
- db_session_with_containers
- )
- conversation = ConversationServiceIntegrationTestDataFactory.create_conversation(
- db_session_with_containers, app_model, user
- )
-
- # Act & Assert
- with pytest.raises(MessageNotExistsError):
- ConversationService.auto_generate_name(app_model, conversation, session=db_session_with_containers)
-
- @patch("services.conversation_service.LLMGenerator.generate_conversation_name")
- def test_auto_generate_name_handles_llm_failure_gracefully(
- self, mock_llm_generator, db_session_with_containers: Session
- ):
- """
- Test that LLM generation failures are suppressed and don't crash.
-
- When the LLM fails to generate a name, the service should not crash
- and should return the original conversation name.
- """
- # Arrange
- app_model, user = ConversationServiceIntegrationTestDataFactory.create_app_and_account(
- db_session_with_containers
- )
- conversation = ConversationServiceIntegrationTestDataFactory.create_conversation(
- db_session_with_containers, app_model, user
- )
- ConversationServiceIntegrationTestDataFactory.create_message(
- db_session_with_containers,
- app_model,
- conversation,
- user,
- created_at=datetime(2024, 1, 1, 12, 0, 0),
- )
- original_name = conversation.name
-
- # Mock the LLM to raise an exception
- mock_llm_generator.side_effect = Exception("LLM service unavailable")
-
- # Act
- ConversationService.auto_generate_name(app_model, conversation, session=db_session_with_containers)
-
- # Assert
- assert conversation.name == original_name # Name remains unchanged
-
- @patch("services.conversation_service.naive_utc_now")
- def test_rename_with_manual_name(self, mock_naive_utc_now, db_session_with_containers: Session):
- """
- Test renaming conversation with manual name.
-
- When auto_generate is False, the service should update the conversation
- name with the provided manual name.
- """
- # Arrange
- app_model, user = ConversationServiceIntegrationTestDataFactory.create_app_and_account(
- db_session_with_containers
- )
- conversation = ConversationServiceIntegrationTestDataFactory.create_conversation(
- db_session_with_containers, app_model, user
- )
- new_name = "My Custom Conversation Name"
- mock_time = datetime(2024, 1, 1, 12, 0, 0)
-
- # Mock the current time to return our mock time
- mock_naive_utc_now.return_value = mock_time
-
- # Act
- ConversationService.rename(
- app_model=app_model,
- conversation_id=conversation.id,
- user=user,
- name=new_name,
- auto_generate=False,
- session=db_session_with_containers,
- )
-
- # Assert
- assert conversation.name == new_name
- assert conversation.updated_at == mock_time
-
- @patch("services.conversation_service.LLMGenerator.generate_conversation_name")
- def test_rename_with_auto_generate(self, mock_llm_generator, db_session_with_containers: Session):
- """
- Test rename delegates to auto_generate_name when auto_generate is True.
-
- When auto_generate is True, the service should call auto_generate_name
- which uses an LLM to create a descriptive conversation title.
- """
- # Arrange
- app_model, user = ConversationServiceIntegrationTestDataFactory.create_app_and_account(
- db_session_with_containers
- )
- conversation = ConversationServiceIntegrationTestDataFactory.create_conversation(
- db_session_with_containers, app_model, user
- )
- ConversationServiceIntegrationTestDataFactory.create_message(
- db_session_with_containers, app_model, conversation, user
- )
- generated_name = "Auto Generated Name"
- mock_llm_generator.return_value = generated_name
-
- # Act
- result = ConversationService.rename(
- app_model=app_model,
- conversation_id=conversation.id,
- user=user,
- name=None,
- auto_generate=True,
- session=db_session_with_containers,
- )
-
- # Assert
- assert result == conversation
- assert conversation.name == generated_name
-
-
class TestConversationServiceRetrieval:
"""
Test conversation and message retrieval operations.
diff --git a/api/tests/e2e_tests/contracts/controllers/service_api/app/test_conversation_rename.py b/api/tests/e2e_tests/contracts/controllers/service_api/app/test_conversation_rename.py
new file mode 100644
index 00000000000..9aeb6c83968
--- /dev/null
+++ b/api/tests/e2e_tests/contracts/controllers/service_api/app/test_conversation_rename.py
@@ -0,0 +1,463 @@
+"""Rename HTTP contracts with real token admission, services, and SQLite transactions."""
+
+from collections.abc import Iterator
+from dataclasses import dataclass
+from datetime import datetime
+from decimal import Decimal
+from uuid import uuid4
+
+import pytest
+from flask import Flask
+from flask_login import LoginManager
+from pydantic import JsonValue
+from sqlalchemy import Connection, Engine, event, select
+from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
+from werkzeug.test import TestResponse
+
+from constants.resource_access_token import ResourceAccessTokenResourceType
+from controllers.service_api.app.conversation import ConversationRenameApi
+from core.errors.error import ProviderTokenNotInitError
+from extensions.application_services.resource_access_token import build_resource_access_token_service
+from extensions.ext_database import db
+from libs.external_api import ExternalApi
+from machinery.context import RequestContext
+from models import Tenant, TenantStatus
+from models.enums import ApiTokenType, ConversationFromSource, EndUserType
+from models.model import ApiToken, App, AppMode, Conversation, EndUser
+from models.resource_access_token import ResourceAccessToken
+from repositories.app_definition_query_repository import AppDefinitionQueryRepository
+from repositories.app_scoped_end_user_repository import AppScopedEndUserRepo
+from repositories.conversation_repository import ConversationRepository
+from services.app_definition_query_service import AppDefinitionQueryService
+from services.app_scoped_end_user_service import AppScopedEndUserService
+from services.auth.resource_access_token_contracts import ResourceAccessTokenResource
+from services.conversation_name_generator import generate_conversation_name
+from services.conversation_name_service import ConversationNameService
+from services.resource_access_token_service import ResourceAccessTokenService
+from tests.helpers.unit.model_factories import make_app, make_conversation, make_end_user, make_message
+
+_CREATED_AT = datetime(2026, 1, 2, 3, 4, 5)
+_UPDATED_AT = datetime(2026, 1, 3, 3, 4, 5)
+_INPUTS: dict[str, JsonValue] = {"text": "", "list": [], "zero": 0, "flag": False, "null": None}
+
+
+@dataclass(frozen=True)
+class _EndUsers:
+ commands: AppScopedEndUserService[EndUser]
+
+
+@dataclass(frozen=True)
+class _Services:
+ app_definitions: AppDefinitionQueryService
+ app_scoped_end_users: _EndUsers
+ conversation_names: ConversationNameService
+ resource_access_tokens: ResourceAccessTokenService
+
+
+@dataclass(frozen=True)
+class _Harness:
+ app: Flask
+ target: App
+ tenant: Tenant
+ end_user: EndUser
+ conversation: Conversation
+ factory: sessionmaker[Session]
+ provision_factory: sessionmaker[Session]
+ admissions: list[Session]
+ provisions: list[Session]
+ queries: list[Session]
+ scoped_sessions: list[Session]
+
+ def post(
+ self,
+ *,
+ body: dict[str, object],
+ user: str | None = "alice",
+ authorization: str | None = "Bearer rename-token",
+ requested_app_id: str | None = None,
+ conversation_id: str | None = None,
+ ) -> TestResponse:
+ headers: dict[str, str] = {"Authorization": authorization} if authorization is not None else {}
+ if requested_app_id is not None:
+ headers["X-Dify-App-ID"] = requested_app_id
+ payload = dict(body)
+ if user is not None:
+ payload["user"] = user
+ return self.app.test_client().post(
+ f"/conversations/{conversation_id or self.conversation.id}/name", json=payload, headers=headers
+ )
+
+ def assert_closed(self) -> None:
+ assert all(
+ not session.in_transaction() and not session.identity_map
+ for session in self.admissions + self.provisions + self.queries + self.scoped_sessions
+ )
+
+ def assert_name(self, name: str) -> None:
+ with self.factory() as session:
+ conversation = session.get(Conversation, self.conversation.id)
+ assert conversation is not None
+ assert conversation.name == name
+
+
+def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]) -> Iterator[_Harness]:
+ tenant = Tenant(name="Rename workspace")
+ target = make_app(app_id=str(uuid4()), tenant_id=tenant.id)
+ end_user = make_end_user(
+ end_user_id=str(uuid4()),
+ tenant_id=tenant.id,
+ app_id=target.id,
+ end_user_type=EndUserType.SERVICE_API,
+ session_id="alice",
+ external_user_id="alice",
+ )
+ conversation = make_conversation(
+ conversation_id=str(uuid4()),
+ app_id=target.id,
+ name="Original name",
+ inputs=dict(_INPUTS),
+ from_source=ConversationFromSource.API,
+ from_end_user_id=end_user.id,
+ )
+ conversation.created_at = _CREATED_AT
+ conversation.updated_at = _UPDATED_AT
+ conversation.introduction = None
+ token = ApiToken(app_id=target.id, tenant_id=tenant.id, type=ApiTokenType.APP, token="rename-token")
+ with sqlite_session_factory.begin() as session:
+ session.add_all([tenant, target, end_user, conversation, token])
+
+ app = Flask(__name__)
+ app.config.update(TESTING=True, RESTX_ERROR_404_HELP=False, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))
+ db.init_app(app)
+ LoginManager(app)
+ admissions: list[Session] = []
+ provisions: list[Session] = []
+ queries: list[Session] = []
+ scoped_sessions: list[Session] = []
+ admission_factory = sessionmaker(bind=sqlite_engine, expire_on_commit=False)
+ provision_factory = sessionmaker(bind=sqlite_engine, expire_on_commit=False)
+ query_factory = sessionmaker(bind=sqlite_engine, expire_on_commit=False)
+
+ def track_admission(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
+ admissions.append(session)
+
+ def track_provision(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
+ assert all(not admission.in_transaction() and not admission.identity_map for admission in admissions)
+ provisions.append(session)
+
+ def track_query(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
+ # This catches the legacy admission retaining a second connection while
+ # the rename repository opens its own transaction, before request teardown.
+ assert not db.session().in_transaction()
+ assert all(
+ not previous.in_transaction() and not previous.identity_map
+ for previous in admissions + provisions + queries + scoped_sessions
+ )
+ queries.append(session)
+
+ def track_scoped(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
+ scoped_sessions.append(session)
+
+ event.listen(admission_factory, "after_begin", track_admission)
+ event.listen(provision_factory, "after_begin", track_provision)
+ event.listen(query_factory, "after_begin", track_query)
+ event.listen(db.session.session_factory, "after_begin", track_scoped)
+ app.extensions["application_services"] = _Services(
+ app_definitions=AppDefinitionQueryService(
+ definitions=AppDefinitionQueryRepository(session_factory=admission_factory), builtin_icon_url_prefix=""
+ ),
+ app_scoped_end_users=_EndUsers(
+ AppScopedEndUserService(end_users=AppScopedEndUserRepo(session_factory=provision_factory))
+ ),
+ conversation_names=ConversationNameService(
+ conversations=ConversationRepository(session_factory=query_factory),
+ generate_name=generate_conversation_name,
+ ),
+ resource_access_tokens=build_resource_access_token_service(database_client=admission_factory),
+ )
+ api = ExternalApi(app)
+ api.add_resource(ConversationRenameApi, "/conversations/<uuid:conversation_id>/name")
+ yield _Harness(
+ app,
+ target,
+ tenant,
+ end_user,
+ conversation,
+ sqlite_session_factory,
+ provision_factory,
+ admissions,
+ provisions,
+ queries,
+ scoped_sessions,
+ )
+ event.remove(admission_factory, "after_begin", track_admission)
+ event.remove(provision_factory, "after_begin", track_provision)
+ event.remove(query_factory, "after_begin", track_query)
+ event.remove(db.session.session_factory, "after_begin", track_scoped)
+ with app.app_context():
+ db.session.remove()
+ db.engine.dispose()
+
+
[email protected]("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT])
+def test_manual_rename_persists_wire_contract_after_admission_connections_close(
+ harness: _Harness, mode: AppMode
+) -> None:
+ with harness.factory.begin() as session:
+ target = session.get(App, harness.target.id)
+ assert target is not None
+ target.mode = mode
+
+ response = harness.post(body={"name": "Renamed title"})
+
+ assert response.status_code == 200
+ assert response.headers["Content-Type"] == "application/json"
+ assert response.json is not None
+ assert response.json == {
+ "id": harness.conversation.id,
+ "name": "Renamed title",
+ "inputs": _INPUTS,
+ "status": harness.conversation.status,
+ "introduction": None,
+ "created_at": int(_CREATED_AT.timestamp()),
+ "updated_at": response.json["updated_at"],
+ }
+ assert isinstance(response.json["updated_at"], int)
+ assert response.json["updated_at"] > int(_UPDATED_AT.timestamp())
+ assert harness.admissions
+ assert harness.provisions
+ assert harness.queries
+ assert harness.scoped_sessions == []
+ harness.assert_closed()
+ with harness.factory() as session:
+ conversation = session.get(Conversation, harness.conversation.id)
+ assert conversation is not None
+ assert conversation.name == "Renamed title"
+ assert conversation.updated_at is not None
+ assert response.json["updated_at"] == int(conversation.updated_at.timestamp())
+
+
[email protected]("body", [{}, {"name": None}, {"name": ""}, {"name": " "}])
+def test_invalid_manual_name_returns_422_without_renaming(harness: _Harness, body: dict[str, object]) -> None:
+ response = harness.post(body=body)
+ assert response.status_code == 422
+ assert response.json is not None
+ assert response.json["code"] == "unprocessable_entity"
+ assert harness.queries == []
+ harness.assert_name("Original name")
+ harness.assert_closed()
+
+
[email protected]("body", [{"auto_generate": True}, {"name": "Ignored manual name", "auto_generate": True}])
+def test_auto_name_ignores_manual_name_and_preserves_current_name_on_provider_failure(
+ harness: _Harness, body: dict[str, object], caplog: pytest.LogCaptureFixture
+) -> None:
+ with harness.factory.begin() as session:
+ session.add_all(
+ [
+ make_message(
+ message_id=str(uuid4()),
+ app_id=harness.target.id,
+ conversation_id=harness.conversation.id,
+ query="Explain this topic",
+ inputs={},
+ message={},
+ answer="Explained.",
+ currency="USD",
+ message_unit_price=Decimal(0),
+ answer_unit_price=Decimal(0),
+ from_source=ConversationFromSource.API,
+ from_end_user_id=harness.end_user.id,
+ ),
+ ]
+ )
+
+ response = harness.post(body=body)
+
+ assert response.status_code == 200
+ assert response.json is not None
+ assert response.json["name"] == "Original name"
+ assert response.json["updated_at"] == int(_UPDATED_AT.timestamp())
+ failures = [
+ record.exc_info[1]
+ for record in caplog.records
+ if record.name == "services.conversation_name_service" and record.exc_info is not None
+ ]
+ assert len(failures) == 1
+ assert isinstance(failures[0], ProviderTokenNotInitError)
+ assert str(failures[0]) == "Default model not found for llm"
+ harness.assert_name("Original name")
+ harness.assert_closed()
+
+
+def test_auto_name_without_messages_returns_explicit_404(harness: _Harness) -> None:
+ response = harness.post(body={"auto_generate": True})
+ assert response.status_code == 404
+ assert response.json is not None
+ assert response.json["code"] == "conversation_first_message_not_found"
+ assert response.json["message"] == "The conversation has no message from which to generate a name."
+ harness.assert_name("Original name")
+ harness.assert_closed()
+
+
[email protected]("mode", [AppMode.COMPLETION, AppMode.WORKFLOW])
+def test_non_chat_mode_is_rejected_without_renaming(harness: _Harness, mode: AppMode) -> None:
+ with harness.factory.begin() as session:
+ target = session.get(App, harness.target.id)
+ assert target is not None
+ target.mode = mode
+ response = harness.post(body={"name": "Rejected"})
+ assert response.status_code == 400
+ assert response.json is not None
+ assert response.json["code"] == "not_chat_app"
+ assert harness.queries == []
+ harness.assert_name("Original name")
+ harness.assert_closed()
+
+
[email protected]("failure", ["different_user", "different_app", "different_workspace", "console", "deleted"])
+def test_conversation_ownership_is_enforced_before_rename(harness: _Harness, failure: str) -> None:
+ with harness.factory.begin() as session:
+ conversation = session.get(Conversation, harness.conversation.id)
+ assert conversation is not None
+ if failure == "different_user":
+ other = make_end_user(
+ end_user_id=str(uuid4()),
+ tenant_id=harness.tenant.id,
+ app_id=harness.target.id,
+ end_user_type=EndUserType.SERVICE_API,
+ session_id="bob",
+ external_user_id="bob",
+ )
+ session.add(other)
+ conversation.from_end_user_id = other.id
+ elif failure in {"different_app", "different_workspace"}:
+ tenant_id = harness.tenant.id if failure == "different_app" else str(uuid4())
+ other_app = make_app(app_id=str(uuid4()), tenant_id=tenant_id)
+ session.add(other_app)
+ conversation.app_id = other_app.id
+ elif failure == "console":
+ conversation.from_source = ConversationFromSource.CONSOLE
+ conversation.from_account_id = str(uuid4())
+ else:
+ conversation.is_deleted = True
+
+ response = harness.post(body={"name": "Rejected"})
+
+ assert response.status_code == 404
+ assert response.json == {
+ "code": "conversation_not_found",
+ "message": "The conversation was not found for this user and app.",
+ "status": 404,
+ }
+ harness.assert_name("Original name")
+ harness.assert_closed()
+
+
[email protected]("change_app_too", [False, True], ids=["end-user-workspace", "app-workspace"])
+def test_workspace_change_after_admission_prevents_rename(harness: _Harness, change_app_too: bool) -> None:
+ def change_owner(_session: Session, _transaction: SessionTransaction) -> None:
+ with harness.factory.begin() as session:
+ end_user = session.get(EndUser, harness.end_user.id)
+ assert end_user is not None
+ end_user.tenant_id = str(uuid4())
+ if change_app_too:
+ target = session.get(App, harness.target.id)
+ assert target is not None
+ target.tenant_id = end_user.tenant_id
+
+ event.listen(harness.provision_factory, "after_transaction_end", change_owner, once=True)
+ try:
+ response = harness.post(body={"name": "Rejected"})
+ finally:
+ event.remove(harness.provision_factory, "after_transaction_end", change_owner)
+ assert response.status_code == 404
+ assert response.json is not None
+ assert response.json["code"] == "conversation_not_found"
+ harness.assert_name("Original name")
+ harness.assert_closed()
+
+
+def test_unknown_conversation_cannot_rename_an_existing_decoy(harness: _Harness) -> None:
+ response = harness.post(body={"name": "Rejected"}, conversation_id=str(uuid4()))
+ assert response.status_code == 404
+ assert response.json is not None
+ assert response.json["code"] == "conversation_not_found"
+ harness.assert_name("Original name")
+ harness.assert_closed()
+
+
[email protected]("authorization", [None, "Basic rename-token", "Bearer invalid-token"])
+def test_invalid_token_returns_401_before_rename(harness: _Harness, authorization: str | None) -> None:
+ response = harness.post(body={"name": "Rejected"}, authorization=authorization)
+ assert response.status_code == 401
+ assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'
+ assert response.json is not None
+ assert response.json["code"] == "unauthorized"
+ assert harness.admissions == harness.provisions == harness.queries == []
+ harness.assert_name("Original name")
+ harness.assert_closed()
+
+
+ ("failure", "code"), [("disabled_api", "app_api_disabled"), ("archived_workspace", "workspace_archived")]
+)
+def test_disabled_app_or_workspace_stops_before_provisioning(harness: _Harness, failure: str, code: str) -> None:
+ with harness.factory.begin() as session:
+ if failure == "disabled_api":
+ target = session.get(App, harness.target.id)
+ assert target is not None
+ target.enable_api = False
+ else:
+ tenant = session.get(Tenant, harness.tenant.id)
+ assert tenant is not None
+ tenant.status = TenantStatus.ARCHIVE
+ response = harness.post(body={"name": "Rejected"}, user="new-user")
+ assert response.status_code == 403
+ assert response.json is not None
+ assert response.json["code"] == code
+ assert harness.provisions == harness.queries == []
+ with harness.factory() as session:
+ assert session.scalars(select(EndUser.id)).all() == [harness.end_user.id]
+ harness.assert_name("Original name")
+ harness.assert_closed()
+
+
[email protected]("multiple_apps", [False, True], ids=["implicit-single-app", "explicit-multiple-apps"])
+def test_resource_token_renames_bound_app_and_records_usage(harness: _Harness, multiple_apps: bool) -> None:
+ app_ids = (harness.target.id,)
+ if multiple_apps:
+ other = make_app(app_id=str(uuid4()), tenant_id=harness.tenant.id)
+ with harness.factory.begin() as session:
+ session.add(other)
+ app_ids = (other.id, harness.target.id)
+ services = harness.app.extensions["application_services"]
+ assert isinstance(services, _Services)
+ token = services.resource_access_tokens.create(
+ RequestContext(
+ request_id="rename-resource-token",
+ trace_id=None,
+ account_id=str(uuid4()),
+ active_workspace_id=harness.tenant.id,
+ ),
+ name="Rename app token",
+ resources=tuple(ResourceAccessTokenResource(ResourceAccessTokenResourceType.APP, app_id) for app_id in app_ids),
+ )
+
+ response = harness.post(
+ body={"name": "Resource token rename"},
+ authorization=f"Bearer {token.token}",
+ requested_app_id=harness.target.id if multiple_apps else None,
+ )
+
+ assert response.status_code == 200
+ assert response.json is not None
+ assert response.json["name"] == "Resource token rename"
+ harness.assert_name("Resource token rename")
+ harness.assert_closed()
+ with harness.factory() as session:
+ stored_token = session.get(ResourceAccessToken, token.token_id)
+ assert stored_token is not None
+ assert stored_token.last_used_at is not None
+ assert session.scalars(select(EndUser.id)).all() == [harness.end_user.id]
diff --git a/api/tests/e2e_tests/contracts/controllers/web/test_conversation_rename.py b/api/tests/e2e_tests/contracts/controllers/web/test_conversation_rename.py
new file mode 100644
index 00000000000..b8c01d6f258
--- /dev/null
+++ b/api/tests/e2e_tests/contracts/controllers/web/test_conversation_rename.py
@@ -0,0 +1,379 @@
+"""Rename through real Web admission, application service, and SQLite persistence."""
+
+from collections.abc import Callable, Iterator
+from dataclasses import dataclass
+from datetime import datetime
+from decimal import Decimal
+from http import HTTPStatus
+from typing import Literal
+from uuid import uuid4
+
+import pytest
+from flask import Flask
+from pydantic import JsonValue
+from sqlalchemy import Connection, Engine, delete, event, update
+from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
+from werkzeug.test import TestResponse
+
+from constants import HEADER_NAME_APP_CODE, HEADER_NAME_PASSPORT
+from controllers.web.conversation import ConversationRenameApi
+from core.errors.error import ProviderTokenNotInitError
+from enums import DeploymentEdition
+from extensions.ext_database import db
+from graphon.file import File, FileTransferMethod, FileType
+from libs.external_api import ExternalApi
+from libs.passport import PassportService
+from models.agent import (
+ Agent,
+ AgentConfigRevision,
+ AgentConfigRevisionOperation,
+ AgentConfigSnapshot,
+ AgentScope,
+ AgentSource,
+)
+from models.agent_config_entities import AgentSoulConfig
+from models.enums import ConversationFromSource, CustomizeTokenStrategy
+from models.model import App, AppMode, AppModelConfig, Conversation, EndUser, Message, Site
+from models.workflow import WorkflowType
+from repositories.conversation_repository import ConversationRepository
+from services.conversation_name_generator import generate_conversation_name
+from services.conversation_name_service import ConversationNameService
+from tests.helpers.unit.model_factories import make_app, make_conversation, make_end_user, make_message, make_workflow
+
+_CREATED_AT = datetime(2026, 1, 2, 3, 4, 5)
+_UPDATED_AT = datetime(2026, 1, 3, 3, 4, 5)
+_INPUTS: dict[str, JsonValue] = {"text": "", "list": [], "zero": 0, "flag": False, "null": None}
+
+
+@dataclass
+class _Services:
+ conversation_names: ConversationNameService
+
+
+@dataclass(frozen=True)
+class _Harness:
+ app: Flask
+ target: App
+ end_user: EndUser
+ conversation: Conversation
+ factory: sessionmaker[Session]
+ passport: str
+ admission_sessions: list[Session]
+ repository_sessions: list[Session]
+ provider_sessions: list[Session]
+
+ def post(self, body: dict[str, object]) -> TestResponse:
+ return self.app.test_client().post(
+ f"/conversations/{self.conversation.id}/name",
+ json=body,
+ headers={HEADER_NAME_APP_CODE: "public-app", HEADER_NAME_PASSPORT: self.passport},
+ )
+
+ def assert_closed(self) -> None:
+ sessions = self.admission_sessions + self.repository_sessions + self.provider_sessions
+ assert sessions
+ assert all(not session.in_transaction() and not session.identity_map for session in sessions)
+
+ def assert_name(self, name: str) -> None:
+ with self.factory() as session:
+ conversation = session.get(Conversation, self.conversation.id)
+ assert conversation is not None
+ assert conversation.name == name
+
+
+def harness(
+ config_overrides: Callable[..., None],
+ sqlite_engine: Engine,
+ sqlite_session_factory: sessionmaker[Session],
+) -> Iterator[_Harness]:
+ config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY, SECRET_KEY="conversation-rename-test-secret-key")
+ target = make_app(app_id=str(uuid4()), tenant_id=str(uuid4()))
+ end_user = make_end_user(end_user_id=str(uuid4()), tenant_id=target.tenant_id, app_id=target.id)
+ site = Site(
+ app_id=target.id,
+ title="Public app",
+ default_language="en-US",
+ customize_token_strategy=CustomizeTokenStrategy.UUID,
+ code="public-app",
+ )
+ conversation = make_conversation(
+ conversation_id=str(uuid4()),
+ app_id=target.id,
+ from_source=ConversationFromSource.API,
+ from_end_user_id=end_user.id,
+ inputs=_INPUTS,
+ name="Original title",
+ )
+ conversation.created_at = _CREATED_AT
+ conversation.updated_at = _UPDATED_AT
+ message = make_message(
+ message_id=str(uuid4()),
+ app_id=target.id,
+ conversation_id=conversation.id,
+ inputs={},
+ message={},
+ query="How does it work?",
+ answer="Like this.",
+ message_unit_price=Decimal(0),
+ answer_unit_price=Decimal(0),
+ currency="USD",
+ from_source=ConversationFromSource.API,
+ from_end_user_id=end_user.id,
+ )
+ with sqlite_session_factory.begin() as session:
+ config = AppModelConfig(app_id=target.id)
+ session.add_all([target, end_user, site, conversation, message, config])
+ session.flush()
+ target.app_model_config_id = config.id
+
+ repository_factory = sessionmaker(bind=sqlite_engine, expire_on_commit=False)
+ admission_sessions: list[Session] = []
+ repository_sessions: list[Session] = []
+ provider_sessions: list[Session] = []
+
+ def track_admission(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
+ admission_sessions.append(session)
+
+ def track_repository(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
+ # Admission and provider lookup must release their transactions before
+ # rename starts its own read/write transaction.
+ assert all(not item.in_transaction() for item in admission_sessions + provider_sessions)
+ repository_sessions.append(session)
+
+ def track_provider(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
+ assert all(not item.in_transaction() for item in admission_sessions + repository_sessions)
+ provider_sessions.append(session)
+
+ event.listen(sqlite_session_factory, "after_begin", track_admission)
+ event.listen(repository_factory, "after_begin", track_repository)
+ passport = PassportService().issue({"app_code": site.code, "app_id": target.id, "end_user_id": end_user.id})
+ app = Flask(__name__)
+ app.config.update(TESTING=True, RESTX_ERROR_404_HELP=False, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))
+ db.init_app(app)
+ event.listen(db.session.session_factory, "after_begin", track_provider)
+ app.extensions["application_services"] = _Services(
+ ConversationNameService(
+ conversations=ConversationRepository(session_factory=repository_factory),
+ generate_name=generate_conversation_name,
+ )
+ )
+ api = ExternalApi(app)
+ api.add_resource(ConversationRenameApi, "/conversations/<uuid:c_id>/name")
+ yield _Harness(
+ app,
+ target,
+ end_user,
+ conversation,
+ sqlite_session_factory,
+ passport,
+ admission_sessions,
+ repository_sessions,
+ provider_sessions,
+ )
+ event.remove(sqlite_session_factory, "after_begin", track_admission)
+ event.remove(repository_factory, "after_begin", track_repository)
+ event.remove(db.session.session_factory, "after_begin", track_provider)
+ with app.app_context():
+ db.session.remove()
+ db.engine.dispose()
+
+
+def _publish_mode(harness: _Harness, mode: AppMode) -> None:
+ with harness.factory.begin() as session:
+ target = session.get(App, harness.target.id)
+ assert target is not None
+ target.mode = mode
+ if mode in {AppMode.ADVANCED_CHAT, AppMode.WORKFLOW}:
+ workflow = make_workflow(
+ tenant_id=target.tenant_id,
+ app_id=target.id,
+ workflow_type=WorkflowType.CHAT if mode == AppMode.ADVANCED_CHAT else WorkflowType.WORKFLOW,
+ version="published",
+ )
+ session.add(workflow)
+ session.flush()
+ target.workflow_id = workflow.id
+ elif mode == AppMode.AGENT:
+ agent = Agent(
+ tenant_id=target.tenant_id,
+ app_id=target.id,
+ name="Published agent",
+ scope=AgentScope.ROSTER,
+ source=AgentSource.AGENT_APP,
+ )
+ session.add(agent)
+ session.flush()
+ snapshot = AgentConfigSnapshot(
+ tenant_id=target.tenant_id,
+ agent_id=agent.id,
+ version=1,
+ config_snapshot=AgentSoulConfig(),
+ )
+ session.add(snapshot)
+ session.flush()
+ agent.active_config_snapshot_id = snapshot.id
+ session.add(
+ AgentConfigRevision(
+ tenant_id=target.tenant_id,
+ agent_id=agent.id,
+ current_snapshot_id=snapshot.id,
+ revision=1,
+ operation=AgentConfigRevisionOperation.PUBLISH_DRAFT,
+ )
+ )
+
+
[email protected]("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT])
+def test_manual_rename_persists_name_and_preserves_response_contract(harness: _Harness, mode: AppMode) -> None:
+ _publish_mode(harness, mode)
+ response = harness.post({"name": "Manual title"})
+ assert response.status_code == HTTPStatus.OK
+ assert response.headers["Content-Type"] == "application/json"
+ body = response.get_json()
+ assert body == {
+ "id": harness.conversation.id,
+ "name": "Manual title",
+ "inputs": _INPUTS,
+ "status": "normal",
+ "introduction": None,
+ "created_at": int(_CREATED_AT.timestamp()),
+ "updated_at": body["updated_at"],
+ }
+ assert isinstance(body["updated_at"], int)
+ assert body["updated_at"] > int(_UPDATED_AT.timestamp())
+ harness.assert_name("Manual title")
+ assert harness.repository_sessions
+ harness.assert_closed()
+
+
[email protected]("mode", [AppMode.COMPLETION, AppMode.WORKFLOW])
+def test_non_chat_mode_is_rejected_before_repository(harness: _Harness, mode: AppMode) -> None:
+ _publish_mode(harness, mode)
+ response = harness.post({"name": "Manual title"})
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ assert response.get_json()["code"] == "not_chat_app"
+ assert not harness.repository_sessions
+ harness.assert_name("Original title")
+ harness.assert_closed()
+
+
[email protected]("body", [{}, {"name": None}, {"name": ""}, {"name": " "}, {"name": []}])
+def test_invalid_manual_payload_is_rejected_without_writing(harness: _Harness, body: dict[str, object]) -> None:
+ response = harness.post(body)
+ assert response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY
+ assert response.get_json()["code"] == "unprocessable_entity"
+ assert not harness.repository_sessions
+ harness.assert_name("Original title")
+ harness.assert_closed()
+
+
[email protected]("field", ["app_id", "from_end_user_id", "from_source", "from_account_id", "is_deleted"])
+def test_conversation_outside_end_user_scope_is_not_renamed(harness: _Harness, field: str) -> None:
+ value: str | bool
+ if field == "is_deleted":
+ value = True
+ elif field == "from_source":
+ value = ConversationFromSource.CONSOLE
+ else:
+ value = str(uuid4())
+ with harness.factory.begin() as session:
+ session.execute(update(Conversation).where(Conversation.id == harness.conversation.id).values({field: value}))
+ response = harness.post({"name": "Manual title"})
+ assert response.status_code == HTTPStatus.NOT_FOUND
+ assert response.get_json()["code"] == "conversation_not_found"
+ assert response.get_json()["message"] == "The conversation was not found for this user and app."
+ harness.assert_name("Original title")
+ harness.assert_closed()
+
+
[email protected]("field", ["app_id", "tenant_id"])
+def test_end_user_outside_app_owner_scope_is_rejected(harness: _Harness, field: Literal["app_id", "tenant_id"]) -> None:
+ with harness.factory.begin() as session:
+ session.execute(update(EndUser).where(EndUser.id == harness.end_user.id).values({field: str(uuid4())}))
+ response = harness.post({"name": "Manual title"})
+ assert response.status_code == HTTPStatus.NOT_FOUND
+ assert response.get_json()["code"] == "not_found"
+ assert not harness.repository_sessions
+ harness.assert_name("Original title")
+ harness.assert_closed()
+
+
+def test_auto_rename_preserves_existing_name_when_real_provider_lookup_fails(
+ harness: _Harness, caplog: pytest.LogCaptureFixture
+) -> None:
+ response = harness.post({"auto_generate": True, "name": "Ignored manual title"})
+ assert response.status_code == HTTPStatus.OK
+ assert response.get_json()["name"] == "Original title"
+ assert response.get_json()["updated_at"] == int(_UPDATED_AT.timestamp())
+ failures = [
+ record.exc_info[1]
+ for record in caplog.records
+ if record.name == "services.conversation_name_service" and record.exc_info is not None
+ ]
+ assert len(failures) == 1
+ assert isinstance(failures[0], ProviderTokenNotInitError)
+ assert str(failures[0]) == "Default model not found for llm"
+ harness.assert_name("Original title")
+ harness.assert_closed()
+
+
+def test_auto_rename_without_first_message_returns_specific_not_found(harness: _Harness) -> None:
+ with harness.factory.begin() as session:
+ session.execute(delete(Message).where(Message.conversation_id == harness.conversation.id))
+ response = harness.post({"auto_generate": True})
+ assert response.status_code == HTTPStatus.NOT_FOUND
+ assert response.get_json()["code"] == "conversation_first_message_not_found"
+ assert response.get_json()["message"] == "The conversation has no message from which to generate a name."
+ harness.assert_name("Original title")
+ harness.assert_closed()
+
+
+def test_restored_remote_input_file_keeps_existing_wire_shape(harness: _Harness) -> None:
+ file = File(
+ file_id=str(uuid4()),
+ file_type=FileType.DOCUMENT,
+ transfer_method=FileTransferMethod.REMOTE_URL,
+ remote_url="https://example.com/document.pdf",
+ filename="document.pdf",
+ extension=".pdf",
+ mime_type="application/pdf",
+ size=12,
+ )
+ with harness.factory.begin() as session:
+ conversation = session.get(Conversation, harness.conversation.id)
+ assert conversation is not None
+ conversation.inputs = {"document": file}
+ response = harness.post({"name": "Manual title"})
+ assert response.status_code == HTTPStatus.OK
+ assert response.get_json()["inputs"] == {"document": dict(file.to_dict())}
+ harness.assert_name("Manual title")
+ harness.assert_closed()
+
+
[email protected]("passport", ["missing", "invalid"])
+def test_web_admission_rejects_missing_or_invalid_passport(harness: _Harness, passport: str) -> None:
+ headers = {HEADER_NAME_APP_CODE: "public-app"}
+ if passport == "invalid":
+ headers[HEADER_NAME_PASSPORT] = "invalid-passport"
+ response = harness.app.test_client().post(
+ f"/conversations/{harness.conversation.id}/name", json={"name": "Manual title"}, headers=headers
+ )
+ assert response.status_code == HTTPStatus.UNAUTHORIZED
+ assert response.get_json()["code"] == "unauthorized"
+ assert response.get_json()["message"] == ("App token is missing." if passport == "missing" else "Invalid token.")
+ assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'
+ assert not harness.repository_sessions
+ harness.assert_name("Original title")
+
+
+def test_web_admission_rejects_disabled_site_before_rename(harness: _Harness) -> None:
+ with harness.factory.begin() as session:
+ session.execute(update(App).where(App.id == harness.target.id).values(enable_site=False))
+ response = harness.post({"name": "Manual title"})
+ assert response.status_code == HTTPStatus.NOT_FOUND
+ assert response.get_json()["code"] == "app_not_found"
+ assert response.get_json()["message"] == "App not found."
+ assert not harness.repository_sessions
+ harness.assert_name("Original title")
+ harness.assert_closed()
diff --git a/api/tests/helpers/unit/services/conversation_name_fixtures.py b/api/tests/helpers/unit/services/conversation_name_fixtures.py
new file mode 100644
index 00000000000..fe1e2dc646e
--- /dev/null
+++ b/api/tests/helpers/unit/services/conversation_name_fixtures.py
@@ -0,0 +1,131 @@
+"""Real plugin HTTP transport and database scope shared by conversation naming tests."""
+
+import json
+from collections.abc import Callable, Iterator
+from dataclasses import dataclass, field
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from threading import Thread
+
+import pytest
+from flask import Flask
+from sqlalchemy import Engine
+from yarl import URL
+
+from core.ops import ops_trace_manager
+from core.plugin.impl import base as plugin_http
+from extensions.ext_database import db
+
+_PROVIDER = "testing/naming/naming"
+_MODEL = "title-model"
+
+
+@dataclass
+class NamingPlugin:
+ """Only the external plugin-daemon boundary is served locally."""
+
+ answer: str = '{"Your Output": "A generated title"}'
+ fail_invoke: bool = False
+ requests: list[tuple[str, dict[str, object]]] = field(default_factory=list)
+
+
+def naming_plugin(config_overrides: Callable[..., None]) -> Iterator[NamingPlugin]:
+ plugin = NamingPlugin()
+ model = {
+ "model": _MODEL,
+ "label": {"en_US": _MODEL},
+ "model_type": "llm",
+ "fetch_from": "predefined-model",
+ "model_properties": {"mode": "chat"},
+ }
+
+ class Handler(BaseHTTPRequestHandler):
+ def do_GET(self) -> None:
+ tenant_id = self.path.split("/")[2]
+ plugin.requests.append((self.path, {}))
+ self.respond(
+ [
+ {
+ "id": "naming-installation",
+ "created_at": "2026-01-01T00:00:00Z",
+ "updated_at": "2026-01-01T00:00:00Z",
+ "provider": "naming",
+ "tenant_id": tenant_id,
+ "plugin_id": "testing/naming",
+ "plugin_unique_identifier": "testing/naming:1.0.0@" + "a" * 64,
+ "installation_source": "marketplace",
+ "declaration": {
+ "provider": "naming",
+ "label": {"en_US": "Naming provider"},
+ "supported_model_types": ["llm"],
+ "configurate_methods": ["predefined-model"],
+ "models": [model],
+ },
+ }
+ ],
+ stream=False,
+ )
+
+ def do_POST(self) -> None:
+ payload = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
+ plugin.requests.append((self.path, payload))
+ if self.path.endswith("/llm/invoke"):
+ if plugin.fail_invoke:
+ error = {
+ "error_type": "PluginInvokeError",
+ "message": json.dumps(
+ {"error_type": "InvokeServerUnavailableError", "message": "Title provider unavailable"}
+ ),
+ }
+ self.respond(None, stream=True, code=-500, message=json.dumps(error))
+ return
+ self.respond(
+ {"model": _MODEL, "delta": {"index": 0, "message": {"content": plugin.answer}}},
+ stream=True,
+ )
+ else:
+ self.send_error(404)
+
+ def respond(self, data: object, *, stream: bool, code: int = 0, message: str = "") -> None:
+ envelope = json.dumps({"code": code, "message": message, "data": data})
+ body = (f"data: {envelope}\n\n" if stream else envelope).encode()
+ self.send_response(200)
+ self.send_header("Content-Type", "text/event-stream" if stream else "application/json")
+ self.send_header("Content-Length", str(len(body)))
+ self.end_headers()
+ self.wfile.write(body)
+
+ server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+ thread = Thread(target=server.serve_forever, daemon=True)
+ original_url = plugin_http.plugin_daemon_inner_api_baseurl
+ original_trace_interval = ops_trace_manager.trace_manager_interval
+ original_trace_timer = ops_trace_manager.trace_manager_timer
+ # Change real connection settings, preserving every production client and method.
+ plugin_http.plugin_daemon_inner_api_baseurl = URL(f"http://127.0.0.1:{server.server_port}")
+ config_overrides(PLUGIN_MODEL_PROVIDERS_CACHE_ENABLED=False)
+ ops_trace_manager.trace_manager_interval = 3600
+ thread.start()
+ try:
+ yield plugin
+ finally:
+ plugin_http.plugin_daemon_inner_api_baseurl = original_url
+ ops_trace_manager.trace_manager_interval = original_trace_interval
+ timer = ops_trace_manager.trace_manager_timer
+ if timer is not None and timer is not original_trace_timer:
+ timer.cancel()
+ timer.join(timeout=1)
+ ops_trace_manager.trace_manager_timer = original_trace_timer
+ server.shutdown()
+ server.server_close()
+ thread.join(timeout=1)
+
+
+def naming_app(sqlite_engine: Engine) -> Iterator[Flask]:
+ app = Flask(__name__)
+ app.config.update(TESTING=True, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))
+ db.init_app(app)
+ yield app
+ with app.app_context():
+ db.session.remove()
+ db.engine.dispose()
diff --git a/api/tests/unit_tests/controllers/console/explore/test_conversation.py b/api/tests/unit_tests/controllers/console/explore/test_conversation.py
index 20a9010d668..5f2f5802183 100644
--- a/api/tests/unit_tests/controllers/console/explore/test_conversation.py
+++ b/api/tests/unit_tests/controllers/console/explore/test_conversation.py
@@ -18,7 +18,8 @@ from models.enums import ConversationFromSource, ConversationStatus, CreatorUser
from models.enums import InvokeFrom as ModelInvokeFrom
from models.model import App, AppMode, Conversation, Message
from models.web import PinnedConversation
-from repositories.installed_app_conversation_repository import SQLAlchemyInstalledAppConversationRepository
+from repositories.conversation_repository import ConversationRepository
+from services.conversation_name_service import ConversationNameService
from services.installed_app_conversation_service import InstalledAppConversationService
from tests.unit_tests.controllers.console.explore.test_installed_app_admission import (
_assert_json_response,
@@ -117,8 +118,10 @@ def conversations(
services = _Services(
installed_apps=_InstalledAppServices(
conversations=InstalledAppConversationService(
- conversations=SQLAlchemyInstalledAppConversationRepository(session_factory=factory),
- generate_name=state.generate_name,
+ conversations=ConversationRepository(session_factory=factory),
+ names=ConversationNameService(
+ conversations=ConversationRepository(session_factory=factory), generate_name=state.generate_name
+ ),
enqueue_delete_cleanup=state.enqueue_cleanup,
)
)
diff --git a/api/tests/unit_tests/controllers/service_api/app/test_conversation.py b/api/tests/unit_tests/controllers/service_api/app/test_conversation.py
index ef4ac87f78e..3f767872a02 100644
--- a/api/tests/unit_tests/controllers/service_api/app/test_conversation.py
+++ b/api/tests/unit_tests/controllers/service_api/app/test_conversation.py
@@ -18,7 +18,6 @@ from controllers.service_api.app.conversation import (
ConversationApi,
ConversationDetailApi,
ConversationListQuery,
- ConversationRenameApi,
ConversationRenamePayload,
ConversationVariableDetailApi,
ConversationVariableInfiniteScrollPaginationResponse,
@@ -501,11 +500,6 @@ class TestConversationCases:
assert hasattr(ConversationService, "delete")
assert callable(ConversationService.delete)
- def test_rename_method_exists(self):
- """Test that ConversationService.rename exists."""
- assert hasattr(ConversationService, "rename")
- assert callable(ConversationService.rename)
-
def test_get_conversational_variable_method_exists(self):
"""Test that ConversationService.get_conversational_variable exists."""
assert hasattr(ConversationService, "get_conversational_variable")
@@ -538,26 +532,6 @@ class TestConversationCases:
assert hasattr(result, "limit")
assert hasattr(result, "has_more")
- def test_rename_returns_conversation(self, sqlite_session: Session):
- """Test rename returns updated conversation."""
- conversation_id = "00000000-0000-0000-0000-000000000001"
- conversation = _conversation(conversation_id=conversation_id)
- sqlite_session.add(conversation)
- sqlite_session.commit()
-
- result = ConversationService.rename(
- app_model=App(id="app-1"),
- conversation_id=conversation_id,
- user=_end_user(),
- name="New Name",
- auto_generate=False,
- session=sqlite_session,
- )
-
- assert result.name == "New Name"
- sqlite_session.refresh(conversation)
- assert conversation.name == "New Name"
-
class TestConversationPayloadsController:
def test_rename_requires_name(self) -> None:
with pytest.raises(
@@ -658,34 +632,6 @@ class TestConversationCases:
conversation_id="00000000-0000-0000-0000-000000000001",
)
- class TestConversationRenameApiController:
- def test_not_found(self, app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
- monkeypatch.setattr(
- ConversationService,
- "rename",
- lambda *_args, **_kwargs: (_ for _ in ()).throw(ConversationNotExistsError()),
- )
-
- api = ConversationRenameApi()
- handler = unwrap(api.post)
- app_model = _app()
- end_user = _end_user()
-
- with app.test_request_context(
- "/conversations/1/name",
- method="POST",
- json={"auto_generate": True},
- ):
- payload = ConversationRenamePayload.model_validate(request.get_json() or {})
- with pytest.raises(NotFound):
- handler(
- api,
- payload,
- app_model=app_model,
- end_user=end_user,
- conversation_id="00000000-0000-0000-0000-000000000001",
- )
-
class TestConversationVariablesApiController:
def test_not_chat(self, app: Flask) -> None:
api = ConversationVariablesApi()
diff --git a/api/tests/unit_tests/extensions/test_ext_application_services.py b/api/tests/unit_tests/extensions/test_ext_application_services.py
index 5176d2fce94..14264b4cec2 100644
--- a/api/tests/unit_tests/extensions/test_ext_application_services.py
+++ b/api/tests/unit_tests/extensions/test_ext_application_services.py
@@ -14,19 +14,21 @@ import httpx
import pytest
from flask import Flask
from redis import Redis
-from sqlalchemy import event, select
-from sqlalchemy.orm import Session, sessionmaker
+from sqlalchemy import Connection, event, select
+from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
-from core.credit_usage import CreditUsageAppType
-from core.llm_generator.llm_generator import LLMGenerator
+from core.credit_usage import CreditUsageAppType, CreditUsageCreatedBy
+from core.llm_generator.prompts import CONVERSATION_TITLE_PROMPT
from core.model_context import get_credit_usage_metadata, use_credit_usage_metadata
from core.ops.base_trace_instance import application_tracing_hooks
+from core.plugin.impl import base as plugin_http
from core.tools.tool_file_manager import ToolFileManager
from enums import DeploymentEdition, WebAppAccessMode
from extensions import ext_application_services
from extensions.application_services.app import AppServices
from extensions.ext_database import db
from extensions.ext_redis import RedisClientWrapper
+from graphon.model_runtime.entities.model_entities import ModelType
from machinery.context import RequestContext
from models.account import Account, Tenant, TenantAccountJoin, TenantAccountRole
from models.enums import AppStatus, ConversationFromSource, CustomizeTokenStrategy
@@ -43,7 +45,7 @@ from models.model import (
Site,
TrialApp,
)
-from models.provider import ProviderCredential
+from models.provider import Provider, ProviderCredential, TenantDefaultModel
from repositories.account.repository import SQLAlchemyAccountRepository
from repositories.account_activation_repository import SQLAlchemyAccountActivationRepository
from repositories.account_integration_repository import SQLAlchemyAccountIntegrationRepository
@@ -168,8 +170,11 @@ 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.helpers.unit.config_override import apply_config_overrides
+from tests.helpers.unit.services.conversation_name_fixtures import _MODEL, _PROVIDER, NamingPlugin
from tests.unit_tests.services.test_app_task_service import _AppTaskServiceStopredis as _StopRedis
+pytest_plugins = ("tests.helpers.unit.services.conversation_name_fixtures",)
+
@pytest.fixture(autouse=True)
def _reject_redis_commands(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -1763,15 +1768,27 @@ def test_installed_app_management_composition_reads_real_installations_and_curre
def test_installed_app_conversations_wire_real_persistence_naming_and_cleanup(
sqlite_session_factory: sessionmaker[Session],
installed_app_ref: InstalledAppRef,
+ naming_app: Flask,
+ naming_plugin: NamingPlugin,
monkeypatch: pytest.MonkeyPatch,
naming_fails: bool,
) -> None:
+ naming_plugin.answer = '{"Your Output": "Generated name"}'
+ naming_plugin.fail_invoke = naming_fails
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
+ session.add_all(
+ [
+ Provider(tenant_id=owner_tenant_id, provider_name=_PROVIDER, is_valid=True),
+ TenantDefaultModel(
+ tenant_id=owner_tenant_id, provider_name=_PROVIDER, model_name=_MODEL, model_type=ModelType.LLM
+ ),
+ ]
+ )
conversation = Conversation(
app_id=app.id,
mode=AppMode.CHAT,
@@ -1815,23 +1832,23 @@ def test_installed_app_conversations_wire_real_persistence_naming_and_cleanup(
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"
+ def observe_naming_session(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
+ naming_sessions.append(session)
+
+ def observe_naming_request(request: httpx.Request) -> None:
+ if request.url.path.endswith("/llm/invoke"):
+ assert active_connections == 0
+ assert naming_sessions
+ assert all(not session.in_transaction() for session in naming_sessions)
+ assert get_credit_usage_metadata() == {
+ "app_type": CreditUsageAppType.CHATBOT,
+ "created_by": CreditUsageCreatedBy.CONVERSATION_NAME,
+ "request_id": "naming-request",
+ }
+ assert f"/{owner_tenant_id}/" in request.url.path
+ assert json.loads(request.content)["data"]["prompt_messages"] == [
+ {"role": "user", "content": CONVERSATION_TITLE_PROMPT + "First question\n", "name": None}
+ ]
queued: list[str] = []
@@ -1844,7 +1861,6 @@ def test_installed_app_conversations_wire_real_persistence_naming_and_cleanup(
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,
@@ -1852,35 +1868,38 @@ def test_installed_app_conversations_wire_real_persistence_naming_and_cleanup(
initialization_password="",
redis=_redis(),
)
- naming_app = Flask(__name__)
admitted_app = services.installed_apps.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_apps.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_apps.conversations.delete(
- installed_app=admitted_app, account_id=account_id, conversation_id=conversation_id
- )
+ event.listen(db.session.session_factory, "after_begin", observe_naming_session)
+ plugin_http._httpx_client.event_hooks["request"].append(observe_naming_request)
+ try:
+ with naming_app.app_context(), use_credit_usage_metadata({"request_id": "naming-request"}):
+ outer_session = db.session()
+ renamed = services.installed_apps.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 naming_sessions
+ assert all(session is not outer_session and not session.in_transaction() for session in naming_sessions)
+ assert db.session() is outer_session
+ services.installed_apps.conversations.delete(
+ installed_app=admitted_app, account_id=account_id, conversation_id=conversation_id
+ )
+ finally:
+ plugin_http._httpx_client.event_hooks["request"].remove(observe_naming_request)
+ event.remove(db.session.session_factory, "after_begin", observe_naming_session)
+ assert len([path for path, _payload in naming_plugin.requests if path.endswith("/llm/invoke")]) == 1
assert get_credit_usage_metadata() == previous_metadata
assert queued == [conversation_id]
assert active_connections == 0
diff --git a/api/tests/unit_tests/repositories/test_installed_app_conversation_repository.py b/api/tests/unit_tests/repositories/test_conversation_repository.py
similarity index 78%
rename from api/tests/unit_tests/repositories/test_installed_app_conversation_repository.py
rename to api/tests/unit_tests/repositories/test_conversation_repository.py
index b4476ec79d6..734635e6545 100644
--- a/api/tests/unit_tests/repositories/test_installed_app_conversation_repository.py
+++ b/api/tests/unit_tests/repositories/test_conversation_repository.py
@@ -10,15 +10,19 @@ 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.enums import ConversationFromSource, CreatorUserRole, EndUserType
from models.enums import InvokeFrom as ModelInvokeFrom
-from models.model import App, AppMode, Conversation, InstalledApp, Message
+from models.model import App, AppMode, Conversation, EndUser, InstalledApp, Message
from models.web import PinnedConversation
-from repositories.installed_app_conversation_repository import SQLAlchemyInstalledAppConversationRepository
+from repositories.conversation_repository import ConversationRepository
+from services.entities.conversation_entities import (
+ ConversationPage,
+ EndUserConversationRef,
+ InstalledAppConversationRef,
+)
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"
@@ -110,7 +114,7 @@ def _pin(
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)
+ repository = ConversationRepository(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=())
@@ -130,7 +134,7 @@ def test_page_keeps_updated_order_cursor_and_detached_inputs(
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)
+ repository = ConversationRepository(session_factory=sqlite_session_factory)
first_page = repository.get_page(
installed_app=installation, account_id=_ACCOUNT_ID, last_id=None, limit=2, pinned=None
@@ -160,7 +164,7 @@ def test_page_keeps_existing_strict_timestamp_behavior_for_ties(
with sqlite_session_factory.begin() as session:
_conversation(session, installation)
_conversation(session, installation)
- repository = SQLAlchemyInstalledAppConversationRepository(session_factory=sqlite_session_factory)
+ repository = ConversationRepository(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
@@ -183,7 +187,7 @@ def test_page_filters_invoke_source_and_scopes_pins_to_account_role_and_owner(
_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)
+ repository = ConversationRepository(session_factory=sqlite_session_factory)
for pinned, expected in [(None, [legacy.id, explore.id]), (True, [legacy.id]), (False, [explore.id])]:
page = repository.get_page(
@@ -209,7 +213,7 @@ def test_every_conversation_ownership_predicate_protects_reads_and_mutations(
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)
+ repository = ConversationRepository(session_factory=sqlite_session_factory)
assert (
repository.get_page(
@@ -222,14 +226,22 @@ def test_every_conversation_ownership_predicate_protects_reads_and_mutations(
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)
+ repository.get(
+ ref=InstalledAppConversationRef(
+ 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)
+ repository.get_name_source(
+ ref=InstalledAppConversationRef(
+ 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,
+ ref=InstalledAppConversationRef(
+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation_id
+ ),
name="Unauthorized",
updated_at=_TIME,
)
@@ -263,17 +275,21 @@ def test_all_operations_revalidate_complete_installation_and_actual_app(
session.delete(installed_app)
else:
installation = replace(installation, **{mismatch: str(uuid4())})
- repository = SQLAlchemyInstalledAppConversationRepository(session_factory=sqlite_session_factory)
+ repository = ConversationRepository(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)
+ repository.get_name_source(
+ ref=InstalledAppConversationRef(
+ 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,
+ ref=InstalledAppConversationRef(
+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id
+ ),
name="Unauthorized",
updated_at=_TIME,
)
@@ -293,7 +309,7 @@ def test_name_source_uses_first_message_and_real_app_owner_tenant(
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)
+ repository = ConversationRepository(session_factory=sqlite_session_factory)
connection_events: list[str] = []
@event.listens_for(sqlite_engine, "checkout")
@@ -305,12 +321,18 @@ def test_name_source_uses_first_message_and_real_app_owner_tenant(
connection_events.append("checkin")
result = repository.get_name_source(
- installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id
+ ref=InstalledAppConversationRef(
+ 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)
+ record = repository.get(
+ ref=InstalledAppConversationRef(
+ 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"]
@@ -324,9 +346,13 @@ def test_name_source_rejects_missing_message_and_message_from_other_app(
_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)
+ repository = ConversationRepository(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)
+ repository.get_name_source(
+ ref=InstalledAppConversationRef(
+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id
+ )
+ )
@pytest.mark.parametrize("updated_at", [None, _TIME + timedelta(hours=1)])
@@ -335,11 +361,11 @@ def test_rename_commits_and_materializes_automatic_or_explicit_updated_at(
) -> None:
with sqlite_session_factory.begin() as session:
conversation = _conversation(session, installation)
- repository = SQLAlchemyInstalledAppConversationRepository(session_factory=sqlite_session_factory)
+ repository = ConversationRepository(session_factory=sqlite_session_factory)
result = repository.rename(
- installed_app=installation,
- account_id=_ACCOUNT_ID,
- conversation_id=conversation.id,
+ ref=InstalledAppConversationRef(
+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id
+ ),
name="",
updated_at=updated_at,
)
@@ -357,32 +383,6 @@ def test_rename_commits_and_materializes_automatic_or_explicit_updated_at(
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:
@@ -391,7 +391,7 @@ def test_pin_and_unpin_are_idempotent_and_preserve_other_owners(
_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)
+ repository = ConversationRepository(session_factory=sqlite_session_factory)
for _ in range(2):
repository.set_pinned(
installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id, is_pinned=True
@@ -423,7 +423,7 @@ def test_existing_pin_and_unpin_do_not_require_live_conversation(
missing_id = str(uuid4())
with sqlite_session_factory.begin() as session:
_pin(session, installation, missing_id)
- repository = SQLAlchemyInstalledAppConversationRepository(session_factory=sqlite_session_factory)
+ repository = ConversationRepository(session_factory=sqlite_session_factory)
repository.set_pinned(
installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=missing_id, is_pinned=True
)
@@ -455,7 +455,7 @@ def test_delete_commits_soft_deletion_and_returns_owner_tenant_for_cleanup(
for index in range(workspace_count)
]
session.add_all(workspaces)
- repository = SQLAlchemyInstalledAppConversationRepository(session_factory=sqlite_session_factory)
+ repository = ConversationRepository(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
@@ -491,14 +491,14 @@ def test_failed_commit_rolls_back_mutations_and_propagates_original_error(
def fail_commit(_session: Session) -> None:
raise failure
- repository = SQLAlchemyInstalledAppConversationRepository(session_factory=failing_factory)
+ repository = ConversationRepository(session_factory=failing_factory)
def mutate() -> None:
if operation == "rename":
repository.rename(
- installed_app=installation,
- account_id=_ACCOUNT_ID,
- conversation_id=conversation.id,
+ ref=InstalledAppConversationRef(
+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=conversation.id
+ ),
name="Discarded",
updated_at=_TIME + timedelta(hours=1),
)
@@ -519,3 +519,60 @@ def test_failed_commit_rolls_back_mutations_and_propagates_original_error(
assert stored.updated_at == _TIME
assert stored.is_deleted is False
assert session.scalars(select(PinnedConversation)).all() == []
+
+
+def test_end_user_and_installed_account_refs_never_cross_owner_domains(
+ sqlite_session_factory: sessionmaker[Session], installation: InstalledAppRef
+) -> None:
+ with sqlite_session_factory.begin() as session:
+ account_conversation = _conversation(session, installation)
+ end_user = EndUser(
+ id=_ACCOUNT_ID,
+ tenant_id=installation.app_owner_tenant_id,
+ app_id=installation.app_id,
+ type=EndUserType.BROWSER,
+ session_id=str(uuid4()),
+ )
+ session.add(end_user)
+ end_user_conversation = Conversation(
+ app_id=installation.app_id,
+ mode=AppMode.CHAT,
+ name="End-user conversation",
+ _inputs={},
+ from_source=ConversationFromSource.API,
+ from_end_user_id=end_user.id,
+ from_account_id=None,
+ is_deleted=False,
+ )
+ session.add(end_user_conversation)
+ session.flush()
+ account_ref = InstalledAppConversationRef(
+ installed_app=installation, account_id=_ACCOUNT_ID, conversation_id=account_conversation.id
+ )
+ end_user_ref = EndUserConversationRef(
+ app_id=installation.app_id,
+ tenant_id=installation.app_owner_tenant_id,
+ end_user_id=end_user.id,
+ conversation_id=end_user_conversation.id,
+ )
+ _message(session, account_conversation, query="Account question", created_at=_TIME)
+ _message(session, end_user_conversation, query="End-user question", created_at=_TIME)
+ repository = ConversationRepository(session_factory=sqlite_session_factory)
+ assert repository.get(ref=account_ref).name == "Original name"
+ assert repository.get(ref=end_user_ref).name == "End-user conversation"
+ assert repository.get_name_source(ref=account_ref).query == "Account question"
+ assert repository.get_name_source(ref=end_user_ref).query == "End-user question"
+
+ for foreign_ref in (
+ replace(account_ref, conversation_id=end_user_ref.conversation_id),
+ replace(end_user_ref, conversation_id=account_ref.conversation_id),
+ replace(end_user_ref, tenant_id=installation.tenant_id),
+ ):
+ with pytest.raises(ConversationNotExistsError):
+ repository.get(ref=foreign_ref)
+ with pytest.raises(ConversationNotExistsError):
+ repository.get_name_source(ref=foreign_ref)
+ with pytest.raises(ConversationNotExistsError):
+ repository.rename(ref=foreign_ref, name="Forbidden", updated_at=_TIME)
+ assert repository.get(ref=account_ref).name == "Original name"
+ assert repository.get(ref=end_user_ref).name == "End-user conversation"
diff --git a/api/tests/unit_tests/services/test_conversation_name_generator.py b/api/tests/unit_tests/services/test_conversation_name_generator.py
new file mode 100644
index 00000000000..94d2994e400
--- /dev/null
+++ b/api/tests/unit_tests/services/test_conversation_name_generator.py
@@ -0,0 +1,234 @@
+"""Real provider resolution keeps naming metadata and the caller's session isolated."""
+
+from uuid import uuid4
+
+import httpx
+import pytest
+from flask import Flask
+from sqlalchemy import Connection, event, select
+from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
+
+from core.credit_usage import CreditUsageAppType, CreditUsageCreatedBy
+from core.errors.error import ProviderTokenNotInitError
+from core.llm_generator.prompts import CONVERSATION_TITLE_PROMPT
+from core.model_context import get_credit_usage_metadata, use_credit_usage_metadata
+from core.plugin.impl import base as plugin_http
+from extensions.ext_database import db
+from graphon.model_runtime.entities.model_entities import ModelType
+from graphon.model_runtime.errors.invoke import InvokeServerUnavailableError
+from models import App, AppMode, Tenant
+from models.provider import Provider, TenantDefaultModel
+from services.conversation_name_generator import generate_conversation_name
+from tests.helpers.unit.services.conversation_name_fixtures import _MODEL, _PROVIDER, NamingPlugin
+
+pytest_plugins = ("tests.helpers.unit.services.conversation_name_fixtures",)
+
+
[email protected]("fail_invoke", [False, True], ids=["success", "provider-error"])
+def test_real_provider_invocation_releases_preparation_session_and_preserves_caller(
+ naming_app: Flask,
+ naming_plugin: NamingPlugin,
+ sqlite_session_factory: sessionmaker[Session],
+ fail_invoke: bool,
+) -> None:
+ naming_plugin.fail_invoke = fail_invoke
+ tenant = Tenant(name="Naming workspace")
+ target = App(
+ id=str(uuid4()),
+ tenant_id=tenant.id,
+ name="Original app",
+ mode=AppMode.CHAT,
+ enable_site=True,
+ enable_api=True,
+ )
+ with sqlite_session_factory.begin() as session:
+ session.add_all(
+ [
+ tenant,
+ target,
+ Provider(tenant_id=tenant.id, provider_name=_PROVIDER, is_valid=True),
+ TenantDefaultModel(
+ tenant_id=tenant.id, provider_name=_PROVIDER, model_name=_MODEL, model_type=ModelType.LLM
+ ),
+ ]
+ )
+
+ naming_sessions: list[Session] = []
+ invocation_metadata: list[dict[str, object]] = []
+ preparation_sessions: list[Session] = []
+
+ def observe_transaction(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
+ naming_sessions.append(session)
+
+ def observe_request(request: httpx.Request) -> None:
+ if request.url.path.endswith("/llm/invoke"):
+ preparation_sessions.extend(naming_sessions)
+ assert preparation_sessions
+ assert all(not session.in_transaction() and not session.identity_map for session in preparation_sessions)
+ assert caller_session.get_transaction() is caller_transaction
+ assert caller_app is not None
+ assert caller_app in caller_session.dirty
+ assert caller_app.name == "Pending caller edit"
+ invocation_metadata.append(dict(get_credit_usage_metadata() or {}))
+
+ with naming_app.app_context():
+ caller_session = db.session()
+ caller_app = caller_session.get(App, target.id)
+ assert caller_app is not None
+ caller_app.name = "Pending caller edit"
+ caller_transaction = caller_session.get_transaction()
+ original_metadata = get_credit_usage_metadata()
+ event.listen(db.session.session_factory, "after_begin", observe_transaction)
+ plugin_http._httpx_client.event_hooks["request"].append(observe_request)
+ try:
+ with use_credit_usage_metadata({"request_id": "name-request", "app_id": target.id}):
+ inherited_metadata = dict(get_credit_usage_metadata() or {})
+ if fail_invoke:
+ with pytest.raises(InvokeServerUnavailableError, match="Title provider unavailable"):
+ generate_conversation_name(
+ tenant_id=tenant.id,
+ app_id=target.id,
+ conversation_id=str(uuid4()),
+ query="First\nquery",
+ app_mode=target.mode,
+ )
+ else:
+ name = generate_conversation_name(
+ tenant_id=tenant.id,
+ app_id=target.id,
+ conversation_id=str(uuid4()),
+ query="First\nquery",
+ app_mode=target.mode,
+ )
+ assert name == "A generated title"
+ assert get_credit_usage_metadata() == inherited_metadata
+ finally:
+ plugin_http._httpx_client.event_hooks["request"].remove(observe_request)
+ event.remove(db.session.session_factory, "after_begin", observe_transaction)
+
+ assert invocation_metadata == [
+ {
+ **inherited_metadata,
+ "app_type": CreditUsageAppType.CHATBOT,
+ "created_by": CreditUsageCreatedBy.CONVERSATION_NAME,
+ }
+ ]
+ assert get_credit_usage_metadata() == original_metadata
+ assert db.session() is caller_session
+ assert caller_session.get_transaction() is caller_transaction
+ assert caller_session.in_transaction()
+ assert caller_app in caller_session.dirty
+ assert caller_app.name == "Pending caller edit"
+ assert all(session is not caller_session for session in naming_sessions)
+ assert all(not session.in_transaction() and not session.identity_map for session in naming_sessions)
+ if fail_invoke:
+ assert naming_sessions == preparation_sessions
+ else:
+ # Trace configuration is read after invocation using a new inner session.
+ assert len(naming_sessions) > len(preparation_sessions)
+ assert naming_sessions[-1] not in preparation_sessions
+ with sqlite_session_factory() as session:
+ assert session.scalar(select(App.name).where(App.id == target.id)) == "Original app"
+
+ invocations = [payload for path, payload in naming_plugin.requests if path.endswith("/llm/invoke")]
+ assert len(invocations) == 1
+ assert invocations[0]["app_id"] == target.id
+ assert invocations[0]["data"] == {
+ "provider": "naming",
+ "model_type": "llm",
+ "model": _MODEL,
+ "credentials": {},
+ "prompt_messages": [{"role": "user", "content": CONVERSATION_TITLE_PROMPT + "First query\n", "name": None}],
+ "model_parameters": {"max_tokens": 500, "temperature": 1},
+ "tools": None,
+ "stop": None,
+ "stream": False,
+ }
+
+
+ ("app_mode", "app_type"),
+ [
+ (AppMode.CHAT, CreditUsageAppType.CHATBOT),
+ (AppMode.AGENT_CHAT, CreditUsageAppType.AGENT),
+ (AppMode.ADVANCED_CHAT, CreditUsageAppType.CHATFLOW),
+ (AppMode.AGENT, CreditUsageAppType.AGENT_V2),
+ ],
+)
+def test_provider_resolution_failure_closes_inner_session_and_preserves_caller_context(
+ naming_app: Flask,
+ sqlite_session_factory: sessionmaker[Session],
+ app_mode: AppMode,
+ app_type: CreditUsageAppType,
+) -> None:
+ tenant = Tenant(name="Naming workspace")
+ target = App(
+ id=str(uuid4()),
+ tenant_id=tenant.id,
+ name="Original app",
+ mode=app_mode,
+ enable_site=True,
+ enable_api=True,
+ )
+ with sqlite_session_factory.begin() as session:
+ session.add_all([tenant, target])
+
+ provider_sessions: list[Session] = []
+ metadata: list[dict[str, object]] = []
+
+ def observe_provider_transaction(
+ session: Session, _transaction: SessionTransaction, connection: Connection
+ ) -> None:
+ # Observe real default-model/provider SQL within the nested app context.
+ # A missing default model fails before plugin I/O.
+ assert session is db.session()
+ assert connection.scalar(select(App.name).where(App.id == target.id)) == "Original app"
+ provider_sessions.append(session)
+ metadata.append(dict(get_credit_usage_metadata() or {}))
+
+ with naming_app.app_context():
+ caller_session = db.session()
+ caller_app = caller_session.get(App, target.id)
+ assert caller_app is not None
+ caller_app.name = "Pending caller edit"
+ caller_transaction = caller_session.get_transaction()
+ original_metadata = get_credit_usage_metadata()
+ event.listen(db.session.session_factory, "after_begin", observe_provider_transaction)
+ try:
+ with use_credit_usage_metadata({"request_id": "name-request"}):
+ inherited_metadata = dict(get_credit_usage_metadata() or {})
+ with pytest.raises(ProviderTokenNotInitError, match="^Default model not found for llm$"):
+ generate_conversation_name(
+ tenant_id=target.tenant_id,
+ app_id=target.id,
+ conversation_id=str(uuid4()),
+ query="First query",
+ app_mode=app_mode.value,
+ )
+ assert get_credit_usage_metadata() == inherited_metadata
+ finally:
+ event.remove(db.session.session_factory, "after_begin", observe_provider_transaction)
+ assert get_credit_usage_metadata() == original_metadata
+ assert provider_sessions
+ assert all(
+ observed
+ == {
+ **inherited_metadata,
+ "app_type": app_type,
+ "created_by": CreditUsageCreatedBy.CONVERSATION_NAME,
+ }
+ for observed in metadata
+ )
+ assert db.session() is caller_session
+ assert caller_session.get_transaction() is caller_transaction
+ assert caller_session.in_transaction()
+ assert caller_app in caller_session.dirty
+ assert caller_app.name == "Pending caller edit"
+ for provider_session in provider_sessions:
+ assert provider_session is not caller_session
+ assert not provider_session.in_transaction()
+ assert not provider_session.identity_map
+ with sqlite_session_factory() as session:
+ stored_app = session.get(App, target.id)
+ assert stored_app is not None
+ assert stored_app.name == "Original app"
diff --git a/api/tests/unit_tests/services/test_conversation_name_service.py b/api/tests/unit_tests/services/test_conversation_name_service.py
new file mode 100644
index 00000000000..1a29113eb79
--- /dev/null
+++ b/api/tests/unit_tests/services/test_conversation_name_service.py
@@ -0,0 +1,340 @@
+"""Conversation naming with real ownership checks and bounded SQLite transactions."""
+
+from dataclasses import replace
+from datetime import datetime, timedelta
+from decimal import Decimal
+from uuid import uuid4
+
+import pytest
+from pydantic import JsonValue
+from sqlalchemy import Engine, delete, event, inspect, select, update
+from sqlalchemy.orm import Session, sessionmaker
+
+from models.enums import ConversationFromSource, EndUserType
+from models.model import App, AppMode, Conversation, EndUser, Message
+from repositories.conversation_repository import ConversationRepository
+from services.conversation_name_service import (
+ ConversationNameRequiredError,
+ ConversationNameService,
+)
+from services.entities.conversation_entities import ConversationRecord, EndUserConversationRef
+from services.errors.conversation import ConversationNotExistsError
+from services.errors.message import MessageNotExistsError
+
+_TIME = datetime(2024, 1, 1, 12, 0)
+_INPUTS: dict[str, JsonValue] = {"empty": "", "list": [], "zero": 0, "flag": False, "none": None}
+
+
+def conversation_ref(sqlite_session_factory: sessionmaker[Session]) -> EndUserConversationRef:
+ with sqlite_session_factory.begin() as session:
+ app = App(tenant_id=str(uuid4()), name="Chat", mode=AppMode.CHAT, enable_site=True, enable_api=True)
+ session.add(app)
+ session.flush()
+ end_user = EndUser(tenant_id=app.tenant_id, app_id=app.id, type=EndUserType.BROWSER, session_id=str(uuid4()))
+ session.add(end_user)
+ session.flush()
+ conversation = Conversation(
+ app_id=app.id,
+ mode=AppMode.CHAT,
+ name="Original name",
+ _inputs=dict(_INPUTS),
+ introduction=None,
+ from_source=ConversationFromSource.API,
+ from_end_user_id=end_user.id,
+ from_account_id=None,
+ is_deleted=False,
+ )
+ conversation.created_at = _TIME - timedelta(days=1)
+ conversation.updated_at = _TIME
+ session.add(conversation)
+ session.flush()
+ return EndUserConversationRef(
+ app_id=app.id, tenant_id=app.tenant_id, end_user_id=end_user.id, conversation_id=conversation.id
+ )
+
+
+def repository(sqlite_session_factory: sessionmaker[Session]) -> ConversationRepository:
+ return ConversationRepository(session_factory=sqlite_session_factory)
+
+
+def _message(session: Session, ref: EndUserConversationRef, *, query: str, created_at: datetime) -> None:
+ message = Message(
+ app_id=ref.app_id,
+ conversation_id=ref.conversation_id,
+ _inputs={},
+ query=query,
+ message={},
+ message_unit_price=Decimal(0),
+ answer="",
+ answer_unit_price=Decimal(0),
+ currency="USD",
+ from_source=ConversationFromSource.API,
+ from_end_user_id=ref.end_user_id,
+ )
+ message.created_at = created_at
+ session.add(message)
+
+
+def _rename(
+ service: ConversationNameService,
+ ref: EndUserConversationRef,
+ *,
+ name: str | None = None,
+ auto_generate: bool = True,
+) -> ConversationRecord:
+ return service.rename(
+ ref=ref,
+ app_mode="chat",
+ name=name,
+ auto_generate=auto_generate,
+ )
+
+
+def _unexpected_generation(**_kwargs: str) -> str:
+ raise AssertionError("Manual names and invalid ownership must not enter the model provider")
+
+
+def test_automatic_name_closes_source_connection_before_provider_and_reopens_for_write(
+ sqlite_session_factory: sessionmaker[Session],
+ sqlite_engine: Engine,
+ conversation_ref: EndUserConversationRef,
+ repository: ConversationRepository,
+) -> None:
+ with sqlite_session_factory.begin() as session:
+ _message(session, conversation_ref, query="Later", created_at=_TIME)
+ _message(session, conversation_ref, query="First", created_at=_TIME - timedelta(hours=1))
+ connection_events: list[str] = []
+
+ @event.listens_for(sqlite_engine, "checkout")
+ def checkout(_connection: object, _record: object, _proxy: object) -> None:
+ connection_events.append("checkout")
+
+ @event.listens_for(sqlite_engine, "checkin")
+ def checkin(_connection: object, _record: object) -> None:
+ connection_events.append("checkin")
+
+ def generate_name(*, tenant_id: str, app_id: str, conversation_id: str, query: str, app_mode: str) -> str:
+ assert connection_events == ["checkout", "checkin"]
+ assert (tenant_id, app_id, conversation_id, query, app_mode) == (
+ conversation_ref.tenant_id,
+ conversation_ref.app_id,
+ conversation_ref.conversation_id,
+ "First",
+ "chat",
+ )
+ connection_events.append("generate")
+ return "Generated name"
+
+ result = _rename(ConversationNameService(conversations=repository, generate_name=generate_name), conversation_ref)
+ assert connection_events == ["checkout", "checkin", "generate", "checkout", "checkin"]
+ assert inspect(result, raiseerr=False) is None
+ assert result.name == "Generated name"
+ assert result.inputs == _INPUTS
+ assert result.introduction is None
+ assert result.created_at == _TIME - timedelta(days=1)
+ stored = repository.get(ref=conversation_ref)
+ assert stored == result
+ # The model's existing onupdate default still runs for an automatic name.
+ assert result.updated_at != _TIME
+
+
[email protected]("name", ["Manual name", ""])
+def test_manual_name_commits_without_entering_provider(
+ conversation_ref: EndUserConversationRef, repository: ConversationRepository, name: str
+) -> None:
+ result = _rename(
+ ConversationNameService(conversations=repository, generate_name=_unexpected_generation),
+ conversation_ref,
+ name=name,
+ auto_generate=False,
+ )
+ assert result.name == name
+ assert result.updated_at is not None
+ assert result.updated_at > _TIME
+ assert result.inputs == _INPUTS
+ assert repository.get(ref=conversation_ref) == result
+
+
+def test_missing_manual_name_does_not_touch_database(
+ sqlite_engine: Engine, conversation_ref: EndUserConversationRef, repository: ConversationRepository
+) -> None:
+ statements: list[str] = []
+
+ @event.listens_for(sqlite_engine, "before_cursor_execute")
+ def record_statement(
+ _connection: object,
+ _cursor: object,
+ statement: str,
+ _parameters: object,
+ _context: object,
+ _executemany: object,
+ ) -> None:
+ statements.append(statement)
+
+ with pytest.raises(ConversationNameRequiredError):
+ _rename(
+ ConversationNameService(conversations=repository, generate_name=_unexpected_generation),
+ conversation_ref,
+ auto_generate=False,
+ )
+ assert statements == []
+
+
+def test_generation_failure_returns_fresh_record_and_does_not_overwrite_concurrent_name(
+ sqlite_session_factory: sessionmaker[Session],
+ conversation_ref: EndUserConversationRef,
+ repository: ConversationRepository,
+) -> None:
+ with sqlite_session_factory.begin() as session:
+ _message(session, conversation_ref, query="First", created_at=_TIME)
+
+ def generate_name(**_kwargs: str) -> str:
+ with sqlite_session_factory.begin() as session:
+ conversation = session.get(Conversation, conversation_ref.conversation_id)
+ assert conversation is not None
+ conversation.name = "Changed while generating"
+ conversation.updated_at = _TIME + timedelta(hours=1)
+ raise RuntimeError("Provider unavailable")
+
+ result = _rename(ConversationNameService(conversations=repository, generate_name=generate_name), conversation_ref)
+ assert result.name == "Changed while generating"
+ assert result.updated_at == _TIME + timedelta(hours=1)
+ assert repository.get(ref=conversation_ref) == result
+
+
+def test_write_commit_failure_rolls_back_and_is_not_suppressed_as_provider_failure(
+ sqlite_session_factory: sessionmaker[Session],
+ sqlite_engine: Engine,
+ conversation_ref: EndUserConversationRef,
+ repository: ConversationRepository,
+) -> None:
+ with sqlite_session_factory.begin() as session:
+ _message(session, conversation_ref, query="First", created_at=_TIME)
+ failing_factory = sessionmaker(bind=sqlite_engine)
+
+ @event.listens_for(failing_factory, "before_commit")
+ def fail_commit(_session: Session) -> None:
+ raise RuntimeError("Database commit unavailable")
+
+ def generate_name(**_kwargs: str) -> str:
+ return "Must be rolled back"
+
+ service = ConversationNameService(
+ conversations=ConversationRepository(session_factory=failing_factory),
+ generate_name=generate_name,
+ )
+ with pytest.raises(RuntimeError, match="Database commit unavailable"):
+ _rename(service, conversation_ref)
+ record = repository.get(ref=conversation_ref)
+ assert record.name == "Original name"
+ assert record.updated_at == _TIME
+
+
[email protected]("change", ["soft_delete", "hard_delete", "end_user", "tenant"])
+def test_generation_rechecks_ownership_and_deletion_before_writing(
+ sqlite_session_factory: sessionmaker[Session],
+ conversation_ref: EndUserConversationRef,
+ repository: ConversationRepository,
+ change: str,
+) -> None:
+ with sqlite_session_factory.begin() as session:
+ _message(session, conversation_ref, query="First", created_at=_TIME)
+
+ def generate_name(**_kwargs: str) -> str:
+ with sqlite_session_factory.begin() as session:
+ statement = update(Conversation).where(Conversation.id == conversation_ref.conversation_id)
+ if change == "hard_delete":
+ session.execute(delete(Message).where(Message.conversation_id == conversation_ref.conversation_id))
+ session.execute(delete(Conversation).where(Conversation.id == conversation_ref.conversation_id))
+ elif change == "soft_delete":
+ session.execute(statement.values(is_deleted=True))
+ elif change == "end_user":
+ session.execute(statement.values(from_end_user_id=str(uuid4())))
+ else:
+ session.execute(update(App).where(App.id == conversation_ref.app_id).values(tenant_id=str(uuid4())))
+ return "Must not be written"
+
+ with pytest.raises(ConversationNotExistsError):
+ _rename(ConversationNameService(conversations=repository, generate_name=generate_name), conversation_ref)
+ with sqlite_session_factory() as session:
+ stored = session.get(Conversation, conversation_ref.conversation_id)
+ if change == "hard_delete":
+ assert stored is None
+ else:
+ assert stored is not None
+ assert stored.name == "Original name"
+
+
+ "mismatch",
+ [
+ "app_id",
+ "tenant_id",
+ "end_user_id",
+ "conversation_app",
+ "source",
+ "account",
+ "deleted",
+ "user_app",
+ "user_tenant",
+ ],
+)
+def test_complete_owner_chain_protects_source_reads_and_writes(
+ sqlite_session_factory: sessionmaker[Session],
+ conversation_ref: EndUserConversationRef,
+ repository: ConversationRepository,
+ mismatch: str,
+) -> None:
+ original_ref = conversation_ref
+ with sqlite_session_factory.begin() as session:
+ _message(session, conversation_ref, query="First", created_at=_TIME)
+ if mismatch in {"app_id", "tenant_id", "end_user_id"}:
+ conversation_ref = replace(conversation_ref, **{mismatch: str(uuid4())})
+ elif mismatch in {"user_app", "user_tenant"}:
+ column = "app_id" if mismatch == "user_app" else "tenant_id"
+ session.execute(
+ update(EndUser).where(EndUser.id == conversation_ref.end_user_id).values({column: str(uuid4())})
+ )
+ else:
+ changes = {
+ "conversation_app": {"app_id": str(uuid4())},
+ "source": {"from_source": ConversationFromSource.CONSOLE},
+ "account": {"from_account_id": str(uuid4())},
+ "deleted": {"is_deleted": True},
+ }
+ session.execute(
+ update(Conversation)
+ .where(Conversation.id == conversation_ref.conversation_id)
+ .values(changes[mismatch])
+ )
+ for operation in [repository.get, repository.get_name_source]:
+ with pytest.raises(ConversationNotExistsError):
+ operation(ref=conversation_ref)
+ service = ConversationNameService(conversations=repository, generate_name=_unexpected_generation)
+ with pytest.raises(ConversationNotExistsError):
+ _rename(service, conversation_ref)
+ with pytest.raises(ConversationNotExistsError):
+ _rename(service, conversation_ref, name="Unauthorized", auto_generate=False)
+ with sqlite_session_factory() as session:
+ assert session.scalar(select(Conversation.name).where(Conversation.id == original_ref.conversation_id)) == (
+ "Original name"
+ )
+
+
[email protected]("foreign_message", [False, True])
+def test_automatic_name_requires_a_message_from_the_owned_app(
+ sqlite_session_factory: sessionmaker[Session],
+ conversation_ref: EndUserConversationRef,
+ repository: ConversationRepository,
+ foreign_message: bool,
+) -> None:
+ if foreign_message:
+ with sqlite_session_factory.begin() as session:
+ _message(session, replace(conversation_ref, app_id=str(uuid4())), query="Wrong app", created_at=_TIME)
+ with pytest.raises(MessageNotExistsError):
+ _rename(
+ ConversationNameService(conversations=repository, generate_name=_unexpected_generation), conversation_ref
+ )
+ assert repository.get(ref=conversation_ref).name == "Original name"
diff --git a/api/tests/unit_tests/services/test_conversation_service.py b/api/tests/unit_tests/services/test_conversation_service.py
index bfc1fcfbec1..197fa6b83a3 100644
--- a/api/tests/unit_tests/services/test_conversation_service.py
+++ b/api/tests/unit_tests/services/test_conversation_service.py
@@ -10,7 +10,6 @@ in-memory SQLite sessions with persisted ORM rows.
import json
from dataclasses import replace
from datetime import timedelta
-from decimal import Decimal
from unittest.mock import MagicMock
from uuid import UUID
@@ -19,8 +18,6 @@ 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 factories import variable_factory
from libs.datetime_utils import naive_utc_now
from models import Account, ConversationVariable
@@ -32,12 +29,11 @@ from models.agent import (
AgentWorkspaceOwnerType,
)
from models.enums import AppStatus, ConversationFromSource, ConversationStatus
-from models.model import App, AppMode, Conversation, Message
+from models.model import App, AppMode, Conversation
from repositories.conversation_lifecycle import retire_conversation
from services import conversation_service
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"
@@ -397,70 +393,6 @@ def test_cleanup_propagates_agent_enqueue_failure_before_conversation_enqueue(mo
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_conversation_service.py b/api/tests/unit_tests/services/test_installed_app_conversation_service.py
index 356d0dedfed..7b91472f902 100644
--- a/api/tests/unit_tests/services/test_installed_app_conversation_service.py
+++ b/api/tests/unit_tests/services/test_installed_app_conversation_service.py
@@ -1,232 +1,289 @@
-"""Conversation orchestration over a stateful persistence fake."""
+"""Installed-app conversation orchestration over real SQLite transactions."""
-from collections.abc import Callable
-from dataclasses import dataclass, field, replace
+from dataclasses import replace
from datetime import datetime
+from decimal import Decimal
+from uuid import uuid4
import pytest
-
+from sqlalchemy import Engine, delete, event, select, update
+from sqlalchemy.orm import Session, sessionmaker
+
+from models.enums import ConversationFromSource
+from models.model import App, AppMode, Conversation, InstalledApp, Message
+from repositories.conversation_repository import ConversationRepository
+from services.conversation_name_service import (
+ ConversationNameGenerator,
+ ConversationNameRequiredError,
+ ConversationNameService,
+)
+from services.entities.conversation_entities import InstalledAppConversationRef
from services.errors.conversation import ConversationNotExistsError
-from services.installed_app_access_service import InstalledAppRef
+from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppRef
from services.installed_app_conversation_service import (
- ConversationDeletion,
- ConversationNameRequiredError,
- ConversationNameSource,
+ ConversationCleanup,
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_owner_tenant_id="66666666-6666-4666-8666-666666666666",
- 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,
+_TIME = datetime(2024, 1, 1)
+
+
+def ref(sqlite_session_factory: sessionmaker[Session]) -> InstalledAppConversationRef:
+ with sqlite_session_factory.begin() as session:
+ app = App(tenant_id=str(uuid4()), name="Shared chat", mode=AppMode.CHAT, enable_site=True, enable_api=True)
+ session.add(app)
+ session.flush()
+ installation = InstalledApp(
+ tenant_id=str(uuid4()), app_id=app.id, app_owner_tenant_id=app.tenant_id, position=0, is_pinned=False
)
- 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"),
+ session.add(installation)
+ session.flush()
+ account_id = str(uuid4())
+ conversation = Conversation(
+ app_id=app.id,
+ mode=AppMode.CHAT,
+ name="Original",
+ _inputs={"count": 0},
+ from_source=ConversationFromSource.CONSOLE,
+ from_account_id=account_id,
+ from_end_user_id=None,
+ is_deleted=False,
)
-
- 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",
+ conversation.updated_at = _TIME
+ session.add(conversation)
+ session.flush()
+ session.add(
+ Message(
+ app_id=app.id,
+ conversation_id=conversation.id,
+ _inputs={},
+ query="First",
+ message={},
+ message_unit_price=Decimal(0),
+ answer="",
+ answer_unit_price=Decimal(0),
+ currency="USD",
+ from_source=ConversationFromSource.CONSOLE,
+ from_account_id=account_id,
+ )
)
- 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,
+ return InstalledAppConversationRef(
+ installed_app=InstalledAppRef(
+ id=installation.id,
+ app_id=app.id,
+ tenant_id=installation.tenant_id,
+ app_owner_tenant_id=app.tenant_id,
+ app_mode=app.mode.value,
+ ),
+ account_id=account_id,
+ conversation_id=conversation.id,
)
- 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 _unexpected_generation(**_kwargs: str) -> str:
+ raise AssertionError("Unexpected generation")
-def orchestration() -> _Orchestration:
- state = _Orchestration(store=_Store())
- state.service = InstalledAppConversationService(
- conversations=state.store,
- generate_name=state.generate_name,
- enqueue_delete_cleanup=state.cleanup,
+
+def _unexpected_cleanup(**_kwargs: object) -> None:
+ raise AssertionError("Unexpected cleanup")
+
+
+def _service(
+ factory: sessionmaker[Session], *, generate_name: ConversationNameGenerator, cleanup: ConversationCleanup
+) -> InstalledAppConversationService:
+ repository = ConversationRepository(session_factory=factory)
+ return InstalledAppConversationService(
+ conversations=repository,
+ names=ConversationNameService(conversations=repository, generate_name=generate_name),
+ enqueue_delete_cleanup=cleanup,
)
- return state
-def test_auto_rename_reads_then_generates_then_writes_without_changing_manual_timestamp(
- orchestration: _Orchestration,
+def test_auto_name_uses_actual_app_owner_and_releases_source_connection(
+ sqlite_session_factory: sessionmaker[Session], sqlite_engine: Engine, ref: InstalledAppConversationRef
) -> None:
- result = orchestration.rename()
- assert result.name == "Generated title"
+ events: list[str] = []
+
+ @event.listens_for(sqlite_engine, "checkout")
+ def checkout(_connection: object, _record: object, _proxy: object) -> None:
+ events.append("checkout")
+
+ @event.listens_for(sqlite_engine, "checkin")
+ def checkin(_connection: object, _record: object) -> None:
+ events.append("checkin")
+
+ def generate_name(*, tenant_id: str, app_id: str, conversation_id: str, query: str, app_mode: str) -> str:
+ assert events == ["checkout", "checkin"]
+ assert tenant_id == ref.installed_app.app_owner_tenant_id != ref.installed_app.tenant_id
+ assert (app_id, conversation_id, query, app_mode) == (ref.app_id, ref.conversation_id, "First", "chat")
+ events.append("generate")
+ return "Generated"
+
+ service = _service(sqlite_session_factory, generate_name=generate_name, cleanup=_unexpected_cleanup)
+ result = service.rename(
+ installed_app=ref.installed_app,
+ account_id=ref.account_id,
+ conversation_id=ref.conversation_id,
+ name="Ignored",
+ auto_generate=True,
+ )
+ assert result.name == "Generated"
assert result.inputs == {"count": 0}
- assert result.updated_at == _UPDATED_AT
- assert orchestration.store.events == ["read source", "generate", "rename"]
-
+ assert result.updated_at != _TIME
+ assert events == ["checkout", "checkin", "generate", "checkout", "checkin"]
+ assert ConversationRepository(session_factory=sqlite_session_factory).get(ref=ref) == result
-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_generation_failure_returns_concurrently_updated_name(
+ sqlite_session_factory: sessionmaker[Session], ref: InstalledAppConversationRef
+) -> None:
+ def generate_name(**_kwargs: str) -> str:
+ with sqlite_session_factory.begin() as session:
+ session.execute(
+ update(Conversation).where(Conversation.id == ref.conversation_id).values(name="Concurrent name")
+ )
+ raise RuntimeError("Provider unavailable")
+
+ service = _service(sqlite_session_factory, generate_name=generate_name, cleanup=_unexpected_cleanup)
+ result = service.rename(
+ installed_app=ref.installed_app,
+ account_id=ref.account_id,
+ conversation_id=ref.conversation_id,
+ name=None,
+ auto_generate=True,
+ )
+ assert result.name == "Concurrent name"
+ assert ConversationRepository(session_factory=sqlite_session_factory).get(ref=ref) == result
-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"]
+ "change", ["conversation_deleted", "account", "installation_deleted", "installation_tenant", "installation_app"]
+)
+def test_auto_name_rechecks_installation_and_account_before_writing(
+ sqlite_session_factory: sessionmaker[Session], ref: InstalledAppConversationRef, change: str
+) -> None:
+ def generate_name(**_kwargs: str) -> str:
+ with sqlite_session_factory.begin() as session:
+ if change == "conversation_deleted":
+ session.execute(
+ update(Conversation).where(Conversation.id == ref.conversation_id).values(is_deleted=True)
+ )
+ elif change == "account":
+ session.execute(
+ update(Conversation)
+ .where(Conversation.id == ref.conversation_id)
+ .values({Conversation.from_account_id: str(uuid4())})
+ )
+ elif change == "installation_deleted":
+ session.execute(delete(InstalledApp).where(InstalledApp.id == ref.installed_app.id))
+ elif change == "installation_tenant":
+ session.execute(
+ update(InstalledApp).where(InstalledApp.id == ref.installed_app.id).values(tenant_id=str(uuid4()))
+ )
+ else:
+ session.execute(
+ update(InstalledApp).where(InstalledApp.id == ref.installed_app.id).values(app_id=str(uuid4()))
+ )
+ return "Must not persist"
+
+ service = _service(sqlite_session_factory, generate_name=generate_name, cleanup=_unexpected_cleanup)
+ error = InstalledAppNotFoundError if change.startswith("installation") else ConversationNotExistsError
+ with pytest.raises(error):
+ service.rename(
+ installed_app=ref.installed_app,
+ account_id=ref.account_id,
+ conversation_id=ref.conversation_id,
+ name=None,
+ auto_generate=True,
+ )
+ with sqlite_session_factory() as session:
+ assert session.scalar(select(Conversation.name).where(Conversation.id == ref.conversation_id)) == "Original"
-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"
+def test_manual_name_is_committed_without_generation(
+ sqlite_session_factory: sessionmaker[Session], ref: InstalledAppConversationRef
+) -> None:
+ service = _service(sqlite_session_factory, generate_name=_unexpected_generation, cleanup=_unexpected_cleanup)
+ result = service.rename(
+ installed_app=ref.installed_app,
+ account_id=ref.account_id,
+ conversation_id=ref.conversation_id,
+ name="Manual",
+ auto_generate=False,
+ )
+ assert result.name == "Manual"
assert result.updated_at is not None
- assert result.updated_at > _UPDATED_AT
- assert orchestration.store.events == ["rename"]
+ assert result.updated_at > _TIME
+ assert ConversationRepository(session_factory=sqlite_session_factory).get(ref=ref) == result
-def test_manual_rename_requires_name_before_writing(orchestration: _Orchestration) -> None:
+def test_missing_manual_name_does_not_modify_conversation(
+ sqlite_session_factory: sessionmaker[Session], ref: InstalledAppConversationRef
+) -> None:
+ service = _service(sqlite_session_factory, generate_name=_unexpected_generation, cleanup=_unexpected_cleanup)
with pytest.raises(ConversationNameRequiredError):
- orchestration.rename(auto_generate=False)
- assert orchestration.store.events == []
+ service.rename(
+ installed_app=ref.installed_app,
+ account_id=ref.account_id,
+ conversation_id=ref.conversation_id,
+ name=None,
+ auto_generate=False,
+ )
+ stored = ConversationRepository(session_factory=sqlite_session_factory).get(ref=ref)
+ assert stored.name == "Original"
+ assert stored.updated_at == _TIME
-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_cleanup_observes_committed_delete_and_app_owner(
+ sqlite_session_factory: sessionmaker[Session], ref: InstalledAppConversationRef
+) -> None:
+ queued: list[str] = []
+
+ def cleanup(*, tenant_id: str, conversation_id: str, retired_workspace_ids: tuple[str, ...]) -> None:
+ assert tenant_id == ref.installed_app.app_owner_tenant_id
+ assert conversation_id == ref.conversation_id
+ assert retired_workspace_ids == ()
+ with sqlite_session_factory() as session:
+ assert session.scalar(select(Conversation.is_deleted).where(Conversation.id == conversation_id)) is True
+ queued.append(conversation_id)
+
+ service = _service(sqlite_session_factory, generate_name=_unexpected_generation, cleanup=cleanup)
+ service.delete(installed_app=ref.installed_app, account_id=ref.account_id, conversation_id=ref.conversation_id)
+ assert queued == [ref.conversation_id]
+
+def test_failed_delete_rolls_back_before_cleanup(
+ sqlite_session_factory: sessionmaker[Session], sqlite_engine: Engine, ref: InstalledAppConversationRef
+) -> None:
+ failing_factory = sessionmaker(bind=sqlite_engine)
+
+ @event.listens_for(failing_factory, "before_commit")
+ def fail_commit(_session: Session) -> None:
+ raise RuntimeError("Commit failed")
-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 == []
+ service = _service(failing_factory, generate_name=_unexpected_generation, cleanup=_unexpected_cleanup)
+ with pytest.raises(RuntimeError, match="Commit failed"):
+ service.delete(installed_app=ref.installed_app, account_id=ref.account_id, conversation_id=ref.conversation_id)
+ assert ConversationRepository(session_factory=sqlite_session_factory).get(ref=ref).name == "Original"
@pytest.mark.parametrize("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
+def test_non_chat_mode_is_rejected_before_rename_or_delete(
+ sqlite_session_factory: sessionmaker[Session], ref: InstalledAppConversationRef, mode: str
+) -> None:
+ service = _service(sqlite_session_factory, generate_name=_unexpected_generation, cleanup=_unexpected_cleanup)
+ installed_app = replace(ref.installed_app, app_mode=mode)
with pytest.raises(ConversationNotChatAppError):
- orchestration.service.delete(
- installed_app=replace(_REF, app_mode=mode), account_id=_ACCOUNT_ID, conversation_id=_CONVERSATION_ID
+ service.rename(
+ installed_app=installed_app,
+ account_id=ref.account_id,
+ conversation_id=ref.conversation_id,
+ name="Forbidden",
+ auto_generate=False,
)
- assert orchestration.store.events == []
- assert orchestration.store.conversation is not None
- assert orchestration.cleanup_calls == []
+ with pytest.raises(ConversationNotChatAppError):
+ service.delete(installed_app=installed_app, account_id=ref.account_id, conversation_id=ref.conversation_id)
+ stored = ConversationRepository(session_factory=sqlite_session_factory).get(ref=ref)
+ assert stored.name == "Original"
diff --git a/packages/contracts/generated/api/service/errors.gen.ts b/packages/contracts/generated/api/service/errors.gen.ts
index 6aa0ea38df2..ef467e76f6f 100644
--- a/packages/contracts/generated/api/service/errors.gen.ts
+++ b/packages/contracts/generated/api/service/errors.gen.ts
@@ -90,6 +90,22 @@ const zCompletionRequestError = /* @__PURE__ */ (() =>
}),
))()
+const zConversationFirstMessageNotFoundError = /* @__PURE__ */ (() =>
+ zErrorResponse.and(
+ z.object({
+ code: z.literal('conversation_first_message_not_found'),
+ status: z.literal(404),
+ }),
+ ))()
+
+const zConversationNotFoundError = /* @__PURE__ */ (() =>
+ zErrorResponse.and(
+ z.object({
+ code: z.literal('conversation_not_found'),
+ status: z.literal(404),
+ }),
+ ))()
+
const zDatasetNameDuplicateError = /* @__PURE__ */ (() =>
zErrorResponse.and(
z.object({
@@ -530,7 +546,20 @@ export const post7Errors = {
provider_quota_exceeded: { status: 400, data: zProviderQuotaExceededError },
}
-export const post8Errors = { not_chat_app: { status: 400, data: zNotChatAppError } }
+export const post8Errors = {
+ app_abnormal_status: { status: 403, data: zAppAbnormalStatusError },
+ app_api_disabled: { status: 403, data: zAppApiDisabledError },
+ app_not_found: { status: 403, data: zAppNotFoundError },
+ conversation_first_message_not_found: {
+ status: 404,
+ data: zConversationFirstMessageNotFoundError,
+ },
+ conversation_not_found: { status: 404, data: zConversationNotFoundError },
+ forbidden: { status: 403, data: zForbiddenError },
+ not_chat_app: { status: 400, data: zNotChatAppError },
+ workspace_archived: { status: 403, data: zWorkspaceArchivedError },
+ workspace_not_found: { status: 403, data: zWorkspaceNotFoundError },
+}
export const put2Errors = { not_chat_app: { status: 400, data: zNotChatAppError } }
diff --git a/packages/contracts/generated/api/service/orpc.gen.ts b/packages/contracts/generated/api/service/orpc.gen.ts
index aefe59bd8b7..512754c6fa6 100644
--- a/packages/contracts/generated/api/service/orpc.gen.ts
+++ b/packages/contracts/generated/api/service/orpc.gen.ts
@@ -13,6 +13,8 @@ import {
zArchivedDocumentImmutableError,
zAudioTooLargeError,
zCompletionRequestError,
+ zConversationFirstMessageNotFoundError,
+ zConversationNotFoundError,
zDatasetNameDuplicateError,
zEndUserNotFoundError,
zFileAccessDeniedError,
@@ -914,7 +916,20 @@ export const post8 = oc
}),
)
.output(zPostConversationsByConversationIdNameResponse)
- .errors({ not_chat_app: { status: 400, data: zNotChatAppError } })
+ .errors({
+ app_abnormal_status: { status: 403, data: zAppAbnormalStatusError },
+ app_api_disabled: { status: 403, data: zAppApiDisabledError },
+ app_not_found: { status: 403, data: zAppNotFoundError },
+ conversation_first_message_not_found: {
+ status: 404,
+ data: zConversationFirstMessageNotFoundError,
+ },
+ conversation_not_found: { status: 404, data: zConversationNotFoundError },
+ forbidden: { status: 403, data: zForbiddenError },
+ not_chat_app: { status: 400, data: zNotChatAppError },
+ workspace_archived: { status: 403, data: zWorkspaceArchivedError },
+ workspace_not_found: { status: 403, data: zWorkspaceNotFoundError },
+ })
export const name = {
post: post8,
diff --git a/packages/contracts/generated/api/service/types.gen.ts b/packages/contracts/generated/api/service/types.gen.ts
index 015e62a0e15..f9c583dee3f 100644
--- a/packages/contracts/generated/api/service/types.gen.ts
+++ b/packages/contracts/generated/api/service/types.gen.ts
@@ -507,6 +507,11 @@ export type Condition = {
value?: string | Array<string> | number | null
}
+export type ConversationFirstMessageNotFoundError = ErrorResponse & {
+ code: 'conversation_first_message_not_found'
+ status: 404
+}
+
export type ConversationInfiniteScrollPagination = {
data: Array<SimpleConversation>
has_more: boolean
@@ -519,6 +524,11 @@ export type ConversationListQuery = {
sort_by?: '-created_at' | '-updated_at' | 'created_at' | 'updated_at'
}
+export type ConversationNotFoundError = ErrorResponse & {
+ code: 'conversation_not_found'
+ status: 404
+}
+
export type ConversationRenamePayload = (
| {
auto_generate: true
@@ -5025,8 +5035,16 @@ export type PostConversationsByConversationIdNameData = {
export type PostConversationsByConversationIdNameErrors = {
400: NotChatAppError | ErrorResponse
401: ErrorResponse
- 403: ErrorResponse
- 404: ErrorResponse
+ 403:
+ | AppAbnormalStatusError
+ | AppApiDisabledError
+ | AppNotFoundError
+ | ForbiddenError
+ | WorkspaceArchivedError
+ | WorkspaceNotFoundError
+ | ErrorResponse
+ 404: ConversationFirstMessageNotFoundError | ConversationNotFoundError | ErrorResponse
+ 422: ErrorResponse
default: ErrorResponse
}
diff --git a/packages/contracts/generated/api/service/zod.gen.ts b/packages/contracts/generated/api/service/zod.gen.ts
index 578de2a6984..8aa6a115612 100644
--- a/packages/contracts/generated/api/service/zod.gen.ts
+++ b/packages/contracts/generated/api/service/zod.gen.ts
@@ -1052,6 +1052,30 @@ export const zCompletionRequestError = zErrorResponse.and(
}),
)
+/**
+ * ConversationFirstMessageNotFoundError
+ *
+ * The conversation has no message from which to generate a name.
+ */
+export const zConversationFirstMessageNotFoundError = zErrorResponse.and(
+ z.object({
+ code: z.literal('conversation_first_message_not_found'),
+ status: z.literal(404),
+ }),
+)
+
+/**
+ * ConversationNotFoundError
+ *
+ * The conversation was not found for this user and app.
+ */
+export const zConversationNotFoundError = zErrorResponse.and(
+ z.object({
+ code: z.literal('conversation_not_found'),
+ status: z.literal(404),
+ }),
+)
+
/**
* DatasetNameDuplicateError
*
@@ -6196,7 +6220,7 @@ export const zPostConversationsByConversationIdNamePath = z.object({
})
/**
- * Conversation renamed successfully.
+ * Conversation renamed successfully; model failure preserves the existing name.
*/
export const zPostConversationsByConversationIdNameResponse = zSimpleConversation
diff --git a/packages/contracts/generated/api/web/errors.gen.ts b/packages/contracts/generated/api/web/errors.gen.ts
index ed6b754b50b..1b4ffd442d8 100644
--- a/packages/contracts/generated/api/web/errors.gen.ts
+++ b/packages/contracts/generated/api/web/errors.gen.ts
@@ -82,6 +82,22 @@ const zCompletionRequestError = /* @__PURE__ */ (() =>
}),
))()
+const zConversationFirstMessageNotFoundError = /* @__PURE__ */ (() =>
+ zErrorResponse.and(
+ z.object({
+ code: z.literal('conversation_first_message_not_found'),
+ status: z.literal(404),
+ }),
+ ))()
+
+const zConversationNotFoundError = /* @__PURE__ */ (() =>
+ zErrorResponse.and(
+ z.object({
+ code: z.literal('conversation_not_found'),
+ status: z.literal(404),
+ }),
+ ))()
+
const zEmailCodeError = /* @__PURE__ */ (() =>
zErrorResponse.and(
z.object({
@@ -439,7 +455,14 @@ export const post5Errors = {
provider_quota_exceeded: { status: 400, data: zProviderQuotaExceededError },
}
-export const post6Errors = { not_chat_app: { status: 400, data: zNotChatAppError } }
+export const post6Errors = {
+ conversation_first_message_not_found: {
+ status: 404,
+ data: zConversationFirstMessageNotFoundError,
+ },
+ conversation_not_found: { status: 404, data: zConversationNotFoundError },
+ not_chat_app: { status: 400, data: zNotChatAppError },
+}
export const patchErrors = { not_chat_app: { status: 400, data: zNotChatAppError } }
diff --git a/packages/contracts/generated/api/web/orpc.gen.ts b/packages/contracts/generated/api/web/orpc.gen.ts
index 9a69f32dd10..e2f99672747 100644
--- a/packages/contracts/generated/api/web/orpc.gen.ts
+++ b/packages/contracts/generated/api/web/orpc.gen.ts
@@ -12,6 +12,8 @@ import {
zAudioTooLargeError,
zAuthenticationFailedError,
zCompletionRequestError,
+ zConversationFirstMessageNotFoundError,
+ zConversationNotFoundError,
zEmailCodeError,
zEmailPasswordResetLimitError,
zEmailSendIpLimitError,
@@ -303,7 +305,14 @@ export const post6 = oc
}),
)
.output(zPostConversationsByCIdNameResponse)
- .errors({ not_chat_app: { status: 400, data: zNotChatAppError } })
+ .errors({
+ conversation_first_message_not_found: {
+ status: 404,
+ data: zConversationFirstMessageNotFoundError,
+ },
+ conversation_not_found: { status: 404, data: zConversationNotFoundError },
+ not_chat_app: { status: 400, data: zNotChatAppError },
+ })
export const name = {
post: post6,
diff --git a/packages/contracts/generated/api/web/types.gen.ts b/packages/contracts/generated/api/web/types.gen.ts
index 976bda7f629..365b170ae5f 100644
--- a/packages/contracts/generated/api/web/types.gen.ts
+++ b/packages/contracts/generated/api/web/types.gen.ts
@@ -148,6 +148,11 @@ export type CompletionRequestError = ErrorResponse & {
status: 400
}
+export type ConversationFirstMessageNotFoundError = ErrorResponse & {
+ code: 'conversation_first_message_not_found'
+ status: 404
+}
+
export type ConversationInfiniteScrollPagination = {
data: Array<SimpleConversation>
has_more: boolean
@@ -161,6 +166,11 @@ export type ConversationListQuery = {
sort_by?: '-created_at' | '-updated_at' | 'created_at' | 'updated_at'
}
+export type ConversationNotFoundError = ErrorResponse & {
+ code: 'conversation_not_found'
+ status: 404
+}
+
export type ConversationRenamePayload = (
| {
auto_generate: true
@@ -1539,7 +1549,8 @@ export type PostConversationsByCIdNameData = {
export type PostConversationsByCIdNameErrors = {
400: NotChatAppError | ErrorResponse
401: ErrorResponse
- 404: ErrorResponse
+ 404: ConversationFirstMessageNotFoundError | ConversationNotFoundError | ErrorResponse
+ 422: ErrorResponse
500: ErrorResponse
default: ErrorResponse
}
diff --git a/packages/contracts/generated/api/web/zod.gen.ts b/packages/contracts/generated/api/web/zod.gen.ts
index 5ea48cd0f0e..d311cf95697 100644
--- a/packages/contracts/generated/api/web/zod.gen.ts
+++ b/packages/contracts/generated/api/web/zod.gen.ts
@@ -314,6 +314,30 @@ export const zCompletionRequestError = zErrorResponse.and(
}),
)
+/**
+ * ConversationFirstMessageNotFoundError
+ *
+ * The conversation has no message from which to generate a name.
+ */
+export const zConversationFirstMessageNotFoundError = zErrorResponse.and(
+ z.object({
+ code: z.literal('conversation_first_message_not_found'),
+ status: z.literal(404),
+ }),
+)
+
+/**
+ * ConversationNotFoundError
+ *
+ * The conversation was not found for this user and app.
+ */
+export const zConversationNotFoundError = zErrorResponse.and(
+ z.object({
+ code: z.literal('conversation_not_found'),
+ status: z.literal(404),
+ }),
+)
+
/**
* EmailCodeError
*
@@ -2031,7 +2055,7 @@ export const zPostConversationsByCIdNameQuery = z.object({
})
/**
- * Conversation renamed successfully
+ * Conversation renamed successfully; model failure preserves the existing name.
*/
export const zPostConversationsByCIdNameResponse = zSimpleConversation