Skip to content

armgit / dify

Public Imported from GitHub
0

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

refactor(api): isolate trial generation admission and execution (#42130)

非法操作a6b41ac6d141
diff --git a/api/.importlinter b/api/.importlinter
index 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 neutral
type = forbidden
diff --git a/api/controllers/console/explore/trial.py b/api/controllers/console/explore/trial.py
index f3eae387503..26bc46cda1c 100644
--- a/api/controllers/console/explore/trial.py
+++ b/api/controllers/console/explore/trial.py
@@ -3,12 +3,12 @@ from dataclasses import dataclass
from datetime import datetime
from typing import Any, Literal
-from flask import request
+from flask import Response, request
from flask_restx import Resource
from pydantic import AliasChoices, BaseModel, Field, field_validator
from sqlalchemy import select
from sqlalchemy.orm import Session
-from werkzeug.exceptions import Forbidden, InternalServerError, NotFound
+from werkzeug.exceptions import Forbidden, InternalServerError, NotFound, Unauthorized
import services
from 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_app
from controllers.console.explore.wraps import TrialAppResource
from controllers.console.files import FILE_UPLOAD_PARAMS, upload_file_from_request
+from controllers.console.flask_admission import console_account_admission
from controllers.console.remote_files import RemoteFileUploadPayload, upload_remote_file
from controllers.console.wraps import cloud_edition_billing_resource_check, model_validate, with_current_user
from controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpError
-from core.app.apps.base_app_queue_manager import AppQueueManager
from core.app.entities.app_invoke_entities import InvokeFrom
from core.errors.error import (
+ AppInvokeQuotaExceededError,
ModelCurrentlyNotSupportError,
ProviderTokenNotInitError,
QuotaExceededError,
@@ -61,23 +63,22 @@ from core.helper import encrypter
from core.workflow.llm_environment_variable import LLMEnvironmentVariable, dump_environment_variable
from extensions.ext_application_services import application_services
from extensions.ext_database import db
-from extensions.ext_redis import redis_client
from fields.base import ResponseModel
from fields.conversation_variable_fields import WorkflowConversationVariableResponse
from fields.file_fields import FileResponse, FileWithSignedUrl
from fields.message_fields import SuggestedQuestionsResponse
-from graphon.graph_engine.manager import GraphEngineManager
from graphon.model_runtime.errors.invoke import InvokeError
from graphon.variables import SecretVariable, VariableBase
from libs import helper
from libs.helper import dump_response, to_timestamp, uuid_value
+from machinery.context import RequestContext
from models import Account, App
from models.account import TenantStatus
from models.model import AppMode, Site
from models.workflow import Workflow
+from services.account_errors import AccountNotFoundError
from services.account_service import TenantService
from services.app_definition_query_service import AppDefinitionUnavailableError
-from services.app_generate_service import AppGenerateService
from services.app_ref_service import AppRefService
from services.app_service import AppResponseView, AppService
from 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_response
return 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 error
except 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_response
return 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 error
except 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_response
return 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 error
except 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 e
except Exception:
diff --git a/api/controllers/console/explore/trial_app_admission.py b/api/controllers/console/explore/trial_app_admission.py
new file mode 100644
index 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.py
index 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 NotFound
from controllers.console.explore.error import (
AppAccessDeniedError,
- TrialAppFeatureDisabledError,
TrialAppLimitExceeded,
TrialAppNotAllowed,
)
+from controllers.console.explore.trial_app_admission import trial_feature_enable
from controllers.console.wraps import account_initialization_required
-from extensions.ext_application_services import application_services
from extensions.ext_database import db
from libs.login import current_account_with_tenant, login_required
from models import AccountTrialAppRecord, App, InstalledApp, TrialApp
@@ -107,16 +106,6 @@ def trial_app_required[**P, R](view: Callable[Concatenate[App, P], R] | None = N
return 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 decorators
diff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.py
index 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 DatabaseRecommendedA
from repositories.sqlalchemy_api_workflow_run_repository import DifyAPISQLAlchemyWorkflowRunRepository
from repositories.step_by_step_tour_repository import SQLAlchemyStepByStepTourStateRepository
from 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 TrialAppRepository
from repositories.upload_file_delivery_repository import UploadFileDeliveryQueryRepository
from repositories.web_passport_repository import WebPassportRepository
from repositories.webapp_access_query_repository import WebAppAccessQueryRepository
@@ -139,6 +138,7 @@ from services.account_profile_service import AccountProfileService
from services.app_definition_query_service import AppDefinitionQueryService
from services.app_site_service import AppSiteService
from services.app_statistic_query import AppStatisticQuery
+from services.app_task_service import AppTaskControlService
from services.app_tracing_config_gateway import OpsTraceManagerGateway
from services.app_tracing_config_service import AppTracingConfigService
from services.auth.data_source_api_key_auth_gateways import (
@@ -190,6 +190,9 @@ from services.step_by_step_tour_service import StepByStepTourService
from services.system_feature_service import SystemFeatureService
from services.tag_application_service import TagApplicationService
from 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 TrialAppGenerationService
from services.trial_app_usage import TrialAppUsageRecorder
from services.upload_file_delivery_service import UploadFileDeliveryService
from services.web_app_runtime_query_service import WebAppRuntimeQueryService
@@ -282,6 +285,9 @@ class ApplicationServices:
partner_tenant_bindings: PartnerTenantBindingService
recommended_app_queries: RecommendedAppQueryService
remote_files: RemoteFileService
+ app_tasks: AppTaskControlService
+ trial_app_access: TrialAppAccessService
+ trial_app_generation: TrialAppGenerationService
trial_app_usage: TrialAppUsageRecorder
workflow_run_archives: WorkflowRunArchiveService
workflow_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.py
index 256e60ef500..e5a62dd9747 100644
--- a/api/libs/helper.py
+++ b/api/libs/helper.py
@@ -7,7 +7,7 @@ import struct
import subprocess
import time
import uuid
-from collections.abc import Callable, Generator, Mapping
+from collections.abc import Callable, Generator, Iterable, Mapping
from datetime import datetime
from hashlib import sha256
from 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.py
deleted file mode 100644
index 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.py
new file mode 100644
index 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 += 1
diff --git a/api/repositories/trial_app_usage_repository.py b/api/repositories/trial_app_usage_repository.py
deleted file mode 100644
index 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 += 1
diff --git a/api/services/app_task_service.py b/api/services/app_task_service.py
index 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_key
from core.app.entities.app_invoke_entities import InvokeFrom
-from extensions.ext_redis import redis_client
+from extensions.ext_redis import RedisClientWrapper, redis_client
from graphon.graph_engine.manager import GraphEngineManager
from 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.py
new file mode 100644
index 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.app
diff --git a/api/services/trial_app_generation_adapters.py b/api/services/trial_app_generation_adapters.py
new file mode 100644
index 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_response
diff --git a/api/services/trial_app_generation_service.py b/api/services/trial_app_generation_service.py
new file mode 100644
index 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 response
diff --git a/api/tests/unit_tests/controllers/console/explore/test_trial.py b/api/tests/unit_tests/controllers/console/explore/test_trial.py
index 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 uuid4
import pytest
from flask import Flask, request
from sqlalchemy.orm import Session
-from werkzeug.exceptions import Forbidden, InternalServerError, NotFound
+from werkzeug.exceptions import Forbidden, NotFound
import controllers.console.explore.trial as module
from 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 TextToSpeechRequest
from core.app.app_config.common.parameters_mapping import get_parameters_from_feature_dict
from core.errors.error import (
ModelCurrentlyNotSupportError,
@@ -48,20 +42,11 @@ from models.workflow import Workflow
from services.app_ref_service import AppRef, MessageRef
from services.errors.audio import SpeechToTextDisabledServiceError
from services.errors.conversation import ConversationNotExistsError
-from services.errors.llm import InvokeRateLimitError
from tests.unit_tests.model_factories import make_app, make_upload_file
unwrap: 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.fixture
def 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.py
new file mode 100644
index 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() == 1
diff --git a/api/tests/unit_tests/controllers/console/explore/test_wraps.py b/api/tests/unit_tests/controllers/console/explore/test_wraps.py
index 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_enable
from 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.py
index 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_services
from extensions.ext_redis import RedisClientWrapper
from machinery.context import RequestContext
from models.account import Account
-from models.model import AccountTrialAppRecord, DifySetup
+from models.model import AccountTrialAppRecord, App, DifySetup, TrialApp
from repositories.account_activation_repository import SQLAlchemyAccountActivationRepository
from repositories.account_integration_repository import SQLAlchemyAccountIntegrationRepository
from repositories.account_oauth_repository import (
@@ -63,6 +63,7 @@ from services.account_oauth_adapters import (
DeploymentOAuthPolicyGateway,
RedisOAuthAccountClaimLock,
)
+from services.app_generate_service import AppGenerateService
from services.app_site_service import AppSiteService
from services.app_tracing_config_gateway import OpsTraceManagerGateway
from 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.py
deleted file mode 100644
index 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.py
new file mode 100644
index 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 == 1
diff --git a/api/tests/unit_tests/repositories/test_trial_app_usage_repository.py b/api/tests/unit_tests/repositories/test_trial_app_usage_repository.py
deleted file mode 100644
index 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 == 1
diff --git a/api/tests/unit_tests/services/test_app_task_control_service.py b/api/tests/unit_tests/services/test_app_task_control_service.py
new file mode 100644
index 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.py
new file mode 100644
index 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()