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): migrate installed app chat generation (#41905)

非法操作bc94f7ead5cb
diff --git a/api/.importlinter b/api/.importlinter
index d4ba781c985..00605db67a4 100644
--- a/api/.importlinter
+++ b/api/.importlinter
@@ -210,11 +210,11 @@ forbidden_modules =
sqlalchemy
werkzeug
-[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 neutral
type = forbidden
source_modules =
- services.installed_app_completion_service
+ services.installed_app_generation_service
forbidden_modules =
controllers
extensions
diff --git a/api/controllers/console/explore/completion.py b/api/controllers/console/explore/completion.py
index 33265e96fa4..491342f8c36 100644
--- a/api/controllers/console/explore/completion.py
+++ b/api/controllers/console/explore/completion.py
@@ -5,7 +5,6 @@ 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, Unauthorized
import services
@@ -19,12 +18,10 @@ from controllers.console.app.error import (
ProviderNotInitializeError,
ProviderQuotaExceededError,
)
-from controllers.console.app.wraps import with_session
from controllers.console.explore.error import NotChatAppError, NotCompletionAppError
from controllers.console.explore.installed_app_admission import get_installed_app
-from controllers.console.explore.wraps import InstalledAppResource
from controllers.console.flask_admission import console_account_admission
-from controllers.console.wraps import model_validate, with_current_user
+from controllers.console.wraps import model_validate
from controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpError
from core.app.entities.app_invoke_entities import InvokeFrom
from 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 db
from graphon.model_runtime.errors.invoke import InvokeError
from libs import helper
-from libs.datetime_utils import naive_utc_now
from machinery.context import RequestContext
-from models import Account
-from models.model import AppMode, InstalledApp
+from models.model import AppMode
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 InstalledAppNotFoundError, InstalledAppRef
-from services.installed_app_completion_service import InstalledAppNotCompletionError
+from services.installed_app_generation_service import InstalledAppNotChatError, InstalledAppNotCompletionError
from .. 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_response
return 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 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 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 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.installed_app_generation_adapters import AppGenerateServiceRuntime as InstalledAppGenerateServiceRuntime
+from services.installed_app_generation_service import InstalledAppGenerationService
from services.message_file_preview_service import MessageFilePreviewService
from services.message_suggested_questions_adapters import MessageSuggestedQuestionsRuntime
from services.message_suggested_questions_service import MessageSuggestedQuestions
@@ -328,7 +328,7 @@ class ApplicationServices:
oauth_device: OAuthDeviceApplicationService
init_validation: InitValidationService
installed_app_access: InstalledAppAccessService
- installed_app_completion: InstalledAppCompletionService
+ installed_app_generation: InstalledAppGenerationService
notifications: NotificationService
step_by_step_tour: StepByStepTourService
partner_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.py
index 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, 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
+from services.installed_app_generation_service import InstalledAppUsageRecorder
class SQLAlchemyInstalledAppRepository(InstalledAppAccessStore, InstalledAppUsageRecorder):
diff --git a/api/services/installed_app_completion_adapters.py b/api/services/installed_app_generation_adapters.py
similarity index 71%
rename from api/services/installed_app_completion_adapters.py
rename to api/services/installed_app_generation_adapters.py
index 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, 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
+from services.conversation_service import ConversationService
+from services.installed_app_generation_service import GenerationResponse, InstalledAppGenerationRuntime
logger = 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 = None
try:
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.py
similarity index 56%
rename from api/services/installed_app_completion_service.py
rename to api/services/installed_app_generation_service.py
index 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, Mapping
from datetime import datetime
@@ -9,7 +9,7 @@ from services.app_definition_query_service import AppDefinitionQueryService
from 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] | GenerationStream
class 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_definitions
self._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.py
index 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 uuid4
import pytest
-from flask import Flask
-from sqlalchemy.orm import Session, object_session
-from werkzeug.exceptions import InternalServerError
+from sqlalchemy.orm import Session, sessionmaker
import 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, ConversationNotExistsError
from 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_AT
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
index 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 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
+import services.installed_app_generation_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
@@ -17,7 +17,7 @@ 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 services.installed_app_generation_service import GenerationResponse, InstalledAppGenerationService
from 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 = None
calls: 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.py
similarity index 53%
rename from api/tests/unit_tests/services/test_installed_app_completion_adapters.py
rename to api/tests/unit_tests/services/test_installed_app_generation_adapters.py
index 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 json
from collections.abc import Callable, Generator, Mapping
from dataclasses import dataclass, field
from typing import cast, override
+from unittest.mock import MagicMock
from uuid import uuid4
import pytest
+from flask import Flask
from sqlalchemy import event, inspect, update
from sqlalchemy.orm import Session, sessionmaker
import services.app_generate_service as generation_module
+from core.app.apps import message_based_app_generator
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 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 WorkflowType
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
+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}
@dataclass
class _RuntimeHarness:
- runtime: AppGenerateServiceCompletionRuntime
+ runtime: AppGenerateServiceRuntime
app_id: str
account_id: str
closed_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) == 1
read_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_err
stream = _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 None
assert 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