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): share installed app suggested questions runtime (#42933)

非法操作9d4629c946dc
diff --git a/api/controllers/console/explore/message.py b/api/controllers/console/explore/message.py
index 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, InstalledAppRef
from services.installed_app_generation_service import InstalledAppNotCompletionError
from services.installed_app_message_service import FeedbackRatingRequiredError, MessageNotChatAppError
+from services.message_suggested_questions_service import SuggestedQuestionsAccount, SuggestedQuestionsActorNotFoundError
logger = logging.getLogger(__name__)
@@ -82,7 +83,7 @@ def _message_errors[**P, R](view: Callable[P, R]) -> Callable[P, R]:
raise InstalledAppNotFoundHTTPError() from error
except AppDefinitionUnavailableError as error:
raise AppUnavailableError() from error
- except AccountNotFoundError as error:
+ except (AccountNotFoundError, SuggestedQuestionsActorNotFoundError) as error:
raise Unauthorized("Account no longer exists.") from error
except 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.py
index 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.py
index 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 logging
from collections.abc import Mapping, Sequence
-from flask import current_app
from pydantic import JsonValue
-from sqlalchemy import select
from 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, InstalledApp
from repositories.sqlalchemy_execution_extra_content_repository import SQLAlchemyExecutionExtraContentRepository
-from services.account_errors import AccountNotFoundError
-from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppRef
from services.installed_app_message_service import MessageFeedbackEvent
-from services.message_service import MessageService
logger = logging.getLogger(__name__)
class InstalledAppMessageRuntime:
def __init__(self, *, session_factory: sessionmaker[Session]) -> None:
- self._session_factory: sessionmaker[Session] = session_factory
self._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.py
index 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 = messages
self._get_extra_contents: MessageExtraContentsQuery = get_extra_contents
- self._suggested_questions: SuggestedQuestionGenerator = suggested_questions
self._emit_feedback: MessageFeedbackEmitter = emit_feedback
def 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)
-
@staticmethod
def _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.py
index 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, replace
from datetime import datetime, timedelta
from decimal import Decimal
-from typing import Literal
+from typing import Literal, cast
from uuid import uuid4
import pytest
from pydantic import JsonValue
-from sqlalchemy import Connection, event, select
+from sqlalchemy import Connection, Engine, event, select, update
from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
from werkzeug.test import TestResponse
import controllers.console.explore.message as module
+import services.message_service as message_module
from core.app.entities.app_invoke_entities import InvokeFrom
from 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 ModelType
from graphon.model_runtime.errors.invoke import InvokeError
-from models import App, AppMode, InstalledApp
+from models import Account, App, AppMode, InstalledApp
from models.enums import ConversationFromSource, ConversationStatus, FeedbackFromSource, FeedbackRating
-from models.model import Conversation, Message, MessageFeedback
+from models.model import AppModelConfig, Conversation, Message, MessageFeedback
from repositories.installed_app_message_repository import SQLAlchemyInstalledAppMessageRepository
from repositories.installed_app_repository import SQLAlchemyInstalledAppRepository
from services.errors.app import MoreLikeThisDisabledError
from services.errors.conversation import ConversationNotExistsError
from services.errors.message import MessageNotExistsError, SuggestedQuestionsAfterAnswerDisabledError
-from services.installed_app_access_service import InstalledAppRef
from services.installed_app_generation_service import GenerationResponse, InstalledAppGenerationService
from 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
@dataclass
class _Messages:
harness: _Harness
factory: 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.content
self.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_error
return 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.py
index 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 MagicMock
from uuid import uuid4
import 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_module
from 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 TraceQueueManager
from core.telemetry import FeedbackCreatedEvent
from 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 ConversationFromSource
from models.execution_extra_content import HumanInputContent
from 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, InstalledAppRef
from services.installed_app_message_adapters import InstalledAppMessageRuntime, emit_installed_app_feedback
from 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_none
display_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]) == 1
content = 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_none
assert isinstance(definition, dict)
assert definition["node_title"] == title
assert "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.py
index 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 Decimal
import pytest
from pydantic import JsonValue
-from services.errors.message import MessageNotExistsError, SuggestedQuestionsAfterAnswerDisabledError
+from services.errors.message import MessageNotExistsError
from services.installed_app_access_service import InstalledAppRef
from services.installed_app_message_service import (
InstalledAppMessageService,
@@ -105,7 +105,6 @@ class _Callbacks:
store: _Store
queried_ids: list[tuple[str, ...]] = field(default_factory=list)
feedback: list[MessageFeedbackEvent] = field(default_factory=list)
- suggestion_error: Exception | None = None
def 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 failure
diff --git a/api/tests/unit_tests/services/test_message_suggested_questions_adapters.py b/api/tests/unit_tests/services/test_message_suggested_questions_adapters.py
index 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, Sequence
from dataclasses import dataclass, field
from decimal import Decimal
from typing import Literal, cast
@@ -9,10 +9,12 @@ from uuid import uuid4
import pytest
from flask import Flask
-from sqlalchemy import Connection, Engine, event, select, update
+from sqlalchemy import Connection, Engine, event, update
from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
import services.message_service as message_module
+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
from core.ops.ops_trace_manager import TraceTask
from extensions.ext_database import db
@@ -24,7 +26,7 @@ from models.model import AppModelConfig, EndUser
from models.workflow import Workflow, WorkflowType
from services.app_definition_query_service import AppDefinitionUnavailableError
from services.errors.conversation import ConversationNotExistsError
-from services.errors.message import MessageNotExistsError
+from services.errors.message import MessageNotExistsError, SuggestedQuestionsAfterAnswerDisabledError
from services.message_suggested_questions_adapters import MessageSuggestedQuestionsRuntime
from 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"]
+
@dataclass
class _Provider:
@@ -40,14 +44,19 @@ class _Provider:
tenant_id: str
prompts: 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 = False
def get_default_model_instance(self, *, tenant_id: str, model_type: ModelType) -> ModelInstance:
assert tenant_id == self.tenant_id
assert model_type == ModelType.LLM
assert self.read_sessions
assert 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 None
self.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.failure
return ["What next?"]
@@ -81,6 +91,22 @@ class _Harness:
provider: _Provider
legacy_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_metadata
assert db.session() is caller_session
assert 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_session
harness.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 Conversation
record_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 ConversationNotExistsError
with 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.histories
harness.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) == 1
assert not harness.provider.histories
+ assert not harness.provider.traces
harness.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_workflow
if 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_workflow
app_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()