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 installed app completion generation (#41894)

非法操作3bf5f2c47e05
diff --git a/api/.importlinter b/api/.importlinter
index c0dde58f038..d4ba781c985 100644
--- a/api/.importlinter
+++ b/api/.importlinter
@@ -210,6 +210,20 @@ forbidden_modules =
sqlalchemy
werkzeug
+[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 neutral
type = forbidden
diff --git a/api/controllers/console/explore/completion.py b/api/controllers/console/explore/completion.py
index 4a5d59b7ac7..33265e96fa4 100644
--- a/api/controllers/console/explore/completion.py
+++ b/api/controllers/console/explore/completion.py
@@ -2,10 +2,11 @@ import logging
from typing import Any, Literal
from uuid import UUID
+from flask import Response
from flask_restx import Resource
from pydantic import BaseModel, Field, field_validator
from sqlalchemy.orm import Session
-from werkzeug.exceptions import InternalServerError, NotFound
+from werkzeug.exceptions import InternalServerError, NotFound, Unauthorized
import services
from controllers.common.fields import SimpleResultResponse
@@ -39,12 +40,14 @@ from libs.datetime_utils import naive_utc_now
from machinery.context import RequestContext
from models import Account
from models.model import AppMode, InstalledApp
+from services.account_errors import AccountNotFoundError
from services.app_definition_query_service import AppDefinitionUnavailableError
from services.app_generate_service import AppGenerateService
from services.app_task_service import AppTaskService
from services.conversation_service import ConversationService
from 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 InstalledAppNotCompletionError
from .. 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_response
return 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 None
except 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.py
index 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 DifyAPIRepositoryFactory
from repositories.file_grant_repository import FileGrantRepository
from repositories.human_input_file_upload_repository import SQLAlchemyHumanInputFileUploadRepository
from repositories.installation_state_repository import InstallationStateRepository
-from repositories.installed_app_access_repository import SQLAlchemyInstalledAppAccessRepository
+from repositories.installed_app_repository import SQLAlchemyInstalledAppRepository
from repositories.message_file_preview_repository import MessageFilePreviewQueryRepository
from repositories.oauth_access_token_repository import SQLAlchemyOAuthAccessTokenRepository
from repositories.oauth_device_token_repository import SQLAlchemyOAuthDeviceTokenRepository
@@ -178,6 +178,8 @@ from services.human_input_file_upload_service import HumanInputFileUploadService
from services.init_validation_service import InitValidationService
from services.inner_mail_service import InnerMailService
from services.installed_app_access_service import InstalledAppAccessService
+from services.installed_app_completion_adapters import AppGenerateServiceCompletionRuntime
+from services.installed_app_completion_service import InstalledAppCompletionService
from services.message_file_preview_service import MessageFilePreviewService
from services.message_suggested_questions_adapters import MessageSuggestedQuestionsRuntime
from services.message_suggested_questions_service import MessageSuggestedQuestions
@@ -326,6 +328,7 @@ class ApplicationServices:
oauth_device: OAuthDeviceApplicationService
init_validation: InitValidationService
installed_app_access: InstalledAppAccessService
+ installed_app_completion: InstalledAppCompletionService
notifications: NotificationService
step_by_step_tour: StepByStepTourService
partner_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.py
deleted file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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_response
diff --git a/api/services/installed_app_completion_service.py b/api/services/installed_app_completion_service.py
new file mode 100644
index 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.py
index 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_module
from controllers.console.app.error import (
ConversationCompletedError,
)
-from controllers.console.explore.error import NotChatAppError, NotCompletionAppError
+from controllers.console.explore.error import NotChatAppError
from controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpError
from models import Account
from models.model import App, AppMode, InstalledApp
@@ -30,11 +30,6 @@ def bind_database(sqlite_session: Session, monkeypatch: pytest.MonkeyPatch) -> N
monkeypatch.setattr(completion_module.db, "session", sqlite_session)
-def completion_app(sqlite_session: Session) -> InstalledApp:
- return _installed_app(AppMode.COMPLETION, sqlite_session)
-
-
@pytest.fixture
def 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.py
index 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 RequestContext
from models import Account, App, AppMode, InstalledApp, Tenant
from models.account import AccountStatus
from repositories.app_definition_query_repository import AppDefinitionQueryRepository
-from repositories.installed_app_access_repository import SQLAlchemyInstalledAppAccessRepository
+from repositories.installed_app_repository import SQLAlchemyInstalledAppRepository
from services.app_definition_query_service import AppDefinitionQueryService
from services.installed_app_access_service import InstalledAppAccessService, InstalledAppRef
from 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.py
new file mode 100644
index 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.py
deleted file mode 100644
index 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 None
diff --git a/api/tests/unit_tests/repositories/test_installed_app_repository.py b/api/tests/unit_tests/repositories/test_installed_app_repository.py
new file mode 100644
index 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 None
diff --git a/api/tests/unit_tests/services/test_installed_app_completion_adapters.py b/api/tests/unit_tests/services/test_installed_app_completion_adapters.py
new file mode 100644
index 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