Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
refactor(api): isolate installed app completion generation (#41894)
非法操作3bf5f2c47e05
diff --git a/api/.importlinter b/api/.importlinterindex c0dde58f038..d4ba781c985 100644--- a/api/.importlinter+++ b/api/.importlinter@@ -210,6 +210,20 @@ forbidden_modules =sqlalchemywerkzeug+[importlinter:contract:installed-app-completion-boundary]+name = Installed app completion service is framework and persistence neutral+type = forbidden+source_modules =+ services.installed_app_completion_service+forbidden_modules =+ controllers+ extensions+ flask+ models+ repositories+ sqlalchemy+ werkzeug+[importlinter:contract:account-application-boundary]name = Account application services and contracts are framework and persistence neutraltype = forbiddendiff --git a/api/controllers/console/explore/completion.py b/api/controllers/console/explore/completion.pyindex 4a5d59b7ac7..33265e96fa4 100644--- a/api/controllers/console/explore/completion.py+++ b/api/controllers/console/explore/completion.py@@ -2,10 +2,11 @@ import loggingfrom typing import Any, Literalfrom uuid import UUID+from flask import Responsefrom flask_restx import Resourcefrom pydantic import BaseModel, Field, field_validatorfrom sqlalchemy.orm import Session-from werkzeug.exceptions import InternalServerError, NotFound+from werkzeug.exceptions import InternalServerError, NotFound, Unauthorizedimport servicesfrom controllers.common.fields import SimpleResultResponse@@ -39,12 +40,14 @@ from libs.datetime_utils import naive_utc_nowfrom machinery.context import RequestContextfrom models import Accountfrom models.model import AppMode, InstalledApp+from services.account_errors import AccountNotFoundErrorfrom services.app_definition_query_service import AppDefinitionUnavailableErrorfrom services.app_generate_service import AppGenerateServicefrom services.app_task_service import AppTaskServicefrom services.conversation_service import ConversationServicefrom services.errors.llm import InvokeRateLimitError-from services.installed_app_access_service import InstalledAppRef+from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppRef+from services.installed_app_completion_service import InstalledAppNotCompletionErrorfrom .. import console_ns@@ -91,45 +94,35 @@ register_response_schema_models(console_ns, SimpleResultResponse)"/installed-apps/<uuid:installed_app_id>/completion-messages",endpoint="installed_app_completion",)-class CompletionApi(InstalledAppResource):+class CompletionApi(Resource):@console_ns.expect(console_ns.models[CompletionMessageExplorePayload.__name__])@console_ns.response(200, "Success")- @with_current_user- @with_session+ @console_account_admission()+ @get_installed_app@model_validate(CompletionMessageExplorePayload)def post(self,req_data: CompletionMessageExplorePayload,- session: Session,- current_user: Account,- installed_app: InstalledApp,- ):- app_model = installed_app.app_with_session(session=session)- if app_model is None:- raise AppUnavailableError()- if app_model.mode != AppMode.COMPLETION:- raise NotCompletionAppError()-- args = req_data.model_dump(exclude_none=True)-- streaming = req_data.response_mode == "streaming"- args["auto_generate_name"] = False-- installed_app.last_used_at = naive_utc_now()- db.session.commit()-+ request_context: RequestContext,+ installed_app: InstalledAppRef,+ ) -> Response:try:- response = AppGenerateService.generate(- session=session,- app_model=app_model,- user=current_user,- args=args,- invoke_from=InvokeFrom.EXPLORE,- streaming=streaming,+ response = application_services().installed_app_completion.generate(+ installed_app=installed_app,+ account_id=request_context.account_id,+ args=req_data.model_dump(exclude_none=True),)# response-contract:ignore compact_generate_responsereturn helper.compact_generate_response(response)+ except AppDefinitionUnavailableError:+ raise AppUnavailableError() from None+ except InstalledAppNotCompletionError:+ raise NotCompletionAppError() from None+ except InstalledAppNotFoundError:+ raise NotFound("Installed app not found") from None+ except AccountNotFoundError:+ raise Unauthorized("Account no longer exists.") from Noneexcept services.errors.conversation.ConversationNotExistsError:raise NotFound("Conversation Not Exists.")except services.errors.conversation.ConversationCompletedError:diff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.pyindex 808d8222414..ed351869273 100644--- a/api/extensions/ext_application_services.py+++ b/api/extensions/ext_application_services.py@@ -53,7 +53,7 @@ from repositories.factory import DifyAPIRepositoryFactoryfrom repositories.file_grant_repository import FileGrantRepositoryfrom repositories.human_input_file_upload_repository import SQLAlchemyHumanInputFileUploadRepositoryfrom repositories.installation_state_repository import InstallationStateRepository-from repositories.installed_app_access_repository import SQLAlchemyInstalledAppAccessRepository+from repositories.installed_app_repository import SQLAlchemyInstalledAppRepositoryfrom repositories.message_file_preview_repository import MessageFilePreviewQueryRepositoryfrom repositories.oauth_access_token_repository import SQLAlchemyOAuthAccessTokenRepositoryfrom repositories.oauth_device_token_repository import SQLAlchemyOAuthDeviceTokenRepository@@ -178,6 +178,8 @@ from services.human_input_file_upload_service import HumanInputFileUploadServicefrom services.init_validation_service import InitValidationServicefrom services.inner_mail_service import InnerMailServicefrom services.installed_app_access_service import InstalledAppAccessService+from services.installed_app_completion_adapters import AppGenerateServiceCompletionRuntime+from services.installed_app_completion_service import InstalledAppCompletionServicefrom services.message_file_preview_service import MessageFilePreviewServicefrom services.message_suggested_questions_adapters import MessageSuggestedQuestionsRuntimefrom services.message_suggested_questions_service import MessageSuggestedQuestions@@ -326,6 +328,7 @@ class ApplicationServices:oauth_device: OAuthDeviceApplicationServiceinit_validation: InitValidationServiceinstalled_app_access: InstalledAppAccessService+ installed_app_completion: InstalledAppCompletionServicenotifications: NotificationServicestep_by_step_tour: StepByStepTourServicepartner_tenant_bindings: PartnerTenantBindingService@@ -502,8 +505,15 @@ def build_application_services(redis: RedisClientWrapper,) -> ApplicationServices:installation_state = InstallationStateRepository(session_factory=database_client)+ installed_apps = SQLAlchemyInstalledAppRepository(session_factory=database_client)data_source_api_key_auth_bindings = SQLAlchemyDataSourceApiKeyAuthBindingRepository(session_factory=database_client)app_definition_repository = AppDefinitionQueryRepository(session_factory=database_client)+ app_definitions = AppDefinitionQueryService(+ definitions=app_definition_repository,+ builtin_icon_url_prefix=(+ dify_config.CONSOLE_API_URL + "/console/api/workspaces/current/tool-provider/builtin/"+ ),+ )webapp_access = WebAppAccessQueryService(access=WebAppAccessQueryRepository(session_factory=database_client),webapp_auth_enabled=SystemFeatureService.is_webapp_auth_enabled(deployment_edition=deployment_edition),@@ -698,12 +708,7 @@ def build_application_services(),agent_apps=build_agent_app_services(database_client=database_client),advanced_prompt_templates=AdvancedPromptTemplateService(),- app_definitions=AppDefinitionQueryService(- definitions=app_definition_repository,- builtin_icon_url_prefix=(- dify_config.CONSOLE_API_URL + "/console/api/workspaces/current/tool-provider/builtin/"- ),- ),+ app_definitions=app_definitions,app_preview_details=AppPreviewDetailsRuntime(details=app_preview_repository),app_previews=AppPreviewQueryService(apps=app_preview_repository,@@ -743,9 +748,14 @@ def build_application_services(),webapp_access=webapp_access,installed_app_access=InstalledAppAccessService(- installed_apps=SQLAlchemyInstalledAppAccessRepository(session_factory=database_client),+ installed_apps=installed_apps,is_user_allowed=webapp_access.is_user_allowed,),+ installed_app_completion=InstalledAppCompletionService(+ app_definitions=app_definitions,+ usage=installed_apps,+ runtime=AppGenerateServiceCompletionRuntime(session_factory=database_client),+ ),web_app_runtime=WebAppRuntimeQueryService(runtime=app_definition_repository,file_service=file_service,diff --git a/api/repositories/installed_app_access_repository.py b/api/repositories/installed_app_access_repository.pydeleted file mode 100644index 61dd6a65453..00000000000--- a/api/repositories/installed_app_access_repository.py+++ /dev/null@@ -1,35 +0,0 @@-"""Resolve workspace installations before external access checks."""--from typing import override--from sqlalchemy import select-from sqlalchemy.orm import Session, sessionmaker--from models.model import App, InstalledApp-from services.installed_app_access_service import InstalledAppAccessStore, InstalledAppRef---class SQLAlchemyInstalledAppAccessRepository(InstalledAppAccessStore):- def __init__(self, *, session_factory: sessionmaker[Session]) -> None:- self._session_factory = session_factory-- @override- def resolve(self, *, installed_app_id: str, tenant_id: str) -> InstalledAppRef | None:- with self._session_factory() as session:- installed_app = session.scalar(- select(InstalledApp)- .where(InstalledApp.id == installed_app_id, InstalledApp.tenant_id == tenant_id)- .limit(1)- )- if installed_app is None:- return None-- # An installed public app can belong to another workspace. Admission- # preserves the existence check; publication policy belongs to its callers.- app_id = session.scalar(select(App.id).where(App.id == installed_app.app_id).limit(1))- if app_id is None:- session.delete(installed_app)- session.commit()- return None-- return InstalledAppRef(id=installed_app.id, app_id=app_id, tenant_id=installed_app.tenant_id)diff --git a/api/repositories/installed_app_repository.py b/api/repositories/installed_app_repository.pynew file mode 100644index 00000000000..a5f449e0320--- /dev/null+++ b/api/repositories/installed_app_repository.py@@ -0,0 +1,54 @@+"""Persist workspace installations with independently scoped operations."""++from datetime import datetime+from typing import cast, override++from sqlalchemy import select, update+from sqlalchemy.engine import CursorResult+from sqlalchemy.orm import Session, sessionmaker++from models.model import App, InstalledApp+from services.installed_app_access_service import InstalledAppAccessStore, InstalledAppNotFoundError, InstalledAppRef+from services.installed_app_completion_service import InstalledAppUsageRecorder+++class SQLAlchemyInstalledAppRepository(InstalledAppAccessStore, InstalledAppUsageRecorder):+ def __init__(self, *, session_factory: sessionmaker[Session]) -> None:+ self._session_factory: sessionmaker[Session] = session_factory++ @override+ def resolve(self, *, installed_app_id: str, tenant_id: str) -> InstalledAppRef | None:+ with self._session_factory() as session:+ installed_app = session.scalar(+ select(InstalledApp)+ .where(InstalledApp.id == installed_app_id, InstalledApp.tenant_id == tenant_id)+ .limit(1)+ )+ if installed_app is None:+ return None++ # An installed public app can belong to another workspace. Admission+ # preserves the existence check; publication policy belongs to its callers.+ app_id = session.scalar(select(App.id).where(App.id == installed_app.app_id).limit(1))+ if app_id is None:+ session.delete(installed_app)+ session.commit()+ return None++ return InstalledAppRef(id=installed_app.id, app_id=app_id, tenant_id=installed_app.tenant_id)++ @override+ def record(self, *, installed_app: InstalledAppRef, used_at: datetime) -> None:+ """Commit usage independently so generation failures do not roll it back."""+ with self._session_factory.begin() as session:+ result = session.execute(+ update(InstalledApp)+ .where(+ InstalledApp.id == installed_app.id,+ InstalledApp.tenant_id == installed_app.tenant_id,+ InstalledApp.app_id == installed_app.app_id,+ )+ .values(last_used_at=used_at)+ )+ if cast(CursorResult, result).rowcount == 0:+ raise InstalledAppNotFoundError(f"Installed app {installed_app.id} no longer exists")diff --git a/api/services/installed_app_completion_adapters.py b/api/services/installed_app_completion_adapters.pynew file mode 100644index 00000000000..aa9541c28d3--- /dev/null+++ b/api/services/installed_app_completion_adapters.py@@ -0,0 +1,63 @@+"""Bridge pure installed app requests to the existing generation runtime."""++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.installed_app_completion_service import CompletionResponse, InstalledAppCompletionRuntime++logger = logging.getLogger(__name__)+++class AppGenerateServiceCompletionRuntime(InstalledAppCompletionRuntime):+ def __init__(self, *, session_factory: sessionmaker[Session]) -> None:+ self._session_factory: sessionmaker[Session] = session_factory++ @override+ def generate(+ self,+ *,+ app_id: str,+ account_id: str,+ args: Mapping[str, object],+ streaming: bool,+ ) -> CompletionResponse:+ with self._session_factory(expire_on_commit=False) as read_session:+ app = read_session.get(App, app_id)+ if app is None:+ raise AppDefinitionUnavailableError(f"App {app_id} no longer exists")+ account = read_session.get(Account, account_id)+ if account is None:+ raise AccountNotFoundError(f"Account {account_id} no longer exists")++ # Release actor/app reads before the runtime's quota and rate-limit checks.+ # Legacy generators still own their internal database and external I/O.+ response: CompletionResponse | None = None+ try:+ with self._session_factory(expire_on_commit=False) as session:+ generated_response: CompletionResponse = AppGenerateService.generate(+ session=session,+ app_model=app,+ user=account,+ args=args,+ invoke_from=InvokeFrom.EXPLORE,+ 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 the generation response after an error")+ raise++ return generated_responsediff --git a/api/services/installed_app_completion_service.py b/api/services/installed_app_completion_service.pynew file mode 100644index 00000000000..f7633a41aa0--- /dev/null+++ b/api/services/installed_app_completion_service.py@@ -0,0 +1,72 @@+"""Generate a completion for an admitted workspace installation."""++from collections.abc import Iterator, Mapping+from datetime import datetime+from typing import Protocol++from libs.datetime_utils import naive_utc_now+from services.app_definition_query_service import AppDefinitionQueryService+from services.installed_app_access_service import InstalledAppRef+++class CompletionStream(Protocol):+ def __iter__(self) -> Iterator[str]: ...++ def __next__(self) -> str: ...++ def close(self) -> None: ...+++type CompletionResponse = Mapping[str, object] | CompletionStream+++class InstalledAppNotCompletionError(ValueError):+ """The installed app does not support the completion endpoint."""+++class InstalledAppUsageRecorder(Protocol):+ def record(self, *, installed_app: InstalledAppRef, used_at: datetime) -> None: ...+++class InstalledAppCompletionRuntime(Protocol):+ def generate(+ self,+ *,+ app_id: str,+ account_id: str,+ args: Mapping[str, object],+ streaming: bool,+ ) -> CompletionResponse: ...+++class InstalledAppCompletionService:+ def __init__(+ self,+ *,+ app_definitions: AppDefinitionQueryService,+ usage: InstalledAppUsageRecorder,+ runtime: InstalledAppCompletionRuntime,+ ) -> None:+ self._app_definitions: AppDefinitionQueryService = app_definitions+ self._usage: InstalledAppUsageRecorder = usage+ self._runtime: InstalledAppCompletionRuntime = runtime++ def generate(+ self, *, installed_app: InstalledAppRef, account_id: str, args: Mapping[str, object]+ ) -> CompletionResponse:+ if self._app_definitions.get_mode(installed_app.app_id) != "completion":+ raise InstalledAppNotCompletionError(f"App {installed_app.app_id} is not a completion app")++ generation_args = dict(args)+ generation_args["auto_generate_name"] = False+ streaming = generation_args.get("response_mode") == "streaming"++ # Opening an installed app records usage even when generation fails.+ # Commit this independently before entering the generation runtime.+ self._usage.record(installed_app=installed_app, used_at=naive_utc_now())+ return self._runtime.generate(+ app_id=installed_app.app_id,+ account_id=account_id,+ args=generation_args,+ streaming=streaming,+ )diff --git a/api/tests/unit_tests/controllers/console/explore/test_completion.py b/api/tests/unit_tests/controllers/console/explore/test_completion.pyindex 15358a3cf23..c7faa7cfdbb 100644--- a/api/tests/unit_tests/controllers/console/explore/test_completion.py+++ b/api/tests/unit_tests/controllers/console/explore/test_completion.py@@ -11,7 +11,7 @@ import controllers.console.explore.completion as completion_modulefrom controllers.console.app.error import (ConversationCompletedError,)-from controllers.console.explore.error import NotChatAppError, NotCompletionAppError+from controllers.console.explore.error import NotChatAppErrorfrom controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpErrorfrom models import Accountfrom models.model import App, AppMode, InstalledApp@@ -30,11 +30,6 @@ def bind_database(sqlite_session: Session, monkeypatch: pytest.MonkeyPatch) -> Nmonkeypatch.setattr(completion_module.db, "session", sqlite_session)-def completion_app(sqlite_session: Session) -> InstalledApp:- return _installed_app(AppMode.COMPLETION, sqlite_session)--@pytest.fixturedef chat_app(sqlite_session: Session) -> InstalledApp:return _installed_app(AppMode.CHAT, sqlite_session)@@ -84,227 +79,6 @@ def payload_patch(payload_data):)-class TestCompletionApi:- def test_post_success(self, app: Flask, completion_app, user, payload_patch, payload_data):- api = completion_module.CompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={}),- payload_patch,- patch.object(- completion_module.AppGenerateService,- "generate",- return_value={"ok": True},- ),- patch.object(- completion_module.helper,- "compact_generate_response",- return_value=("ok", 200),- ),- ):- result = method(- api,- completion_module.CompletionMessageExplorePayload.model_validate(payload_data),- _session(completion_app),- user,- completion_app,- )-- assert result == ("ok", 200)-- def test_post_wrong_app_mode(self, user, sqlite_session: Session):- api = completion_module.CompletionApi()- method = unwrap(api.post)-- installed_app = _installed_app(AppMode.CHAT, sqlite_session)-- with pytest.raises(NotCompletionAppError):- method(- api,- completion_module.CompletionMessageExplorePayload.model_validate({"inputs": {}, "query": "hi"}),- sqlite_session,- user,- installed_app,- )-- def test_conversation_completed(self, app: Flask, completion_app, user, payload_patch, payload_data):- api = completion_module.CompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={}),- payload_patch,- patch.object(- completion_module.AppGenerateService,- "generate",- side_effect=completion_module.services.errors.conversation.ConversationCompletedError(),- ),- ):- with pytest.raises(ConversationCompletedError):- method(- api,- completion_module.CompletionMessageExplorePayload.model_validate(payload_data),- _session(completion_app),- user,- completion_app,- )-- def test_internal_error(self, app: Flask, completion_app, user, payload_patch, payload_data):- api = completion_module.CompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={}),- payload_patch,- patch.object(- completion_module.AppGenerateService,- "generate",- side_effect=Exception("boom"),- ),- ):- with pytest.raises(InternalServerError):- method(- api,- completion_module.CompletionMessageExplorePayload.model_validate(payload_data),- _session(completion_app),- user,- completion_app,- )-- def test_conversation_not_exists(self, app: Flask, completion_app, user, payload_patch, payload_data):- api = completion_module.CompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={}),- payload_patch,- patch.object(- completion_module.AppGenerateService,- "generate",- side_effect=completion_module.services.errors.conversation.ConversationNotExistsError(),- ),- ):- with pytest.raises(completion_module.NotFound):- method(- api,- completion_module.CompletionMessageExplorePayload.model_validate(payload_data),- _session(completion_app),- user,- completion_app,- )-- def test_app_unavailable(self, app: Flask, completion_app, user, payload_patch, payload_data):- api = completion_module.CompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={}),- payload_patch,- patch.object(- completion_module.AppGenerateService,- "generate",- side_effect=completion_module.services.errors.app_model_config.AppModelConfigBrokenError(),- ),- ):- with pytest.raises(completion_module.AppUnavailableError):- method(- api,- completion_module.CompletionMessageExplorePayload.model_validate(payload_data),- _session(completion_app),- user,- completion_app,- )-- def test_provider_not_initialized(self, app: Flask, completion_app, user, payload_patch, payload_data):- api = completion_module.CompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={}),- payload_patch,- patch.object(- completion_module.AppGenerateService,- "generate",- side_effect=completion_module.ProviderTokenNotInitError("not init"),- ),- ):- with pytest.raises(completion_module.ProviderNotInitializeError):- method(- api,- completion_module.CompletionMessageExplorePayload.model_validate(payload_data),- _session(completion_app),- user,- completion_app,- )-- def test_quota_exceeded(self, app: Flask, completion_app, user, payload_patch, payload_data):- api = completion_module.CompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={}),- payload_patch,- patch.object(- completion_module.AppGenerateService,- "generate",- side_effect=completion_module.QuotaExceededError(),- ),- ):- with pytest.raises(completion_module.ProviderQuotaExceededError):- method(- api,- completion_module.CompletionMessageExplorePayload.model_validate(payload_data),- _session(completion_app),- user,- completion_app,- )-- def test_model_not_supported(self, app: Flask, completion_app, user, payload_patch, payload_data):- api = completion_module.CompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={}),- payload_patch,- patch.object(- completion_module.AppGenerateService,- "generate",- side_effect=completion_module.ModelCurrentlyNotSupportError(),- ),- ):- with pytest.raises(completion_module.ProviderModelCurrentlyNotSupportError):- method(- api,- completion_module.CompletionMessageExplorePayload.model_validate(payload_data),- _session(completion_app),- user,- completion_app,- )-- def test_invoke_error(self, app: Flask, completion_app, user, payload_patch, payload_data):- api = completion_module.CompletionApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={}),- payload_patch,- patch.object(- completion_module.AppGenerateService,- "generate",- side_effect=completion_module.InvokeError("invoke failed"),- ),- ):- with pytest.raises(completion_module.CompletionRequestError):- method(- api,- completion_module.CompletionMessageExplorePayload.model_validate(payload_data),- _session(completion_app),- user,- completion_app,- )--class TestChatApi:def test_post_success(self, app: Flask, chat_app, user, payload_patch, payload_data):api = completion_module.ChatApi()diff --git a/api/tests/unit_tests/controllers/console/explore/test_installed_app_admission.py b/api/tests/unit_tests/controllers/console/explore/test_installed_app_admission.pyindex 3200901e01e..be2aefeaff7 100644--- a/api/tests/unit_tests/controllers/console/explore/test_installed_app_admission.py+++ b/api/tests/unit_tests/controllers/console/explore/test_installed_app_admission.py@@ -32,7 +32,7 @@ from machinery.context import RequestContextfrom models import Account, App, AppMode, InstalledApp, Tenantfrom models.account import AccountStatusfrom repositories.app_definition_query_repository import AppDefinitionQueryRepository-from repositories.installed_app_access_repository import SQLAlchemyInstalledAppAccessRepository+from repositories.installed_app_repository import SQLAlchemyInstalledAppRepositoryfrom services.app_definition_query_service import AppDefinitionQueryServicefrom services.installed_app_access_service import InstalledAppAccessService, InstalledAppReffrom services.saved_message_service import SavedMessageActor, SavedMessagePage, SavedMessageRecord, SavedMessageService@@ -124,7 +124,7 @@ def harness(services = _ApplicationServices(installed_app_access=InstalledAppAccessService(- installed_apps=SQLAlchemyInstalledAppAccessRepository(session_factory=repository_factory),+ installed_apps=SQLAlchemyInstalledAppRepository(session_factory=repository_factory),is_user_allowed=permission_check,))diff --git a/api/tests/unit_tests/controllers/console/explore/test_installed_app_completion.py b/api/tests/unit_tests/controllers/console/explore/test_installed_app_completion.pynew file mode 100644index 00000000000..78a9e6e28cc--- /dev/null+++ b/api/tests/unit_tests/controllers/console/explore/test_installed_app_completion.py@@ -0,0 +1,393 @@+import json+from collections.abc import Generator, Mapping+from dataclasses import dataclass, field+from datetime import datetime++import pytest+from sqlalchemy.orm import Session, sessionmaker++import controllers.console.explore.completion as completion_module+import services.installed_app_completion_service as completion_service_module+from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError+from graphon.model_runtime.errors.invoke import InvokeError+from models import App, AppMode, InstalledApp, Tenant+from repositories.app_definition_query_repository import AppDefinitionQueryRepository+from repositories.installed_app_repository import SQLAlchemyInstalledAppRepository+from services.account_errors import AccountNotFoundError+from services.app_definition_query_service import AppDefinitionQueryService+from services.errors.app_model_config import AppModelConfigBrokenError+from services.errors.conversation import ConversationCompletedError, ConversationNotExistsError+from services.installed_app_completion_service import CompletionResponse, InstalledAppCompletionService+from tests.unit_tests.controllers.console.explore.test_installed_app_admission import (+ _assert_json_response,+ _Harness,+ harness,+)++__all__ = ["harness"]++_USED_AT = datetime(2026, 9, 6, 12, 30, 0)+_BLOCKING_RESPONSE: dict[str, object] = {"event": "message", "answer": "Hello", "metadata": {}, "usage": None}+++@dataclass(frozen=True)+class _RuntimeCall:+ app_id: str+ account_id: str+ args: Mapping[str, object]+ streaming: bool+++@dataclass+class _Runtime:+ session_factory: sessionmaker[Session]+ installed_app_id: str+ response: CompletionResponse = field(default_factory=lambda: dict(_BLOCKING_RESPONSE))+ error: Exception | None = None+ calls: list[_RuntimeCall] = field(default_factory=list)++ def generate(+ self, *, app_id: str, account_id: str, args: Mapping[str, object], streaming: bool+ ) -> CompletionResponse:+ # The runtime sees a committed usage update through an independent+ # connection, including when generation immediately fails.+ with self.session_factory() as session:+ installation = session.get(InstalledApp, self.installed_app_id)+ assert installation is not None+ assert installation.last_used_at == _USED_AT+ self.calls.append(_RuntimeCall(app_id, account_id, dict(args), streaming))+ if self.error is not None:+ raise self.error+ return self.response+++@dataclass(frozen=True)+class _Services:+ installed_app_completion: InstalledAppCompletionService+++def runtime(+ harness: _Harness,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session_factory: sessionmaker[Session],+) -> _Runtime:+ runtime = _Runtime(sqlite_session_factory, harness.installed_app.id)+ service = InstalledAppCompletionService(+ app_definitions=AppDefinitionQueryService(+ definitions=AppDefinitionQueryRepository(session_factory=sqlite_session_factory),+ builtin_icon_url_prefix="/tools/icons",+ ),+ usage=SQLAlchemyInstalledAppRepository(session_factory=sqlite_session_factory),+ runtime=runtime,+ )+ services = _Services(installed_app_completion=service)+ monkeypatch.setattr(completion_module, "application_services", lambda: services)+ monkeypatch.setattr(completion_service_module, "naive_utc_now", lambda: _USED_AT)+ harness.api.add_resource(+ completion_module.CompletionApi,+ "/installed-apps/<uuid:installed_app_id>/completion-messages",+ )+ return runtime+++def _url(harness: _Harness) -> str:+ return f"/installed-apps/{harness.installed_app.id}/completion-messages"+++def _last_used_at(harness: _Harness, session_factory: sessionmaker[Session]) -> datetime | None:+ with session_factory() as session:+ installation = session.get(InstalledApp, harness.installed_app.id)+ assert installation is not None+ return installation.last_used_at+++ ("payload", "expected_args"),+ [+ (+ {"inputs": {"zero": 0, "enabled": False, "empty": [], "nullable": None}},+ {+ "inputs": {"zero": 0, "enabled": False, "empty": [], "nullable": None},+ "query": "",+ "retriever_from": "explore_app",+ "auto_generate_name": False,+ },+ ),+ (+ {"inputs": {}, "query": "Hi", "files": None, "response_mode": None},+ {"inputs": {}, "query": "Hi", "retriever_from": "explore_app", "auto_generate_name": False},+ ),+ (+ {"inputs": {}, "files": [], "response_mode": "blocking", "auto_generate_name": True},+ {+ "inputs": {},+ "query": "",+ "files": [],+ "response_mode": "blocking",+ "retriever_from": "explore_app",+ "auto_generate_name": False,+ },+ ),+ (+ {+ "inputs": {},+ "files": [{"type": "image", "transfer_method": "remote_url", "url": "https://example.com/image.png"}],+ "retriever_from": "custom-source",+ },+ {+ "inputs": {},+ "query": "",+ "files": [{"type": "image", "transfer_method": "remote_url", "url": "https://example.com/image.png"}],+ "retriever_from": "custom-source",+ "auto_generate_name": False,+ },+ ),+ ],+)+def test_blocking_completion_preserves_payload_defaults_and_response(+ harness: _Harness,+ runtime: _Runtime,+ sqlite_session_factory: sessionmaker[Session],+ payload: dict[str, object],+ expected_args: dict[str, object],+) -> None:+ response = harness.app.test_client().post(_url(harness), json=payload)++ assert response.status_code == 200+ assert response.get_json() == _BLOCKING_RESPONSE+ assert dict(response.headers) == {+ "Content-Type": "application/json; charset=utf-8",+ "Content-Length": str(len(response.data)),+ }+ assert runtime.calls == [_RuntimeCall(harness.target_app.id, harness.account.id, expected_args, False)]+ assert _last_used_at(harness, sqlite_session_factory) == _USED_AT+ assert harness.installed_app.tenant_id != harness.target_app.tenant_id++[email protected]("consume_all", [False, True])+def test_streaming_completion_preserves_bytes_headers_and_closes_runtime_iterator(+ harness: _Harness,+ runtime: _Runtime,+ consume_all: bool,+) -> None:+ closed: list[bool] = []++ def chunks() -> Generator[str]:+ try:+ yield 'data: {"answer":"你好"}\n\n'+ yield "data: [DONE]\n\n"+ finally:+ closed.append(True)++ runtime.response = chunks()+ response = harness.app.test_client().post(+ _url(harness), json={"inputs": {}, "response_mode": "streaming"}, buffered=False+ )++ assert response.status_code == 200+ assert dict(response.headers) == {"Content-Type": "text/event-stream; charset=utf-8"}+ if consume_all:+ assert response.data == 'data: {"answer":"你好"}\n\ndata: [DONE]\n\n'.encode()+ else:+ assert next(iter(response.response)) == 'data: {"answer":"你好"}\n\n'.encode()+ assert closed == []+ response.close()+ assert closed == [True]+ assert runtime.calls == [+ _RuntimeCall(+ harness.target_app.id,+ harness.account.id,+ {+ "inputs": {},+ "query": "",+ "response_mode": "streaming",+ "retriever_from": "explore_app",+ "auto_generate_name": False,+ },+ True,+ )+ ]++[email protected]("response_mode", ["blocking", "streaming"])+ ("failure", "status", "code", "message"),+ [+ (ConversationNotExistsError(), 404, "not_found", "Conversation Not Exists."),+ (+ ConversationCompletedError(),+ 400,+ "conversation_completed",+ "The conversation has ended. Please start a new conversation.",+ ),+ (AppModelConfigBrokenError(), 400, "app_unavailable", "App unavailable, please check your app configurations."),+ (+ ProviderTokenNotInitError("Missing provider credentials"),+ 400,+ "provider_not_initialize",+ "Missing provider credentials",+ ),+ (+ QuotaExceededError(),+ 400,+ "provider_quota_exceeded",+ "Your quota for Dify Hosted Model Provider has been exhausted. "+ "Please go to Settings -> Model Provider to complete your own provider credentials.",+ ),+ (+ ModelCurrentlyNotSupportError(),+ 400,+ "model_currently_not_support",+ "Dify Hosted OpenAI trial currently not support the GPT-4 model.",+ ),+ (InvokeError("Provider rejected input"), 400, "completion_request_error", "Provider rejected input"),+ (ValueError("Invalid runtime arguments"), 400, "invalid_param", "Invalid runtime arguments"),+ (AccountNotFoundError(), 401, "unauthorized", "Account no longer exists."),+ (+ RuntimeError("Unexpected runtime failure"),+ 500,+ "internal_server_error",+ "The server encountered an internal error and was unable to complete your request. "+ "Either the server is overloaded or there is an error in the application.",+ ),+ ],+)+def test_completion_preserves_error_contract_and_committed_usage_on_runtime_failure(+ harness: _Harness,+ runtime: _Runtime,+ sqlite_session_factory: sessionmaker[Session],+ failure: Exception,+ status: int,+ code: str,+ message: str,+ response_mode: str,+) -> None:+ runtime.error = failure++ response = harness.app.test_client().post(_url(harness), json={"inputs": {}, "response_mode": response_mode})++ _assert_json_response(response, status=status, body={"code": code, "message": message, "status": status})+ assert len(runtime.calls) == 1+ assert runtime.calls[0].streaming == (response_mode == "streaming")+ assert _last_used_at(harness, sqlite_session_factory) == _USED_AT+ if status == 401:+ assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'+++ ("payload", "error"),+ [+ ({}, {"type": "missing", "loc": ["inputs"], "msg": "Field required"}),+ ({"inputs": None}, {"type": "dict_type", "loc": ["inputs"], "msg": "Input should be a valid dictionary"}),+ (+ {"inputs": {}, "response_mode": "invalid"},+ {"type": "literal_error", "loc": ["response_mode"], "msg": "Input should be 'blocking' or 'streaming'"},+ ),+ ],+)+def test_invalid_payload_does_not_record_usage_or_start_runtime(+ harness: _Harness,+ runtime: _Runtime,+ sqlite_session_factory: sessionmaker[Session],+ payload: dict[str, object],+ error: dict[str, object],+) -> None:+ response = harness.app.test_client().post(_url(harness), json=payload)++ _assert_json_response(+ response,+ status=422,+ body={"code": "unprocessable_entity", "message": json.dumps([error]), "status": 422},+ )+ assert runtime.calls == []+ assert _last_used_at(harness, sqlite_session_factory) is None+++def test_wrong_mode_does_not_record_usage_or_start_runtime(+ harness: _Harness,+ runtime: _Runtime,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ with sqlite_session_factory.begin() as session:+ app = session.get(App, harness.target_app.id)+ assert app is not None+ app.mode = AppMode.CHAT++ response = harness.app.test_client().post(_url(harness), json={"inputs": {}})++ _assert_json_response(+ response, status=400, body={"code": "not_completion_app", "message": "Not Completion App", "status": 400}+ )+ assert runtime.calls == []+ assert _last_used_at(harness, sqlite_session_factory) is None++[email protected]("rejection", ["permission", "missing", "tenant"])+def test_completion_requires_installed_app_admission_before_payload_validation(+ harness: _Harness,+ runtime: _Runtime,+ sqlite_session_factory: sessionmaker[Session],+ rejection: str,+) -> None:+ if rejection == "permission":+ harness.state.allowed = False+ elif rejection == "tenant":+ harness.account._current_tenant = Tenant(name="Other workspace")+ else:+ with sqlite_session_factory.begin() as session:+ installation = session.get(InstalledApp, harness.installed_app.id)+ assert installation is not None+ session.delete(installation)++ response = harness.app.test_client().post(_url(harness), json={})++ if rejection == "permission":+ _assert_json_response(+ response, status=403, body={"code": "access_denied", "message": "App access denied.", "status": 403}+ )+ else:+ _assert_json_response(+ response, status=404, body={"code": "not_found", "message": "Installed app not found", "status": 404}+ )+ assert runtime.calls == []+ if rejection != "missing":+ assert _last_used_at(harness, sqlite_session_factory) is None++[email protected]("deleted_resource", ["app", "installation"])+def test_resource_removed_after_admission_does_not_start_runtime(+ harness: _Harness,+ runtime: _Runtime,+ sqlite_session_factory: sessionmaker[Session],+ deleted_resource: str,+) -> None:+ def delete_resource() -> None:+ with sqlite_session_factory.begin() as session:+ if deleted_resource == "app":+ resource = session.get(App, harness.target_app.id)+ else:+ resource = session.get(InstalledApp, harness.installed_app.id)+ assert resource is not None+ session.delete(resource)++ harness.state.permission_action = delete_resource++ response = harness.app.test_client().post(_url(harness), json={"inputs": {}})++ if deleted_resource == "app":+ _assert_json_response(+ response,+ status=400,+ body={+ "code": "app_unavailable",+ "message": "App unavailable, please check your app configurations.",+ "status": 400,+ },+ )+ assert _last_used_at(harness, sqlite_session_factory) is None+ else:+ _assert_json_response(+ response, status=404, body={"code": "not_found", "message": "Installed app not found", "status": 404}+ )+ assert runtime.calls == []diff --git a/api/tests/unit_tests/repositories/test_installed_app_access_repository.py b/api/tests/unit_tests/repositories/test_installed_app_access_repository.pydeleted file mode 100644index a1ecd1b8ba8..00000000000--- a/api/tests/unit_tests/repositories/test_installed_app_access_repository.py+++ /dev/null@@ -1,103 +0,0 @@-from uuid import uuid4--import pytest-from sqlalchemy import inspect-from sqlalchemy.orm import Session, sessionmaker--from models.model import App, AppMode, InstalledApp-from repositories.installed_app_access_repository import SQLAlchemyInstalledAppAccessRepository-from services.installed_app_access_service import InstalledAppRef--_VIEWER_TENANT_ID = "11111111-1111-4111-8111-111111111111"-_OWNER_TENANT_ID = "22222222-2222-4222-8222-222222222222"---def _installation(*, app_id: str) -> InstalledApp:- return InstalledApp(- app_id=app_id,- tenant_id=_VIEWER_TENANT_ID,- app_owner_tenant_id=_OWNER_TENANT_ID,- position=0,- is_pinned=False,- last_used_at=None,- )---def test_resolve_returns_pure_reference_to_cross_workspace_app(- sqlite_session_factory: sessionmaker[Session],-) -> None:- with sqlite_session_factory.begin() as session:- # Admission must not add public, published, or app-mode constraints.- app = App(- tenant_id=_OWNER_TENANT_ID,- name="Installed app",- mode=AppMode.AGENT,- is_public=False,- enable_site=True,- enable_api=True,- )- session.add(app)- session.flush()- installed_app = _installation(app_id=app.id)- session.add(installed_app)- session.flush()- installed_app_id = installed_app.id- app_id = app.id-- repository = SQLAlchemyInstalledAppAccessRepository(session_factory=sqlite_session_factory)- result = repository.resolve(installed_app_id=installed_app_id, tenant_id=_VIEWER_TENANT_ID)-- assert result == InstalledAppRef(id=installed_app_id, app_id=app_id, tenant_id=_VIEWER_TENANT_ID)- assert inspect(result, raiseerr=False) is None- with sqlite_session_factory() as session:- assert session.get(InstalledApp, installed_app_id) is not None---def test_missing_installation_returns_none(sqlite_session_factory: sessionmaker[Session]) -> None:- repository = SQLAlchemyInstalledAppAccessRepository(session_factory=sqlite_session_factory)-- assert repository.resolve(installed_app_id=str(uuid4()), tenant_id=_VIEWER_TENANT_ID) is None--[email protected]("orphaned", [False, True])-def test_other_workspace_cannot_resolve_or_clean_up_installation(- sqlite_session_factory: sessionmaker[Session],- orphaned: bool,-) -> None:- with sqlite_session_factory.begin() as session:- app_id = str(uuid4())- if not orphaned:- app = App(- id=app_id,- tenant_id=_OWNER_TENANT_ID,- name="Installed app",- mode=AppMode.COMPLETION,- enable_site=True,- enable_api=True,- )- session.add(app)- installed_app = _installation(app_id=app_id)- session.add(installed_app)- session.flush()- installed_app_id = installed_app.id-- repository = SQLAlchemyInstalledAppAccessRepository(session_factory=sqlite_session_factory)-- assert repository.resolve(installed_app_id=installed_app_id, tenant_id=_OWNER_TENANT_ID) is None- with sqlite_session_factory() as session:- assert session.get(InstalledApp, installed_app_id) is not None---def test_orphan_cleanup_is_committed_and_idempotent(sqlite_session_factory: sessionmaker[Session]) -> None:- with sqlite_session_factory.begin() as session:- installed_app = _installation(app_id=str(uuid4()))- session.add(installed_app)- session.flush()- installed_app_id = installed_app.id-- repository = SQLAlchemyInstalledAppAccessRepository(session_factory=sqlite_session_factory)-- assert repository.resolve(installed_app_id=installed_app_id, tenant_id=_VIEWER_TENANT_ID) is None- with sqlite_session_factory() as session:- assert session.get(InstalledApp, installed_app_id) is None- assert repository.resolve(installed_app_id=installed_app_id, tenant_id=_VIEWER_TENANT_ID) is Nonediff --git a/api/tests/unit_tests/repositories/test_installed_app_repository.py b/api/tests/unit_tests/repositories/test_installed_app_repository.pynew file mode 100644index 00000000000..99b7599d0c7--- /dev/null+++ b/api/tests/unit_tests/repositories/test_installed_app_repository.py@@ -0,0 +1,201 @@+from dataclasses import replace+from datetime import datetime+from uuid import uuid4++import pytest+from sqlalchemy import event, inspect+from sqlalchemy.orm import Session, sessionmaker++from models.model import App, AppMode, InstalledApp+from repositories.installed_app_repository import SQLAlchemyInstalledAppRepository+from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppRef++_USED_AT = datetime(2026, 9, 6, 12, 30, 45)+_VIEWER_TENANT_ID = "11111111-1111-4111-8111-111111111111"+_OWNER_TENANT_ID = "22222222-2222-4222-8222-222222222222"+++def _installation(*, app_id: str) -> InstalledApp:+ return InstalledApp(+ app_id=app_id,+ tenant_id=_VIEWER_TENANT_ID,+ app_owner_tenant_id=_OWNER_TENANT_ID,+ position=0,+ is_pinned=False,+ last_used_at=None,+ )+++def test_resolve_returns_pure_reference_to_cross_workspace_app(+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ with sqlite_session_factory.begin() as session:+ # Admission must not add public, published, or app-mode constraints.+ app = App(+ tenant_id=_OWNER_TENANT_ID,+ name="Installed app",+ mode=AppMode.AGENT,+ is_public=False,+ enable_site=True,+ enable_api=True,+ )+ session.add(app)+ session.flush()+ installed_app = _installation(app_id=app.id)+ session.add(installed_app)+ session.flush()+ installed_app_id = installed_app.id+ app_id = app.id++ repository = SQLAlchemyInstalledAppRepository(session_factory=sqlite_session_factory)+ result = repository.resolve(installed_app_id=installed_app_id, tenant_id=_VIEWER_TENANT_ID)++ assert result == InstalledAppRef(id=installed_app_id, app_id=app_id, tenant_id=_VIEWER_TENANT_ID)+ assert inspect(result, raiseerr=False) is None+ with sqlite_session_factory() as session:+ assert session.get(InstalledApp, installed_app_id) is not None+++def test_missing_installation_returns_none(sqlite_session_factory: sessionmaker[Session]) -> None:+ repository = SQLAlchemyInstalledAppRepository(session_factory=sqlite_session_factory)++ assert repository.resolve(installed_app_id=str(uuid4()), tenant_id=_VIEWER_TENANT_ID) is None++[email protected]("orphaned", [False, True])+def test_other_workspace_cannot_resolve_or_clean_up_installation(+ sqlite_session_factory: sessionmaker[Session],+ orphaned: bool,+) -> None:+ with sqlite_session_factory.begin() as session:+ app_id = str(uuid4())+ if not orphaned:+ app = App(+ id=app_id,+ tenant_id=_OWNER_TENANT_ID,+ name="Installed app",+ mode=AppMode.COMPLETION,+ enable_site=True,+ enable_api=True,+ )+ session.add(app)+ installed_app = _installation(app_id=app_id)+ session.add(installed_app)+ session.flush()+ installed_app_id = installed_app.id++ repository = SQLAlchemyInstalledAppRepository(session_factory=sqlite_session_factory)++ assert repository.resolve(installed_app_id=installed_app_id, tenant_id=_OWNER_TENANT_ID) is None+ with sqlite_session_factory() as session:+ assert session.get(InstalledApp, installed_app_id) is not None+++def test_orphan_cleanup_is_committed_and_idempotent(sqlite_session_factory: sessionmaker[Session]) -> None:+ with sqlite_session_factory.begin() as session:+ installed_app = _installation(app_id=str(uuid4()))+ session.add(installed_app)+ session.flush()+ installed_app_id = installed_app.id++ repository = SQLAlchemyInstalledAppRepository(session_factory=sqlite_session_factory)++ assert repository.resolve(installed_app_id=installed_app_id, tenant_id=_VIEWER_TENANT_ID) is None+ with sqlite_session_factory() as session:+ assert session.get(InstalledApp, installed_app_id) is None+ assert repository.resolve(installed_app_id=installed_app_id, tenant_id=_VIEWER_TENANT_ID) is None+++def installed_app(sqlite_session_factory: sessionmaker[Session]) -> InstalledApp:+ with sqlite_session_factory.begin() as session:+ app = App(tenant_id=str(uuid4()), name="Shared app", mode=AppMode.COMPLETION, enable_site=True, enable_api=True)+ session.add(app)+ session.flush()+ installation = InstalledApp(+ tenant_id=str(uuid4()),+ app_id=app.id,+ app_owner_tenant_id=app.tenant_id,+ position=7,+ is_pinned=True,+ )+ session.add(installation)+ return installation+++def _reference(installation: InstalledApp) -> InstalledAppRef:+ return InstalledAppRef(id=installation.id, app_id=installation.app_id, tenant_id=installation.tenant_id)+++def test_record_commits_usage_for_cross_workspace_app_without_changing_installation_settings(+ sqlite_session_factory: sessionmaker[Session], installed_app: InstalledApp+) -> None:+ repository = SQLAlchemyInstalledAppRepository(session_factory=sqlite_session_factory)++ repository.record(installed_app=_reference(installed_app), used_at=_USED_AT)++ with sqlite_session_factory() as session:+ stored = session.get(InstalledApp, installed_app.id)+ assert stored is not None+ assert stored.last_used_at == _USED_AT+ assert stored.tenant_id != stored.app_owner_tenant_id+ assert stored.app_owner_tenant_id == installed_app.app_owner_tenant_id+ assert stored.position == 7+ assert stored.is_pinned is True++[email protected]("field", ["id", "tenant_id", "app_id"])+def test_record_requires_every_part_of_admitted_installation_scope(+ sqlite_session_factory: sessionmaker[Session], installed_app: InstalledApp, field: str+) -> None:+ reference = replace(_reference(installed_app), **{field: str(uuid4())})+ repository = SQLAlchemyInstalledAppRepository(session_factory=sqlite_session_factory)++ with pytest.raises(InstalledAppNotFoundError, match=reference.id):+ repository.record(installed_app=reference, used_at=_USED_AT)++ with sqlite_session_factory() as session:+ stored = session.get(InstalledApp, installed_app.id)+ assert stored is not None+ assert stored.last_used_at is None+++def test_record_is_repeatable_and_committed_usage_survives_a_later_rollback(+ sqlite_session_factory: sessionmaker[Session], installed_app: InstalledApp+) -> None:+ repository = SQLAlchemyInstalledAppRepository(session_factory=sqlite_session_factory)+ repository.record(installed_app=_reference(installed_app), used_at=_USED_AT)+ repository.record(installed_app=_reference(installed_app), used_at=_USED_AT)++ with sqlite_session_factory() as session:+ stored = session.get(InstalledApp, installed_app.id)+ assert stored is not None+ stored.last_used_at = None+ session.flush()+ session.rollback()++ with sqlite_session_factory() as session:+ stored = session.get(InstalledApp, installed_app.id)+ assert stored is not None+ assert stored.last_used_at == _USED_AT+++def test_record_rolls_back_and_preserves_commit_error(+ sqlite_session_factory: sessionmaker[Session], installed_app: InstalledApp+) -> None:+ failure = RuntimeError("usage commit unavailable")+ repository_factory = sessionmaker(bind=sqlite_session_factory.kw["bind"], expire_on_commit=False)++ @event.listens_for(repository_factory, "before_commit")+ def fail_commit(_session: Session) -> None:+ raise failure++ repository = SQLAlchemyInstalledAppRepository(session_factory=repository_factory)+ with pytest.raises(RuntimeError) as raised:+ repository.record(installed_app=_reference(installed_app), used_at=_USED_AT)++ assert raised.value is failure+ with sqlite_session_factory() as session:+ stored = session.get(InstalledApp, installed_app.id)+ assert stored is not None+ assert stored.last_used_at is Nonediff --git a/api/tests/unit_tests/services/test_installed_app_completion_adapters.py b/api/tests/unit_tests/services/test_installed_app_completion_adapters.pynew file mode 100644index 00000000000..e3de8680a5e--- /dev/null+++ b/api/tests/unit_tests/services/test_installed_app_completion_adapters.py@@ -0,0 +1,323 @@+import json+from collections.abc import Callable, Generator, Mapping+from dataclasses import dataclass, field+from typing import cast, override+from uuid import uuid4++import pytest+from sqlalchemy import event, inspect, update+from sqlalchemy.orm import Session, sessionmaker++import services.app_generate_service as generation_module+from core.app.entities.app_invoke_entities import InvokeFrom+from core.app.features.rate_limiting.rate_limit import RateLimit, RateLimitGenerator+from enums import DeploymentEdition+from models import Account, App, AppMode, AppModelConfig+from services.account_errors import AccountNotFoundError+from services.app_definition_query_service import AppDefinitionUnavailableError+from services.installed_app_completion_adapters import AppGenerateServiceCompletionRuntime+from services.installed_app_completion_service import CompletionResponse++_ARGS: dict[str, object] = {"inputs": {"count": 0}, "query": "hello", "auto_generate_name": False}+++@dataclass+class _RuntimeHarness:+ runtime: AppGenerateServiceCompletionRuntime+ app_id: str+ account_id: str+ closed_sessions: list[Session]+ committed_sessions: list[Session]+++def harness(sqlite_session_factory: sessionmaker[Session]) -> _RuntimeHarness:+ with sqlite_session_factory.begin() as session:+ app = App(+ tenant_id=str(uuid4()), name="Original app", mode=AppMode.COMPLETION, enable_site=True, enable_api=True+ )+ 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 close(self) -> None:+ super().close()+ closed_sessions.append(self)+ failure = self.info.get("close_failure")+ if isinstance(failure, Exception):+ raise failure++ # The adapter must preserve loaded snapshots even if its supplied factory+ # normally expires ORM state on commit.+ factory = sessionmaker(bind=sqlite_session_factory.kw["bind"], class_=TrackedSession, expire_on_commit=True)++ @event.listens_for(factory, "after_commit")+ def record_commit(session: Session) -> None:+ committed_sessions.append(session)++ return _RuntimeHarness(+ AppGenerateServiceCompletionRuntime(session_factory=cast(sessionmaker[Session], factory)),+ app.id,+ account.id,+ closed_sessions,+ committed_sessions,+ )+++def _patch_generation(+ monkeypatch: pytest.MonkeyPatch,+ harness: _RuntimeHarness,+ generate: Callable[[Session], CompletionResponse],+ *,+ streaming: bool,+) -> None:+ def legacy_generate(+ *,+ session: Session,+ app_model: App,+ user: Account,+ args: Mapping[str, object],+ invoke_from: InvokeFrom,+ streaming: bool,+ ) -> CompletionResponse:+ 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, user.id) == (harness.app_id, harness.account_id)+ assert (app_model.name, user.name) == ("Original app", "Viewer")+ assert args == _ARGS+ assert invoke_from == InvokeFrom.EXPLORE+ assert streaming is expected_streaming+ return generate(session)++ expected_streaming = streaming+ monkeypatch.setattr(generation_module.AppGenerateService, "generate", legacy_generate)+++@dataclass+class _RateLimitExit:+ exits: list[str] = field(default_factory=list)+ failure: Exception | None = None++ def exit(self, request_id: str) -> None:+ self.exits.append(request_id)+ if self.failure is not None:+ raise self.failure+++def _rate_limited_stream(source: Generator[str, None, None], rate: _RateLimitExit) -> RateLimitGenerator:+ return RateLimitGenerator(rate_limit=cast(RateLimit, rate), generator=source, request_id="request-1")+++def test_runtime_loads_detached_entities_then_commits_work_and_returns_the_same_mapping(+ harness: _RuntimeHarness,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ response: dict[str, object] = {"answer": "", "metadata": {"tokens": 0}}++ def generate(session: Session) -> CompletionResponse:+ session.execute(update(App).where(App.id == harness.app_id).values(name="Generated app"))+ return response++ _patch_generation(monkeypatch, harness, generate, streaming=False)+ result = harness.runtime.generate(app_id=harness.app_id, 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:+ stored = session.get(App, harness.app_id)+ assert stored is not None+ assert stored.name == "Generated app"++[email protected]("finish", ["complete", "cancel", "error"])+def test_runtime_preserves_stream_identity_and_original_close_lifecycle(+ harness: _RuntimeHarness, monkeypatch: pytest.MonkeyPatch, finish: str+) -> None:+ events: list[str] = []+ failure = RuntimeError("stream failed")+ rate = _RateLimitExit()++ def source() -> Generator[str, None, None]:+ assert len(harness.closed_sessions) == 2+ events.append("start")+ try:+ yield "data: first\n\n"+ if finish == "error":+ raise failure+ yield "data: second\n\n"+ finally:+ events.append("close")++ stream = _rate_limited_stream(source(), rate)+ _patch_generation(monkeypatch, harness, lambda _session: stream, streaming=True)+ result = harness.runtime.generate(app_id=harness.app_id, account_id=harness.account_id, args=_ARGS, streaming=True)++ assert result is stream+ assert events == []+ assert rate.exits == []+ assert harness.committed_sessions == [harness.closed_sessions[1]]+ assert next(stream) == "data: first\n\n"+ if finish == "complete":+ assert list(stream) == ["data: second\n\n"]+ elif finish == "cancel":+ stream.close()+ else:+ with pytest.raises(RuntimeError) as raised:+ next(stream)+ assert raised.value is failure++ stream.close()+ assert stream.closed is True+ assert rate.exits == ["request-1"]+ assert events == ["start", "close"]+++def test_streaming_preparation_errors_raise_eagerly_and_rollback_runtime_writes(+ harness: _RuntimeHarness,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ failure = ValueError("query must be a string")++ def generate(session: Session) -> CompletionResponse:+ session.execute(update(App).where(App.id == harness.app_id).values(name="Uncommitted app"))+ raise failure++ _patch_generation(monkeypatch, harness, generate, streaming=True)+ with pytest.raises(ValueError) as raised:+ harness.runtime.generate(app_id=harness.app_id, 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:+ stored = session.get(App, harness.app_id)+ assert stored is not None+ assert stored.name == "Original app"++[email protected]("missing", ["app", "account"])+def test_missing_runtime_entities_keep_precise_errors_and_do_not_enter_generation(+ harness: _RuntimeHarness, monkeypatch: pytest.MonkeyPatch, missing: str+) -> None:+ def unexpected_generation(**_kwargs: object) -> CompletionResponse:+ pytest.fail("Missing app or account must not reach generation")++ monkeypatch.setattr(generation_module.AppGenerateService, "generate", unexpected_generation)+ app_id = str(uuid4()) if missing == "app" else harness.app_id+ account_id = str(uuid4()) if missing == "account" else harness.account_id+ error_type = AppDefinitionUnavailableError if missing == "app" else AccountNotFoundError++ with pytest.raises(error_type, match=app_id if missing == "app" else account_id):+ harness.runtime.generate(app_id=app_id, account_id=account_id, args=_ARGS, streaming=True)++ assert len(harness.closed_sessions) == 1+ assert harness.committed_sessions == []++[email protected]("failure_phase", ["commit", "session_close"])[email protected]("stream_close_fails", [False, True])+def test_failure_before_stream_handoff_closes_stream_without_masking_primary_error(+ harness: _RuntimeHarness,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session_factory: sessionmaker[Session],+ failure_phase: str,+ stream_close_fails: bool,+) -> None:+ failure = RuntimeError(f"runtime {failure_phase} failed")+ rate = _RateLimitExit(failure=ValueError("stream close failed") if stream_close_fails else None)++ def source() -> Generator[str, None, None]:+ pytest.fail("A response that failed before handoff must not be consumed")+ yield "unreachable"++ stream = _rate_limited_stream(source(), rate)++ def generate(session: Session) -> CompletionResponse:+ session.execute(update(App).where(App.id == harness.app_id).values(name="Generated app"))+ if failure_phase == "commit":++ @event.listens_for(session, "before_commit")+ def fail_commit(_session: Session) -> None:+ raise failure+ else:+ session.info["close_failure"] = failure+ return stream++ _patch_generation(monkeypatch, harness, generate, streaming=True)+ with pytest.raises(RuntimeError) as raised:+ harness.runtime.generate(app_id=harness.app_id, account_id=harness.account_id, args=_ARGS, streaming=True)++ assert raised.value is failure+ assert stream.closed is True+ assert rate.exits == ["request-1"]+ with sqlite_session_factory() as session:+ stored = session.get(App, harness.app_id)+ assert stored is not None+ assert stored.name == ("Original app" if failure_phase == "commit" else "Generated app")++[email protected]("legacy_agent", [False, True])+def test_runtime_keeps_shared_completion_and_legacy_agent_dispatch(+ harness: _RuntimeHarness,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session_factory: sessionmaker[Session],+ config_overrides: Callable[..., None],+ legacy_agent: bool,+) -> None:+ config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY, ENABLE_OTEL=False)+ if legacy_agent:+ with sqlite_session_factory.begin() as session:+ app = session.get(App, harness.app_id)+ assert app is not None+ config = AppModelConfig(app_id=app.id, agent_mode=json.dumps({"enabled": True, "strategy": "react"}))+ session.add(config)+ app.app_model_config_id = config.id++ calls: list[AppMode] = []++ def generate(+ _self: object,+ *,+ app_model: App,+ user: Account,+ args: Mapping[str, object],+ invoke_from: InvokeFrom,+ streaming: bool,+ session: Session,+ ) -> dict[str, object]:+ assert user.id == harness.account_id+ assert args == _ARGS+ assert invoke_from == InvokeFrom.EXPLORE+ assert streaming is True+ calls.append(app_model.mode)+ assert session is not harness.closed_sessions[0]+ return {"mode": app_model.mode.value}++ monkeypatch.setattr(generation_module.CompletionAppGenerator, "generate", generate)+ monkeypatch.setattr(generation_module.AgentChatAppGenerator, "generate", generate)+ monkeypatch.setattr(RateLimit, "__init__", lambda _self, _app_id, _limit: None)+ monkeypatch.setattr(RateLimit, "enter", lambda _self, request_id: request_id)++ result = harness.runtime.generate(app_id=harness.app_id, account_id=harness.account_id, args=_ARGS, streaming=True)++ expected_mode = AppMode.AGENT_CHAT if legacy_agent else AppMode.COMPLETION+ assert result == {"mode": expected_mode.value}+ assert calls == [expected_mode]+ with sqlite_session_factory() as session:+ app = session.get(App, harness.app_id)+ assert app is not None+ assert app.mode == expected_mode