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): migrate installed app chat generation (#41905)
非法操作bc94f7ead5cb
diff --git a/api/.importlinter b/api/.importlinterindex d4ba781c985..00605db67a4 100644--- a/api/.importlinter+++ b/api/.importlinter@@ -210,11 +210,11 @@ forbidden_modules =sqlalchemywerkzeug-[importlinter:contract:installed-app-completion-boundary]-name = Installed app completion service is framework and persistence neutral+[importlinter:contract:installed-app-generation-boundary]+name = Installed app generation service is framework and persistence neutraltype = forbiddensource_modules =- services.installed_app_completion_service+ services.installed_app_generation_serviceforbidden_modules =controllersextensionsdiff --git a/api/controllers/console/explore/completion.py b/api/controllers/console/explore/completion.pyindex 33265e96fa4..491342f8c36 100644--- a/api/controllers/console/explore/completion.py+++ b/api/controllers/console/explore/completion.py@@ -5,7 +5,6 @@ from uuid import UUIDfrom flask import Responsefrom flask_restx import Resourcefrom pydantic import BaseModel, Field, field_validator-from sqlalchemy.orm import Sessionfrom werkzeug.exceptions import InternalServerError, NotFound, Unauthorizedimport services@@ -19,12 +18,10 @@ from controllers.console.app.error import (ProviderNotInitializeError,ProviderQuotaExceededError,)-from controllers.console.app.wraps import with_sessionfrom controllers.console.explore.error import NotChatAppError, NotCompletionAppErrorfrom controllers.console.explore.installed_app_admission import get_installed_app-from controllers.console.explore.wraps import InstalledAppResourcefrom controllers.console.flask_admission import console_account_admission-from controllers.console.wraps import model_validate, with_current_user+from controllers.console.wraps import model_validatefrom controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpErrorfrom core.app.entities.app_invoke_entities import InvokeFromfrom core.errors.error import (@@ -33,21 +30,16 @@ from core.errors.error import (QuotaExceededError,)from extensions.ext_application_services import application_services-from extensions.ext_database import dbfrom graphon.model_runtime.errors.invoke import InvokeErrorfrom libs import helper-from libs.datetime_utils import naive_utc_nowfrom machinery.context import RequestContext-from models import Account-from models.model import AppMode, InstalledApp+from models.model import AppModefrom services.account_errors import AccountNotFoundErrorfrom services.app_definition_query_service import AppDefinitionUnavailableError-from services.app_generate_service import AppGenerateServicefrom services.app_task_service import AppTaskService-from services.conversation_service import ConversationServicefrom services.errors.llm import InvokeRateLimitErrorfrom services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppRef-from services.installed_app_completion_service import InstalledAppNotCompletionError+from services.installed_app_generation_service import InstalledAppNotChatError, InstalledAppNotCompletionErrorfrom .. import console_ns@@ -107,7 +99,7 @@ class CompletionApi(Resource):installed_app: InstalledAppRef,) -> Response:try:- response = application_services().installed_app_completion.generate(+ response = application_services().installed_app_generation.generate_completion(installed_app=installed_app,account_id=request_context.account_id,args=req_data.model_dump(exclude_none=True),@@ -177,48 +169,35 @@ class CompletionStopApi(Resource):"/installed-apps/<uuid:installed_app_id>/chat-messages",endpoint="installed_app_chat_completion",)-class ChatApi(InstalledAppResource):+class ChatApi(Resource):@console_ns.expect(console_ns.models[ChatMessagePayload.__name__])@console_ns.response(200, "Success")- @with_current_user- @with_session+ @console_account_admission()+ @get_installed_app@model_validate(ChatMessagePayload)- def post(self, req_data: ChatMessagePayload, session: Session, current_user: Account, installed_app: InstalledApp):- app_model = installed_app.app_with_session(session=session)- if app_model is None:- raise AppUnavailableError()- app_mode = AppMode.value_of(app_model.mode)- if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:- raise NotChatAppError()-- args = req_data.model_dump(exclude_none=True)-- args["auto_generate_name"] = False-- installed_app.last_used_at = naive_utc_now()- db.session.commit()-+ def post(+ self,+ req_data: ChatMessagePayload,+ request_context: RequestContext,+ installed_app: InstalledAppRef,+ ) -> Response:try:- # Eagerly validate conversation to avoid hanging on invalid conversation_id- if req_data.conversation_id:- ConversationService.get_conversation(- app_model=app_model,- conversation_id=req_data.conversation_id,- user=current_user,- session=session,- )-- response = AppGenerateService.generate(- session=session,- app_model=app_model,- user=current_user,- args=args,- invoke_from=InvokeFrom.EXPLORE,- streaming=True,+ response = application_services().installed_app_generation.generate_chat(+ 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 InstalledAppNotChatError:+ raise NotChatAppError() 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 ed351869273..5fc8e6be954 100644--- a/api/extensions/ext_application_services.py+++ b/api/extensions/ext_application_services.py@@ -178,8 +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 InstalledAppCompletionService+from services.installed_app_generation_adapters import AppGenerateServiceRuntime as InstalledAppGenerateServiceRuntime+from services.installed_app_generation_service import InstalledAppGenerationServicefrom services.message_file_preview_service import MessageFilePreviewServicefrom services.message_suggested_questions_adapters import MessageSuggestedQuestionsRuntimefrom services.message_suggested_questions_service import MessageSuggestedQuestions@@ -328,7 +328,7 @@ class ApplicationServices:oauth_device: OAuthDeviceApplicationServiceinit_validation: InitValidationServiceinstalled_app_access: InstalledAppAccessService- installed_app_completion: InstalledAppCompletionService+ installed_app_generation: InstalledAppGenerationServicenotifications: NotificationServicestep_by_step_tour: StepByStepTourServicepartner_tenant_bindings: PartnerTenantBindingService@@ -751,10 +751,10 @@ def build_application_services(installed_apps=installed_apps,is_user_allowed=webapp_access.is_user_allowed,),- installed_app_completion=InstalledAppCompletionService(+ installed_app_generation=InstalledAppGenerationService(app_definitions=app_definitions,usage=installed_apps,- runtime=AppGenerateServiceCompletionRuntime(session_factory=database_client),+ runtime=InstalledAppGenerateServiceRuntime(session_factory=database_client),),web_app_runtime=WebAppRuntimeQueryService(runtime=app_definition_repository,diff --git a/api/repositories/installed_app_repository.py b/api/repositories/installed_app_repository.pyindex a5f449e0320..e16a0e82632 100644--- a/api/repositories/installed_app_repository.py+++ b/api/repositories/installed_app_repository.py@@ -9,7 +9,7 @@ from sqlalchemy.orm import Session, sessionmakerfrom models.model import App, InstalledAppfrom services.installed_app_access_service import InstalledAppAccessStore, InstalledAppNotFoundError, InstalledAppRef-from services.installed_app_completion_service import InstalledAppUsageRecorder+from services.installed_app_generation_service import InstalledAppUsageRecorderclass SQLAlchemyInstalledAppRepository(InstalledAppAccessStore, InstalledAppUsageRecorder):diff --git a/api/services/installed_app_completion_adapters.py b/api/services/installed_app_generation_adapters.pysimilarity index 71%rename from api/services/installed_app_completion_adapters.pyrename to api/services/installed_app_generation_adapters.pyindex aa9541c28d3..f19405b17d8 100644--- a/api/services/installed_app_completion_adapters.py+++ b/api/services/installed_app_generation_adapters.py@@ -11,12 +11,13 @@ from models import Account, Appfrom services.account_errors import AccountNotFoundErrorfrom services.app_definition_query_service import AppDefinitionUnavailableErrorfrom services.app_generate_service import AppGenerateService-from services.installed_app_completion_service import CompletionResponse, InstalledAppCompletionRuntime+from services.conversation_service import ConversationService+from services.installed_app_generation_service import GenerationResponse, InstalledAppGenerationRuntimelogger = logging.getLogger(__name__)-class AppGenerateServiceCompletionRuntime(InstalledAppCompletionRuntime):+class AppGenerateServiceRuntime(InstalledAppGenerationRuntime):def __init__(self, *, session_factory: sessionmaker[Session]) -> None:self._session_factory: sessionmaker[Session] = session_factory@@ -28,7 +29,7 @@ class AppGenerateServiceCompletionRuntime(InstalledAppCompletionRuntime):account_id: str,args: Mapping[str, object],streaming: bool,- ) -> CompletionResponse:+ ) -> GenerationResponse:with self._session_factory(expire_on_commit=False) as read_session:app = read_session.get(App, app_id)if app is None:@@ -37,12 +38,23 @@ class AppGenerateServiceCompletionRuntime(InstalledAppCompletionRuntime):if account is None:raise AccountNotFoundError(f"Account {account_id} no longer exists")+ # Resolve the validated chat conversation before a streaming generator+ # is created, preserving the legacy eager 404 and ownership checks.+ conversation_id = args.get("conversation_id")+ if isinstance(conversation_id, str) and conversation_id:+ ConversationService.get_conversation(+ app_model=app,+ conversation_id=conversation_id,+ user=account,+ session=read_session,+ )+# 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+ response: GenerationResponse | None = Nonetry:with self._session_factory(expire_on_commit=False) as session:- generated_response: CompletionResponse = AppGenerateService.generate(+ generated_response: GenerationResponse = AppGenerateService.generate(session=session,app_model=app,user=account,diff --git a/api/services/installed_app_completion_service.py b/api/services/installed_app_generation_service.pysimilarity index 56%rename from api/services/installed_app_completion_service.pyrename to api/services/installed_app_generation_service.pyindex f7633a41aa0..e1bf446a9af 100644--- a/api/services/installed_app_completion_service.py+++ b/api/services/installed_app_generation_service.py@@ -1,4 +1,4 @@-"""Generate a completion for an admitted workspace installation."""+"""Generate completion and chat responses for an admitted workspace installation."""from collections.abc import Iterator, Mappingfrom datetime import datetime@@ -9,7 +9,7 @@ from services.app_definition_query_service import AppDefinitionQueryServicefrom services.installed_app_access_service import InstalledAppRef-class CompletionStream(Protocol):+class GenerationStream(Protocol):def __iter__(self) -> Iterator[str]: ...def __next__(self) -> str: ...@@ -17,18 +17,22 @@ class CompletionStream(Protocol):def close(self) -> None: ...-type CompletionResponse = Mapping[str, object] | CompletionStream+type GenerationResponse = Mapping[str, object] | GenerationStreamclass InstalledAppNotCompletionError(ValueError):"""The installed app does not support the completion endpoint."""+class InstalledAppNotChatError(ValueError):+ """The installed app does not support the chat endpoint."""++class InstalledAppUsageRecorder(Protocol):def record(self, *, installed_app: InstalledAppRef, used_at: datetime) -> None: ...-class InstalledAppCompletionRuntime(Protocol):+class InstalledAppGenerationRuntime(Protocol):def generate(self,*,@@ -36,30 +40,52 @@ class InstalledAppCompletionRuntime(Protocol):account_id: str,args: Mapping[str, object],streaming: bool,- ) -> CompletionResponse: ...+ ) -> GenerationResponse: ...-class InstalledAppCompletionService:+class InstalledAppGenerationService:def __init__(self,*,app_definitions: AppDefinitionQueryService,usage: InstalledAppUsageRecorder,- runtime: InstalledAppCompletionRuntime,+ runtime: InstalledAppGenerationRuntime,) -> None:self._app_definitions: AppDefinitionQueryService = app_definitionsself._usage: InstalledAppUsageRecorder = usage- self._runtime: InstalledAppCompletionRuntime = runtime+ self._runtime: InstalledAppGenerationRuntime = runtime- def generate(+ def generate_completion(self, *, installed_app: InstalledAppRef, account_id: str, args: Mapping[str, object]- ) -> CompletionResponse:+ ) -> GenerationResponse:if self._app_definitions.get_mode(installed_app.app_id) != "completion":raise InstalledAppNotCompletionError(f"App {installed_app.app_id} is not a completion app")+ return self._generate(+ installed_app=installed_app,+ account_id=account_id,+ args=args,+ streaming=args.get("response_mode") == "streaming",+ )++ def generate_chat(+ self, *, installed_app: InstalledAppRef, account_id: str, args: Mapping[str, object]+ ) -> GenerationResponse:+ if self._app_definitions.get_mode(installed_app.app_id) not in {"chat", "agent-chat", "advanced-chat"}:+ raise InstalledAppNotChatError(f"App {installed_app.app_id} is not a chat app")++ return self._generate(installed_app=installed_app, account_id=account_id, args=args, streaming=True)++ def _generate(+ self,+ *,+ installed_app: InstalledAppRef,+ account_id: str,+ args: Mapping[str, object],+ streaming: bool,+ ) -> GenerationResponse: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.diff --git a/api/tests/unit_tests/controllers/console/explore/test_completion.py b/api/tests/unit_tests/controllers/console/explore/test_completion.pyindex c7faa7cfdbb..9d952539277 100644--- a/api/tests/unit_tests/controllers/console/explore/test_completion.py+++ b/api/tests/unit_tests/controllers/console/explore/test_completion.py@@ -1,367 +1,362 @@-import uuid-from inspect import unwrap-from unittest.mock import MagicMock, PropertyMock, patch+import json+from collections.abc import Generator+from uuid import uuid4import pytest-from flask import Flask-from sqlalchemy.orm import Session, object_session-from werkzeug.exceptions import InternalServerError+from sqlalchemy.orm import Session, sessionmakerimport controllers.console.explore.completion as completion_module-from controllers.console.app.error import (- ConversationCompletedError,-)-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+from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError+from graphon.model_runtime.errors.invoke import InvokeError+from models import AppMode, Conversation, 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.app_generate_service import AppGenerateService+from services.errors.app_model_config import AppModelConfigBrokenError+from services.errors.conversation import ConversationCompletedError, ConversationNotExistsErrorfrom services.errors.llm import InvokeRateLimitError+from services.installed_app_generation_adapters import AppGenerateServiceRuntime+from services.installed_app_generation_service import GenerationResponse, InstalledAppGenerationService+from tests.unit_tests.controllers.console.explore.test_installed_app_admission import (+ _assert_json_response,+ _Harness,+ _set_app_mode,+ harness,+)+from tests.unit_tests.controllers.console.explore.test_installed_app_completion import (+ _USED_AT,+ _last_used_at,+ _Runtime,+ _RuntimeCall,+ _Services,+ runtime,+)+__all__ = ["harness", "runtime"]-def user():- account = Account(name="User", email="user.com")- account.id = "uid"- return account--[email protected](autouse=True)-def bind_database(sqlite_session: Session, monkeypatch: pytest.MonkeyPatch) -> None:- monkeypatch.setattr(completion_module.db, "session", sqlite_session)+_CONVERSATION_ID = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa"+_PARENT_MESSAGE_ID = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb"@pytest.fixture-def chat_app(sqlite_session: Session) -> InstalledApp:- return _installed_app(AppMode.CHAT, sqlite_session)---def _installed_app(mode: AppMode, session: Session) -> InstalledApp:- app = App(- tenant_id="owner-tenant",- name=f"{mode.value} App",- mode=mode,- enable_site=True,- enable_api=False,- )- session.add(app)- session.flush()- installed_app = InstalledApp(- tenant_id="viewer-tenant",- app_id=app.id,- app_owner_tenant_id=app.tenant_id,- position=0,- is_pinned=False,- last_used_at=None,+def chat_runtime(+ harness: _Harness,+ runtime: _Runtime,+ sqlite_session_factory: sessionmaker[Session],+) -> _Runtime:+ _set_app_mode(harness, sqlite_session_factory, AppMode.CHAT)+ harness.api.add_resource(completion_module.ChatApi, "/installed-apps/<uuid:installed_app_id>/chat-messages")+ return runtime+++def _url(harness: _Harness) -> str:+ return f"/installed-apps/{harness.installed_app.id}/chat-messages"+++ ("payload", "expected_args"),+ [+ (+ {"inputs": {"zero": 0, "enabled": False, "empty": [], "nullable": None}, "query": ""},+ {"inputs": {"zero": 0, "enabled": False, "empty": [], "nullable": None}, "query": ""},+ ),+ (+ {"inputs": {}, "query": "Hi", "files": None, "conversation_id": None, "parent_message_id": None},+ {"inputs": {}, "query": "Hi"},+ ),+ (+ {+ "inputs": {},+ "query": "Hi",+ "files": [],+ "conversation_id": "",+ "parent_message_id": "",+ "response_mode": "blocking",+ "auto_generate_name": True,+ },+ {"inputs": {}, "query": "Hi", "files": []},+ ),+ (+ {+ "inputs": {},+ "query": "Hi",+ "files": [{"type": "image", "transfer_method": "remote_url", "url": "https://example.com/image.png"}],+ "conversation_id": _CONVERSATION_ID.upper(),+ "parent_message_id": _PARENT_MESSAGE_ID.replace("-", ""),+ "retriever_from": "custom-source",+ },+ {+ "inputs": {},+ "query": "Hi",+ "files": [{"type": "image", "transfer_method": "remote_url", "url": "https://example.com/image.png"}],+ "conversation_id": _CONVERSATION_ID,+ "parent_message_id": _PARENT_MESSAGE_ID,+ "retriever_from": "custom-source",+ },+ ),+ ],+)+def test_chat_preserves_payload_defaults_and_always_requests_streaming(+ harness: _Harness,+ chat_runtime: _Runtime,+ payload: dict[str, object],+ expected_args: dict[str, object],+) -> None:+ def chunks() -> Generator[str]:+ yield 'data: {"answer":"你好","metadata":{},"usage":null}\n\n'++ chat_runtime.response = chunks()+ response = harness.app.test_client().post(_url(harness), json=payload)++ assert response.status_code == 200+ assert dict(response.headers) == {"Content-Type": "text/event-stream; charset=utf-8"}+ assert response.data == 'data: {"answer":"你好","metadata":{},"usage":null}\n\n'.encode()+ response.close()+ expected_args = {"retriever_from": "explore_app", **expected_args, "auto_generate_name": False}+ assert chat_runtime.calls == [_RuntimeCall(harness.target_app.id, harness.account.id, expected_args, True)]+ assert harness.installed_app.tenant_id != harness.target_app.tenant_id++[email protected]("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT])[email protected]("consume_all", [False, True])+def test_chat_modes_preserve_stream_bytes_headers_and_close_on_completion_or_disconnect(+ harness: _Harness,+ chat_runtime: _Runtime,+ sqlite_session_factory: sessionmaker[Session],+ mode: AppMode,+ consume_all: bool,+) -> None:+ _set_app_mode(harness, sqlite_session_factory, mode)+ closed: list[bool] = []++ def chunks() -> Generator[str]:+ try:+ yield 'data: {"answer":"Hello"}\n\n'+ yield "data: [DONE]\n\n"+ finally:+ closed.append(True)++ chat_runtime.response = chunks()+ response = harness.app.test_client().post(_url(harness), json={"inputs": {}, "query": "Hi"}, 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 == b'data: {"answer":"Hello"}\n\ndata: [DONE]\n\n'+ else:+ assert next(iter(response.response)) == b'data: {"answer":"Hello"}\n\n'+ assert closed == []+ response.close()+ assert closed == [True]+ assert len(chat_runtime.calls) == 1+ assert chat_runtime.calls[0].streaming is True+ assert _last_used_at(harness, sqlite_session_factory) == _USED_AT+++ ("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 credentials"), 400, "provider_not_initialize", "Missing 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"),+ (+ InvokeRateLimitError("Concurrent request limit exceeded"),+ 429,+ "rate_limit_error",+ "Concurrent request limit exceeded",+ ),+ (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_chat_preserves_precise_errors_and_committed_usage_when_generation_fails(+ harness: _Harness,+ chat_runtime: _Runtime,+ sqlite_session_factory: sessionmaker[Session],+ failure: Exception,+ status: int,+ code: str,+ message: str,+) -> None:+ chat_runtime.error = failure++ response = harness.app.test_client().post(_url(harness), json={"inputs": {}, "query": "Hi"})++ _assert_json_response(response, status=status, body={"code": code, "message": message, "status": status})+ assert len(chat_runtime.calls) == 1+ assert chat_runtime.calls[0].streaming is True+ assert _last_used_at(harness, sqlite_session_factory) == _USED_AT+ if status == 401:+ assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'+++ ("payload", "error"),+ [+ ({"inputs": {}}, {"type": "missing", "loc": ["query"], "msg": "Field required"}),+ (+ {"inputs": {}, "query": None},+ {"type": "string_type", "loc": ["query"], "msg": "Input should be a valid string"},+ ),+ (+ {"inputs": None, "query": "Hi"},+ {"type": "dict_type", "loc": ["inputs"], "msg": "Input should be a valid dictionary"},+ ),+ (+ {"inputs": {}, "query": "Hi", "conversation_id": "invalid"},+ {"type": "value_error", "loc": ["conversation_id"], "msg": "Value error, must be a valid UUID"},+ ),+ (+ {"inputs": {}, "query": "Hi", "parent_message_id": "invalid"},+ {"type": "value_error", "loc": ["parent_message_id"], "msg": "Value error, must be a valid UUID"},+ ),+ ],+)+def test_chat_validates_payload_before_mode_and_never_records_usage_for_invalid_input(+ harness: _Harness,+ chat_runtime: _Runtime,+ sqlite_session_factory: sessionmaker[Session],+ payload: dict[str, object],+ error: dict[str, object],+) -> None:+ _set_app_mode(harness, sqlite_session_factory, AppMode.COMPLETION)++ 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},)- session.add(installed_app)- session.commit()- return installed_app+ assert chat_runtime.calls == []+ assert _last_used_at(harness, sqlite_session_factory) is None-def _session(installed_app: InstalledApp) -> Session:- session = object_session(installed_app)- assert session is not None- return session---def payload_data():- return {"inputs": {}, "query": "hi"}---def payload_patch(payload_data):- return patch.object(- type(completion_module.console_ns),- "payload",- new_callable=PropertyMock,- return_value=payload_data,+ "mode", [AppMode.COMPLETION, AppMode.WORKFLOW, AppMode.AGENT, AppMode.CHANNEL, AppMode.RAG_PIPELINE]+)+def test_chat_rejects_other_modes_before_recording_usage(+ harness: _Harness,+ chat_runtime: _Runtime,+ sqlite_session_factory: sessionmaker[Session],+ mode: AppMode,+) -> None:+ _set_app_mode(harness, sqlite_session_factory, mode)++ response = harness.app.test_client().post(_url(harness), json={"inputs": {}, "query": "Hi"})++ _assert_json_response(+ response, status=400, body={"code": "not_chat_app", "message": "App mode is invalid.", "status": 400})---class TestChatApi:- def test_post_success(self, app: Flask, chat_app, user, payload_patch, payload_data):- api = completion_module.ChatApi()- 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.ChatMessagePayload.model_validate(payload_data),- _session(chat_app),- user,- chat_app,- )-- assert result == ("ok", 200)-- def test_post_not_chat_app(self, user, sqlite_session: Session):- api = completion_module.ChatApi()- method = unwrap(api.post)-- installed_app = _installed_app(AppMode.COMPLETION, sqlite_session)-- with pytest.raises(NotChatAppError):- method(- api,- completion_module.ChatMessagePayload.model_validate({"inputs": {}, "query": "hi"}),- sqlite_session,- user,- installed_app,- )-- def test_rate_limit_error(self, app: Flask, chat_app, user, payload_patch, payload_data):- api = completion_module.ChatApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={}),- payload_patch,- patch.object(- completion_module.AppGenerateService,- "generate",- side_effect=InvokeRateLimitError("limit"),- ),- ):- with pytest.raises(InvokeRateLimitHttpError):- method(- api,- completion_module.ChatMessagePayload.model_validate(payload_data),- _session(chat_app),- user,- chat_app,- )-- def test_conversation_completed_chat(self, app: Flask, chat_app, user, payload_patch, payload_data):- api = completion_module.ChatApi()- 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.ChatMessagePayload.model_validate(payload_data),- _session(chat_app),- user,- chat_app,- )-- def test_conversation_not_exists_chat(self, app: Flask, chat_app, user, payload_patch, payload_data):- api = completion_module.ChatApi()- 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.ChatMessagePayload.model_validate(payload_data),- _session(chat_app),- user,- chat_app,- )-- def test_invalid_conversation_id_fails_fast_as_not_found(self, app: Flask, chat_app, user) -> None:- # A nonexistent conversation_id must fail fast as 404, before the streaming- # generator is created. Previously the lookup only ran inside the generator,- # so an invalid id surfaced as a hang instead of a clean error.- conversation_id = str(uuid.uuid4())- payload_patch = patch.object(- type(completion_module.console_ns),- "payload",- new_callable=PropertyMock,- return_value={"inputs": {}, "query": "hi", "conversation_id": conversation_id},+ assert chat_runtime.calls == []+ assert _last_used_at(harness, sqlite_session_factory) is None++[email protected]("rejection", ["permission", "tenant"])+def test_chat_enforces_admission_before_payload_validation(+ harness: _Harness,+ chat_runtime: _Runtime,+ sqlite_session_factory: sessionmaker[Session],+ rejection: str,+) -> None:+ if rejection == "permission":+ harness.state.allowed = False+ else:+ harness.account._current_tenant = Tenant(name="Other workspace")++ 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})- generate_mock = MagicMock(return_value={"ok": True})- get_conversation_mock = MagicMock(- side_effect=completion_module.services.errors.conversation.ConversationNotExistsError()+ else:+ _assert_json_response(+ response, status=404, body={"code": "not_found", "message": "Installed app not found", "status": 404})- session = _session(chat_app)-- api = completion_module.ChatApi()- method = unwrap(api.post)-- with (- app.test_request_context("/", json={}),- payload_patch,- patch.object(- completion_module.ConversationService,- "get_conversation",- get_conversation_mock,- ),- patch.object(completion_module.AppGenerateService, "generate", generate_mock),- ):- with pytest.raises(completion_module.NotFound):- method(- api,- completion_module.ChatMessagePayload.model_validate(- {"inputs": {}, "query": "hi", "conversation_id": conversation_id}- ),- session,- user,- chat_app,- )-- # The lookup must run before generation, so the generator is never started.- generate_mock.assert_not_called()- assert get_conversation_mock.call_args.kwargs["session"] is session-- def test_app_unavailable_chat(self, app: Flask, chat_app, user, payload_patch, payload_data):- api = completion_module.ChatApi()- 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.ChatMessagePayload.model_validate(payload_data),- _session(chat_app),- user,- chat_app,+ assert chat_runtime.calls == []+ assert _last_used_at(harness, sqlite_session_factory) is None++[email protected]("rejection", ["missing", "other_app", "other_account", "api", "deleted"])[email protected]("chat_runtime")+def test_chat_conversation_preflight_returns_404_before_starting_generation_and_preserves_usage(+ harness: _Harness,+ sqlite_session_factory: sessionmaker[Session],+ monkeypatch: pytest.MonkeyPatch,+ rejection: str,+) -> None:+ conversation_id = str(uuid4())+ with sqlite_session_factory.begin() as session:+ session.add(harness.account)+ if rejection != "missing":+ session.add(+ Conversation(+ id=conversation_id,+ app_id=str(uuid4()) if rejection == "other_app" else harness.target_app.id,+ from_account_id=str(uuid4()) if rejection == "other_account" else harness.account.id,+ from_source="api" if rejection == "api" else "console",+ mode=AppMode.CHAT,+ name="Existing conversation",+ _inputs={},+ is_deleted=rejection == "deleted",)+ )- def test_provider_not_initialized_chat(self, app: Flask, chat_app, user, payload_patch, payload_data):- api = completion_module.ChatApi()- 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"),+ services = _Services(+ installed_app_generation=InstalledAppGenerationService(+ app_definitions=AppDefinitionQueryService(+ definitions=AppDefinitionQueryRepository(session_factory=sqlite_session_factory),+ builtin_icon_url_prefix="/tools/icons",),- ):- with pytest.raises(completion_module.ProviderNotInitializeError):- method(- api,- completion_module.ChatMessagePayload.model_validate(payload_data),- _session(chat_app),- user,- chat_app,- )+ usage=SQLAlchemyInstalledAppRepository(session_factory=sqlite_session_factory),+ runtime=AppGenerateServiceRuntime(session_factory=sqlite_session_factory),+ )+ )+ monkeypatch.setattr(completion_module, "application_services", lambda: services)+ generation_started: list[bool] = []- def test_quota_exceeded_chat(self, app: Flask, chat_app, user, payload_patch, payload_data):- api = completion_module.ChatApi()- 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.ChatMessagePayload.model_validate(payload_data),- _session(chat_app),- user,- chat_app,- )+ def generate(**_kwargs: object) -> GenerationResponse:+ generation_started.append(True)+ pytest.fail("The generation runtime must not start for an inaccessible conversation")- def test_model_not_supported_chat(self, app: Flask, chat_app, user, payload_patch, payload_data):- api = completion_module.ChatApi()- 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.ChatMessagePayload.model_validate(payload_data),- _session(chat_app),- user,- chat_app,- )+ monkeypatch.setattr(AppGenerateService, "generate", generate)- def test_invoke_error_chat(self, app: Flask, chat_app, user, payload_patch, payload_data):- api = completion_module.ChatApi()- 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.ChatMessagePayload.model_validate(payload_data),- _session(chat_app),- user,- chat_app,- )+ response = harness.app.test_client().post(+ _url(harness), json={"inputs": {}, "query": "Hi", "conversation_id": conversation_id}, buffered=False+ )- def test_internal_error_chat(self, app: Flask, chat_app, user, payload_patch, payload_data):- api = completion_module.ChatApi()- 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.ChatMessagePayload.model_validate(payload_data),- _session(chat_app),- user,- chat_app,- )+ _assert_json_response(+ response, status=404, body={"code": "not_found", "message": "Conversation Not Exists.", "status": 404}+ )+ assert generation_started == []+ assert _last_used_at(harness, sqlite_session_factory) == _USED_ATdiff --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.pyindex 78a9e6e28cc..808ffee6351 100644--- 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@@ -7,7 +7,7 @@ import pytestfrom sqlalchemy.orm import Session, sessionmakerimport controllers.console.explore.completion as completion_module-import services.installed_app_completion_service as completion_service_module+import services.installed_app_generation_service as completion_service_modulefrom core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededErrorfrom graphon.model_runtime.errors.invoke import InvokeErrorfrom models import App, AppMode, InstalledApp, Tenant@@ -17,7 +17,7 @@ from services.account_errors import AccountNotFoundErrorfrom services.app_definition_query_service import AppDefinitionQueryServicefrom services.errors.app_model_config import AppModelConfigBrokenErrorfrom services.errors.conversation import ConversationCompletedError, ConversationNotExistsError-from services.installed_app_completion_service import CompletionResponse, InstalledAppCompletionService+from services.installed_app_generation_service import GenerationResponse, InstalledAppGenerationServicefrom tests.unit_tests.controllers.console.explore.test_installed_app_admission import (_assert_json_response,_Harness,@@ -42,13 +42,13 @@ class _RuntimeCall:class _Runtime:session_factory: sessionmaker[Session]installed_app_id: str- response: CompletionResponse = field(default_factory=lambda: dict(_BLOCKING_RESPONSE))+ response: GenerationResponse = field(default_factory=lambda: dict(_BLOCKING_RESPONSE))error: Exception | None = Nonecalls: list[_RuntimeCall] = field(default_factory=list)def generate(self, *, app_id: str, account_id: str, args: Mapping[str, object], streaming: bool- ) -> CompletionResponse:+ ) -> GenerationResponse:# The runtime sees a committed usage update through an independent# connection, including when generation immediately fails.with self.session_factory() as session:@@ -63,7 +63,7 @@ class _Runtime:@dataclass(frozen=True)class _Services:- installed_app_completion: InstalledAppCompletionService+ installed_app_generation: InstalledAppGenerationService@pytest.fixture@@ -73,7 +73,7 @@ def runtime(sqlite_session_factory: sessionmaker[Session],) -> _Runtime:runtime = _Runtime(sqlite_session_factory, harness.installed_app.id)- service = InstalledAppCompletionService(+ service = InstalledAppGenerationService(app_definitions=AppDefinitionQueryService(definitions=AppDefinitionQueryRepository(session_factory=sqlite_session_factory),builtin_icon_url_prefix="/tools/icons",@@ -81,7 +81,7 @@ def runtime(usage=SQLAlchemyInstalledAppRepository(session_factory=sqlite_session_factory),runtime=runtime,)- services = _Services(installed_app_completion=service)+ services = _Services(installed_app_generation=service)monkeypatch.setattr(completion_module, "application_services", lambda: services)monkeypatch.setattr(completion_service_module, "naive_utc_now", lambda: _USED_AT)harness.api.add_resource(diff --git a/api/tests/unit_tests/services/test_installed_app_completion_adapters.py b/api/tests/unit_tests/services/test_installed_app_generation_adapters.pysimilarity index 53%rename from api/tests/unit_tests/services/test_installed_app_completion_adapters.pyrename to api/tests/unit_tests/services/test_installed_app_generation_adapters.pyindex e3de8680a5e..08d3b346b12 100644--- a/api/tests/unit_tests/services/test_installed_app_completion_adapters.py+++ b/api/tests/unit_tests/services/test_installed_app_generation_adapters.py@@ -2,28 +2,36 @@ import jsonfrom collections.abc import Callable, Generator, Mappingfrom dataclasses import dataclass, fieldfrom typing import cast, override+from unittest.mock import MagicMockfrom uuid import uuid4import pytest+from flask import Flaskfrom sqlalchemy import event, inspect, updatefrom sqlalchemy.orm import Session, sessionmakerimport services.app_generate_service as generation_module+from core.app.apps import message_based_app_generatorfrom core.app.entities.app_invoke_entities import InvokeFromfrom core.app.features.rate_limiting.rate_limit import RateLimit, RateLimitGeneratorfrom enums import DeploymentEdition-from models import Account, App, AppMode, AppModelConfig+from extensions.ext_database import db+from libs.broadcast_channel.channel import BroadcastChannel, Subscription, SupportsPreparedSubscription, Topic+from models import Account, App, AppMode, AppModelConfig, Conversation, Workflow+from models.enums import ConversationFromSource+from models.workflow import WorkflowTypefrom services.account_errors import AccountNotFoundErrorfrom services.app_definition_query_service import AppDefinitionUnavailableError-from services.installed_app_completion_adapters import AppGenerateServiceCompletionRuntime-from services.installed_app_completion_service import CompletionResponse+from services.errors.conversation import ConversationNotExistsError+from services.installed_app_generation_adapters import AppGenerateServiceRuntime+from services.installed_app_generation_service import GenerationResponse_ARGS: dict[str, object] = {"inputs": {"count": 0}, "query": "hello", "auto_generate_name": False}@dataclassclass _RuntimeHarness:- runtime: AppGenerateServiceCompletionRuntime+ runtime: AppGenerateServiceRuntimeapp_id: straccount_id: strclosed_sessions: list[Session]@@ -60,7 +68,7 @@ def harness(sqlite_session_factory: sessionmaker[Session]) -> _RuntimeHarness:committed_sessions.append(session)return _RuntimeHarness(- AppGenerateServiceCompletionRuntime(session_factory=cast(sessionmaker[Session], factory)),+ AppGenerateServiceRuntime(session_factory=cast(sessionmaker[Session], factory)),app.id,account.id,closed_sessions,@@ -71,7 +79,7 @@ def harness(sqlite_session_factory: sessionmaker[Session]) -> _RuntimeHarness:def _patch_generation(monkeypatch: pytest.MonkeyPatch,harness: _RuntimeHarness,- generate: Callable[[Session], CompletionResponse],+ generate: Callable[[Session], GenerationResponse],*,streaming: bool,) -> None:@@ -83,7 +91,7 @@ def _patch_generation(args: Mapping[str, object],invoke_from: InvokeFrom,streaming: bool,- ) -> CompletionResponse:+ ) -> GenerationResponse:assert len(harness.closed_sessions) == 1read_session = harness.closed_sessions[0]assert not read_session.in_transaction()@@ -125,7 +133,7 @@ def test_runtime_loads_detached_entities_then_commits_work_and_returns_the_same_) -> None:response: dict[str, object] = {"answer": "", "metadata": {"tokens": 0}}- def generate(session: Session) -> CompletionResponse:+ def generate(session: Session) -> GenerationResponse:session.execute(update(App).where(App.id == harness.app_id).values(name="Generated app"))return response@@ -192,7 +200,7 @@ def test_streaming_preparation_errors_raise_eagerly_and_rollback_runtime_writes() -> None:failure = ValueError("query must be a string")- def generate(session: Session) -> CompletionResponse:+ def generate(session: Session) -> GenerationResponse:session.execute(update(App).where(App.id == harness.app_id).values(name="Uncommitted app"))raise failure@@ -213,7 +221,7 @@ def test_streaming_preparation_errors_raise_eagerly_and_rollback_runtime_writes(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:+ def unexpected_generation(**_kwargs: object) -> GenerationResponse:pytest.fail("Missing app or account must not reach generation")monkeypatch.setattr(generation_module.AppGenerateService, "generate", unexpected_generation)@@ -246,7 +254,7 @@ def test_failure_before_stream_handoff_closes_stream_without_masking_primary_errstream = _rate_limited_stream(source(), rate)- def generate(session: Session) -> CompletionResponse:+ def generate(session: Session) -> GenerationResponse:session.execute(update(App).where(App.id == harness.app_id).values(name="Generated app"))if failure_phase == "commit":@@ -321,3 +329,222 @@ def test_runtime_keeps_shared_completion_and_legacy_agent_dispatch(app = session.get(App, harness.app_id)assert app is not Noneassert app.mode == expected_mode+++def _seed_chat_conversation(+ harness: _RuntimeHarness,+ session_factory: sessionmaker[Session],+ *,+ mode: AppMode = AppMode.CHAT,+) -> str:+ with session_factory.begin() as session:+ app = session.get(App, harness.app_id)+ assert app is not None+ app.mode = mode+ app.max_active_requests = 0+ conversation = Conversation(+ app_id=app.id,+ mode=mode,+ name="Existing conversation",+ inputs={},+ from_source=ConversationFromSource.CONSOLE,+ from_account_id=harness.account_id,+ from_end_user_id=None,+ )+ session.add(conversation)+ session.flush()+ conversation_id = conversation.id+ return conversation_id++[email protected]("mismatch", ["missing", "app", "account", "source", "end_user", "deleted"])+def test_conversation_preflight_rejects_each_ownership_mismatch_before_generation(+ harness: _RuntimeHarness,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session_factory: sessionmaker[Session],+ mismatch: str,+) -> None:+ conversation_id = _seed_chat_conversation(harness, sqlite_session_factory)+ with sqlite_session_factory.begin() as session:+ conversation = session.get(Conversation, conversation_id)+ assert conversation is not None+ match mismatch:+ case "missing":+ conversation_id = str(uuid4())+ case "app":+ conversation.app_id = str(uuid4())+ case "account":+ conversation.from_account_id = str(uuid4())+ case "source":+ conversation.from_source = ConversationFromSource.API+ case "end_user":+ conversation.from_end_user_id = str(uuid4())+ case "deleted":+ conversation.is_deleted = True++ def unexpected_generation(_self: object, **_kwargs: object) -> GenerationResponse:+ pytest.fail("An invisible conversation must fail before entering the generator")++ monkeypatch.setattr(generation_module.ChatAppGenerator, "generate", unexpected_generation)+ with pytest.raises(ConversationNotExistsError):+ harness.runtime.generate(+ app_id=harness.app_id,+ account_id=harness.account_id,+ args={**_ARGS, "conversation_id": conversation_id},+ streaming=True,+ )++ assert len(harness.closed_sessions) == 1+ assert not harness.closed_sessions[0].in_transaction()+ assert harness.committed_sessions == []++[email protected]("mode", [AppMode.CHAT, AppMode.AGENT_CHAT])+def test_visible_conversation_uses_shared_chat_dispatch_after_preflight_session_closes(+ harness: _RuntimeHarness,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session_factory: sessionmaker[Session],+ config_overrides: Callable[..., None],+ mode: AppMode,+) -> None:+ config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY, ENABLE_OTEL=False, APP_MAX_ACTIVE_REQUESTS=0)+ conversation_id = _seed_chat_conversation(harness, sqlite_session_factory, mode=mode)+ args = {**_ARGS, "conversation_id": conversation_id}+ calls: list[str] = []++ def generate(+ generator: object,+ *,+ session: Session,+ app_model: App,+ user: Account,+ args: Mapping[str, object],+ invoke_from: InvokeFrom,+ streaming: bool,+ ) -> Generator[Mapping[str, object] | str, None, None]:+ assert len(harness.closed_sessions) == 1+ assert not harness.closed_sessions[0].in_transaction()+ assert session is not harness.closed_sessions[0]+ assert inspect(app_model).detached+ assert inspect(user).detached+ assert (app_model.id, user.id) == (harness.app_id, harness.account_id)+ assert args == {**_ARGS, "conversation_id": conversation_id}+ assert invoke_from == InvokeFrom.EXPLORE+ assert streaming is True+ calls.append(type(generator).__name__)++ def chunks() -> Generator[Mapping[str, object] | str, None, None]:+ assert len(harness.closed_sessions) == 2+ assert not session.in_transaction()+ yield {"event": "message", "answer": mode.value}++ return chunks()++ monkeypatch.setattr(generation_module.ChatAppGenerator, "generate", generate)+ monkeypatch.setattr(generation_module.AgentChatAppGenerator, "generate", generate)++ result = harness.runtime.generate(app_id=harness.app_id, account_id=harness.account_id, args=args, streaming=True)++ expected_generator = "ChatAppGenerator" if mode == AppMode.CHAT else "AgentChatAppGenerator"+ assert calls == [expected_generator]+ assert isinstance(result, RateLimitGenerator)+ assert harness.committed_sessions == [harness.closed_sessions[1]]+ assert [json.loads(chunk.removeprefix("data: ")) for chunk in result] == [+ {"event": "message", "answer": mode.value}+ ]+ assert result.closed is True+++def test_advanced_chat_dispatch_starts_task_after_subscription_with_runtime_session_closed(+ harness: _RuntimeHarness,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session_factory: sessionmaker[Session],+ config_overrides: Callable[..., None],+) -> None:+ config_overrides(+ DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY,+ ENABLE_OTEL=False,+ APP_MAX_ACTIVE_REQUESTS=0,+ PUBSUB_REDIS_CHANNEL_TYPE="streams",+ )+ conversation_id = _seed_chat_conversation(harness, sqlite_session_factory, mode=AppMode.ADVANCED_CHAT)+ with sqlite_session_factory.begin() as session:+ app = session.get(App, harness.app_id)+ assert app is not None+ workflow = Workflow(+ tenant_id=app.tenant_id,+ app_id=app.id,+ type=WorkflowType.CHAT,+ version="2026-09-07 00:00:00",+ graph='{"nodes": [], "edges": []}',+ _features="{}",+ created_by=harness.account_id,+ )+ session.add(workflow)+ session.flush()+ app.workflow_id = workflow.id+ workflow_id, tenant_id = workflow.id, app.tenant_id++ transport_events: list[str] = []+ subscription = MagicMock(spec=Subscription)+ subscriber = MagicMock(spec=SupportsPreparedSubscription)+ subscriber.prepare_subscription.return_value = subscription+ topic = MagicMock(spec=Topic)+ topic.as_subscriber.return_value = subscriber+ channel = MagicMock(spec=BroadcastChannel)+ channel.topic.return_value = topic++ def activate_subscription() -> Subscription:+ assert len(harness.closed_sessions) == 2+ assert all(not session.in_transaction() for session in harness.closed_sessions)+ transport_events.append("subscribe")+ return subscription++ subscription.__enter__.side_effect = activate_subscription+ subscription.receive.return_value = b'{"event":"workflow_finished"}'+ monkeypatch.setattr(message_based_app_generator, "get_pubsub_broadcast_channel", lambda: channel)+ args = {**_ARGS, "conversation_id": conversation_id}+ submitted: list[generation_module.AppExecutionParams] = []++ def enqueue(payload_json: str) -> None:+ assert transport_events == ["subscribe"]+ assert len(harness.closed_sessions) == 2+ assert all(not session.in_transaction() for session in harness.closed_sessions)+ submitted.append(generation_module.AppExecutionParams.model_validate_json(payload_json))+ transport_events.append("enqueue")++ monkeypatch.setattr(generation_module.workflow_based_app_execution_task, "delay", enqueue)++ # WorkflowService also creates its repository factory from Flask's db.engine.+ # Bind it to the same real database without replacing workflow lookup or dispatch.+ runtime_app = Flask(__name__)+ runtime_app.config["SQLALCHEMY_DATABASE_URI"] = str(sqlite_session_factory.kw["bind"].url)+ db.init_app(runtime_app)+ with runtime_app.app_context():+ try:+ result = harness.runtime.generate(+ app_id=harness.app_id, account_id=harness.account_id, args=args, streaming=True+ )+ finally:+ db.engine.dispose()++ assert isinstance(result, RateLimitGenerator)+ assert len(harness.closed_sessions) == 2+ assert submitted == []+ subscriber.prepare_subscription.assert_called_once_with()+ subscription.__enter__.assert_not_called()+ assert next(result) == "event: ping\n\n"+ assert submitted == []+ assert json.loads(next(result).removeprefix("data: ")) == {"event": "workflow_finished"}+ assert list(result) == []+ assert transport_events == ["subscribe", "enqueue"]+ assert len(submitted) == 1+ payload = submitted[0]+ assert (payload.app_id, payload.workflow_id, payload.tenant_id) == (harness.app_id, workflow_id, tenant_id)+ assert payload.app_mode == AppMode.ADVANCED_CHAT+ assert payload.user.model_dump(mode="json") == {"TYPE": "account", "user_id": harness.account_id}+ assert payload.args == args+ assert payload.invoke_from == InvokeFrom.EXPLORE+ assert payload.streaming is True+ subscription.__exit__.assert_called_once()+ assert result.closed is True