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): share installed app suggested questions runtime (#42933)
非法操作9d4629c946dc
diff --git a/api/controllers/console/explore/message.py b/api/controllers/console/explore/message.pyindex 9308e910678..188b9a59409 100644--- a/api/controllers/console/explore/message.py+++ b/api/controllers/console/explore/message.py@@ -56,6 +56,7 @@ from services.errors.message import (from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppReffrom services.installed_app_generation_service import InstalledAppNotCompletionErrorfrom services.installed_app_message_service import FeedbackRatingRequiredError, MessageNotChatAppError+from services.message_suggested_questions_service import SuggestedQuestionsAccount, SuggestedQuestionsActorNotFoundErrorlogger = logging.getLogger(__name__)@@ -82,7 +83,7 @@ def _message_errors[**P, R](view: Callable[P, R]) -> Callable[P, R]:raise InstalledAppNotFoundHTTPError() from errorexcept AppDefinitionUnavailableError as error:raise AppUnavailableError() from error- except AccountNotFoundError as error:+ except (AccountNotFoundError, SuggestedQuestionsActorNotFoundError) as error:raise Unauthorized("Account no longer exists.") from errorexcept MessageNotChatAppError as error:raise NotChatAppError() from error@@ -209,10 +210,15 @@ class MessageSuggestedQuestionApi(Resource):def get(self, request_context: RequestContext, installed_app: InstalledAppRef, message_id: UUID) -> dict[str, object]:+ if installed_app.app_mode not in {"chat", "agent-chat", "advanced-chat"}:+ raise NotChatAppError()+try:- questions = application_services().installed_apps.messages.get_suggested_questions(- installed_app=installed_app,- account_id=request_context.account_id,+ questions = application_services().message_suggested_questions.get_suggested_questions(+ app_id=installed_app.app_id,+ app_owner_tenant_id=installed_app.app_owner_tenant_id,+ expected_app_mode=installed_app.app_mode,+ actor=SuggestedQuestionsAccount(account_id=request_context.account_id, invoke_from="explore"),message_id=str(message_id),)except (diff --git a/api/extensions/application_services/installed_app.py b/api/extensions/application_services/installed_app.pyindex f0811dc8b20..84f1e46d88a 100644--- a/api/extensions/application_services/installed_app.py+++ b/api/extensions/application_services/installed_app.py@@ -74,7 +74,6 @@ def build_installed_app_services(messages=InstalledAppMessageService(messages=SQLAlchemyInstalledAppMessageRepository(session_factory=database_client),get_extra_contents=message_runtime.get_extra_contents,- suggested_questions=message_runtime.get_suggested_questions,emit_feedback=emit_installed_app_feedback,),)diff --git a/api/services/installed_app_message_adapters.py b/api/services/installed_app_message_adapters.pyindex cd64b7dea3a..418445fa827 100644--- a/api/services/installed_app_message_adapters.py+++ b/api/services/installed_app_message_adapters.py@@ -1,28 +1,19 @@-"""Boundaries to the existing message runtime and execution extra contents."""+"""Execution extra contents and feedback telemetry for installed-app messages."""import loggingfrom collections.abc import Mapping, Sequence-from flask import current_appfrom pydantic import JsonValue-from sqlalchemy import selectfrom sqlalchemy.orm import Session, sessionmaker-from core.app.entities.app_invoke_entities import InvokeFrom-from extensions.ext_database import db-from models import Account, App, InstalledAppfrom repositories.sqlalchemy_execution_extra_content_repository import SQLAlchemyExecutionExtraContentRepository-from services.account_errors import AccountNotFoundError-from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppReffrom services.installed_app_message_service import MessageFeedbackEvent-from services.message_service import MessageServicelogger = logging.getLogger(__name__)class InstalledAppMessageRuntime:def __init__(self, *, session_factory: sessionmaker[Session]) -> None:- self._session_factory: sessionmaker[Session] = session_factoryself._extra_contents: SQLAlchemyExecutionExtraContentRepository = SQLAlchemyExecutionExtraContentRepository(session_maker=session_factory)@@ -34,35 +25,6 @@ class InstalledAppMessageRuntime:for message_id, items in zip(message_ids, contents, strict=True)}- def get_suggested_questions(self, *, installed_app: InstalledAppRef, account_id: str, message_id: str) -> list[str]:- with self._session_factory(expire_on_commit=False) as session:- app = session.scalar(- select(App)- .join(InstalledApp, InstalledApp.app_id == App.id)- .where(- InstalledApp.id == installed_app.id,- InstalledApp.tenant_id == installed_app.tenant_id,- InstalledApp.app_id == installed_app.app_id,- )- )- if app is None:- raise InstalledAppNotFoundError(f"Installed app {installed_app.id} no longer exists")- account = session.get(Account, account_id)- if account is None:- raise AccountNotFoundError(f"Account {account_id} no longer exists")-- # TODO: Migrate the legacy history, model configuration, and provider- # lookups together. They still use db.session internally. A separate app- # context releases that scoped session without touching the request's.- with current_app.app_context():- return MessageService.get_suggested_questions_after_answer(- app_model=app,- user=account,- message_id=message_id,- invoke_from=InvokeFrom.EXPLORE,- session=db.session(),- )-def emit_installed_app_feedback(*, feedback: MessageFeedbackEvent) -> None:# Feedback has already committed. Telemetry failure must not reject it.diff --git a/api/services/installed_app_message_service.py b/api/services/installed_app_message_service.pyindex e6d4aaa0727..2abd664cda0 100644--- a/api/services/installed_app_message_service.py+++ b/api/services/installed_app_message_service.py@@ -125,10 +125,6 @@ class MessageExtraContentsQuery(Protocol):def __call__(self, *, message_ids: Sequence[str]) -> Mapping[str, list[dict[str, JsonValue]]]: ...-class SuggestedQuestionGenerator(Protocol):- def __call__(self, *, installed_app: InstalledAppRef, account_id: str, message_id: str) -> list[str]: ...--class MessageFeedbackEmitter(Protocol):def __call__(self, *, feedback: MessageFeedbackEvent) -> None: ...@@ -139,12 +135,10 @@ class InstalledAppMessageService:*,messages: InstalledAppMessageStore,get_extra_contents: MessageExtraContentsQuery,- suggested_questions: SuggestedQuestionGenerator,emit_feedback: MessageFeedbackEmitter,) -> None:self._messages: InstalledAppMessageStore = messagesself._get_extra_contents: MessageExtraContentsQuery = get_extra_contents- self._suggested_questions: SuggestedQuestionGenerator = suggested_questionsself._emit_feedback: MessageFeedbackEmitter = emit_feedbackdef get_page(@@ -191,10 +185,6 @@ class InstalledAppMessageService:if feedback is not None:self._emit_feedback(feedback=feedback)- def get_suggested_questions(self, *, installed_app: InstalledAppRef, account_id: str, message_id: str) -> list[str]:- self._require_chat_app(installed_app)- return self._suggested_questions(installed_app=installed_app, account_id=account_id, message_id=message_id)-@staticmethoddef _require_chat_app(installed_app: InstalledAppRef) -> None:if installed_app.app_mode not in {"chat", "agent-chat", "advanced-chat"}:diff --git a/api/tests/unit_tests/controllers/console/explore/test_message.py b/api/tests/unit_tests/controllers/console/explore/test_message.pyindex 9960a84eb10..702da44c7a4 100644--- a/api/tests/unit_tests/controllers/console/explore/test_message.py+++ b/api/tests/unit_tests/controllers/console/explore/test_message.py@@ -1,34 +1,45 @@"""Explore message HTTP contracts through real admission, services and SQLite."""import json-from collections.abc import Generator, Mapping, Sequence-from dataclasses import dataclass, field+from collections.abc import Generator, Iterator, Mapping, Sequence+from dataclasses import dataclass, field, replacefrom datetime import datetime, timedeltafrom decimal import Decimal-from typing import Literal+from typing import Literal, castfrom uuid import uuid4import pytestfrom pydantic import JsonValue-from sqlalchemy import Connection, event, select+from sqlalchemy import Connection, Engine, event, select, updatefrom sqlalchemy.orm import Session, SessionTransaction, sessionmakerfrom werkzeug.test import TestResponseimport controllers.console.explore.message as module+import services.message_service as message_modulefrom core.app.entities.app_invoke_entities import InvokeFromfrom core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError+from core.model_manager import ModelInstance+from core.ops.ops_trace_manager import TraceTask+from extensions.ext_database import db+from graphon.model_runtime.entities import PromptMessage+from graphon.model_runtime.entities.model_entities import ModelTypefrom graphon.model_runtime.errors.invoke import InvokeError-from models import App, AppMode, InstalledApp+from models import Account, App, AppMode, InstalledAppfrom models.enums import ConversationFromSource, ConversationStatus, FeedbackFromSource, FeedbackRating-from models.model import Conversation, Message, MessageFeedback+from models.model import AppModelConfig, Conversation, Message, MessageFeedbackfrom repositories.installed_app_message_repository import SQLAlchemyInstalledAppMessageRepositoryfrom repositories.installed_app_repository import SQLAlchemyInstalledAppRepositoryfrom services.errors.app import MoreLikeThisDisabledErrorfrom services.errors.conversation import ConversationNotExistsErrorfrom services.errors.message import MessageNotExistsError, SuggestedQuestionsAfterAnswerDisabledError-from services.installed_app_access_service import InstalledAppReffrom services.installed_app_generation_service import GenerationResponse, InstalledAppGenerationServicefrom services.installed_app_message_service import InstalledAppMessageService, MessageFeedbackEvent+from services.message_suggested_questions_adapters import MessageSuggestedQuestionsRuntime+from services.message_suggested_questions_service import (+ MessageSuggestedQuestions,+ SuggestedQuestionsAccount,+ SuggestedQuestionsActor,+)from tests.unit_tests.controllers.console.explore.test_installed_app_admission import (_assert_json_response,_Harness,@@ -52,18 +63,20 @@ class _InstalledAppServices:@dataclass(frozen=True)class _Services:installed_apps: _InstalledAppServices+ message_suggested_questions: MessageSuggestedQuestions@dataclassclass _Messages:harness: _Harnessfactory: sessionmaker[Session]+ services: _Services = field(init=False)sessions: list[Session] = field(default_factory=list)extras: dict[str, list[dict[str, JsonValue]]] = field(default_factory=dict)extra_calls: list[list[str]] = field(default_factory=list)feedback_events: list[MessageFeedbackEvent] = field(default_factory=list)questions: list[str] = field(default_factory=lambda: ["Next question?", "还有吗?"])- question_calls: list[tuple[InstalledAppRef, str, str]] = field(default_factory=list)+ question_calls: list[tuple[str, str, str, SuggestedQuestionsActor, str]] = field(default_factory=list)generation_calls: list[tuple[str, str, str, bool]] = field(default_factory=list)generation_response: GenerationResponse = field(default_factory=lambda: dict(_BLOCKING))external_error: Exception | None = None@@ -85,9 +98,17 @@ class _Messages:assert persisted.content == feedback.contentself.feedback_events.append(feedback)- def suggested_questions(self, *, installed_app: InstalledAppRef, account_id: str, message_id: str) -> list[str]:+ def get_suggested_questions(+ self,+ *,+ app_id: str,+ app_owner_tenant_id: str,+ expected_app_mode: str,+ actor: SuggestedQuestionsActor,+ message_id: str,+ ) -> list[str]:self.assert_sessions_closed()- self.question_calls.append((installed_app, account_id, message_id))+ self.question_calls.append((app_id, app_owner_tenant_id, expected_app_mode, actor, message_id))if self.external_error is not None:raise self.external_errorreturn self.questions@@ -148,20 +169,20 @@ def messages(def track_session(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:state.sessions.append(session)- services = _Services(+ state.services = _Services(installed_apps=_InstalledAppServices(messages=InstalledAppMessageService(messages=SQLAlchemyInstalledAppMessageRepository(session_factory=factory),get_extra_contents=state.get_extra_contents,- suggested_questions=state.suggested_questions,emit_feedback=state.emit_feedback,),generation=InstalledAppGenerationService(usage=SQLAlchemyInstalledAppRepository(session_factory=factory), runtime=state),),+ message_suggested_questions=state,)- monkeypatch.setattr(module, "application_services", lambda: services)+ monkeypatch.setattr(module, "application_services", lambda: state.services)for resource, suffix in ((module.MessageListApi, ""),(module.MessageFeedbackApi, "/<uuid:message_id>/feedbacks"),@@ -172,6 +193,89 @@ def messages(return state+@dataclass+class _QuestionProvider:+ messages: _Messages+ message: Message+ legacy_sessions: list[Session] = field(default_factory=list)+ histories: list[str] = field(default_factory=list)+ traces: list[TraceTask] = field(default_factory=list)++ def get_default_model_instance(self, *, tenant_id: str, model_type: ModelType) -> ModelInstance:+ assert tenant_id == self.messages.harness.target_app.tenant_id+ assert model_type == ModelType.LLM+ self.messages.assert_sessions_closed()+ return cast(ModelInstance, self)++ def get_llm_num_tokens(self, prompt_messages: Sequence[PromptMessage]) -> int:+ return len(prompt_messages)++ def generate(+ self, *, tenant_id: str, histories: str, instruction_prompt: str | None, model_config: object+ ) -> list[str]:+ assert tenant_id == self.messages.harness.target_app.tenant_id+ assert instruction_prompt == "Published questions"+ assert model_config is None+ self.messages.assert_sessions_closed()+ self.histories.append(histories)+ if self.messages.external_error is not None:+ raise self.messages.external_error+ return self.messages.questions++ def add_trace_task(self, task: TraceTask) -> None:+ self.traces.append(task)++ def assert_closed(self) -> None:+ self.messages.assert_sessions_closed()+ assert all(not session.in_transaction() and not session.identity_map for session in self.legacy_sessions)+++def real_questions(+ messages: _Messages, monkeypatch: pytest.MonkeyPatch, sqlite_engine: Engine+) -> Iterator[_QuestionProvider]:+ config = AppModelConfig(+ app_id=messages.harness.target_app.id,+ suggested_questions_after_answer='{"enabled":true,"prompt":"Published questions"}',+ )+ with messages.factory.begin() as session:+ session.add_all([messages.harness.account, config])+ conversation = _conversation(messages)+ with messages.factory.begin() as session:+ session.execute(+ update(Conversation).where(Conversation.id == conversation.id).values(app_model_config_id=config.id)+ )+ provider = _QuestionProvider(messages=messages, message=_message(messages, conversation))++ def model_manager(*, tenant_id: str) -> _QuestionProvider:+ assert tenant_id == messages.harness.target_app.tenant_id+ return provider++ def trace_manager(*, app_id: str) -> _QuestionProvider:+ assert app_id == messages.harness.target_app.id+ return provider++ monkeypatch.setattr(message_module.ModelManager, "for_tenant", model_manager)+ monkeypatch.setattr(message_module.LLMGenerator, "generate_suggested_questions_after_answer", provider.generate)+ monkeypatch.setattr(message_module, "TraceQueueManager", trace_manager)+ messages.services = replace(+ messages.services,+ message_suggested_questions=MessageSuggestedQuestionsRuntime(session_factory=messages.factory),+ )+ messages.harness.app.config["SQLALCHEMY_DATABASE_URI"] = str(sqlite_engine.url)+ db.init_app(messages.harness.app)++ def track_legacy(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:+ provider.legacy_sessions.append(session)++ event.listen(db.session.session_factory, "after_begin", track_legacy)+ yield provider+ event.remove(db.session.session_factory, "after_begin", track_legacy)+ with messages.harness.app.app_context():+ db.session.remove()+ db.engine.dispose()++def _set_mode(state: _Messages, mode: AppMode) -> None:with state.factory.begin() as session:app = session.get(App, state.harness.target_app.id)@@ -454,16 +558,23 @@ def test_invalid_feedback_uses_shared_422(messages: _Messages, body: dict[str, o@pytest.mark.parametrize("operation", _OPERATIONS)[email protected]("admission", ["missing", "denied"])[email protected]("admission", ["missing", "denied", "wrong-workspace"])def test_all_message_handlers_apply_installed_app_admission(messages: _Messages, operation: _Operation, admission: str) -> None:if admission == "denied":messages.harness.state.allowed = False+ elif admission == "wrong-workspace":+ with messages.factory.begin() as session:+ session.execute(+ update(InstalledApp)+ .where(InstalledApp.id == messages.harness.installed_app.id)+ .values(tenant_id=str(uuid4()))+ )_error(messages.request(operation, installed_app_id=str(uuid4()) if admission == "missing" else None),- status=404 if admission == "missing" else 403,- code="installed_app_not_found" if admission == "missing" else "access_denied",+ status=403 if admission == "denied" else 404,+ code="access_denied" if admission == "denied" else "installed_app_not_found",)assert (messages.extra_calls == messages.feedback_events == messages.question_calls == messages.generation_calls == []@@ -538,13 +649,112 @@ def test_suggested_questions_preserves_results_and_empty_fallback(messages: _Mes_assert_json_response(messages.request("suggested-questions", message_id=message_id), status=200, body={"data": questions})- installed_app, account_id, called_message_id = messages.question_calls[0]- assert installed_app.id == messages.harness.installed_app.id- assert installed_app.app_id == messages.harness.target_app.id- assert installed_app.tenant_id == messages.harness.installed_app.tenant_id- assert installed_app.app_mode == "chat"- assert account_id == messages.harness.account.id- assert called_message_id == message_id+ assert messages.question_calls == [+ (+ messages.harness.target_app.id,+ messages.harness.target_app.tenant_id,+ "chat",+ SuggestedQuestionsAccount(account_id=messages.harness.account.id, invoke_from="explore"),+ message_id,+ )+ ]++[email protected]("failure", [None, InvokeError("Provider rejected input")])+def test_shared_suggested_questions_uses_owner_tenant_and_releases_sessions(+ real_questions: _QuestionProvider, failure: Exception | None+) -> None:+ messages = real_questions.messages+ assert messages.harness.target_app.tenant_id != messages.harness.installed_app.tenant_id+ messages.external_error = failure+ response = messages.request("suggested-questions", message_id=real_questions.message.id)+ if failure is None:+ _assert_json_response(response, status=200, body={"data": messages.questions})+ assert len(real_questions.traces) == 1+ else:+ _error(response, status=400, code="completion_request_error", message="Provider rejected input")+ assert not real_questions.traces+ assert real_questions.histories == ["Human: Hello\nAssistant: 你好"]+ assert real_questions.legacy_sessions+ real_questions.assert_closed()+ messages.assert_unused()++[email protected]("entity", ["message", "conversation"])+def test_shared_suggested_questions_rejects_other_account_history(+ real_questions: _QuestionProvider, entity: str+) -> None:+ messages = real_questions.messages+ model = Message if entity == "message" else Conversation+ record_id = real_questions.message.id if entity == "message" else real_questions.message.conversation_id+ with messages.factory.begin() as session:+ session.execute(update(model).where(model.id == record_id).values(from_account_id=str(uuid4())))+ _error(+ messages.request("suggested-questions", message_id=real_questions.message.id),+ status=404,+ code="message_not_found" if entity == "message" else "conversation_not_found",+ )+ assert not real_questions.histories+ real_questions.assert_closed()++[email protected]("change", ["mode", "owner", "app", "account"])+def test_shared_suggested_questions_rejects_stale_admitted_app_and_actor(+ real_questions: _QuestionProvider, change: str+) -> None:+ messages = real_questions.messages++ def change_admitted_resource() -> None:+ with messages.factory.begin() as session:+ if change == "account":+ account = session.get(Account, messages.harness.account.id)+ assert account is not None+ session.delete(account)+ return+ app = session.get(App, messages.harness.target_app.id)+ assert app is not None+ if change == "mode":+ app.mode = AppMode.COMPLETION+ elif change == "owner":+ app.tenant_id = str(uuid4())+ else:+ session.delete(app)++ messages.harness.state.permission_action = change_admitted_resource+ _error(+ messages.request("suggested-questions", message_id=real_questions.message.id),+ status=401 if change == "account" else 400,+ code="unauthorized" if change == "account" else "app_unavailable",+ message="Account no longer exists." if change == "account" else None,+ )+ assert not real_questions.histories+ assert not real_questions.legacy_sessions+ real_questions.assert_closed()+++def test_suggested_questions_uses_admitted_installation_until_next_request(real_questions: _QuestionProvider) -> None:+ messages = real_questions.messages++ def remove_installation() -> None:+ with messages.factory.begin() as session:+ installation = session.get(InstalledApp, messages.harness.installed_app.id)+ assert installation is not None+ session.delete(installation)++ messages.harness.state.permission_action = remove_installation+ _assert_json_response(+ messages.request("suggested-questions", message_id=real_questions.message.id),+ status=200,+ body={"data": messages.questions},+ )+ messages.harness.state.permission_action = None+ _error(+ messages.request("suggested-questions", message_id=real_questions.message.id),+ status=404,+ code="installed_app_not_found",+ )+ assert len(real_questions.histories) == 1+ real_questions.assert_closed()@pytest.mark.parametrize("operation", ["more-like-this", "suggested-questions"])@@ -577,6 +787,7 @@ def test_generation_failures_keep_provider_errors_and_context(("more-like-this", ValueError("Bad runtime arguments"), 400, "invalid_param"),("suggested-questions", MessageNotExistsError(), 404, "message_not_found"),("suggested-questions", ConversationNotExistsError(), 404, "conversation_not_found"),+ ("suggested-questions", ValueError("Invalid legacy configuration"), 500, "internal_server_error"),("suggested-questions",SuggestedQuestionsAfterAnswerDisabledError(),diff --git a/api/tests/unit_tests/services/test_installed_app_message_adapters.py b/api/tests/unit_tests/services/test_installed_app_message_adapters.pyindex 680210ad929..76060330e2c 100644--- a/api/tests/unit_tests/services/test_installed_app_message_adapters.py+++ b/api/tests/unit_tests/services/test_installed_app_message_adapters.py@@ -1,317 +1,40 @@-import json-from collections.abc import Iterator-from dataclasses import dataclass, replace+"""Installed message extra contents and committed feedback telemetry."""+from datetime import datetime, timedelta-from decimal import Decimal-from typing import cast, override-from unittest.mock import MagicMockfrom uuid import uuid4import pytest-from flask import Flask-from sqlalchemy import update-from sqlalchemy.orm import Session, sessionmaker+from sqlalchemy import Connection, Engine, event+from sqlalchemy.orm import Session, SessionTransaction, sessionmaker-import services.message_service as message_modulefrom core import telemetry-from core.credit_usage import CreditUsageAppType-from core.model_context import get_credit_usage_metadata, use_credit_usage_metadata-from core.model_manager import ModelInstance, ModelManager-from core.ops.ops_trace_manager import TraceQueueManagerfrom core.telemetry import FeedbackCreatedEventfrom core.workflow.nodes.human_input.entities import FormDefinition, UserActionConfig-from extensions.ext_database import db-from models import Account, App, AppMode, AppModelConfig, Conversation, InstalledApp, Message-from models.enums import ConversationFromSourcefrom models.execution_extra_content import HumanInputContentfrom models.human_input import HumanInputForm-from services.account_errors import AccountNotFoundError-from services.errors.conversation import ConversationNotExistsError-from services.errors.message import MessageNotExistsError, SuggestedQuestionsAfterAnswerDisabledError-from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppReffrom services.installed_app_message_adapters import InstalledAppMessageRuntime, emit_installed_app_feedbackfrom services.installed_app_message_service import MessageFeedbackEvent-@dataclass-class _Harness:- runtime: InstalledAppMessageRuntime- installation: InstalledAppRef- account_id: str- message_id: str- conversation_id: str- config_id: str- read_sessions: list[Session]- legacy_sessions: list[Session]- model_manager: MagicMock-- def suggested_questions(self) -> list[str]:- return self.runtime.get_suggested_questions(- installed_app=self.installation, account_id=self.account_id, message_id=self.message_id- )---def harness(sqlite_session_factory: sessionmaker[Session], monkeypatch: pytest.MonkeyPatch) -> Iterator[_Harness]:- with sqlite_session_factory.begin() as session:- app = App(tenant_id=str(uuid4()), name="Original", mode=AppMode.CHAT, enable_site=True, enable_api=True)- account = Account(name="Viewer", email="[email protected]")- session.add_all([app, account])- session.flush()- installed = InstalledApp(- tenant_id=str(uuid4()), app_id=app.id, app_owner_tenant_id=app.tenant_id, position=0, is_pinned=False- )- config = AppModelConfig(- app_id=app.id,- suggested_questions_after_answer=json.dumps(- {- "enabled": True,- "prompt": "Ask a follow-up",- "model": {"provider": "vendor", "name": "question-model"},- }- ),- )- session.add_all([installed, config])- session.flush()- app.app_model_config_id = config.id- conversation = Conversation(- app_id=app.id,- app_model_config_id=config.id,- mode=AppMode.CHAT,- name="Conversation",- inputs={},- from_source=ConversationFromSource.CONSOLE,- from_account_id=account.id,- from_end_user_id=None,- is_deleted=False,- )- session.add(conversation)- session.flush()- message = Message(- app_id=app.id,- conversation_id=conversation.id,- inputs={},- query="Original question",- answer="Original answer",- message={},- message_unit_price=Decimal(0),- answer_unit_price=Decimal(0),- currency="USD",- from_source=ConversationFromSource.CONSOLE,- from_account_id=account.id,- from_end_user_id=None,- )- session.add(message)- session.flush()-- read_sessions: list[Session] = []- legacy_sessions: list[Session] = []-- class TrackedSession(Session):- @override- def close(self) -> None:- super().close()- read_sessions.append(self)-- factory = sessionmaker(bind=sqlite_session_factory.kw["bind"], class_=TrackedSession, expire_on_commit=True)- runtime_app = Flask(__name__)- runtime_app.config["SQLALCHEMY_DATABASE_URI"] = str(sqlite_session_factory.kw["bind"].url)- db.init_app(runtime_app)-- @runtime_app.teardown_appcontext- def capture_legacy_session(_error: BaseException | None) -> None:- # Registered after db.init_app, so this runs before its session removal.- legacy_sessions.append(db.session())-- manager = MagicMock(spec=ModelManager)- model = MagicMock(spec=ModelInstance)- model.get_llm_num_tokens.return_value = 4- manager.get_default_model_instance.return_value = model-- def provider(*, tenant_id: str) -> ModelManager:- assert tenant_id == app.tenant_id- return manager-- monkeypatch.setattr(message_module.ModelManager, "for_tenant", provider)- with runtime_app.app_context():- try:- yield _Harness(- runtime=InstalledAppMessageRuntime(session_factory=cast(sessionmaker[Session], factory)),- installation=InstalledAppRef(- id=installed.id,- tenant_id=installed.tenant_id,- app_id=app.id,- app_owner_tenant_id=app.tenant_id,- app_mode="chat",- ),- account_id=account.id,- message_id=message.id,- conversation_id=conversation.id,- config_id=config.id,- read_sessions=read_sessions,- legacy_sessions=legacy_sessions,- model_manager=manager,- )- finally:- db.session.remove()- db.engine.dispose()--[email protected]("fail", [False, True])-def test_suggestions_keep_real_history_and_release_isolated_legacy_session_on_success_or_failure(- harness: _Harness, monkeypatch: pytest.MonkeyPatch, fail: bool-) -> None:- outer = db.session()- app = outer.get(App, harness.installation.app_id)- assert app is not None- app.name = "Pending outer edit"- owner_tenant_id = app.tenant_id- failure = RuntimeError("Suggestion provider unavailable")- calls: list[str] = []- tracing = MagicMock(spec=TraceQueueManager)-- def trace_manager(*, app_id: str) -> TraceQueueManager:- assert app_id == harness.installation.app_id- return tracing-- def generate(- *, tenant_id: str, histories: str, instruction_prompt: str | None = None, model_config: object | None = None- ) -> list[str]:- assert tenant_id == owner_tenant_id- assert histories == "Human: Original question\nAssistant: Original answer"- assert instruction_prompt == "Ask a follow-up"- assert model_config == {"provider": "vendor", "name": "question-model"}- assert len(harness.read_sessions) == 1- assert not harness.read_sessions[0].in_transaction()- assert not harness.read_sessions[0].identity_map- assert db.session() is not outer- assert db.session().in_transaction()- assert get_credit_usage_metadata() == {- "app_type": CreditUsageAppType.CHATBOT,- "request_id": "suggestions-request",- }- calls.append(histories)- if fail:- raise failure- return ["Follow-up one?", "Follow-up two?"]-- monkeypatch.setattr(message_module.LLMGenerator, "generate_suggested_questions_after_answer", generate)- monkeypatch.setattr(message_module, "TraceQueueManager", trace_manager)- previous_metadata = get_credit_usage_metadata()- with use_credit_usage_metadata({"request_id": "suggestions-request"}):- inherited_metadata = get_credit_usage_metadata()- if fail:- with pytest.raises(RuntimeError) as error:- harness.suggested_questions()- assert error.value is failure- else:- assert harness.suggested_questions() == ["Follow-up one?", "Follow-up two?"]- assert get_credit_usage_metadata() == inherited_metadata- assert get_credit_usage_metadata() == previous_metadata- assert len(calls) == 1- assert len(harness.legacy_sessions) == 1- legacy = harness.legacy_sessions[0]- assert legacy is not outer- assert not legacy.in_transaction()- assert not legacy.identity_map- assert db.session() is outer- assert outer.in_transaction()- assert app in outer.dirty- assert app.name == "Pending outer edit"- assert tracing.add_trace_task.call_count == (0 if fail else 1)--[email protected]("case", ["disabled", "missing_workflow", "history_provider_failure"])-def test_suggestions_keep_disabled_feature_and_missing_workflow_or_model_behavior(- harness: _Harness, sqlite_session_factory: sessionmaker[Session], case: str-) -> None:- with sqlite_session_factory.begin() as session:- if case == "disabled":- config = session.get(AppModelConfig, harness.config_id)- assert config is not None- config.suggested_questions_after_answer = '{"enabled":false}'- elif case == "missing_workflow":- app = session.get(App, harness.installation.app_id)- assert app is not None- app.mode = AppMode.ADVANCED_CHAT- else:- harness.model_manager.get_default_model_instance.side_effect = RuntimeError("No history model")- if case == "disabled":- with pytest.raises(SuggestedQuestionsAfterAnswerDisabledError):- harness.suggested_questions()- else:- assert harness.suggested_questions() == []- assert len(harness.legacy_sessions) == 1- assert not harness.legacy_sessions[0].in_transaction()- assert not harness.legacy_sessions[0].identity_map--[email protected]("entity", ["message", "conversation"])[email protected]("mismatch", ["app_id", "from_account_id", "from_source", "from_end_user_id"])-def test_suggestions_preserve_each_message_and_conversation_ownership_predicate(- harness: _Harness, sqlite_session_factory: sessionmaker[Session], entity: str, mismatch: str-) -> None:- value = ConversationFromSource.API if mismatch == "from_source" else str(uuid4())- with sqlite_session_factory.begin() as session:- if entity == "message":- session.execute(update(Message).where(Message.id == harness.message_id).values({mismatch: value}))- else:- session.execute(- update(Conversation).where(Conversation.id == harness.conversation_id).values({mismatch: value})- )- expected = MessageNotExistsError if entity == "message" else ConversationNotExistsError- with pytest.raises(expected):- harness.suggested_questions()- harness.model_manager.get_default_model_instance.assert_not_called()- assert len(harness.legacy_sessions) == 1- assert not harness.legacy_sessions[0].in_transaction()---def test_suggestions_reject_deleted_conversation(- harness: _Harness, sqlite_session_factory: sessionmaker[Session]-) -> None:- with sqlite_session_factory.begin() as session:- session.execute(update(Conversation).where(Conversation.id == harness.conversation_id).values(is_deleted=True))- with pytest.raises(ConversationNotExistsError):- harness.suggested_questions()--[email protected]("missing", ["installation", "app", "account", "viewer_tenant"])-def test_missing_admission_entities_fail_before_legacy_runtime(- harness: _Harness, sqlite_session_factory: sessionmaker[Session], missing: str+def test_extra_contents_use_real_repository_preserve_message_order_and_omit_none(+ sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]) -> None:- with sqlite_session_factory.begin() as session:- if missing == "installation":- entity = session.get(InstalledApp, harness.installation.id)- assert entity is not None- session.delete(entity)- elif missing == "app":- app = session.get(App, harness.installation.app_id)- assert app is not None- session.delete(app)- elif missing == "account":- account = session.get(Account, harness.account_id)- assert account is not None- session.delete(account)- else:- harness.installation = replace(harness.installation, tenant_id=str(uuid4()))- expected = AccountNotFoundError if missing == "account" else InstalledAppNotFoundError- with pytest.raises(expected):- harness.suggested_questions()- assert len(harness.read_sessions) == 1- assert harness.legacy_sessions == []+ read_factory = sessionmaker(bind=sqlite_engine)+ read_sessions: list[Session] = []+ @event.listens_for(read_factory, "after_begin")+ def track_read(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:+ read_sessions.append(session)-def test_extra_contents_use_real_repository_preserve_message_order_and_omit_none(- harness: _Harness, sqlite_session_factory: sessionmaker[Session]-) -> None:- assert harness.runtime.get_extra_contents(message_ids=[]) == {}- assert harness.read_sessions == []+ runtime = InstalledAppMessageRuntime(session_factory=read_factory)+ assert runtime.get_extra_contents(message_ids=[]) == {}+ assert read_sessions == []+ tenant_id, app_id, first_message_id = str(uuid4()), str(uuid4()), str(uuid4())second_message_id = str(uuid4())absent_message_id = str(uuid4())expiration = datetime(2026, 9, 10)with sqlite_session_factory.begin() as session:- for index, (message_id, title) in enumerate([(second_message_id, "Second"), (harness.message_id, "First")]):+ for index, (message_id, title) in enumerate([(second_message_id, "Second"), (first_message_id, "First")]):definition = FormDefinition(form_content="Approve?",inputs=[],@@ -322,8 +45,8 @@ def test_extra_contents_use_real_repository_preserve_message_order_and_omit_nonedisplay_in_ui=True,)form = HumanInputForm(- tenant_id=harness.installation.tenant_id,- app_id=harness.installation.app_id,+ tenant_id=tenant_id,+ app_id=app_id,workflow_run_id=str(uuid4()),node_id=f"node-{index}",form_definition=definition.model_dump_json(),@@ -337,12 +60,10 @@ def test_extra_contents_use_real_repository_preserve_message_order_and_omit_none)content.created_at = expiration - timedelta(days=index)session.add(content)- contents = harness.runtime.get_extra_contents(- message_ids=[harness.message_id, absent_message_id, second_message_id]- )- assert list(contents) == [harness.message_id, absent_message_id, second_message_id]+ contents = runtime.get_extra_contents(message_ids=[first_message_id, absent_message_id, second_message_id])+ assert list(contents) == [first_message_id, absent_message_id, second_message_id]assert contents[absent_message_id] == []- for message_id, title in [(harness.message_id, "First"), (second_message_id, "Second")]:+ for message_id, title in [(first_message_id, "First"), (second_message_id, "Second")]:assert len(contents[message_id]) == 1content = contents[message_id][0]assert content["type"] == "human_input"@@ -352,9 +73,9 @@ def test_extra_contents_use_real_repository_preserve_message_order_and_omit_noneassert isinstance(definition, dict)assert definition["node_title"] == titleassert "form_token" not in definition- assert len(harness.read_sessions) == 1- assert not harness.read_sessions[0].in_transaction()- assert not harness.read_sessions[0].identity_map+ assert len(read_sessions) == 1+ assert not read_sessions[0].in_transaction()+ assert not read_sessions[0].identity_map@pytest.mark.parametrize("fail", [False, True])diff --git a/api/tests/unit_tests/services/test_installed_app_message_service.py b/api/tests/unit_tests/services/test_installed_app_message_service.pyindex c74301b19f4..4db73c982c7 100644--- a/api/tests/unit_tests/services/test_installed_app_message_service.py+++ b/api/tests/unit_tests/services/test_installed_app_message_service.py@@ -6,7 +6,7 @@ from decimal import Decimalimport pytestfrom pydantic import JsonValue-from services.errors.message import MessageNotExistsError, SuggestedQuestionsAfterAnswerDisabledError+from services.errors.message import MessageNotExistsErrorfrom services.installed_app_access_service import InstalledAppReffrom services.installed_app_message_service import (InstalledAppMessageService,@@ -105,7 +105,6 @@ class _Callbacks:store: _Storequeried_ids: list[tuple[str, ...]] = field(default_factory=list)feedback: list[MessageFeedbackEvent] = field(default_factory=list)- suggestion_error: Exception | None = Nonedef get_extra_contents(self, *, message_ids: Sequence[str]) -> Mapping[str, list[dict[str, JsonValue]]]:assert self.store.events == ["read closed"]@@ -113,14 +112,6 @@ class _Callbacks:self.queried_ids.append(tuple(message_ids))return {"first": [{"type": "workflow", "workflow_run_id": "run"}], "not-in-page": [{"type": "ignored"}]}- def suggested_questions(self, *, installed_app: InstalledAppRef, account_id: str, message_id: str) -> list[str]:- assert installed_app.app_id == _REF.app_id- assert (account_id, message_id) == ("account", "message")- self.store.events.append("suggested questions")- if self.suggestion_error is not None:- raise self.suggestion_error- return ["Next question?"]-def emit_feedback(self, *, feedback: MessageFeedbackEvent) -> None:assert self.store.events[-1] == "write committed and closed"assert self.store.rating == feedback.rating@@ -131,7 +122,6 @@ class _Callbacks:return InstalledAppMessageService(messages=self.store,get_extra_contents=self.get_extra_contents,- suggested_questions=self.suggested_questions,emit_feedback=self.emit_feedback,)@@ -202,27 +192,11 @@ def test_feedback_write_error_propagates_without_emitting() -> None:@pytest.mark.parametrize("mode", ["completion", "workflow"])-def test_non_chat_admission_rejects_reads_before_database_or_generation(mode: str) -> None:+def test_non_chat_admission_rejects_reads_before_database(mode: str) -> None:state = _Callbacks(store=_Store())ref = replace(_REF, app_mode=mode)with pytest.raises(MessageNotChatAppError):state.service().get_page(installed_app=ref, account_id="account", conversation_id="conversation", first_id=None, limit=2)- with pytest.raises(MessageNotChatAppError):- state.service().get_suggested_questions(installed_app=ref, account_id="account", message_id="message")assert state.store.events == []--[email protected]("mode", ["chat", "agent-chat", "advanced-chat"])-def test_suggested_questions_accepts_all_chat_modes_and_preserves_errors(mode: str) -> None:- state = _Callbacks(store=_Store())- ref = replace(_REF, app_mode=mode)- assert state.service().get_suggested_questions(installed_app=ref, account_id="account", message_id="message") == [- "Next question?"- ]- failure = SuggestedQuestionsAfterAnswerDisabledError("Suggested questions are disabled")- state.suggestion_error = failure- with pytest.raises(SuggestedQuestionsAfterAnswerDisabledError) as error:- state.service().get_suggested_questions(installed_app=ref, account_id="account", message_id="message")- assert error.value is failurediff --git a/api/tests/unit_tests/services/test_message_suggested_questions_adapters.py b/api/tests/unit_tests/services/test_message_suggested_questions_adapters.pyindex 2f2cea6ef4b..95e7795cf33 100644--- a/api/tests/unit_tests/services/test_message_suggested_questions_adapters.py+++ b/api/tests/unit_tests/services/test_message_suggested_questions_adapters.py@@ -1,7 +1,7 @@"""Shared runtime ownership, configuration selection, and session lifecycle."""import json-from collections.abc import Iterator, Sequence+from collections.abc import Iterator, Mapping, Sequencefrom dataclasses import dataclass, fieldfrom decimal import Decimalfrom typing import Literal, cast@@ -9,10 +9,12 @@ from uuid import uuid4import pytestfrom flask import Flask-from sqlalchemy import Connection, Engine, event, select, update+from sqlalchemy import Connection, Engine, event, updatefrom sqlalchemy.orm import Session, SessionTransaction, sessionmakerimport services.message_service as message_module+from core.credit_usage import CreditUsageAppType+from core.model_context import get_credit_usage_metadata, use_credit_usage_metadatafrom core.model_manager import ModelInstancefrom core.ops.ops_trace_manager import TraceTaskfrom extensions.ext_database import db@@ -24,7 +26,7 @@ from models.model import AppModelConfig, EndUserfrom models.workflow import Workflow, WorkflowTypefrom services.app_definition_query_service import AppDefinitionUnavailableErrorfrom services.errors.conversation import ConversationNotExistsError-from services.errors.message import MessageNotExistsError+from services.errors.message import MessageNotExistsError, SuggestedQuestionsAfterAnswerDisabledErrorfrom services.message_suggested_questions_adapters import MessageSuggestedQuestionsRuntimefrom services.message_suggested_questions_service import (SuggestedQuestionsAccount,@@ -33,6 +35,8 @@ from services.message_suggested_questions_service import (SuggestedQuestionsEndUser,)+type _InvokeFrom = Literal["debugger", "explore", "web-app", "service-api"]+@dataclassclass _Provider:@@ -40,14 +44,19 @@ class _Provider:tenant_id: strprompts: list[str | None] = field(default_factory=list)histories: list[str] = field(default_factory=list)+ model_configs: list[object] = field(default_factory=list)+ metadata: list[Mapping[str, object] | None] = field(default_factory=list)traces: list[TraceTask] = field(default_factory=list)failure: Exception | None = None+ history_model_failure: bool = Falsedef get_default_model_instance(self, *, tenant_id: str, model_type: ModelType) -> ModelInstance:assert tenant_id == self.tenant_idassert model_type == ModelType.LLMassert self.read_sessionsassert all(not session.in_transaction() and not session.identity_map for session in self.read_sessions)+ if self.history_model_failure:+ raise RuntimeError("No history model")return cast(ModelInstance, self)def get_llm_num_tokens(self, prompt_messages: Sequence[PromptMessage]) -> int:@@ -57,9 +66,10 @@ class _Provider:self, *, tenant_id: str, histories: str, instruction_prompt: str | None, model_config: object) -> list[str]:assert tenant_id == self.tenant_id- assert model_config is Noneself.prompts.append(instruction_prompt)self.histories.append(histories)+ self.model_configs.append(model_config)+ self.metadata.append(get_credit_usage_metadata())if self.failure is not None:raise self.failurereturn ["What next?"]@@ -81,6 +91,22 @@ class _Harness:provider: _Providerlegacy_sessions: list[Session]+ def actor(self, invoke_from: _InvokeFrom) -> SuggestedQuestionsActor:+ if invoke_from in {"explore", "debugger"}:+ with self.factory.begin() as session:+ for model, record_id in ((Message, self.message.id), (Conversation, self.conversation.id)):+ session.execute(+ update(model)+ .where(model.id == record_id)+ .values(+ from_source=ConversationFromSource.CONSOLE,+ from_account_id=self.account.id,+ from_end_user_id=None,+ )+ )+ return SuggestedQuestionsAccount(account_id=self.account.id, invoke_from=invoke_from)+ return SuggestedQuestionsEndUser(end_user_id=self.end_user.id, invoke_from=invoke_from)+def get(self, actor: SuggestedQuestionsActor) -> list[str]:return self.runtime.get_suggested_questions(app_id=self.target.id,@@ -225,57 +251,120 @@ def test_end_user_reload_requires_the_admitted_app_owner(harness.assert_closed()[email protected]("invoke_from", ["web-app", "service-api"])[email protected]("invoke_from", ["debugger", "explore", "web-app", "service-api"])@pytest.mark.parametrize("provider_failure", [False, True])-def test_end_user_runtime_preserves_history_and_caller_session(- harness: _Harness, invoke_from: Literal["web-app", "service-api"], provider_failure: bool+def test_runtime_preserves_history_configuration_credit_context_and_caller_session(+ harness: _Harness, invoke_from: _InvokeFrom, provider_failure: bool) -> None:if provider_failure:harness.provider.failure = RuntimeError("Provider unavailable")- actor = SuggestedQuestionsEndUser(end_user_id=harness.end_user.id, invoke_from=invoke_from)+ actor = harness.actor(invoke_from)+ model_config = {"provider": "vendor", "name": "question-model"}+ with harness.factory.begin() as session:+ session.execute(+ update(AppModelConfig)+ .where(AppModelConfig.id == harness.target.app_model_config_id)+ .values(+ suggested_questions_after_answer=json.dumps(+ {"enabled": True, "prompt": "Published questions", "model": model_config}+ )+ )+ )with harness.flask_app.app_context():caller_session = db.session()- assert caller_session.scalar(select(App.id).where(App.id == harness.target.id)) == harness.target.id+ caller_app = caller_session.get(App, harness.target.id)+ assert caller_app is not None+ caller_app.name = "Pending caller edit"harness.legacy_sessions.clear()- if provider_failure:- with pytest.raises(RuntimeError, match="Provider unavailable"):- harness.get(actor)- else:- assert harness.get(actor) == ["What next?"]+ original_metadata = get_credit_usage_metadata()+ with use_credit_usage_metadata({"request_id": "suggestions-request"}):+ inherited_metadata = get_credit_usage_metadata()+ if provider_failure:+ with pytest.raises(RuntimeError, match="Provider unavailable"):+ harness.get(actor)+ else:+ assert harness.get(actor) == ["What next?"]+ assert get_credit_usage_metadata() == inherited_metadata+ assert harness.provider.metadata == [{**(inherited_metadata or {}), "app_type": CreditUsageAppType.CHATBOT}]+ assert get_credit_usage_metadata() == original_metadataassert db.session() is caller_sessionassert caller_session.in_transaction()+ assert caller_app in caller_session.dirty+ assert caller_app.name == "Pending caller edit"assert len(harness.legacy_sessions) == 1+ assert harness.legacy_sessions[0] is not caller_sessionharness.assert_closed()assert harness.provider.prompts == ["Published questions"]assert harness.provider.histories == ["Human: How does this work?\nAssistant: Like this."]+ assert harness.provider.model_configs == [model_config]assert len(harness.provider.traces) == (0 if provider_failure else 1)[email protected]("invoke_from", ["explore", "service-api"])@pytest.mark.parametrize("entity", ["message", "conversation"])@pytest.mark.parametrize("change", ["id", "app_id", "from_account_id", "from_end_user_id", "from_source"])-def test_end_user_message_and_conversation_ownership_are_enforced(+def test_message_and_conversation_ownership_are_enforced(harness: _Harness,+ invoke_from: Literal["explore", "service-api"],entity: Literal["message", "conversation"],change: Literal["id", "app_id", "from_account_id", "from_end_user_id", "from_source"],) -> None:+ actor = harness.actor(invoke_from)model = Message if entity == "message" else Conversationrecord_id = harness.message.id if entity == "message" else harness.conversation.id- value = ConversationFromSource.CONSOLE if change == "from_source" else str(uuid4())+ if change == "from_source":+ value = ConversationFromSource.API if invoke_from == "explore" else ConversationFromSource.CONSOLE+ else:+ value = str(uuid4())with harness.factory.begin() as session:session.execute(update(model).where(model.id == record_id).values({change: value}))error_type = MessageNotExistsError if entity == "message" else ConversationNotExistsErrorwith harness.flask_app.app_context(), pytest.raises(error_type):- harness.get(SuggestedQuestionsEndUser(end_user_id=harness.end_user.id, invoke_from="service-api"))+ harness.get(actor)assert not harness.provider.historiesharness.assert_closed()-def test_end_user_cannot_read_a_deleted_conversation(harness: _Harness) -> None:[email protected]("invoke_from", ["explore", "web-app"])+def test_actor_cannot_read_a_deleted_conversation(+ harness: _Harness, invoke_from: Literal["explore", "web-app"]+) -> None:+ actor = harness.actor(invoke_from)with harness.factory.begin() as session:session.execute(update(Conversation).where(Conversation.id == harness.conversation.id).values(is_deleted=True))with harness.flask_app.app_context(), pytest.raises(ConversationNotExistsError):- harness.get(SuggestedQuestionsEndUser(end_user_id=harness.end_user.id, invoke_from="web-app"))+ harness.get(actor)+ assert not harness.provider.histories+ harness.assert_closed()++[email protected]("case", ["disabled", "missing_workflow", "history_provider_failure"])+def test_account_preserves_disabled_feature_and_missing_workflow_or_model_behavior(+ harness: _Harness, case: Literal["disabled", "missing_workflow", "history_provider_failure"]+) -> None:+ actor = harness.actor("explore")+ with harness.factory.begin() as session:+ if case == "disabled":+ session.execute(+ update(AppModelConfig)+ .where(AppModelConfig.id == harness.target.app_model_config_id)+ .values(suggested_questions_after_answer='{"enabled":false}')+ )+ elif case == "missing_workflow":+ session.execute(update(App).where(App.id == harness.target.id).values(mode=AppMode.ADVANCED_CHAT))+ # Admit the new mode so this covers missing workflow, not a stale reference.+ harness.target.mode = AppMode.ADVANCED_CHAT+ else:+ harness.provider.history_model_failure = True+ with harness.flask_app.app_context():+ if case == "disabled":+ with pytest.raises(SuggestedQuestionsAfterAnswerDisabledError):+ harness.get(actor)+ else:+ assert harness.get(actor) == []+ assert len(harness.legacy_sessions) == 1assert not harness.provider.histories+ assert not harness.provider.tracesharness.assert_closed()@@ -283,6 +372,7 @@ def test_end_user_cannot_read_a_deleted_conversation(harness: _Harness) -> None:def test_advanced_chat_debugger_uses_draft_while_explore_uses_published_workflow(harness: _Harness, invoke_from: Literal["debugger", "explore"]) -> None:+ actor = harness.actor(invoke_from)with harness.factory.begin() as session:for version, prompt in ((Workflow.VERSION_DRAFT, "Draft questions"), ("published", "Published questions")):workflow = Workflow(@@ -299,16 +389,6 @@ def test_advanced_chat_debugger_uses_draft_while_explore_uses_published_workflowif version != Workflow.VERSION_DRAFT:session.execute(update(App).where(App.id == harness.target.id).values({App.workflow_id: workflow.id}))session.execute(update(App).where(App.id == harness.target.id).values(mode=AppMode.ADVANCED_CHAT))- for model, record_id in ((Message, harness.message.id), (Conversation, harness.conversation.id)):- session.execute(- update(model)- .where(model.id == record_id)- .values(- from_source=ConversationFromSource.CONSOLE,- from_account_id=harness.account.id,- from_end_user_id=None,- )- )session.execute(update(Conversation).where(Conversation.id == harness.conversation.id).values(mode=AppMode.ADVANCED_CHAT))@@ -317,8 +397,9 @@ def test_advanced_chat_debugger_uses_draft_while_explore_uses_published_workflowapp_id=harness.target.id,app_owner_tenant_id=harness.target.tenant_id,expected_app_mode=AppMode.ADVANCED_CHAT,- actor=SuggestedQuestionsAccount(account_id=harness.account.id, invoke_from=invoke_from),+ actor=actor,message_id=harness.message.id,) == ["What next?"]assert harness.provider.prompts == ["Draft questions" if invoke_from == "debugger" else "Published questions"]+ assert harness.provider.model_configs == [None]harness.assert_closed()