Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
refactor(api): isolate trial generation admission and execution (#42130)
非法操作a6b41ac6d141
diff --git a/api/.importlinter b/api/.importlinterindex d9796d56504..cee3d8ca3d9 100644--- a/api/.importlinter+++ b/api/.importlinter@@ -568,6 +568,22 @@ source_modules =forbidden_modules =flask+[importlinter:contract:trial-app-application-boundary]+name = Trial app access and generation services are framework and persistence neutral+type = forbidden+source_modules =+ services.trial_app_access_service+ services.trial_app_generation_service+forbidden_modules =+ controllers+ extensions+ flask+ models+ repositories+ services.app_generate_service+ sqlalchemy+ werkzeug+[importlinter:contract:billing-application-boundary]name = Billing application services and ports are framework and infrastructure neutraltype = forbiddendiff --git a/api/controllers/console/explore/trial.py b/api/controllers/console/explore/trial.pyindex f3eae387503..26bc46cda1c 100644--- a/api/controllers/console/explore/trial.py+++ b/api/controllers/console/explore/trial.py@@ -3,12 +3,12 @@ from dataclasses import dataclassfrom datetime import datetimefrom typing import Any, Literal-from flask import request+from flask import Response, requestfrom flask_restx import Resourcefrom pydantic import AliasChoices, BaseModel, Field, field_validatorfrom sqlalchemy import selectfrom sqlalchemy.orm import Session-from werkzeug.exceptions import Forbidden, InternalServerError, NotFound+from werkzeug.exceptions import Forbidden, InternalServerError, NotFound, Unauthorizedimport servicesfrom controllers.common.fields import (@@ -45,14 +45,16 @@ from controllers.console.explore.error import (NotCompletionAppError,NotWorkflowAppError,)+from controllers.console.explore.trial_app_admission import get_trial_appfrom controllers.console.explore.wraps import TrialAppResourcefrom controllers.console.files import FILE_UPLOAD_PARAMS, upload_file_from_request+from controllers.console.flask_admission import console_account_admissionfrom controllers.console.remote_files import RemoteFileUploadPayload, upload_remote_filefrom controllers.console.wraps import cloud_edition_billing_resource_check, model_validate, with_current_userfrom controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpError-from core.app.apps.base_app_queue_manager import AppQueueManagerfrom core.app.entities.app_invoke_entities import InvokeFromfrom core.errors.error import (+ AppInvokeQuotaExceededError,ModelCurrentlyNotSupportError,ProviderTokenNotInitError,QuotaExceededError,@@ -61,23 +63,22 @@ from core.helper import encrypterfrom core.workflow.llm_environment_variable import LLMEnvironmentVariable, dump_environment_variablefrom extensions.ext_application_services import application_servicesfrom extensions.ext_database import db-from extensions.ext_redis import redis_clientfrom fields.base import ResponseModelfrom fields.conversation_variable_fields import WorkflowConversationVariableResponsefrom fields.file_fields import FileResponse, FileWithSignedUrlfrom fields.message_fields import SuggestedQuestionsResponse-from graphon.graph_engine.manager import GraphEngineManagerfrom graphon.model_runtime.errors.invoke import InvokeErrorfrom graphon.variables import SecretVariable, VariableBasefrom libs import helperfrom libs.helper import dump_response, to_timestamp, uuid_value+from machinery.context import RequestContextfrom models import Account, Appfrom models.account import TenantStatusfrom models.model import AppMode, Sitefrom models.workflow import Workflow+from services.account_errors import AccountNotFoundErrorfrom services.account_service import TenantServicefrom services.app_definition_query_service import AppDefinitionUnavailableError-from services.app_generate_service import AppGenerateServicefrom services.app_ref_service import AppRefServicefrom services.app_service import AppResponseView, AppServicefrom services.audio_service import AudioService@@ -96,6 +97,12 @@ from services.errors.message import (SuggestedQuestionsAfterAnswerDisabledError,)from services.message_service import MessageService+from services.trial_app_access_service import TrialAppRef+from services.trial_app_generation_service import (+ TrialAppNotChatError,+ TrialAppNotCompletionError,+ TrialAppNotWorkflowError,+)logger = logging.getLogger(__name__)@@ -483,38 +490,32 @@ class TrialAppRemoteFileUploadApi(TrialAppResource):return dump_response(FileWithSignedUrl, remote_file), 201-class TrialAppWorkflowRunApi(TrialAppResource):+class TrialAppWorkflowRunApi(Resource):@console_ns.expect(console_ns.models[WorkflowRunRequest.__name__])@console_ns.response(200, "Success")- @with_current_user- @with_session+ @console_account_admission()+ @get_trial_app@model_validate(WorkflowRunRequest)- def post(self, req_data: WorkflowRunRequest, session: Session, current_user: Account, trial_app):+ def post(self, req_data: WorkflowRunRequest, request_context: RequestContext, trial_app: TrialAppRef) -> Response:"""Run workflow"""- app_model = trial_app- if not app_model:- raise NotWorkflowAppError()- app_mode = AppMode.value_of(app_model.mode)- if app_mode != AppMode.WORKFLOW:- raise NotWorkflowAppError()-- args = req_data.model_dump()try:- app_id = app_model.id- user_id = current_user.id- response = AppGenerateService.generate(- session=session,- app_model=app_model,- user=current_user,- args=args,- invoke_from=InvokeFrom.EXPLORE,- streaming=True,+ response = application_services().trial_app_generation.generate_workflow(+ trial_app=trial_app,+ account_id=request_context.account_id,+ args=req_data.model_dump(),)- application_services().trial_app_usage.record(app_id=app_id, account_id=user_id)# response-contract:ignore compact_generate_responsereturn helper.compact_generate_response(response)+ except TrialAppNotWorkflowError as error:+ raise NotWorkflowAppError() from error+ except AppDefinitionUnavailableError as error:+ raise AppUnavailableError() from error+ except AccountNotFoundError as error:+ raise Unauthorized("Account no longer exists.") from error+ except services.errors.app_model_config.AppModelConfigBrokenError as error:+ raise AppUnavailableError() from errorexcept ProviderTokenNotInitError as ex:raise ProviderNotInitializeError(ex.description)except QuotaExceededError:@@ -523,7 +524,7 @@ class TrialAppWorkflowRunApi(TrialAppResource):raise ProviderModelCurrentlyNotSupportError()except InvokeError as e:raise CompletionRequestError(e.description)- except InvokeRateLimitError as ex:+ except (AppInvokeQuotaExceededError, InvokeRateLimitError) as ex:raise InvokeRateLimitHttpError(ex.description)except ValueError as e:raise e@@ -532,41 +533,29 @@ class TrialAppWorkflowRunApi(TrialAppResource):raise InternalServerError()-class TrialAppWorkflowTaskStopApi(TrialAppResource):+class TrialAppWorkflowTaskStopApi(Resource):@console_ns.response(200, "Success", console_ns.models[SimpleResultResponse.__name__])- def post(self, trial_app, task_id: str):+ @console_account_admission()+ @get_trial_app+ def post(self, request_context: RequestContext, trial_app: TrialAppRef, task_id: str) -> dict[str, object]:"""Stop workflow task"""- app_model = trial_app- if not app_model:+ if trial_app.app_mode != "workflow":raise NotWorkflowAppError()- app_mode = AppMode.value_of(app_model.mode)- if app_mode != AppMode.WORKFLOW:- raise NotWorkflowAppError()-- # Stop using both mechanisms for backward compatibility- # Legacy stop flag mechanism (without user check)- AppQueueManager.set_stop_flag_no_user_check(task_id)- # New graph engine command channel mechanism- GraphEngineManager(redis_client).send_stop_command(task_id)+ application_services().app_tasks.stop_workflow_task_no_user_check(task_id=task_id)- return {"result": "success"}+ return dump_response(SimpleResultResponse, {"result": "success"})-class TrialChatApi(TrialAppResource):+class TrialChatApi(Resource):@console_ns.expect(console_ns.models[ChatRequest.__name__])@console_ns.response(200, "Success")- @with_current_user- @with_session+ @console_account_admission()+ @get_trial_app@model_validate(ChatRequest)- def post(self, req_data: ChatRequest, session: Session, current_user: Account, trial_app):- app_model = trial_app- app_mode = AppMode.value_of(app_model.mode)- if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:- raise NotChatAppError()-+ def post(self, req_data: ChatRequest, request_context: RequestContext, trial_app: TrialAppRef) -> Response:args = req_data.model_dump()# Validate UUID values if provided@@ -575,24 +564,20 @@ class TrialChatApi(TrialAppResource):if args.get("parent_message_id"):args["parent_message_id"] = uuid_value(args["parent_message_id"])- args["auto_generate_name"] = False-try:- # Get IDs before they might be detached from session- app_id = app_model.id- user_id = current_user.id-- response = AppGenerateService.generate(- session=session,- app_model=app_model,- user=current_user,+ response = application_services().trial_app_generation.generate_chat(+ trial_app=trial_app,+ account_id=request_context.account_id,args=args,- invoke_from=InvokeFrom.EXPLORE,- streaming=True,)- application_services().trial_app_usage.record(app_id=app_id, account_id=user_id)# response-contract:ignore compact_generate_responsereturn helper.compact_generate_response(response)+ except TrialAppNotChatError as error:+ raise NotChatAppError() from error+ except AppDefinitionUnavailableError as error:+ raise AppUnavailableError() from error+ except AccountNotFoundError as error:+ raise Unauthorized("Account no longer exists.") from errorexcept services.errors.conversation.ConversationNotExistsError:raise NotFound("Conversation Not Exists.")except services.errors.conversation.ConversationCompletedError:@@ -608,7 +593,7 @@ class TrialChatApi(TrialAppResource):raise ProviderModelCurrentlyNotSupportError()except InvokeError as e:raise CompletionRequestError(e.description)- except InvokeRateLimitError as ex:+ except (AppInvokeQuotaExceededError, InvokeRateLimitError) as ex:raise InvokeRateLimitHttpError(ex.description)except ValueError as e:raise e@@ -765,39 +750,27 @@ class TrialChatTextApi(TrialAppResource):raise InternalServerError()-class TrialCompletionApi(TrialAppResource):+class TrialCompletionApi(Resource):@console_ns.expect(console_ns.models[CompletionRequest.__name__])@console_ns.response(200, "Success")- @with_current_user- @with_session+ @console_account_admission()+ @get_trial_app@model_validate(CompletionRequest)- def post(self, req_data: CompletionRequest, session: Session, current_user: Account, trial_app):- app_model = trial_app- if app_model.mode != "completion":- raise NotCompletionAppError()-- args = req_data.model_dump()-- streaming = args["response_mode"] == "streaming"- args["auto_generate_name"] = False-+ def post(self, req_data: CompletionRequest, request_context: RequestContext, trial_app: TrialAppRef) -> Response:try:- # Get IDs before they might be detached from session- app_id = app_model.id- user_id = current_user.id-- response = AppGenerateService.generate(- session=session,- app_model=app_model,- user=current_user,- args=args,- invoke_from=InvokeFrom.EXPLORE,- streaming=streaming,+ response = application_services().trial_app_generation.generate_completion(+ trial_app=trial_app,+ account_id=request_context.account_id,+ args=req_data.model_dump(),)-- application_services().trial_app_usage.record(app_id=app_id, account_id=user_id)# response-contract:ignore compact_generate_responsereturn helper.compact_generate_response(response)+ except TrialAppNotCompletionError as error:+ raise NotCompletionAppError() from error+ except AppDefinitionUnavailableError as error:+ raise AppUnavailableError() from error+ except AccountNotFoundError as error:+ raise Unauthorized("Account no longer exists.") from errorexcept services.errors.conversation.ConversationNotExistsError:raise NotFound("Conversation Not Exists.")except services.errors.conversation.ConversationCompletedError:@@ -813,6 +786,8 @@ class TrialCompletionApi(TrialAppResource):raise ProviderModelCurrentlyNotSupportError()except InvokeError as e:raise CompletionRequestError(e.description)+ except (AppInvokeQuotaExceededError, InvokeRateLimitError) as ex:+ raise InvokeRateLimitHttpError(ex.description)except ValueError as e:raise eexcept Exception:diff --git a/api/controllers/console/explore/trial_app_admission.py b/api/controllers/console/explore/trial_app_admission.pynew file mode 100644index 00000000000..d4ea89a6bc8--- /dev/null+++ b/api/controllers/console/explore/trial_app_admission.py@@ -0,0 +1,49 @@+"""Trial execution admission for handlers using a detached app reference."""++from collections.abc import Callable+from functools import wraps+from typing import Concatenate++from controllers.console.explore.error import TrialAppFeatureDisabledError, TrialAppLimitExceeded, TrialAppNotAllowed+from extensions.ext_application_services import application_services+from machinery.context import RequestContext+from services.trial_app_access_service import (+ TrialAppRef,+ TrialAppUnavailableError,+ TrialAppUsageLimitExceededError,+)+++def trial_feature_enable[**P, R](view: Callable[P, R]) -> Callable[P, R]:+ """Gate trial execution before resolving app membership or account usage."""++ @wraps(view)+ def decorated(*args: P.args, **kwargs: P.kwargs) -> R:+ if not application_services().recommended_app_queries.is_trial_enabled():+ raise TrialAppFeatureDisabledError()+ return view(*args, **kwargs)++ return decorated+++def get_trial_app[T, **P, R](+ view: Callable[Concatenate[T, RequestContext, TrialAppRef, P], R],+) -> Callable[Concatenate[T, RequestContext, P], R]:+ """Check trial availability and inject an admitted app after Console admission."""++ @wraps(view)+ def decorated(self: T, request_context: RequestContext, /, *args: P.args, **kwargs: P.kwargs) -> R:+ app_id = kwargs.pop("app_id", None)+ if app_id is None:+ raise RuntimeError("The trial app admission route must provide app_id")+ try:+ trial_app = application_services().trial_app_access.get_access(+ app_id=str(app_id), account_id=request_context.account_id+ )+ except TrialAppUnavailableError as error:+ raise TrialAppNotAllowed() from error+ except TrialAppUsageLimitExceededError as error:+ raise TrialAppLimitExceeded() from error+ return view(self, request_context, trial_app, *args, **kwargs)++ return trial_feature_enable(decorated)diff --git a/api/controllers/console/explore/wraps.py b/api/controllers/console/explore/wraps.pyindex 872c48538c3..6e9faa1a6fa 100644--- a/api/controllers/console/explore/wraps.py+++ b/api/controllers/console/explore/wraps.py@@ -8,12 +8,11 @@ from werkzeug.exceptions import NotFoundfrom controllers.console.explore.error import (AppAccessDeniedError,- TrialAppFeatureDisabledError,TrialAppLimitExceeded,TrialAppNotAllowed,)+from controllers.console.explore.trial_app_admission import trial_feature_enablefrom controllers.console.wraps import account_initialization_required-from extensions.ext_application_services import application_servicesfrom extensions.ext_database import dbfrom libs.login import current_account_with_tenant, login_requiredfrom models import AccountTrialAppRecord, App, InstalledApp, TrialApp@@ -107,16 +106,6 @@ def trial_app_required[**P, R](view: Callable[Concatenate[App, P], R] | None = Nreturn decorator-def trial_feature_enable[**P, R](view: Callable[P, R]):- @wraps(view)- def decorated(*args: P.args, **kwargs: P.kwargs):- if not application_services().recommended_app_queries.is_trial_enabled():- raise TrialAppFeatureDisabledError()- return view(*args, **kwargs)-- return decorated--class InstalledAppResource(Resource):# must be reversed if there are multiple decoratorsdiff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.pyindex 07aa6edc21e..d0ccf52e4dc 100644--- a/api/extensions/ext_application_services.py+++ b/api/extensions/ext_application_services.py@@ -57,8 +57,7 @@ from repositories.recommended_app_catalog_repository import DatabaseRecommendedAfrom repositories.sqlalchemy_api_workflow_run_repository import DifyAPISQLAlchemyWorkflowRunRepositoryfrom repositories.step_by_step_tour_repository import SQLAlchemyStepByStepTourStateRepositoryfrom repositories.tag_repository import TagRepository-from repositories.trial_app_query_repository import TrialAppQueryRepository-from repositories.trial_app_usage_repository import TrialAppUsageRepository+from repositories.trial_app_repository import TrialAppRepositoryfrom repositories.upload_file_delivery_repository import UploadFileDeliveryQueryRepositoryfrom repositories.web_passport_repository import WebPassportRepositoryfrom repositories.webapp_access_query_repository import WebAppAccessQueryRepository@@ -139,6 +138,7 @@ from services.account_profile_service import AccountProfileServicefrom services.app_definition_query_service import AppDefinitionQueryServicefrom services.app_site_service import AppSiteServicefrom services.app_statistic_query import AppStatisticQuery+from services.app_task_service import AppTaskControlServicefrom services.app_tracing_config_gateway import OpsTraceManagerGatewayfrom services.app_tracing_config_service import AppTracingConfigServicefrom services.auth.data_source_api_key_auth_gateways import (@@ -190,6 +190,9 @@ from services.step_by_step_tour_service import StepByStepTourServicefrom services.system_feature_service import SystemFeatureServicefrom services.tag_application_service import TagApplicationServicefrom services.tool_file_download_service import ToolFileDownloadService+from services.trial_app_access_service import TrialAppAccessService+from services.trial_app_generation_adapters import AppGenerateServiceRuntime+from services.trial_app_generation_service import TrialAppGenerationServicefrom services.trial_app_usage import TrialAppUsageRecorderfrom services.upload_file_delivery_service import UploadFileDeliveryServicefrom services.web_app_runtime_query_service import WebAppRuntimeQueryService@@ -282,6 +285,9 @@ class ApplicationServices:partner_tenant_bindings: PartnerTenantBindingServicerecommended_app_queries: RecommendedAppQueryServiceremote_files: RemoteFileService+ app_tasks: AppTaskControlService+ trial_app_access: TrialAppAccessService+ trial_app_generation: TrialAppGenerationServicetrial_app_usage: TrialAppUsageRecorderworkflow_run_archives: WorkflowRunArchiveServiceworkflow_runs: WorkflowRunService@@ -428,6 +434,7 @@ def build_application_services(accounts = SQLAlchemyAccountRepository(session_factory=database_client)integrations = SQLAlchemyAccountIntegrationRepository(session_factory=database_client)trial_app_enabled = SystemFeatureService.is_trial_app_enabled()+ trial_apps = TrialAppRepository(session_factory=database_client)database_catalog = DatabaseRecommendedAppCatalogRepository(session_factory=database_client, redis=redis)builtin_catalog = BuiltinRecommendedAppCatalogGateway()remote_catalog = RemoteRecommendedAppCatalogGateway()@@ -707,11 +714,16 @@ def build_application_services(),recommended_app_queries=RecommendedAppQueryService(catalog=recommended_app_catalog,- trial_apps=TrialAppQueryRepository(session_factory=database_client),+ trial_apps=trial_apps,trial_enabled=trial_app_enabled,),remote_files=remote_file_service,- trial_app_usage=TrialAppUsageRepository(session_factory=database_client),+ app_tasks=AppTaskControlService(redis_client=redis),+ trial_app_access=TrialAppAccessService(apps=trial_apps),+ trial_app_generation=TrialAppGenerationService(+ runtime=AppGenerateServiceRuntime(session_factory=database_client), usage=trial_apps+ ),+ trial_app_usage=trial_apps,workflow_run_archives=WorkflowRunArchiveService(bundles=WorkflowRunArchiveBundleQueryRepository(session_factory=database_client),tasks=WorkflowRunArchiveDownloadTaskCache(redis=redis),diff --git a/api/libs/helper.py b/api/libs/helper.pyindex 256e60ef500..e5a62dd9747 100644--- a/api/libs/helper.py+++ b/api/libs/helper.py@@ -7,7 +7,7 @@ import structimport subprocessimport timeimport uuid-from collections.abc import Callable, Generator, Mapping+from collections.abc import Callable, Generator, Iterable, Mappingfrom datetime import datetimefrom hashlib import sha256from typing import TYPE_CHECKING, Annotated, Any, Protocol, cast, overload, override@@ -414,7 +414,7 @@ def generate_text_hash(text: str) -> str:def compact_generate_response(- response: Mapping[str, Any] | Generator[str, None, None] | RateLimitGenerator,+ response: Mapping[str, Any] | Iterable[str],) -> Response:if isinstance(response, Mapping):return Response(diff --git a/api/repositories/trial_app_query_repository.py b/api/repositories/trial_app_query_repository.pydeleted file mode 100644index d8890724466..00000000000--- a/api/repositories/trial_app_query_repository.py+++ /dev/null@@ -1,23 +0,0 @@-"""Database repository for recommended app trial eligibility."""--from collections.abc import Sequence, Set-from typing import override--from sqlalchemy import select-from sqlalchemy.orm import Session, sessionmaker--from models.model import TrialApp-from services.recommended_app_query_service import TrialAppQuery---class TrialAppQueryRepository(TrialAppQuery):- def __init__(self, session_factory: sessionmaker[Session]) -> None:- self._session_factory = session_factory-- @override- def existing_ids(self, app_ids: Sequence[str]) -> Set[str]:- if not app_ids:- return frozenset()-- with self._session_factory() as session:- return frozenset(session.scalars(select(TrialApp.app_id).where(TrialApp.app_id.in_(app_ids))).all())diff --git a/api/repositories/trial_app_repository.py b/api/repositories/trial_app_repository.pynew file mode 100644index 00000000000..d93e866bb7f--- /dev/null+++ b/api/repositories/trial_app_repository.py@@ -0,0 +1,65 @@+"""Query trial app eligibility and record account usage in independent sessions."""++from collections.abc import Sequence, Set+from typing import override++from sqlalchemy import and_, select+from sqlalchemy.orm import Session, sessionmaker++from models.model import AccountTrialAppRecord, App, TrialApp+from services.recommended_app_query_service import TrialAppQuery+from services.trial_app_access_service import TrialAppAccessQuery, TrialAppAccessSnapshot, TrialAppRef+from services.trial_app_usage import TrialAppUsageRecorder+++class TrialAppRepository(TrialAppQuery, TrialAppAccessQuery, TrialAppUsageRecorder):+ def __init__(self, session_factory: sessionmaker[Session]) -> None:+ self._session_factory: sessionmaker[Session] = session_factory++ @override+ def existing_ids(self, app_ids: Sequence[str]) -> Set[str]:+ if not app_ids:+ return frozenset()++ with self._session_factory() as session:+ return frozenset(session.scalars(select(TrialApp.app_id).where(TrialApp.app_id.in_(app_ids))).all())++ @override+ def resolve(self, *, app_id: str, account_id: str) -> TrialAppAccessSnapshot | None:+ with self._session_factory() as session:+ row = session.execute(+ select(App.id, App.tenant_id, App.mode, TrialApp.trial_limit, AccountTrialAppRecord.count)+ .select_from(TrialApp)+ .join(App, App.id == TrialApp.app_id)+ .outerjoin(+ AccountTrialAppRecord,+ and_(+ AccountTrialAppRecord.app_id == App.id,+ AccountTrialAppRecord.account_id == account_id,+ ),+ )+ .where(TrialApp.app_id == app_id)+ ).one_or_none()+ if row is None:+ return None++ resolved_app_id, tenant_id, app_mode, trial_limit, used_count = row+ return TrialAppAccessSnapshot(+ app=TrialAppRef(app_id=resolved_app_id, tenant_id=tenant_id, app_mode=app_mode),+ trial_limit=trial_limit,+ used_count=used_count,+ )++ @override+ def record(self, *, app_id: str, account_id: str) -> None:+ """Increment usage without committing the caller's request transaction."""+ with self._session_factory() as session, session.begin():+ record = session.scalar(+ select(AccountTrialAppRecord)+ .where(AccountTrialAppRecord.app_id == app_id, AccountTrialAppRecord.account_id == account_id)+ .limit(1)+ )+ if record is None:+ session.add(AccountTrialAppRecord(app_id=app_id, account_id=account_id, count=1))+ else:+ record.count += 1diff --git a/api/repositories/trial_app_usage_repository.py b/api/repositories/trial_app_usage_repository.pydeleted file mode 100644index a9c60738445..00000000000--- a/api/repositories/trial_app_usage_repository.py+++ /dev/null@@ -1,28 +0,0 @@-"""Database repository for recommended trial app usage."""--from typing import override--from sqlalchemy import select-from sqlalchemy.orm import Session, sessionmaker--from models.model import AccountTrialAppRecord-from services.trial_app_usage import TrialAppUsageRecorder---class TrialAppUsageRepository(TrialAppUsageRecorder):- def __init__(self, session_factory: sessionmaker[Session]) -> None:- self._session_factory = session_factory-- @override- def record(self, *, app_id: str, account_id: str) -> None:- """Increment usage without committing the caller's request transaction."""- with self._session_factory() as session, session.begin():- record = session.scalar(- select(AccountTrialAppRecord)- .where(AccountTrialAppRecord.app_id == app_id, AccountTrialAppRecord.account_id == account_id)- .limit(1)- )- if record is None:- session.add(AccountTrialAppRecord(app_id=app_id, account_id=account_id, count=1))- else:- record.count += 1diff --git a/api/services/app_task_service.py b/api/services/app_task_service.pyindex 6e9d6b1c737..d6e82226ee9 100644--- a/api/services/app_task_service.py+++ b/api/services/app_task_service.py@@ -6,12 +6,30 @@ new GraphEngine command channel mechanism."""from core.app.apps.base_app_queue_manager import AppQueueManager+from core.app.apps.execution_coordinator import app_task_stop_flag_keyfrom core.app.entities.app_invoke_entities import InvokeFrom-from extensions.ext_redis import redis_client+from extensions.ext_redis import RedisClientWrapper, redis_clientfrom graphon.graph_engine.manager import GraphEngineManagerfrom models.model import AppMode+class AppTaskControlService:+ """Injected task control for entry points that already admit app access."""++ def __init__(self, *, redis_client: RedisClientWrapper) -> None:+ self._redis_client: RedisClientWrapper = redis_client++ def stop_workflow_task_no_user_check(self, *, task_id: str) -> None:+ """Send both cancellation signals after the caller has admitted the app.++ Preserve the legacy stop flag even if the GraphEngine command fails.+ Trial workflow stops do not consult the task's user ownership cache.+ """+ if task_id:+ self._redis_client.setex(app_task_stop_flag_key(task_id), 600, 1)+ GraphEngineManager(self._redis_client).send_stop_command(task_id)++class AppTaskService:"""Service for managing application task operations."""diff --git a/api/services/trial_app_access_service.py b/api/services/trial_app_access_service.pynew file mode 100644index 00000000000..4e4bf6789a8--- /dev/null+++ b/api/services/trial_app_access_service.py@@ -0,0 +1,48 @@+"""Resolve trial execution access without exposing persistence models."""++from dataclasses import dataclass+from typing import Protocol+++@dataclass(frozen=True)+class TrialAppRef:+ app_id: str+ tenant_id: str+ app_mode: str+++@dataclass(frozen=True)+class TrialAppAccessSnapshot:+ app: TrialAppRef+ trial_limit: int+ used_count: int | None+++class TrialAppAccessQuery(Protocol):+ def resolve(self, *, app_id: str, account_id: str) -> TrialAppAccessSnapshot | None: ...+++class TrialAppUnavailableError(Exception):+ """The requested app is unavailable for trial execution."""+++class TrialAppUsageLimitExceededError(Exception):+ """The account has exhausted the requested app's trial allowance."""+++class TrialAppAccessService:+ def __init__(self, *, apps: TrialAppAccessQuery) -> None:+ self._apps: TrialAppAccessQuery = apps++ def get_access(self, *, app_id: str, account_id: str) -> TrialAppRef:+ access = self._apps.resolve(app_id=app_id, account_id=account_id)+ if access is None:+ raise TrialAppUnavailableError(f"App {app_id} is unavailable for trial execution")++ # Preserve the first-use allowance, including when the configured limit is zero.+ if access.used_count is not None and access.used_count >= access.trial_limit:+ raise TrialAppUsageLimitExceededError(+ f"Account {account_id} has used {access.used_count} trials of app {app_id} "+ f"with a limit of {access.trial_limit}"+ )+ return access.appdiff --git a/api/services/trial_app_generation_adapters.py b/api/services/trial_app_generation_adapters.pynew file mode 100644index 00000000000..c151f12a822--- /dev/null+++ b/api/services/trial_app_generation_adapters.py@@ -0,0 +1,66 @@+"""Bridge admitted trial references to the existing ORM generation runtime.++AppGenerateService and its generators still own their internal database and+provider operations. Keep that compatibility here until their migration.+"""++import logging+from collections.abc import Mapping+from typing import override++from sqlalchemy.orm import Session, sessionmaker++from core.app.entities.app_invoke_entities import InvokeFrom+from models import Account, App+from services.account_errors import AccountNotFoundError+from services.app_definition_query_service import AppDefinitionUnavailableError+from services.app_generate_service import AppGenerateService+from services.trial_app_access_service import TrialAppRef+from services.trial_app_generation_service import GenerationResponse, TrialAppGenerationRuntime++logger = logging.getLogger(__name__)+++class AppGenerateServiceRuntime(TrialAppGenerationRuntime):+ def __init__(self, *, session_factory: sessionmaker[Session]) -> None:+ self._session_factory: sessionmaker[Session] = session_factory++ @override+ def generate(+ self, *, app: TrialAppRef, account_id: str, args: Mapping[str, object], streaming: bool+ ) -> GenerationResponse:+ with self._session_factory(expire_on_commit=False) as read_session:+ app_model = read_session.get(App, app.app_id)+ if app_model is None or app_model.tenant_id != app.tenant_id:+ raise AppDefinitionUnavailableError(f"App {app.app_id} no longer exists in tenant {app.tenant_id}")+ if app_model.mode != app.app_mode:+ raise AppDefinitionUnavailableError(+ f"App {app.app_id} mode changed from {app.app_mode} to {app_model.mode} after admission"+ )+ account = read_session.get(Account, account_id)+ if account is None:+ raise AccountNotFoundError(f"Account {account_id} no longer exists")++ response: GenerationResponse | None = None+ try:+ # Release context reads before quota/provider I/O. Legacy generation+ # receives its own session, never the admission or usage transaction.+ with self._session_factory(expire_on_commit=False) as session:+ generated_response: GenerationResponse = AppGenerateService.generate(+ app_model=app_model,+ user=account,+ args=args,+ invoke_from=InvokeFrom.EXPLORE,+ session=session,+ streaming=streaming,+ )+ response = generated_response+ session.commit()+ except BaseException:+ if response is not None and not isinstance(response, Mapping):+ try:+ response.close()+ except BaseException:+ logger.exception("Failed to close trial generation response for app %s", app.app_id)+ raise+ return generated_responsediff --git a/api/services/trial_app_generation_service.py b/api/services/trial_app_generation_service.pynew file mode 100644index 00000000000..c2b9a1f3f92--- /dev/null+++ b/api/services/trial_app_generation_service.py@@ -0,0 +1,95 @@+"""Generate responses and record usage for an admitted trial app."""++import logging+from collections.abc import Iterator, Mapping+from typing import Protocol++from services.trial_app_access_service import TrialAppRef+from services.trial_app_usage import TrialAppUsageRecorder++logger = logging.getLogger(__name__)+++class GenerationStream(Protocol):+ def __iter__(self) -> Iterator[str]: ...++ def __next__(self) -> str: ...++ def close(self) -> None: ...+++type GenerationResponse = Mapping[str, object] | GenerationStream+++class TrialAppNotCompletionError(ValueError):+ """The trial app does not support completion requests."""+++class TrialAppNotChatError(ValueError):+ """The trial app does not support chat requests."""+++class TrialAppNotWorkflowError(ValueError):+ """The trial app does not support workflow requests."""+++class TrialAppGenerationRuntime(Protocol):+ def generate(+ self,+ *,+ app: TrialAppRef,+ account_id: str,+ args: Mapping[str, object],+ streaming: bool,+ ) -> GenerationResponse: ...+++class TrialAppGenerationService:+ def __init__(self, *, runtime: TrialAppGenerationRuntime, usage: TrialAppUsageRecorder) -> None:+ self._runtime: TrialAppGenerationRuntime = runtime+ self._usage: TrialAppUsageRecorder = usage++ def generate_chat(+ self, *, trial_app: TrialAppRef, account_id: str, args: Mapping[str, object]+ ) -> GenerationResponse:+ if trial_app.app_mode not in {"chat", "agent-chat", "advanced-chat"}:+ raise TrialAppNotChatError(f"App {trial_app.app_id} is not a chat app")+ return self._generate(+ trial_app=trial_app, account_id=account_id, args={**args, "auto_generate_name": False}, streaming=True+ )++ def generate_completion(+ self, *, trial_app: TrialAppRef, account_id: str, args: Mapping[str, object]+ ) -> GenerationResponse:+ if trial_app.app_mode != "completion":+ raise TrialAppNotCompletionError(f"App {trial_app.app_id} is not a completion app")+ return self._generate(+ trial_app=trial_app,+ account_id=account_id,+ args={**args, "auto_generate_name": False},+ streaming=args.get("response_mode") == "streaming",+ )++ def generate_workflow(+ self, *, trial_app: TrialAppRef, account_id: str, args: Mapping[str, object]+ ) -> GenerationResponse:+ if trial_app.app_mode != "workflow":+ raise TrialAppNotWorkflowError(f"App {trial_app.app_id} is not a workflow app")+ return self._generate(trial_app=trial_app, account_id=account_id, args=args, streaming=True)++ def _generate(+ self, *, trial_app: TrialAppRef, account_id: str, args: Mapping[str, object], streaming: bool+ ) -> GenerationResponse:+ response = self._runtime.generate(app=trial_app, account_id=account_id, args=args, streaming=streaming)+ try:+ # Trial usage is recorded after generation returns, before any SSE+ # consumption. A later stream failure does not refund this attempt.+ self._usage.record(app_id=trial_app.app_id, account_id=account_id)+ except BaseException:+ if not isinstance(response, Mapping):+ try:+ response.close()+ except BaseException:+ logger.exception("Failed to close trial generation response for app %s", trial_app.app_id)+ raise+ return responsediff --git a/api/tests/unit_tests/controllers/console/explore/test_trial.py b/api/tests/unit_tests/controllers/console/explore/test_trial.pyindex dc7d3ac12c3..9cdd3012c09 100644--- a/api/tests/unit_tests/controllers/console/explore/test_trial.py+++ b/api/tests/unit_tests/controllers/console/explore/test_trial.py@@ -10,25 +10,19 @@ from uuid import uuid4import pytestfrom flask import Flask, requestfrom sqlalchemy.orm import Session-from werkzeug.exceptions import Forbidden, InternalServerError, NotFound+from werkzeug.exceptions import Forbidden, NotFoundimport controllers.console.explore.trial as modulefrom controllers.console.app.error import (AppUnavailableError,CompletionRequestError,- ConversationCompletedError,ProviderModelCurrentlyNotSupportError,ProviderNotInitializeError,ProviderQuotaExceededError,SpeechToTextDisabledError,)-from controllers.console.explore.error import (- NotChatAppError,- NotCompletionAppError,- NotWorkflowAppError,-)-from controllers.console.explore.trial import ChatRequest, CompletionRequest, TextToSpeechRequest, WorkflowRunRequest-from controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpError+from controllers.console.explore.error import NotChatAppError+from controllers.console.explore.trial import TextToSpeechRequestfrom core.app.app_config.common.parameters_mapping import get_parameters_from_feature_dictfrom core.errors.error import (ModelCurrentlyNotSupportError,@@ -48,20 +42,11 @@ from models.workflow import Workflowfrom services.app_ref_service import AppRef, MessageReffrom services.errors.audio import SpeechToTextDisabledServiceErrorfrom services.errors.conversation import ConversationNotExistsError-from services.errors.llm import InvokeRateLimitErrorfrom tests.unit_tests.model_factories import make_app, make_upload_fileunwrap: Any = inspect_unwrap-class _UsesSQLiteSession:- sqlite_session: Session-- @pytest.fixture(autouse=True)- def _provide_sqlite_session(self, sqlite_session: Session):- self.sqlite_session = sqlite_session--@pytest.fixturedef account() -> Account:acc = Account(name="User", email="[email protected]")@@ -119,16 +104,6 @@ def trial_app_chat() -> App:return _app(app_id="a-chat", mode=AppMode.CHAT)-def trial_app_completion() -> App:- return _app(app_id="a-comp", mode=AppMode.COMPLETION)---def trial_app_workflow() -> App:- return _app(app_id="a-workflow", mode=AppMode.WORKFLOW)--def test_trial_workflow_uses_trial_scoped_simple_account_model() -> None:assert module.simple_account_model.name == "TrialSimpleAccount"assert module.simple_account_model.__schema__["properties"].keys() >= {"id", "name", "email"}@@ -259,610 +234,6 @@ class TestTrialAppRemoteFileUploadApi:dump.assert_called_once_with(module.FileWithSignedUrl, remote_file)-class TestTrialAppWorkflowRunApi(_UsesSQLiteSession):- def test_not_workflow_app(self, app: Flask, account: Account) -> None:- api = module.TrialAppWorkflowRunApi()- method = unwrap(api.post)-- with app.test_request_context("/", json={"inputs": {}}):- with pytest.raises(NotWorkflowAppError):- method(- api,- WorkflowRunRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- _app(app_id="not-workflow", mode=AppMode.CHAT),- )-- def test_success(- self,- app: Flask,- trial_app_workflow: App,- account: Account,- trial_app_usage: MagicMock,- ) -> None:- api = module.TrialAppWorkflowRunApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}}),- patch.object(module.AppGenerateService, "generate", return_value=MagicMock()),- ):- result = method(- api,- WorkflowRunRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- trial_app_workflow,- )-- assert result is not None- trial_app_usage.record.assert_called_once_with(app_id="a-workflow", account_id="u1")-- def test_workflow_provider_not_init(self, app: Flask, trial_app_workflow: App, account: Account) -> None:- api = module.TrialAppWorkflowRunApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=ProviderTokenNotInitError("test"),- ),- ):- with pytest.raises(ProviderNotInitializeError):- method(- api,- WorkflowRunRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- trial_app_workflow,- )-- def test_workflow_quota_exceeded(self, app: Flask, trial_app_workflow: App, account: Account) -> None:- api = module.TrialAppWorkflowRunApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=QuotaExceededError(),- ),- ):- with pytest.raises(ProviderQuotaExceededError):- method(- api,- WorkflowRunRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- trial_app_workflow,- )-- def test_workflow_model_not_support(self, app: Flask, trial_app_workflow: App, account: Account) -> None:- api = module.TrialAppWorkflowRunApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=ModelCurrentlyNotSupportError(),- ),- ):- with pytest.raises(ProviderModelCurrentlyNotSupportError):- method(- api,- WorkflowRunRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- trial_app_workflow,- )-- def test_workflow_invoke_error(self, app: Flask, trial_app_workflow: App, account: Account) -> None:- api = module.TrialAppWorkflowRunApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=InvokeError("test error"),- ),- ):- with pytest.raises(CompletionRequestError):- method(- api,- WorkflowRunRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- trial_app_workflow,- )-- def test_workflow_rate_limit_error(self, app: Flask, trial_app_workflow: App, account: Account) -> None:- api = module.TrialAppWorkflowRunApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=InvokeRateLimitError("test"),- ),- ):- with pytest.raises(InvokeRateLimitHttpError):- method(- api,- WorkflowRunRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- trial_app_workflow,- )-- def test_workflow_value_error(self, app: Flask, trial_app_workflow: App, account: Account) -> None:- api = module.TrialAppWorkflowRunApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "files": []}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=ValueError("test error"),- ),- ):- with pytest.raises(ValueError):- method(- api,- WorkflowRunRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- trial_app_workflow,- )-- def test_workflow_generic_exception(self, app: Flask, trial_app_workflow: App, account: Account) -> None:- api = module.TrialAppWorkflowRunApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "files": []}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=RuntimeError("unexpected error"),- ),- ):- with pytest.raises(InternalServerError):- method(- api,- WorkflowRunRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- trial_app_workflow,- )---class TestTrialChatApi(_UsesSQLiteSession):- def test_not_chat_app(self, app: Flask, account: Account) -> None:- api = module.TrialChatApi()- method = unwrap(api.post)-- with app.test_request_context("/", json={"inputs": {}, "query": "hi"}):- with pytest.raises(NotChatAppError):- method(- api,- ChatRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- _app(app_id="not-chat", mode=AppMode.COMPLETION),- )-- def test_success(- self,- app: Flask,- trial_app_chat: App,- account: Account,- trial_app_usage: MagicMock,- ) -> None:- api = module.TrialChatApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": "hi"}),- patch.object(module.AppGenerateService, "generate", return_value=MagicMock()),- ):- result = method(- api, ChatRequest.model_validate(request.get_json()), self.sqlite_session, account, trial_app_chat- )-- assert result is not None- trial_app_usage.record.assert_called_once_with(app_id="a-chat", account_id="u1")-- def test_chat_conversation_not_exists(self, app: Flask, trial_app_chat: App, account: Account) -> None:- api = module.TrialChatApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": "hi"}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=module.services.errors.conversation.ConversationNotExistsError(),- ),- ):- with pytest.raises(NotFound):- method(- api, ChatRequest.model_validate(request.get_json()), self.sqlite_session, account, trial_app_chat- )-- def test_chat_conversation_completed(self, app: Flask, trial_app_chat: App, account: Account) -> None:- api = module.TrialChatApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": "hi"}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=module.services.errors.conversation.ConversationCompletedError(),- ),- ):- with pytest.raises(ConversationCompletedError):- method(- api, ChatRequest.model_validate(request.get_json()), self.sqlite_session, account, trial_app_chat- )-- def test_chat_app_config_broken(self, app: Flask, trial_app_chat: App, account: Account) -> None:- api = module.TrialChatApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": "hi"}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=module.services.errors.app_model_config.AppModelConfigBrokenError(),- ),- ):- with pytest.raises(AppUnavailableError):- method(- api, ChatRequest.model_validate(request.get_json()), self.sqlite_session, account, trial_app_chat- )-- def test_chat_provider_not_init(self, app: Flask, trial_app_chat: App, account: Account) -> None:- api = module.TrialChatApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": "hi"}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=ProviderTokenNotInitError("test"),- ),- ):- with pytest.raises(ProviderNotInitializeError):- method(- api, ChatRequest.model_validate(request.get_json()), self.sqlite_session, account, trial_app_chat- )-- def test_chat_quota_exceeded(self, app: Flask, trial_app_chat: App, account: Account) -> None:- api = module.TrialChatApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": "hi"}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=QuotaExceededError(),- ),- ):- with pytest.raises(ProviderQuotaExceededError):- method(- api, ChatRequest.model_validate(request.get_json()), self.sqlite_session, account, trial_app_chat- )-- def test_chat_model_not_support(self, app: Flask, trial_app_chat: App, account: Account) -> None:- api = module.TrialChatApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": "hi"}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=ModelCurrentlyNotSupportError(),- ),- ):- with pytest.raises(ProviderModelCurrentlyNotSupportError):- method(- api, ChatRequest.model_validate(request.get_json()), self.sqlite_session, account, trial_app_chat- )-- def test_chat_invoke_error(self, app: Flask, trial_app_chat: App, account: Account) -> None:- api = module.TrialChatApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": "hi"}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=InvokeError("test error"),- ),- ):- with pytest.raises(CompletionRequestError):- method(- api, ChatRequest.model_validate(request.get_json()), self.sqlite_session, account, trial_app_chat- )-- def test_chat_rate_limit_error(self, app: Flask, trial_app_chat: App, account: Account) -> None:- api = module.TrialChatApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": "hi"}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=InvokeRateLimitError("test"),- ),- ):- with pytest.raises(InvokeRateLimitHttpError):- method(- api, ChatRequest.model_validate(request.get_json()), self.sqlite_session, account, trial_app_chat- )-- def test_chat_value_error(self, app: Flask, trial_app_chat: App, account: Account) -> None:- api = module.TrialChatApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": "hi"}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=ValueError("test error"),- ),- ):- with pytest.raises(ValueError):- method(- api, ChatRequest.model_validate(request.get_json()), self.sqlite_session, account, trial_app_chat- )-- def test_chat_generic_exception(self, app: Flask, trial_app_chat: App, account: Account) -> None:- api = module.TrialChatApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": "hi"}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=RuntimeError("unexpected error"),- ),- ):- with pytest.raises(InternalServerError):- method(- api, ChatRequest.model_validate(request.get_json()), self.sqlite_session, account, trial_app_chat- )---class TestTrialCompletionApi(_UsesSQLiteSession):- def test_not_completion_app(self, app: Flask, account: Account) -> None:- api = module.TrialCompletionApi()- method = unwrap(api.post)-- with app.test_request_context("/", json={"inputs": {}, "query": ""}):- with pytest.raises(NotCompletionAppError):- method(- api,- CompletionRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- _app(app_id="not-completion", mode=AppMode.CHAT),- )-- def test_success(- self,- app: Flask,- trial_app_completion: App,- account: Account,- trial_app_usage: MagicMock,- ) -> None:- api = module.TrialCompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": ""}),- patch.object(module.AppGenerateService, "generate", return_value=MagicMock()),- ):- result = method(- api,- CompletionRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- trial_app_completion,- )-- assert result is not None- trial_app_usage.record.assert_called_once_with(app_id="a-comp", account_id="u1")-- def test_completion_app_config_broken(self, app: Flask, trial_app_completion: App, account: Account) -> None:- api = module.TrialCompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": ""}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=module.services.errors.app_model_config.AppModelConfigBrokenError(),- ),- ):- with pytest.raises(AppUnavailableError):- method(- api,- CompletionRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- trial_app_completion,- )-- def test_completion_provider_not_init(self, app: Flask, trial_app_completion: App, account: Account) -> None:- api = module.TrialCompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": ""}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=ProviderTokenNotInitError("test"),- ),- ):- with pytest.raises(ProviderNotInitializeError):- method(- api,- CompletionRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- trial_app_completion,- )-- def test_completion_quota_exceeded(self, app: Flask, trial_app_completion: App, account: Account) -> None:- api = module.TrialCompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": ""}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=QuotaExceededError(),- ),- ):- with pytest.raises(ProviderQuotaExceededError):- method(- api,- CompletionRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- trial_app_completion,- )-- def test_completion_model_not_support(self, app: Flask, trial_app_completion: App, account: Account) -> None:- api = module.TrialCompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": ""}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=ModelCurrentlyNotSupportError(),- ),- ):- with pytest.raises(ProviderModelCurrentlyNotSupportError):- method(- api,- CompletionRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- trial_app_completion,- )-- def test_completion_invoke_error(self, app: Flask, trial_app_completion: App, account: Account) -> None:- api = module.TrialCompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": ""}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=InvokeError("test error"),- ),- ):- with pytest.raises(CompletionRequestError):- method(- api,- CompletionRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- trial_app_completion,- )-- def test_completion_rate_limit_error(self, app: Flask, trial_app_completion: App, account: Account) -> None:- api = module.TrialCompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": ""}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=InvokeRateLimitError("test"),- ),- ):- with pytest.raises(InternalServerError):- method(- api,- CompletionRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- trial_app_completion,- )-- def test_completion_value_error(self, app: Flask, trial_app_completion: App, account: Account) -> None:- api = module.TrialCompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": ""}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=ValueError("test error"),- ),- ):- with pytest.raises(ValueError):- method(- api,- CompletionRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- trial_app_completion,- )-- def test_completion_generic_exception(self, app: Flask, trial_app_completion: App, account: Account) -> None:- api = module.TrialCompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={"inputs": {}, "query": ""}),- patch.object(- module.AppGenerateService,- "generate",- side_effect=RuntimeError("unexpected error"),- ),- ):- with pytest.raises(InternalServerError):- method(- api,- CompletionRequest.model_validate(request.get_json()),- self.sqlite_session,- account,- trial_app_completion,- )--class TestTrialMessageSuggestedQuestionApi:def test_not_chat_app(self, app: Flask, account: Account) -> None:api = module.TrialMessageSuggestedQuestionApi()@@ -1363,30 +734,6 @@ class TestTrialChatTextApi:)-class TestTrialAppWorkflowTaskStopApi:- def test_not_workflow_app(self, app: Flask, trial_app_chat: App) -> None:- api = module.TrialAppWorkflowTaskStopApi()-- with app.test_request_context("/", json={"inputs": {}}):- with pytest.raises(NotWorkflowAppError):- api.post(trial_app_chat, str(uuid4()))-- def test_success(self, app: Flask, trial_app_workflow: App) -> None:- api = module.TrialAppWorkflowTaskStopApi()-- task_id = str(uuid4())- with (- app.test_request_context("/"),- patch.object(module.AppQueueManager, "set_stop_flag_no_user_check") as mock_set_flag,- patch.object(module.GraphEngineManager, "send_stop_command") as mock_send_cmd,- ):- result = api.post(trial_app_workflow, task_id)-- assert result == {"result": "success"}- mock_set_flag.assert_called_once_with(task_id)- mock_send_cmd.assert_called_once_with(task_id)--class TestTrialSitApi:def test_no_site(self,diff --git a/api/tests/unit_tests/controllers/console/explore/test_trial_generation.py b/api/tests/unit_tests/controllers/console/explore/test_trial_generation.pynew file mode 100644index 00000000000..1cca9c4e84a--- /dev/null+++ b/api/tests/unit_tests/controllers/console/explore/test_trial_generation.py@@ -0,0 +1,570 @@+"""Trial admission and generation through real HTTP handlers and SQLite repositories."""++from collections.abc import Callable, Iterator, Mapping+from dataclasses import dataclass, field+from typing import override+from uuid import uuid4++import pytest+from flask import Flask, Request+from sqlalchemy import Connection, event, select+from sqlalchemy.orm import Mapper, Session, SessionTransaction, sessionmaker+from werkzeug.exceptions import Unauthorized+from werkzeug.test import TestResponse++import controllers.console.explore.trial as trial_module+import controllers.console.explore.trial_app_admission as admission_module+import controllers.console.wraps as console_wraps+import libs.login as login_module+from core.errors.error import (+ AppInvokeQuotaExceededError,+ ModelCurrentlyNotSupportError,+ ProviderTokenNotInitError,+ QuotaExceededError,+)+from enums import DeploymentEdition+from extensions.ext_login import DifyLoginManager, unauthorized_handler+from graphon.model_runtime.errors.invoke import InvokeError+from libs.external_api import ExternalApi+from models import Account, AccountTrialAppRecord, App, AppMode, Tenant, TrialApp+from models.account import AccountStatus+from repositories.trial_app_repository import TrialAppRepository+from services.account_errors import AccountNotFoundError+from services.app_definition_query_service import AppDefinitionUnavailableError+from services.errors.app_model_config import AppModelConfigBrokenError+from services.errors.conversation import ConversationCompletedError, ConversationNotExistsError+from services.errors.llm import InvokeRateLimitError+from services.trial_app_access_service import TrialAppAccessService, TrialAppRef+from services.trial_app_generation_service import GenerationResponse, TrialAppGenerationService+++@dataclass+class _FeatureState:+ enabled: bool = True+ setup_completed: bool = True+ events: list[str] = field(default_factory=list)++ def is_trial_enabled(self) -> bool:+ self.events.append("feature")+ return self.enabled+++@dataclass(frozen=True)+class _GenerationCall:+ app: TrialAppRef+ account_id: str+ args: Mapping[str, object]+ streaming: bool+++@dataclass+class _Stream(Iterator[str]):+ chunks: Iterator[str] = field(default_factory=lambda: iter(['data: {"answer":"first"}\n\n', "data: [DONE]\n\n"]))+ reads: int = 0+ close_calls: int = 0+ close_error: Exception | None = None+ on_read: Callable[[], None] | None = None++ @override+ def __next__(self) -> str:+ if self.on_read is not None:+ self.on_read()+ chunk = next(self.chunks)+ self.reads += 1+ return chunk++ def close(self) -> None:+ self.close_calls += 1+ if self.close_error is not None:+ raise self.close_error+++@dataclass+class _Runtime:+ sessions: list[Session]+ response: GenerationResponse = field(+ default_factory=lambda: {"answer": "", "metadata": dict[str, object](), "created_at": 0}+ )+ error: Exception | None = None+ calls: list[_GenerationCall] = field(default_factory=list)+ before_generate: Callable[[], None] | None = None++ def generate(+ self, *, app: TrialAppRef, account_id: str, args: Mapping[str, object], streaming: bool+ ) -> GenerationResponse:+ # Database admission must release its connection before model invocation.+ assert self.sessions+ assert all(not session.in_transaction() and not session.identity_map for session in self.sessions)+ self.calls.append(_GenerationCall(app, account_id, dict(args), streaming))+ if self.before_generate is not None:+ self.before_generate()+ if self.error is not None:+ raise self.error+ return self.response+++@dataclass+class _Tasks:+ calls: list[str] = field(default_factory=list)++ def stop_workflow_task_no_user_check(self, *, task_id: str) -> None:+ self.calls.append(task_id)+++@dataclass(frozen=True)+class _ApplicationServices:+ trial_app_access: TrialAppAccessService+ trial_app_generation: TrialAppGenerationService+ recommended_app_queries: _FeatureState+ app_tasks: _Tasks+++@dataclass(frozen=True)+class _Harness:+ app: Flask+ account: Account+ target: App+ trial: TrialApp+ factory: sessionmaker[Session]+ services: _ApplicationServices+ runtime: _Runtime+ state: _FeatureState++ def url(self, endpoint: str, *, app_id: str | None = None) -> str:+ return f"/trial-apps/{app_id or self.target.id}/{endpoint}"++ def post(self, endpoint: str, *, payload: Mapping[str, object] | None = None) -> TestResponse:+ return self.app.test_client().post(self.url(endpoint), json=dict(payload or {"inputs": {}}))++ def set_mode(self, mode: AppMode) -> None:+ with self.factory.begin() as session:+ app = session.get(App, self.target.id)+ assert app is not None+ app.mode = mode++ def usage(self) -> int | None:+ with self.factory() as session:+ return session.scalar(+ select(AccountTrialAppRecord.count).where(+ AccountTrialAppRecord.app_id == self.target.id,+ AccountTrialAppRecord.account_id == self.account.id,+ )+ )+++def harness(+ monkeypatch: pytest.MonkeyPatch,+ config_overrides: Callable[..., None],+ sqlite_session_factory: sessionmaker[Session],+) -> _Harness:+ config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY, INIT_PASSWORD="", LOGIN_DISABLED=False)+ state = _FeatureState()+ account = Account(name="Viewer", email="[email protected]")+ account._current_tenant = Tenant(name="Viewer workspace")+ target = App(tenant_id=str(uuid4()), name="Trial app", mode=AppMode.COMPLETION, enable_site=True, enable_api=True)+ target.id = str(uuid4())+ trial = TrialApp(app_id=target.id, tenant_id=target.tenant_id, trial_limit=3)+ with sqlite_session_factory.begin() as session:+ session.add_all([target, trial])++ sessions: list[Session] = []+ repository_factory = sessionmaker(bind=sqlite_session_factory.kw["bind"], expire_on_commit=False)++ @event.listens_for(repository_factory, "after_begin")+ def track_session(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:+ sessions.append(session)++ runtime = _Runtime(sessions=sessions)+ repository = TrialAppRepository(session_factory=repository_factory)+ services = _ApplicationServices(+ trial_app_access=TrialAppAccessService(apps=repository),+ trial_app_generation=TrialAppGenerationService(runtime=runtime, usage=repository),+ recommended_app_queries=state,+ app_tasks=_Tasks(),+ )++ def setup_completed() -> bool:+ state.events.append("setup")+ return state.setup_completed++ def csrf(_request: Request, account_id: str) -> None:+ assert account_id == account.id+ state.events.append("csrf")++ for module in (trial_module, admission_module):+ monkeypatch.setattr(module, "application_services", lambda: services)+ monkeypatch.setattr(console_wraps, "_is_setup_completed", setup_completed)+ monkeypatch.setattr(login_module, "current_user", account)+ monkeypatch.setattr(login_module, "check_csrf_token", csrf)++ app = Flask(__name__)+ app.config.update(TESTING=True, RESTX_ERROR_404_HELP=False)+ login_manager = DifyLoginManager()+ login_manager.init_app(app)+ login_manager.unauthorized_handler(unauthorized_handler)+ api = ExternalApi(app)+ for resource, endpoint in (+ (trial_module.TrialAppWorkflowRunApi, "workflows/run"),+ (trial_module.TrialChatApi, "chat-messages"),+ (trial_module.TrialCompletionApi, "completion-messages"),+ (trial_module.TrialAppWorkflowTaskStopApi, "workflows/tasks/<string:task_id>/stop"),+ ):+ api.add_resource(resource, f"/trial-apps/<uuid:app_id>/{endpoint}")+ return _Harness(app, account, target, trial, sqlite_session_factory, services, runtime, state)+++def _assert_error(response: TestResponse, status: int, code: str) -> Mapping[str, object]:+ assert response.status_code == status+ body = response.get_json()+ assert isinstance(body, dict)+ assert body["code"] == code+ assert body["status"] == status+ assert response.headers["Content-Type"] == "application/json"+ assert isinstance(body["message"], str)+ assert body["message"]+ return body++[email protected]("response_mode", [None, "blocking"])+def test_completion_blocking_preserves_response_and_uses_app_owner(+ harness: _Harness, response_mode: str | None+) -> None:+ response = harness.post("completion-messages", payload={"inputs": {}, "response_mode": response_mode})++ assert response.status_code == 200+ assert response.get_json() == {"answer": "", "metadata": {}, "created_at": 0}+ assert response.headers["Content-Type"] == "application/json; charset=utf-8"+ assert int(response.headers["Content-Length"]) == len(response.data)+ assert harness.usage() == 1+ assert harness.state.events == ["setup", "csrf", "feature"]+ call = harness.runtime.calls[0]+ assert call.app == TrialAppRef(+ app_id=harness.target.id, tenant_id=harness.target.tenant_id, app_mode=AppMode.COMPLETION+ )+ assert call.app.tenant_id != harness.account.current_tenant_id+ assert call.account_id == harness.account.id+ assert call.streaming is False+ assert call.args == {+ "inputs": {},+ "query": "",+ "files": None,+ "response_mode": response_mode,+ "retriever_from": "explore_app",+ "auto_generate_name": False,+ }+++ ("endpoint", "mode", "payload"),+ [+ ("workflows/run", AppMode.WORKFLOW, {"inputs": {"number": 0}, "files": []}),+ ("chat-messages", AppMode.CHAT, {"inputs": {}, "query": "hello"}),+ ("chat-messages", AppMode.ADVANCED_CHAT, {"inputs": {}, "query": "hello"}),+ ("chat-messages", AppMode.AGENT_CHAT, {"inputs": {}, "query": "hello"}),+ ("completion-messages", AppMode.COMPLETION, {"inputs": {}, "response_mode": "streaming"}),+ ],+)+def test_stream_records_usage_after_runtime_returns_before_consumption(+ harness: _Harness, endpoint: str, mode: AppMode, payload: Mapping[str, object]+) -> None:+ harness.set_mode(mode)++ def before_generate() -> None:+ assert harness.usage() is None++ def before_read() -> None:+ assert harness.usage() == 1++ stream = _Stream(on_read=before_read)+ harness.runtime.response = stream+ harness.runtime.before_generate = before_generate+ response = harness.post(endpoint, payload=payload)++ assert response.status_code == 200+ assert response.headers["Content-Type"] == "text/event-stream; charset=utf-8"+ assert "Content-Length" not in response.headers+ assert response.data == b'data: {"answer":"first"}\n\ndata: [DONE]\n\n'+ response.close()+ assert harness.usage() == 1+ assert harness.runtime.calls[0].streaming is True+ if endpoint == "chat-messages":+ assert harness.runtime.calls[0].args["auto_generate_name"] is False+ elif endpoint == "workflows/run":+ assert harness.runtime.calls[0].args == payload+++ "endpoint", ["completion-messages", "chat-messages", "workflows/run", "workflows/tasks/task/stop"]+)+ ("state", "status", "code"), [("setup", 401, "not_setup"), ("feature", 403, "trial_app_feature_disabled")]+)+def test_bootstrap_and_feature_admission_apply_before_trial_lookup(+ harness: _Harness, endpoint: str, state: str, status: int, code: str+) -> None:+ if state == "setup":+ harness.state.setup_completed = False+ else:+ harness.state.enabled = False+ response = harness.app.test_client().post(harness.url(endpoint, app_id=str(uuid4())), json={})++ _assert_error(response, status, code)+ assert harness.state.events == (["setup"] if state == "setup" else ["setup", "csrf", "feature"])+ assert harness.runtime.calls == []+ assert harness.services.app_tasks.calls == []+++ ("case", "code"),+ [+ ("missing_trial", "trial_app_not_allowed"),+ ("missing_app", "trial_app_not_allowed"),+ ("limit", "trial_app_limit_exceeded"),+ ],+)+def test_trial_lookup_and_account_limit_block_generation(harness: _Harness, case: str, code: str) -> None:+ with harness.factory.begin() as session:+ if case == "missing_trial":+ trial = session.get(TrialApp, harness.trial.id)+ assert trial is not None+ session.delete(trial)+ elif case == "missing_app":+ target = session.get(App, harness.target.id)+ assert target is not None+ session.delete(target)+ else:+ session.add(AccountTrialAppRecord(app_id=harness.target.id, account_id=harness.account.id, count=3))+ response = harness.post("completion-messages")++ _assert_error(response, 403, code)+ assert harness.runtime.calls == []++[email protected]("count", [0, 2])+def test_usage_increments_existing_record_and_ignores_other_account(harness: _Harness, count: int) -> None:+ other_id = str(uuid4())+ with harness.factory.begin() as session:+ session.add_all(+ [+ AccountTrialAppRecord(app_id=harness.target.id, account_id=harness.account.id, count=count),+ AccountTrialAppRecord(app_id=harness.target.id, account_id=other_id, count=99),+ ]+ )+ response = harness.post("completion-messages")++ assert response.status_code == 200+ assert harness.usage() == count + 1+ with harness.factory() as session:+ assert (+ session.scalar(select(AccountTrialAppRecord.count).where(AccountTrialAppRecord.account_id == other_id))+ == 99+ )+++ ("endpoint", "mode", "code"),+ [+ ("completion-messages", AppMode.CHAT, "not_completion_app"),+ ("chat-messages", AppMode.COMPLETION, "not_chat_app"),+ ("workflows/run", AppMode.CHAT, "not_workflow_app"),+ ("workflows/tasks/task/stop", AppMode.CHAT, "not_workflow_app"),+ ],+)+def test_wrong_mode_returns_specific_error_without_invocation(+ harness: _Harness, endpoint: str, mode: AppMode, code: str+) -> None:+ harness.set_mode(mode)+ response = harness.post(endpoint, payload={"inputs": {}, "query": "hello"})++ _assert_error(response, 400, code)+ assert harness.runtime.calls == []+ assert harness.services.app_tasks.calls == []+ assert harness.usage() is None++[email protected]("field", ["conversation_id", "parent_message_id"])+def test_chat_rejects_invalid_uuid_before_runtime(harness: _Harness, field: str) -> None:+ harness.set_mode(AppMode.CHAT)+ response = harness.post("chat-messages", payload={"inputs": {}, "query": "hello", field: "not-a-uuid"})++ _assert_error(response, 400, "invalid_param")+ assert harness.runtime.calls == []+ assert harness.usage() is None+++def test_chat_normalizes_uuid_and_preserves_empty_ids(harness: _Harness) -> None:+ harness.set_mode(AppMode.CHAT)+ conversation_id = uuid4()+ response = harness.post(+ "chat-messages",+ payload={+ "inputs": {},+ "query": "hello",+ "conversation_id": conversation_id.hex.upper(),+ "parent_message_id": "",+ },+ )++ assert response.status_code == 200+ assert harness.runtime.calls[0].args["conversation_id"] == str(conversation_id)+ assert harness.runtime.calls[0].args["parent_message_id"] == ""+++ ("error", "status", "code"),+ [+ (ProviderTokenNotInitError("missing key for provider"), 400, "provider_not_initialize"),+ (QuotaExceededError(), 400, "provider_quota_exceeded"),+ (ModelCurrentlyNotSupportError(), 400, "model_currently_not_support"),+ (InvokeError("provider rejected request"), 400, "completion_request_error"),+ (InvokeRateLimitError("too many requests"), 429, "rate_limit_error"),+ (AppInvokeQuotaExceededError("active requests exceeded"), 429, "rate_limit_error"),+ (AppDefinitionUnavailableError("app removed"), 400, "app_unavailable"),+ (AccountNotFoundError("account removed"), 401, "unauthorized"),+ (AppModelConfigBrokenError(), 400, "app_unavailable"),+ ],+)+ ("endpoint", "mode"),+ [+ ("completion-messages", AppMode.COMPLETION),+ ("chat-messages", AppMode.CHAT),+ ("workflows/run", AppMode.WORKFLOW),+ ],+)+def test_runtime_errors_keep_specific_codes_and_do_not_record_usage(+ harness: _Harness, endpoint: str, mode: AppMode, error: Exception, status: int, code: str+) -> None:+ harness.set_mode(mode)+ harness.runtime.error = error+ response = harness.post(endpoint, payload={"inputs": {}, "query": "hello"})++ body = _assert_error(response, status, code)+ if isinstance(error, (ProviderTokenNotInitError, InvokeError, InvokeRateLimitError)):+ assert body["message"] == error.description+ assert harness.usage() is None+++ ("error", "status", "code"),+ [+ (ConversationNotExistsError(), 404, "not_found"),+ (ConversationCompletedError(), 400, "conversation_completed"),+ (AppModelConfigBrokenError(), 400, "app_unavailable"),+ ],+)+ ("endpoint", "mode"), [("completion-messages", AppMode.COMPLETION), ("chat-messages", AppMode.CHAT)]+)+def test_conversation_and_config_errors_remain_actionable(+ harness: _Harness, endpoint: str, mode: AppMode, error: Exception, status: int, code: str+) -> None:+ harness.set_mode(mode)+ harness.runtime.error = error+ response = harness.post(endpoint, payload={"inputs": {}, "query": "hello"})++ _assert_error(response, status, code)+ assert harness.usage() is None+++def test_stop_retains_trial_quota_admission_without_recording_usage(harness: _Harness) -> None:+ harness.set_mode(AppMode.WORKFLOW)+ response = harness.post("workflows/tasks/task-123/stop")++ assert response.status_code == 200+ assert response.get_json() == {"result": "success"}+ assert harness.services.app_tasks.calls == ["task-123"]+ assert harness.usage() is None+ with harness.factory.begin() as session:+ session.add(AccountTrialAppRecord(app_id=harness.target.id, account_id=harness.account.id, count=3))+ blocked = harness.post("workflows/tasks/task-456/stop")+ _assert_error(blocked, 403, "trial_app_limit_exceeded")+ assert harness.services.app_tasks.calls == ["task-123"]+++def test_unauthenticated_account_cannot_enter_trial(harness: _Harness, monkeypatch: pytest.MonkeyPatch) -> None:+ monkeypatch.setattr(login_module, "current_user", None)+ response = harness.post("completion-messages")++ assert response.status_code == 401+ assert harness.state.events == ["setup"]+ assert harness.runtime.calls == []+++def test_uninitialized_account_cannot_enter_trial(harness: _Harness) -> None:+ harness.account.status = AccountStatus.UNINITIALIZED+ response = harness.post("completion-messages")++ _assert_error(response, 400, "account_not_initialized")+ assert harness.state.events == ["setup", "csrf"]+ assert harness.runtime.calls == []+++def test_failed_csrf_cannot_enter_trial(harness: _Harness, monkeypatch: pytest.MonkeyPatch) -> None:+ def reject_csrf(_request: Request, _account_id: str) -> None:+ raise Unauthorized("invalid csrf token")++ monkeypatch.setattr(login_module, "check_csrf_token", reject_csrf)+ response = harness.post("completion-messages")++ _assert_error(response, 401, "unauthorized")+ assert harness.runtime.calls == []+++def test_payload_validation_keeps_field_context(harness: _Harness) -> None:+ response = harness.post("completion-messages", payload={"inputs": [], "response_mode": "invalid"})++ body = _assert_error(response, 422, "unprocessable_entity")+ assert "inputs" in str(body)+ assert harness.runtime.calls == []+ assert harness.usage() is None++[email protected]("cleanup_fails", [False, True])+ ("endpoint", "mode"),+ [("completion-messages", AppMode.COMPLETION), ("chat-messages", AppMode.CHAT), ("workflows/run", AppMode.WORKFLOW)],+)+def test_usage_write_failure_closes_unconsumed_stream_without_hiding_database_error(+ harness: _Harness, endpoint: str, mode: AppMode, cleanup_fails: bool, caplog: pytest.LogCaptureFixture+) -> None:+ harness.set_mode(mode)+ stream = _Stream(close_error=RuntimeError("cleanup failed") if cleanup_fails else None)+ harness.runtime.response = stream+ failure = RuntimeError("usage database unavailable")++ def reject_usage_insert(+ _mapper: Mapper[AccountTrialAppRecord], _connection: Connection, _record: AccountTrialAppRecord+ ) -> None:+ raise failure++ # Fail the persistence boundary, retaining the real service, unit of work,+ # SQLAlchemy rollback and HTTP error handler.+ event.listen(AccountTrialAppRecord, "before_insert", reject_usage_insert)+ try:+ response = harness.post(endpoint, payload={"inputs": {}, "query": "hello", "response_mode": "streaming"})+ finally:+ event.remove(AccountTrialAppRecord, "before_insert", reject_usage_insert)++ _assert_error(response, 500, "internal_server_error")+ assert stream.close_calls == 1+ assert stream.reads == 0+ assert harness.usage() is None+ assert any(record.exc_info is not None and record.exc_info[1] is failure for record in caplog.records)+++def test_later_stream_failure_does_not_refund_trial_usage(harness: _Harness) -> None:+ def chunks() -> Iterator[str]:+ yield 'data: {"answer":"partial"}\n\n'+ raise RuntimeError("provider disconnected")++ harness.runtime.response = _Stream(chunks=chunks())+ response = harness.post("completion-messages", payload={"inputs": {}, "response_mode": "streaming"})++ chunks = iter(response.response)+ assert next(chunks) == b'data: {"answer":"partial"}\n\n'+ with pytest.raises(RuntimeError, match="provider disconnected"):+ next(chunks)+ response.close()+ assert harness.usage() == 1diff --git a/api/tests/unit_tests/controllers/console/explore/test_wraps.py b/api/tests/unit_tests/controllers/console/explore/test_wraps.pyindex c3f104de1a6..a285ec582c8 100644--- a/api/tests/unit_tests/controllers/console/explore/test_wraps.py+++ b/api/tests/unit_tests/controllers/console/explore/test_wraps.py@@ -13,12 +13,12 @@ from controllers.console.explore.error import (TrialAppLimitExceeded,TrialAppNotAllowed,)+from controllers.console.explore.trial_app_admission import trial_feature_enablefrom controllers.console.explore.wraps import (InstalledAppResource,TrialAppResource,installed_app_required,trial_app_required,- trial_feature_enable,user_allowed_to_access_app,)from models import Account, AccountTrialAppRecord, App, InstalledApp, TrialApp@@ -242,14 +242,14 @@ def test_trial_app_required_success(assert result.id == app.id-def test_trial_feature_enable_disabled():+def test_trial_feature_enable_disabled() -> None:@trial_feature_enable- def view():+ def view() -> str:return "ok"services = MagicMock()services.recommended_app_queries.is_trial_enabled.return_value = False- with patch("controllers.console.explore.wraps.application_services", return_value=services):+ with patch("controllers.console.explore.trial_app_admission.application_services", return_value=services):with pytest.raises(TrialAppFeatureDisabledError) as exc_info:view()@@ -260,14 +260,14 @@ def test_trial_feature_enable_disabled():}-def test_trial_feature_enable_enabled():+def test_trial_feature_enable_enabled() -> None:@trial_feature_enable- def view():+ def view() -> str:return "ok"services = MagicMock()services.recommended_app_queries.is_trial_enabled.return_value = True- with patch("controllers.console.explore.wraps.application_services", return_value=services):+ with patch("controllers.console.explore.trial_app_admission.application_services", return_value=services):assert view() == "ok"diff --git a/api/tests/unit_tests/extensions/test_ext_application_services.py b/api/tests/unit_tests/extensions/test_ext_application_services.pyindex df115b908bf..dc435736ec2 100644--- a/api/tests/unit_tests/extensions/test_ext_application_services.py+++ b/api/tests/unit_tests/extensions/test_ext_application_services.py@@ -19,7 +19,7 @@ from extensions import ext_application_servicesfrom extensions.ext_redis import RedisClientWrapperfrom machinery.context import RequestContextfrom models.account import Account-from models.model import AccountTrialAppRecord, DifySetup+from models.model import AccountTrialAppRecord, App, DifySetup, TrialAppfrom repositories.account_activation_repository import SQLAlchemyAccountActivationRepositoryfrom repositories.account_integration_repository import SQLAlchemyAccountIntegrationRepositoryfrom repositories.account_oauth_repository import (@@ -63,6 +63,7 @@ from services.account_oauth_adapters import (DeploymentOAuthPolicyGateway,RedisOAuthAccountClaimLock,)+from services.app_generate_service import AppGenerateServicefrom services.app_site_service import AppSiteServicefrom services.app_tracing_config_gateway import OpsTraceManagerGatewayfrom services.app_tracing_config_service import AppTracingConfigService@@ -700,6 +701,42 @@ def test_build_application_services_wires_trial_app_usage(assert record.count == 1+def test_trial_generation_uses_configured_access_runtime_and_usage(+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ services = ext_application_services.build_application_services(+ database_client=sqlite_session_factory,+ deployment_edition=DeploymentEdition.COMMUNITY,+ initialization_password="",+ redis=MagicMock(spec=RedisClientWrapper),+ )+ app_id, tenant_id, account_id = str(uuid4()), str(uuid4()), str(uuid4())+ with sqlite_session_factory.begin() as session:+ session.add(+ App(id=app_id, tenant_id=tenant_id, name="Trial", mode="completion", enable_site=True, enable_api=False)+ )+ account = Account(name="Account", email="[email protected]")+ account.id = account_id+ session.add(account)+ session.add(TrialApp(app_id=app_id, tenant_id=tenant_id))++ admitted = services.trial_app_access.get_access(app_id=app_id, account_id=account_id)+ with patch.object(AppGenerateService, "generate", return_value={"answer": "hello"}):+ response = services.trial_app_generation.generate_completion(+ trial_app=admitted, account_id=account_id, args={"inputs": {}}+ )++ assert response == {"answer": "hello"}+ with sqlite_session_factory() as session:+ record = session.scalar(+ select(AccountTrialAppRecord).where(+ AccountTrialAppRecord.app_id == app_id, AccountTrialAppRecord.account_id == account_id+ )+ )+ assert record is not None+ assert record.count == 1++def test_build_application_services_adapts_enterprise_webapp_access_mode(sqlite_session_factory: sessionmaker[Session],) -> None:diff --git a/api/tests/unit_tests/repositories/test_trial_app_query_repository.py b/api/tests/unit_tests/repositories/test_trial_app_query_repository.pydeleted file mode 100644index 0f2bbb3ac46..00000000000--- a/api/tests/unit_tests/repositories/test_trial_app_query_repository.py+++ /dev/null@@ -1,28 +0,0 @@-import uuid-from unittest.mock import MagicMock--from sqlalchemy.orm import Session, sessionmaker--from models.model import TrialApp-from repositories.trial_app_query_repository import TrialAppQueryRepository---def test_existing_ids_returns_only_trial_apps(sqlite_session_factory: sessionmaker[Session]) -> None:- eligible_id = str(uuid.uuid4())- other_id = str(uuid.uuid4())- with sqlite_session_factory() as session:- session.add(TrialApp(app_id=eligible_id, tenant_id=str(uuid.uuid4())))- session.commit()-- result = TrialAppQueryRepository(sqlite_session_factory).existing_ids([eligible_id, other_id])-- assert result == frozenset({eligible_id})---def test_existing_ids_skips_session_for_empty_input() -> None:- session_factory = MagicMock(spec=sessionmaker)-- result = TrialAppQueryRepository(session_factory).existing_ids([])-- assert result == frozenset()- session_factory.assert_not_called()diff --git a/api/tests/unit_tests/repositories/test_trial_app_repository.py b/api/tests/unit_tests/repositories/test_trial_app_repository.pynew file mode 100644index 00000000000..fd8d926ac42--- /dev/null+++ b/api/tests/unit_tests/repositories/test_trial_app_repository.py@@ -0,0 +1,232 @@+import uuid+from unittest.mock import MagicMock++import pytest+from sqlalchemy import Engine, select+from sqlalchemy.orm import Session, sessionmaker+from sqlalchemy.pool import QueuePool++from models.model import AccountTrialAppRecord, App, AppMode, TrialApp+from repositories.trial_app_repository import TrialAppRepository+from services.trial_app_access_service import (+ TrialAppAccessService,+ TrialAppAccessSnapshot,+ TrialAppRef,+ TrialAppUnavailableError,+ TrialAppUsageLimitExceededError,+)++_APP_ID = "11111111-1111-1111-1111-111111111111"+_OWNER_TENANT_ID = "22222222-2222-2222-2222-222222222222"+_ACCOUNT_ID = "33333333-3333-3333-3333-333333333333"+_OTHER_APP_ID = "44444444-4444-4444-4444-444444444444"+_OTHER_ACCOUNT_ID = "55555555-5555-5555-5555-555555555555"+_OTHER_TENANT_ID = "66666666-6666-6666-6666-666666666666"+++def _add_app(session: Session) -> None:+ session.add(+ App(+ id=_APP_ID,+ tenant_id=_OWNER_TENANT_ID,+ name="Trial App",+ mode=AppMode.CHAT,+ enable_site=True,+ enable_api=False,+ )+ )+++def _add_trial(session: Session, *, trial_limit: int = 3) -> None:+ # The actual app owner can differ from the tenant stored on the trial listing.+ session.add(TrialApp(app_id=_APP_ID, tenant_id=_OTHER_TENANT_ID, trial_limit=trial_limit))+++def test_existing_ids_returns_only_trial_apps(sqlite_session_factory: sessionmaker[Session]) -> None:+ eligible_id = str(uuid.uuid4())+ other_id = str(uuid.uuid4())+ with sqlite_session_factory() as session:+ session.add(TrialApp(app_id=eligible_id, tenant_id=str(uuid.uuid4())))+ session.commit()++ result = TrialAppRepository(sqlite_session_factory).existing_ids([eligible_id, other_id])++ assert result == frozenset({eligible_id})+++def test_existing_ids_skips_session_for_empty_input() -> None:+ session_factory = MagicMock(spec=sessionmaker)++ result = TrialAppRepository(session_factory).existing_ids([])++ assert result == frozenset()+ session_factory.assert_not_called()+++def test_resolve_returns_actual_app_owner_and_account_usage(sqlite_session_factory: sessionmaker[Session]) -> None:+ with sqlite_session_factory.begin() as session:+ _add_app(session)+ _add_trial(session)+ session.add(AccountTrialAppRecord(app_id=_APP_ID, account_id=_ACCOUNT_ID, count=2))++ result = TrialAppRepository(sqlite_session_factory).resolve(app_id=_APP_ID, account_id=_ACCOUNT_ID)++ assert result == TrialAppAccessSnapshot(+ app=TrialAppRef(app_id=_APP_ID, tenant_id=_OWNER_TENANT_ID, app_mode="chat"),+ trial_limit=3,+ used_count=2,+ )++[email protected](("has_app", "has_trial"), [(False, False), (True, False), (False, True)])+def test_resolve_requires_both_trial_listing_and_app(+ sqlite_session_factory: sessionmaker[Session], has_app: bool, has_trial: bool+) -> None:+ with sqlite_session_factory.begin() as session:+ if has_app:+ _add_app(session)+ if has_trial:+ _add_trial(session)+ session.add_all(+ [+ App(+ id=_OTHER_APP_ID,+ tenant_id=_OTHER_TENANT_ID,+ name="Another trial app",+ mode=AppMode.CHAT,+ enable_site=True,+ enable_api=False,+ ),+ TrialApp(app_id=_OTHER_APP_ID, tenant_id=_OTHER_TENANT_ID, trial_limit=3),+ ]+ )++ repository = TrialAppRepository(sqlite_session_factory)+ assert repository.resolve(app_id=_OTHER_APP_ID, account_id=_ACCOUNT_ID) == TrialAppAccessSnapshot(+ app=TrialAppRef(app_id=_OTHER_APP_ID, tenant_id=_OTHER_TENANT_ID, app_mode="chat"),+ trial_limit=3,+ used_count=None,+ )+ assert repository.resolve(app_id=_APP_ID, account_id=_ACCOUNT_ID) is None+ with pytest.raises(TrialAppUnavailableError, match=_APP_ID):+ TrialAppAccessService(apps=repository).get_access(app_id=_APP_ID, account_id=_ACCOUNT_ID)+++def test_resolve_does_not_use_other_account_or_app_usage(sqlite_session_factory: sessionmaker[Session]) -> None:+ with sqlite_session_factory.begin() as session:+ _add_app(session)+ _add_trial(session)+ session.add_all(+ [+ AccountTrialAppRecord(app_id=_APP_ID, account_id=_OTHER_ACCOUNT_ID, count=10),+ AccountTrialAppRecord(app_id=_OTHER_APP_ID, account_id=_ACCOUNT_ID, count=10),+ ]+ )++ repository = TrialAppRepository(sqlite_session_factory)+ result = repository.resolve(app_id=_APP_ID, account_id=_ACCOUNT_ID)++ assert result is not None+ assert result.used_count is None+ assert TrialAppAccessService(apps=repository).get_access(app_id=_APP_ID, account_id=_ACCOUNT_ID) == result.app+++ ("trial_limit", "used_count", "allowed"),+ [+ pytest.param(3, None, True, id="first-use"),+ pytest.param(0, None, True, id="first-use-zero-limit"),+ pytest.param(-1, None, True, id="first-use-negative-limit"),+ pytest.param(3, 0, True, id="zero-count"),+ pytest.param(3, 2, True, id="below-limit"),+ pytest.param(3, 3, False, id="at-limit"),+ pytest.param(3, 4, False, id="over-limit"),+ pytest.param(0, 0, False, id="zero-limit-existing-count"),+ pytest.param(-1, 0, False, id="negative-limit-existing-count"),+ ],+)+def test_access_enforces_limits_only_for_existing_usage(+ sqlite_session_factory: sessionmaker[Session], trial_limit: int, used_count: int | None, allowed: bool+) -> None:+ with sqlite_session_factory.begin() as session:+ _add_app(session)+ _add_trial(session, trial_limit=trial_limit)+ if used_count is not None:+ session.add(AccountTrialAppRecord(app_id=_APP_ID, account_id=_ACCOUNT_ID, count=used_count))++ service = TrialAppAccessService(apps=TrialAppRepository(sqlite_session_factory))++ if allowed:+ assert service.get_access(app_id=_APP_ID, account_id=_ACCOUNT_ID) == TrialAppRef(+ app_id=_APP_ID, tenant_id=_OWNER_TENANT_ID, app_mode="chat"+ )+ else:+ with pytest.raises(TrialAppUsageLimitExceededError) as error:+ service.get_access(app_id=_APP_ID, account_id=_ACCOUNT_ID)+ assert _APP_ID in str(error.value)+ assert _ACCOUNT_ID in str(error.value)+ assert f"used {used_count}" in str(error.value)+ assert f"limit of {trial_limit}" in str(error.value)++[email protected]("has_trial", [True, False])+def test_resolve_releases_connection_before_returning(+ sqlite_session_factory: sessionmaker[Session], sqlite_engine: Engine, has_trial: bool+) -> None:+ with sqlite_session_factory.begin() as session:+ _add_app(session)+ if has_trial:+ _add_trial(session)++ assert isinstance(sqlite_engine.pool, QueuePool)+ assert sqlite_engine.pool.checkedout() == 0+ result = TrialAppRepository(sqlite_session_factory).resolve(app_id=_APP_ID, account_id=_ACCOUNT_ID)++ assert (result is not None) == has_trial+ assert sqlite_engine.pool.checkedout() == 0+++def _record(+ session_factory: sessionmaker[Session],+ *,+ app_id: str,+ account_id: str,+) -> AccountTrialAppRecord | None:+ with session_factory() as session:+ return session.scalar(+ select(AccountTrialAppRecord).where(+ AccountTrialAppRecord.app_id == app_id,+ AccountTrialAppRecord.account_id == account_id,+ )+ )+++def test_record_increments_existing_usage(sqlite_session_factory: sessionmaker[Session]) -> None:+ app_id = str(uuid.uuid4())+ account_id = str(uuid.uuid4())+ with sqlite_session_factory.begin() as session:+ session.add(AccountTrialAppRecord(app_id=app_id, account_id=account_id, count=3))++ TrialAppRepository(sqlite_session_factory).record(app_id=app_id, account_id=account_id)++ record = _record(sqlite_session_factory, app_id=app_id, account_id=account_id)+ assert record is not None+ assert record.count == 4+++def test_record_does_not_commit_caller_session(sqlite_session_factory: sessionmaker[Session]) -> None:+ pending_app_id = str(uuid.uuid4())+ usage_app_id = str(uuid.uuid4())+ account_id = str(uuid.uuid4())++ with sqlite_session_factory() as caller_session:+ caller_session.add(AccountTrialAppRecord(app_id=pending_app_id, account_id=account_id, count=1))++ TrialAppRepository(sqlite_session_factory).record(app_id=usage_app_id, account_id=account_id)++ caller_session.rollback()++ assert _record(sqlite_session_factory, app_id=pending_app_id, account_id=account_id) is None+ usage = _record(sqlite_session_factory, app_id=usage_app_id, account_id=account_id)+ assert usage is not None+ assert usage.count == 1diff --git a/api/tests/unit_tests/repositories/test_trial_app_usage_repository.py b/api/tests/unit_tests/repositories/test_trial_app_usage_repository.pydeleted file mode 100644index 57d7e59f7bd..00000000000--- a/api/tests/unit_tests/repositories/test_trial_app_usage_repository.py+++ /dev/null@@ -1,53 +0,0 @@-import uuid--from sqlalchemy import select-from sqlalchemy.orm import Session, sessionmaker--from models.model import AccountTrialAppRecord-from repositories.trial_app_usage_repository import TrialAppUsageRepository---def _record(- session_factory: sessionmaker[Session],- *,- app_id: str,- account_id: str,-) -> AccountTrialAppRecord | None:- with session_factory() as session:- return session.scalar(- select(AccountTrialAppRecord).where(- AccountTrialAppRecord.app_id == app_id,- AccountTrialAppRecord.account_id == account_id,- )- )---def test_record_increments_existing_usage(sqlite_session_factory: sessionmaker[Session]) -> None:- app_id = str(uuid.uuid4())- account_id = str(uuid.uuid4())- with sqlite_session_factory.begin() as session:- session.add(AccountTrialAppRecord(app_id=app_id, account_id=account_id, count=3))-- TrialAppUsageRepository(sqlite_session_factory).record(app_id=app_id, account_id=account_id)-- record = _record(sqlite_session_factory, app_id=app_id, account_id=account_id)- assert record is not None- assert record.count == 4---def test_record_does_not_commit_caller_session(sqlite_session_factory: sessionmaker[Session]) -> None:- pending_app_id = str(uuid.uuid4())- usage_app_id = str(uuid.uuid4())- account_id = str(uuid.uuid4())-- with sqlite_session_factory() as caller_session:- caller_session.add(AccountTrialAppRecord(app_id=pending_app_id, account_id=account_id, count=1))-- TrialAppUsageRepository(sqlite_session_factory).record(app_id=usage_app_id, account_id=account_id)-- caller_session.rollback()-- assert _record(sqlite_session_factory, app_id=pending_app_id, account_id=account_id) is None- usage = _record(sqlite_session_factory, app_id=usage_app_id, account_id=account_id)- assert usage is not None- assert usage.count == 1diff --git a/api/tests/unit_tests/services/test_app_task_control_service.py b/api/tests/unit_tests/services/test_app_task_control_service.pynew file mode 100644index 00000000000..bb1d36f2790--- /dev/null+++ b/api/tests/unit_tests/services/test_app_task_control_service.py@@ -0,0 +1,51 @@+"""Injected workflow cancellation preserves both transport mechanisms."""++from unittest.mock import MagicMock, patch++import pytest++from extensions.ext_redis import RedisClientWrapper+from services.app_task_service import AppTaskControlService++[email protected]("command_fails", [False, True])[email protected]("task_id", ["task-1", ""])+def test_workflow_stop_sets_flag_before_sending_command(command_fails: bool, task_id: str) -> None:+ redis = MagicMock(spec=RedisClientWrapper)+ events: list[str] = []+ redis.setex.side_effect = lambda *_: events.append("flag")+ failure = RuntimeError("command channel unavailable")++ def send_stop(requested_task_id: str) -> None:+ assert requested_task_id == task_id+ events.append("command")+ if command_fails:+ raise failure++ with patch("services.app_task_service.GraphEngineManager") as manager:+ manager.return_value.send_stop_command.side_effect = send_stop+ service = AppTaskControlService(redis_client=redis)+ if command_fails:+ with pytest.raises(RuntimeError) as caught:+ service.stop_workflow_task_no_user_check(task_id=task_id)+ assert caught.value is failure+ else:+ service.stop_workflow_task_no_user_check(task_id=task_id)+ manager.assert_called_once_with(redis)++ if task_id:+ assert events == ["flag", "command"]+ redis.setex.assert_called_once_with("generate_task_stopped:task-1", 600, 1)+ else:+ assert events == ["command"]+ redis.setex.assert_not_called()+ redis.get.assert_not_called()+++def test_flag_failure_does_not_send_command() -> None:+ redis = MagicMock(spec=RedisClientWrapper)+ redis.setex.side_effect = RuntimeError("flag store unavailable")+ with patch("services.app_task_service.GraphEngineManager") as manager:+ with pytest.raises(RuntimeError, match="flag store unavailable"):+ AppTaskControlService(redis_client=redis).stop_workflow_task_no_user_check(task_id="task-1")+ manager.assert_not_called()diff --git a/api/tests/unit_tests/services/test_trial_app_generation_adapters.py b/api/tests/unit_tests/services/test_trial_app_generation_adapters.pynew file mode 100644index 00000000000..826bcc35de0--- /dev/null+++ b/api/tests/unit_tests/services/test_trial_app_generation_adapters.py@@ -0,0 +1,465 @@+from collections.abc import Callable, Iterator, Mapping+from dataclasses import dataclass, field, replace+from typing import cast, override+from uuid import uuid4++import pytest+from sqlalchemy import Engine, inspect, select, update+from sqlalchemy.orm import Session, sessionmaker+from sqlalchemy.pool import QueuePool++from core.app.apps.chat.app_generator import ChatAppGenerator+from core.app.entities.app_invoke_entities import InvokeFrom+from models import Account, App, AppMode, Conversation+from models.enums import ConversationFromSource+from models.model import AccountTrialAppRecord+from repositories.trial_app_repository import TrialAppRepository+from services.account_errors import AccountNotFoundError+from services.app_definition_query_service import AppDefinitionUnavailableError+from services.app_generate_service import AppGenerateService+from services.errors.app_model_config import AppModelConfigBrokenError+from services.errors.conversation import ConversationNotExistsError+from services.trial_app_access_service import TrialAppRef+from services.trial_app_generation_adapters import AppGenerateServiceRuntime+from services.trial_app_generation_service import GenerationResponse, TrialAppGenerationService++_ARGS: dict[str, object] = {"inputs": {"count": 0}, "query": "hello", "auto_generate_name": False}+++@dataclass+class _Harness:+ runtime: AppGenerateServiceRuntime+ app: TrialAppRef+ account_id: str+ closed_sessions: list[Session]+ committed_sessions: list[Session]+++def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]) -> _Harness:+ with sqlite_session_factory.begin() as session:+ app = App(tenant_id=str(uuid4()), name="Trial app", mode=AppMode.CHAT, enable_site=True, enable_api=False)+ account = Account(name="Viewer", email="[email protected]")+ session.add_all([app, account])++ closed_sessions: list[Session] = []+ committed_sessions: list[Session] = []++ class TrackedSession(Session):+ @override+ def commit(self) -> None:+ failure = self.info.get("commit_failure")+ if isinstance(failure, BaseException):+ raise failure+ super().commit()+ committed_sessions.append(self)++ @override+ def close(self) -> None:+ super().close()+ closed_sessions.append(self)+ failure = self.info.get("close_failure")+ if isinstance(failure, BaseException):+ raise failure++ factory = sessionmaker(bind=sqlite_engine, class_=TrackedSession, expire_on_commit=True)+ return _Harness(+ runtime=AppGenerateServiceRuntime(session_factory=cast(sessionmaker[Session], factory)),+ app=TrialAppRef(app_id=app.id, tenant_id=app.tenant_id, app_mode=app.mode),+ account_id=account.id,+ closed_sessions=closed_sessions,+ committed_sessions=committed_sessions,+ )+++@dataclass+class _Stream:+ close_error: Exception | None = None+ close_calls: int = 0+ read_calls: int = 0+ _chunks: Iterator[str] = field(default_factory=lambda: iter(("data: first\n\n", "data: second\n\n")))++ def __iter__(self) -> "_Stream":+ return self++ def __next__(self) -> str:+ self.read_calls += 1+ return next(self._chunks)++ def close(self) -> None:+ self.close_calls += 1+ if self.close_error is not None:+ raise self.close_error+++def _patch_generation(+ monkeypatch: pytest.MonkeyPatch,+ harness: _Harness,+ generate: Callable[[Session], GenerationResponse],+ *,+ streaming: bool,+ args: Mapping[str, object] = _ARGS,+) -> None:+ expected_streaming = streaming+ expected_args = args++ def legacy_generate(+ *,+ session: Session,+ app_model: App,+ user: Account,+ args: Mapping[str, object],+ invoke_from: InvokeFrom,+ streaming: bool,+ ) -> GenerationResponse:+ assert len(harness.closed_sessions) == 1+ read_session = harness.closed_sessions[0]+ assert not read_session.in_transaction()+ assert not read_session.identity_map+ assert session is not read_session+ assert not session.in_transaction()+ assert inspect(app_model).detached+ assert inspect(user).detached+ assert (app_model.id, app_model.tenant_id, user.id) == (+ harness.app.app_id,+ harness.app.tenant_id,+ harness.account_id,+ )+ assert (app_model.name, user.name) == ("Trial app", "Viewer")+ assert invoke_from == InvokeFrom.EXPLORE+ assert streaming is expected_streaming+ assert args == expected_args+ return generate(session)++ monkeypatch.setattr(AppGenerateService, "generate", legacy_generate)+++def test_mapping_result_is_unchanged_and_generation_writes_are_committed(+ harness: _Harness, monkeypatch: pytest.MonkeyPatch, sqlite_session_factory: sessionmaker[Session]+) -> None:+ response: dict[str, object] = {"answer": "", "metadata": {"tokens": 0}}++ def generate(session: Session) -> GenerationResponse:+ session.execute(update(App).where(App.id == harness.app.app_id).values(name="Generated app"))+ return response++ _patch_generation(monkeypatch, harness, generate, streaming=False)++ result = harness.runtime.generate(app=harness.app, account_id=harness.account_id, args=_ARGS, streaming=False)++ assert result is response+ assert len(harness.closed_sessions) == 2+ assert harness.committed_sessions == [harness.closed_sessions[1]]+ assert all(not session.in_transaction() for session in harness.closed_sessions)+ with sqlite_session_factory() as session:+ app = session.get(App, harness.app.app_id)+ assert app is not None+ assert app.name == "Generated app"+++def test_usage_is_recorded_after_generation_session_closes_and_before_stream_consumption(+ harness: _Harness,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session_factory: sessionmaker[Session],+ sqlite_engine: Engine,+) -> None:+ stream = _Stream()++ def generate(session: Session) -> GenerationResponse:+ session.execute(update(App).where(App.id == harness.app.app_id).values(name="Generated app"))+ return stream++ class UsageRepository(TrialAppRepository):+ @override+ def record(self, *, app_id: str, account_id: str) -> None:+ assert len(harness.closed_sessions) == 2+ assert harness.committed_sessions == [harness.closed_sessions[1]]+ assert isinstance(sqlite_engine.pool, QueuePool)+ assert sqlite_engine.pool.checkedout() == 0+ assert stream.read_calls == 0+ super().record(app_id=app_id, account_id=account_id)++ _patch_generation(monkeypatch, harness, generate, streaming=True)+ service = TrialAppGenerationService(runtime=harness.runtime, usage=UsageRepository(sqlite_session_factory))++ result = service.generate_chat(trial_app=harness.app, account_id=harness.account_id, args=_ARGS)++ assert result is stream+ assert stream.read_calls == stream.close_calls == 0+ with sqlite_session_factory() as session:+ usage = session.scalar(+ select(AccountTrialAppRecord).where(+ AccountTrialAppRecord.app_id == harness.app.app_id,+ AccountTrialAppRecord.account_id == harness.account_id,+ )+ )+ assert usage is not None+ assert usage.count == 1+ assert next(stream) == "data: first\n\n"+ stream.close()+ assert stream.close_calls == 1++[email protected]("failure", [ValueError("Invalid query"), RuntimeError("Provider failed")])+def test_generation_failure_preserves_error_and_rolls_back_writes(+ harness: _Harness,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session_factory: sessionmaker[Session],+ failure: Exception,+) -> None:+ def generate(session: Session) -> GenerationResponse:+ session.execute(update(App).where(App.id == harness.app.app_id).values(name="Uncommitted app"))+ raise failure++ _patch_generation(monkeypatch, harness, generate, streaming=True)++ with pytest.raises(type(failure)) as raised:+ harness.runtime.generate(app=harness.app, account_id=harness.account_id, args=_ARGS, streaming=True)++ assert raised.value is failure+ assert len(harness.closed_sessions) == 2+ assert harness.committed_sessions == []+ with sqlite_session_factory() as session:+ app = session.get(App, harness.app.app_id)+ assert app is not None+ assert app.name == "Trial app"++[email protected]("close_failure", [False, True])+def test_commit_failure_closes_created_stream_and_preserves_commit_error(+ harness: _Harness,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session_factory: sessionmaker[Session],+ close_failure: bool,+) -> None:+ failure = RuntimeError("Commit failed")+ stream = _Stream(close_error=RuntimeError("Stream close failed") if close_failure else None)++ def generate(session: Session) -> GenerationResponse:+ session.execute(update(App).where(App.id == harness.app.app_id).values(name="Uncommitted app"))+ session.info["commit_failure"] = failure+ return stream++ _patch_generation(monkeypatch, harness, generate, streaming=True)++ with pytest.raises(RuntimeError) as raised:+ harness.runtime.generate(app=harness.app, account_id=harness.account_id, args=_ARGS, streaming=True)++ assert raised.value is failure+ assert stream.close_calls == 1+ assert stream.read_calls == 0+ assert len(harness.closed_sessions) == 2+ assert harness.committed_sessions == []+ with sqlite_session_factory() as session:+ app = session.get(App, harness.app.app_id)+ assert app is not None+ assert app.name == "Trial app"+++def test_session_close_failure_closes_created_stream_and_preserves_session_error(+ harness: _Harness, monkeypatch: pytest.MonkeyPatch+) -> None:+ failure = RuntimeError("Session close failed")+ stream = _Stream()++ def generate(session: Session) -> GenerationResponse:+ session.info["close_failure"] = failure+ return stream++ _patch_generation(monkeypatch, harness, generate, streaming=True)++ with pytest.raises(RuntimeError) as raised:+ harness.runtime.generate(app=harness.app, account_id=harness.account_id, args=_ARGS, streaming=True)++ assert raised.value is failure+ assert stream.close_calls == 1+ assert stream.read_calls == 0+ assert len(harness.closed_sessions) == 2+ assert harness.committed_sessions == [harness.closed_sessions[1]]++[email protected]("invalid", ["missing-app", "wrong-owner", "missing-account"])+def test_unavailable_generation_context_fails_before_entering_runtime(+ harness: _Harness, monkeypatch: pytest.MonkeyPatch, invalid: str+) -> None:+ def unexpected_generate(**_kwargs: object) -> GenerationResponse:+ pytest.fail("Unavailable context must fail before generation")++ monkeypatch.setattr(AppGenerateService, "generate", unexpected_generate)+ app = harness.app+ account_id = harness.account_id+ error_type: type[Exception] = AppDefinitionUnavailableError+ if invalid == "missing-app":+ app = replace(app, app_id=str(uuid4()))+ elif invalid == "wrong-owner":+ app = replace(app, tenant_id=str(uuid4()))+ else:+ account_id = str(uuid4())+ error_type = AccountNotFoundError++ with pytest.raises(error_type):+ harness.runtime.generate(app=app, account_id=account_id, args=_ARGS, streaming=True)++ assert len(harness.closed_sessions) == 1+ assert not harness.closed_sessions[0].in_transaction()+ assert harness.committed_sessions == []++[email protected]("current_mode", [AppMode.COMPLETION, AppMode.WORKFLOW, AppMode.ADVANCED_CHAT])+def test_mode_changed_after_admission_fails_before_generation_and_usage_recording(+ harness: _Harness,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session_factory: sessionmaker[Session],+ current_mode: AppMode,+) -> None:+ with sqlite_session_factory.begin() as session:+ session.execute(update(App).where(App.id == harness.app.app_id).values(mode=current_mode))++ def unexpected_generate(**_kwargs: object) -> GenerationResponse:+ pytest.fail("A stale app mode must fail before generation")++ monkeypatch.setattr(AppGenerateService, "generate", unexpected_generate)+ service = TrialAppGenerationService(runtime=harness.runtime, usage=TrialAppRepository(sqlite_session_factory))++ with pytest.raises(AppDefinitionUnavailableError) as raised:+ service.generate_chat(trial_app=harness.app, account_id=harness.account_id, args=_ARGS)++ assert harness.app.app_id in str(raised.value)+ assert harness.app.app_mode in str(raised.value)+ assert current_mode.value in str(raised.value)+ assert len(harness.closed_sessions) == 1+ assert not harness.closed_sessions[0].in_transaction()+ assert harness.committed_sessions == []+ with sqlite_session_factory() as session:+ assert session.scalar(select(AccountTrialAppRecord)) is None+++def _add_conversation(harness: _Harness, session_factory: sessionmaker[Session]) -> str:+ with session_factory.begin() as session:+ conversation = Conversation(+ app_id=harness.app.app_id,+ mode=AppMode.CHAT,+ name="Conversation",+ inputs={},+ from_source=ConversationFromSource.CONSOLE,+ from_account_id=harness.account_id,+ from_end_user_id=None,+ )+ session.add(conversation)+ session.flush()+ return conversation.id+++def _patch_chat_generation(monkeypatch: pytest.MonkeyPatch, harness: _Harness) -> None:+ def legacy_generate(+ *,+ session: Session,+ app_model: App,+ user: Account,+ args: Mapping[str, object],+ invoke_from: InvokeFrom,+ streaming: bool,+ ) -> GenerationResponse:+ assert len(harness.closed_sessions) == 1+ assert not harness.closed_sessions[0].in_transaction()+ assert session is not harness.closed_sessions[0]+ assert not session.in_transaction()+ response = ChatAppGenerator().generate(+ app_model=app_model, user=user, args=args, invoke_from=invoke_from, streaming=streaming, session=session+ )+ return cast(GenerationResponse, ChatAppGenerator.convert_to_event_stream(response))++ monkeypatch.setattr(AppGenerateService, "generate", legacy_generate)++[email protected]("mismatch", ["missing", "app", "account", "source", "end-user", "deleted"])+def test_chat_runtime_preserves_legacy_conversation_ownership_errors(+ harness: _Harness,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session_factory: sessionmaker[Session],+ mismatch: str,+) -> None:+ conversation_id = _add_conversation(harness, sqlite_session_factory)+ with sqlite_session_factory.begin() as session:+ conversation = session.get(Conversation, conversation_id)+ assert conversation is not None+ match mismatch:+ case "missing":+ conversation_id = str(uuid4())+ case "app":+ conversation.app_id = str(uuid4())+ case "account":+ conversation.from_account_id = str(uuid4())+ case "source":+ conversation.from_source = ConversationFromSource.API+ case "end-user":+ conversation.from_end_user_id = str(uuid4())+ case "deleted":+ conversation.is_deleted = True++ _patch_chat_generation(monkeypatch, harness)++ with pytest.raises(ConversationNotExistsError):+ harness.runtime.generate(+ app=harness.app,+ account_id=harness.account_id,+ args={**_ARGS, "conversation_id": conversation_id},+ streaming=True,+ )++ assert len(harness.closed_sessions) == 2+ assert all(not session.in_transaction() for session in harness.closed_sessions)+ assert harness.committed_sessions == []+++def test_chat_runtime_accepts_owned_conversation_before_checking_its_model_config(+ harness: _Harness, monkeypatch: pytest.MonkeyPatch, sqlite_session_factory: sessionmaker[Session]+) -> None:+ conversation_id = _add_conversation(harness, sqlite_session_factory)+ args = {**_ARGS, "conversation_id": conversation_id}+ _patch_chat_generation(monkeypatch, harness)++ # A visible conversation reaches the following shared model-config check.+ with pytest.raises(AppModelConfigBrokenError):+ harness.runtime.generate(app=harness.app, account_id=harness.account_id, args=args, streaming=True)++ assert len(harness.closed_sessions) == 2+ assert all(not session.in_transaction() for session in harness.closed_sessions)+ assert harness.committed_sessions == []++[email protected](("query", "message"), [("", "query is required"), (1, "query must be a string")])+def test_chat_runtime_keeps_query_validation_before_missing_conversation_error(+ harness: _Harness, monkeypatch: pytest.MonkeyPatch, query: str | int, message: str+) -> None:+ _patch_chat_generation(monkeypatch, harness)++ with pytest.raises(ValueError, match=message):+ harness.runtime.generate(+ app=harness.app,+ account_id=harness.account_id,+ args={**_ARGS, "query": query, "conversation_id": str(uuid4())},+ streaming=True,+ )++ assert len(harness.closed_sessions) == 2+ assert harness.committed_sessions == []+++def test_advanced_chat_passes_conversation_to_runtime_without_eager_validation(+ harness: _Harness, monkeypatch: pytest.MonkeyPatch, sqlite_session_factory: sessionmaker[Session]+) -> None:+ with sqlite_session_factory.begin() as session:+ session.execute(update(App).where(App.id == harness.app.app_id).values(mode=AppMode.ADVANCED_CHAT))+ harness.app = replace(harness.app, app_mode=AppMode.ADVANCED_CHAT)+ args = {**_ARGS, "conversation_id": str(uuid4())}+ stream = _Stream()+ _patch_generation(monkeypatch, harness, lambda _session: stream, streaming=True, args=args)++ result = harness.runtime.generate(app=harness.app, account_id=harness.account_id, args=args, streaming=True)++ assert result is stream+ assert len(harness.closed_sessions) == 2+ assert harness.committed_sessions == [harness.closed_sessions[1]]+ assert stream.read_calls == stream.close_calls == 0+ stream.close()