Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
refactor(api): share conversation rename service and repository (#43991)
非法操作55501cf62bfb
diff --git a/api/.importlinter b/api/.importlinterindex 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 servicestype = forbiddensource_modules =- repositories.installed_app_conversation_repository+ repositories.conversation_repositoryrepositories.conversation_lifecyclerepositories.agent_workspace_repositoryforbidden_modules =@@ -1039,6 +1039,21 @@ forbidden_modules =sqlalchemywerkzeug+[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 neutraltype = forbiddendiff --git a/api/controllers/common/errors.py b/api/controllers/common/errors.pyindex 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.pyindex 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, Resfrom libs.external_api import error_responsesfrom libs.helper import UUIDStrOrEmpty, dump_responsefrom machinery.context import RequestContext+from services.conversation_name_service import ConversationNameRequiredErrorfrom services.errors.conversation import ConversationNotExistsError, LastConversationNotExistsErrorfrom services.errors.message import MessageNotExistsErrorfrom services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppRef-from services.installed_app_conversation_service import ConversationNameRequiredError, ConversationNotChatAppError+from services.installed_app_conversation_service import ConversationNotChatAppErrorclass ConversationListQuery(BaseModel):diff --git a/api/controllers/service_api/app/conversation.py b/api/controllers/service_api/app/conversation.pyindex 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 HTTPStatusfrom typing import Annotated, Any, Literalfrom uuid import UUID@@ -9,13 +10,16 @@ from werkzeug.exceptions import BadRequest, NotFoundimport servicesfrom controllers.common.controller_schemas import ConversationRenamePayload+from controllers.common.errors import ConversationFirstMessageNotFoundHTTPError, ConversationNotFoundHTTPErrorfrom controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_modelsfrom controllers.console.wraps import model_validatefrom controllers.service_api import service_api_nsfrom controllers.service_api.app.error import NotChatAppError+from controllers.service_api.flask_admission import service_api_end_user_admissionfrom controllers.service_api.schema import expect_user_json, expect_with_userfrom controllers.service_api.wraps import FetchUserArg, WhereisUserArg, validate_app_tokenfrom core.app.entities.app_invoke_entities import InvokeFrom+from extensions.ext_application_services import application_servicesfrom extensions.ext_database import dbfrom fields._value_type_serializer import serialize_value_typefrom fields.base import ResponseModel@@ -27,8 +31,11 @@ from fields.conversation_fields import (from graphon.variables.types import SegmentTypefrom libs.external_api import error_responsesfrom libs.helper import UUIDStrOrEmpty, dump_response, to_timestamp+from machinery.context import ServiceApiEndUserContextfrom models.model import App, AppMode, EndUserfrom services.conversation_service import ConversationService+from services.entities.conversation_entities import EndUserConversationRef+from services.errors.message import MessageNotExistsErrorUUIDString = 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.pyindex 774b299706b..f84b0782673 100644--- a/api/controllers/web/conversation.py+++ b/api/controllers/web/conversation.py@@ -1,3 +1,4 @@+from http import HTTPStatusfrom typing import Literalfrom uuid import UUID@@ -7,12 +8,14 @@ from sqlalchemy.orm import sessionmakerfrom werkzeug.exceptions import NotFoundfrom controllers.common.controller_schemas import ConversationRenamePayload+from controllers.common.errors import ConversationFirstMessageNotFoundHTTPError, ConversationNotFoundHTTPErrorfrom controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_modelsfrom controllers.console.wraps import model_validatefrom controllers.web import web_nsfrom controllers.web.error import NotChatAppErrorfrom controllers.web.wraps import WebApiResourcefrom core.app.entities.app_invoke_entities import InvokeFrom+from extensions.ext_application_services import application_servicesfrom extensions.ext_database import dbfrom 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_valuefrom models.model import App, AppMode, EndUserfrom services.conversation_service import ConversationService+from services.entities.conversation_entities import EndUserConversationReffrom services.errors.conversation import ConversationNotExistsError, LastConversationNotExistsError+from services.errors.message import MessageNotExistsErrorfrom 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.pyindex 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, ModelManagerfrom core.ops.entities.trace_entity import TraceTaskNamefrom core.ops.ops_trace_manager import TraceQueueManager, TraceTaskfrom 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_PROMPTif 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.pyindex 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_appfrom sqlalchemy.orm import Session, sessionmaker-from repositories.installed_app_conversation_repository import SQLAlchemyInstalledAppConversationRepositoryfrom repositories.installed_app_repository import SQLAlchemyInstalledAppRepository+from services.conversation_name_service import ConversationNameServicefrom services.conversation_service import ConversationServicefrom services.installed_app_access_service import InstalledAppAccessService-from services.installed_app_conversation_service import InstalledAppConversationService+from services.installed_app_conversation_service import InstalledAppConversationService, InstalledAppConversationStorefrom services.installed_app_generation_adapters import AppGenerateServiceRuntimefrom services.installed_app_generation_service import InstalledAppGenerationServicefrom 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.pyindex 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 AppDefinitionQueryReposfrom repositories.app_preview_query_repository import AppPreviewQueryRepositoryfrom repositories.app_scoped_end_user_repository import AppScopedEndUserRepofrom repositories.app_statistic_query_repository import AppStatisticQueryRepository+from repositories.conversation_repository import ConversationRepositoryfrom repositories.conversation_variable_query_repository import ConversationVariableQueryRepositoryfrom repositories.credentials.query_repository import CredentialQueryRepositoryfrom repositories.explore_banner_query_repository import ExploreBannerQueryRepository@@ -135,6 +136,8 @@ from services.app_tracing_config_service import AppTracingConfigServicefrom services.billing_portal_service import BillingPortalServicefrom services.billing_service import BillingServicefrom services.compliance_download_service import ComplianceDownloadService+from services.conversation_name_generator import generate_conversation_name+from services.conversation_name_service import ConversationNameServicefrom services.conversation_variable_query import ConversationVariableQueryfrom services.credentials.query import CredentialQueryfrom services.enterprise.enterprise_service import EnterpriseService@@ -310,6 +313,7 @@ class ApplicationServices:agent_tracing_configs: AgentTracingConfigServicebilling_portal: BillingPortalServicecompliance_downloads: ComplianceDownloadService+ conversation_names: ConversationNameServicedata_sources: DataSourceServicesknowledge: KnowledgeServicesapp_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.mdindex 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.mdindex 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.pysimilarity index 75%rename from api/repositories/installed_app_conversation_repository.pyrename to api/repositories/conversation_repository.pyindex 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 deepcopyfrom dataclasses import replacefrom datetime import datetime-from typing import cast, override+from typing import castfrom sqlalchemy import Select, exists, or_, selectfrom sqlalchemy.orm import Session, sessionmakerfrom core.app.entities.app_invoke_entities import InvokeFromfrom models.enums import ConversationFromSource, CreatorUserRole-from models.model import App, Conversation, InstalledApp, Message+from models.model import App, Conversation, EndUser, InstalledApp, Messagefrom models.web import PinnedConversationfrom 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)- @overridedef 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 = nameif updated_at is not None:@@ -126,7 +104,6 @@ class SQLAlchemyInstalledAppConversationRepository(InstalledAppConversationStorerenamed = replace(record, name=conversation.name, updated_at=conversation.updated_at)return renamed- @overridedef 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(InstalledAppConversationStoreretired_workspace_ids=retired_workspace_ids,)- @overridedef set_pinned(self, *, installed_app: InstalledAppRef, account_id: str, conversation_id: str, is_pinned: bool) -> None:@@ -173,6 +149,38 @@ class SQLAlchemyInstalledAppConversationRepository(InstalledAppConversationStoreelif 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]+@staticmethoddef _get_app(*, session: Session, installed_app: InstalledAppRef) -> App:app = session.scalar(@@ -214,7 +222,7 @@ class SQLAlchemyInstalledAppConversationRepository(InstalledAppConversationStorereturn 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pyindex a87cba2013b..345eed9c75a 100644--- a/api/services/conversation_service.py+++ b/api/services/conversation_service.py@@ -1,4 +1,3 @@-import contextlibimport loggingfrom collections.abc import Callable, Sequencefrom typing import Any@@ -7,15 +6,13 @@ from sqlalchemy import asc, desc, func, or_, selectfrom sqlalchemy.orm import Sessionfrom 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 InvokeFromfrom factories import variable_factoryfrom graphon.variables.types import SegmentTypefrom libs.datetime_utils import naive_utc_nowfrom libs.infinite_scroll_pagination import InfiniteScrollPaginationfrom models import Account, ConversationVariable-from models.model import App, Conversation, EndUser, Message+from models.model import App, Conversation, EndUserfrom repositories.conversation_lifecycle import retire_conversationfrom services.errors.conversation import (ConversationNotExistsError,@@ -23,7 +20,6 @@ from services.errors.conversation import (ConversationVariableTypeMismatchError,LastConversationNotExistsError,)-from services.errors.message import MessageNotExistsErrorfrom tasks.collect_agent_resources_task import enqueue_agent_resource_collectionfrom 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)-@classmethoddef get_conversation(cls, app_model: App, conversation_id: str, user: Account | EndUser | None, *, session: Sessiondiff --git a/api/services/entities/conversation_entities.py b/api/services/entities/conversation_entities.pynew file mode 100644index 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.pyindex 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 datetimefrom 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 = namesself._enqueue_delete_cleanup: ConversationCleanup = enqueue_delete_cleanupdef 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.pyindex 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.fixturedef 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.pyindex 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, EndUserTypefrom models.model import App, Conversation, EndUser, Messagefrom services.conversation_service import ConversationServicefrom services.errors.conversation import ConversationNotExistsError-from services.errors.message import MessageNotExistsErrorclass 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pyindex 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, CreatorUserfrom models.enums import InvokeFrom as ModelInvokeFromfrom models.model import App, AppMode, Conversation, Messagefrom models.web import PinnedConversation-from repositories.installed_app_conversation_repository import SQLAlchemyInstalledAppConversationRepository+from repositories.conversation_repository import ConversationRepository+from services.conversation_name_service import ConversationNameServicefrom services.installed_app_conversation_service import InstalledAppConversationServicefrom 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.pyindex 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.pyindex 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 httpximport pytestfrom flask import Flaskfrom 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_PROMPTfrom core.model_context import get_credit_usage_metadata, use_credit_usage_metadatafrom core.ops.base_trace_instance import application_tracing_hooks+from core.plugin.impl import base as plugin_httpfrom core.tools.tool_file_manager import ToolFileManagerfrom enums import DeploymentEdition, WebAppAccessModefrom extensions import ext_application_servicesfrom extensions.application_services.app import AppServicesfrom extensions.ext_database import dbfrom extensions.ext_redis import RedisClientWrapper+from graphon.model_runtime.entities.model_entities import ModelTypefrom machinery.context import RequestContextfrom models.account import Account, Tenant, TenantAccountJoin, TenantAccountRolefrom 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, TenantDefaultModelfrom repositories.account.repository import SQLAlchemyAccountRepositoryfrom repositories.account_activation_repository import SQLAlchemyAccountActivationRepositoryfrom repositories.account_integration_repository import SQLAlchemyAccountIntegrationRepository@@ -168,8 +170,11 @@ from services.workflow_run_service import WorkflowRunServicefrom services.workflow_statistic_query_service import WorkflowStatisticQueryServicefrom tasks.delete_conversation_task import delete_conversation_related_datafrom tests.helpers.unit.config_override import apply_config_overrides+from tests.helpers.unit.services.conversation_name_fixtures import _MODEL, _PROVIDER, NamingPluginfrom 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_curredef 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_failsaccount_id = str(uuid4())with sqlite_session_factory.begin() as session:app = session.get(App, installed_app_ref.app_id)assert app is not Noneapp.mode = AppMode.CHATowner_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_deletedqueued.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")]) == 1assert get_credit_usage_metadata() == previous_metadataassert queued == [conversation_id]assert active_connections == 0diff --git a/api/tests/unit_tests/repositories/test_installed_app_conversation_repository.py b/api/tests/unit_tests/repositories/test_conversation_repository.pysimilarity index 78%rename from api/tests/unit_tests/repositories/test_installed_app_conversation_repository.pyrename to api/tests/unit_tests/repositories/test_conversation_repository.pyindex 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, sessionmakerfrom core.app.entities.app_invoke_entities import InvokeFromfrom models.agent import AgentWorkingResourceStatus, AgentWorkspace, AgentWorkspaceOwnerType-from models.enums import ConversationFromSource, CreatorUserRole+from models.enums import ConversationFromSource, CreatorUserRole, EndUserTypefrom models.enums import InvokeFrom as ModelInvokeFrom-from models.model import App, AppMode, Conversation, InstalledApp, Message+from models.model import App, AppMode, Conversation, EndUser, InstalledApp, Messagefrom 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, LastConversationNotExistsErrorfrom services.errors.message import MessageNotExistsErrorfrom 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) == 1assert 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.APIsession.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_idassert 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 Noneassert 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 == _TIMEassert stored.is_deleted is Falseassert 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pyindex 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 jsonfrom dataclasses import replacefrom datetime import timedelta-from decimal import Decimalfrom unittest.mock import MagicMockfrom uuid import UUID@@ -19,8 +18,6 @@ from sqlalchemy import asc, desc, eventfrom sqlalchemy.orm import Sessionfrom core.app.entities.app_invoke_entities import InvokeFrom-from core.credit_usage import CreditUsageAppType-from core.model_context import get_credit_usage_metadata, use_credit_usage_metadatafrom factories import variable_factoryfrom libs.datetime_utils import naive_utc_nowfrom 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, Conversationfrom repositories.conversation_lifecycle import retire_conversationfrom services import conversation_servicefrom services.agent.workspace_service import AgentWorkspaceNotFoundError, WorkspaceOwnerScopefrom services.conversation_service import ConversationService-from services.errors.message import MessageNotExistsErrorTENANT_ID = "11111111-1111-1111-1111-111111111111"APP_ID = "22222222-2222-2222-2222-222222222222"@@ -397,70 +393,6 @@ def test_cleanup_propagates_agent_enqueue_failure_before_conversation_enqueue(modelete_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.pyindex 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 replacefrom datetime import datetime+from decimal import Decimal+from uuid import uuid4import 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 InstalledAppConversationReffrom services.errors.conversation import ConversationNotExistsError-from services.installed_app_access_service import InstalledAppRef+from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppReffrom 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.tsindex 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.tsindex 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.tsindex 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 | ErrorResponse401: ErrorResponse- 403: ErrorResponse- 404: ErrorResponse+ 403:+ | AppAbnormalStatusError+ | AppApiDisabledError+ | AppNotFoundError+ | ForbiddenError+ | WorkspaceArchivedError+ | WorkspaceNotFoundError+ | ErrorResponse+ 404: ConversationFirstMessageNotFoundError | ConversationNotFoundError | ErrorResponse+ 422: ErrorResponsedefault: ErrorResponse}diff --git a/packages/contracts/generated/api/service/zod.gen.ts b/packages/contracts/generated/api/service/zod.gen.tsindex 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 = zSimpleConversationdiff --git a/packages/contracts/generated/api/web/errors.gen.ts b/packages/contracts/generated/api/web/errors.gen.tsindex 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.tsindex 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.tsindex 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 | ErrorResponse401: ErrorResponse- 404: ErrorResponse+ 404: ConversationFirstMessageNotFoundError | ConversationNotFoundError | ErrorResponse+ 422: ErrorResponse500: ErrorResponsedefault: ErrorResponse}diff --git a/packages/contracts/generated/api/web/zod.gen.ts b/packages/contracts/generated/api/web/zod.gen.tsindex 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