fix(completion): preserve legacy workflow compatibility

Replace the dedicated Completion runner with a Workflow Entry backed execution path.

Adapt GraphOn events back into legacy Completion queue events and keep existing message persistence in the EasyUI task pipeline.

Refs #37572

api/controllers/console/app/audio.py

@@ -278,7 +278,9 @@ class ChatMessageTextApi(Resource):
     @get_app_model
     def post(self, app_model: App):
         try:
-            payload = TextToSpeechPayload.model_validate(console_ns.payload)
+            payload_data = dict(console_ns.payload or {})
+            payload_data.setdefault("text", "")
+            payload = TextToSpeechPayload.model_validate(payload_data)
             message_ref = None
             if payload.message_id:
                 app_ref = AppRefService.create_app_ref(app_model)

api/core/app/apps/base_app_runner.py

@@ -1,7 +1,7 @@
 import base64
 import logging
 import time
-from collections.abc import Generator, Mapping, Sequence
+from collections.abc import Generator, Mapping, MutableMapping, Sequence
 from mimetypes import guess_extension
 from typing import TYPE_CHECKING, Any, Union
 
@@ -54,9 +54,15 @@ _logger = logging.getLogger(__name__)
 
 class AppRunner:
     def recalc_llm_max_tokens(
-        self, model_config: ModelConfigWithCredentialsEntity, prompt_messages: list[PromptMessage]
-    ):
+        self,
+        model_config: ModelConfigWithCredentialsEntity,
+        prompt_messages: list[PromptMessage],
+        *,
+        model_parameters: MutableMapping[str, Any] | None = None,
+    ) -> int | None:
+        """Clamp max tokens against the final prompt on the selected parameter mapping."""
         # recalc max_tokens if sum(prompt_token +  max_tokens) over model token limit
+        parameters = model_parameters if model_parameters is not None else model_config.parameters
         model_instance = ModelInstance(
             provider_model_bundle=model_config.provider_model_bundle, model=model_config.model
         )
@@ -69,8 +75,7 @@ class AppRunner:
                 parameter_rule.use_template and parameter_rule.use_template == "max_tokens"
             ):
                 max_tokens = (
-                    model_config.parameters.get(parameter_rule.name)
-                    or model_config.parameters.get(parameter_rule.use_template or "")
+                    parameters.get(parameter_rule.name) or parameters.get(parameter_rule.use_template or "")
                 ) or 0
 
         if model_context_tokens is None:
@@ -85,7 +90,9 @@ class AppRunner:
                 if parameter_rule.name == "max_tokens" or (
                     parameter_rule.use_template and parameter_rule.use_template == "max_tokens"
                 ):
-                    model_config.parameters[parameter_rule.name] = max_tokens
+                    parameters[parameter_rule.name] = max_tokens
+
+        return None
 
     def organize_prompt_messages(
         self,

api/core/app/apps/completion/app_generator.py

@@ -15,8 +15,8 @@ from core.app.app_config.easy_ui_based_app.model_config.converter import ModelCo
 from core.app.app_config.features.file_upload.manager import FileUploadConfigManager
 from core.app.apps.base_app_queue_manager import AppQueueManager, PublishFrom
 from core.app.apps.completion.app_config_manager import CompletionAppConfigManager
-from core.app.apps.completion.app_runner import CompletionAppRunner
 from core.app.apps.completion.generate_response_converter import CompletionAppGenerateResponseConverter
+from core.app.apps.completion.workflow_runner import CompletionWorkflowRunner
 from core.app.apps.exc import GenerateTaskStoppedError
 from core.app.apps.message_based_app_generator import MessageBasedAppGenerator
 from core.app.apps.message_based_app_queue_manager import MessageBasedAppQueueManager
@@ -243,7 +243,7 @@ class CompletionAppGenerator(MessageBasedAppGenerator):
                 message = self._get_message(message_id)
 
                 # chatbot app
-                runner = CompletionAppRunner()
+                runner = CompletionWorkflowRunner()
                 with session_factory.create_session() as session:
                     runner.run(
                         application_generate_entity=application_generate_entity,

api/core/app/apps/completion/app_runner.py

@@ -1,208 +0,0 @@
-import logging
-from typing import cast
-
-from sqlalchemy import select
-from sqlalchemy.orm import Session
-
-from core.app.apps.base_app_queue_manager import AppQueueManager
-from core.app.apps.base_app_runner import AppRunner
-from core.app.apps.completion.app_config_manager import CompletionAppConfig
-from core.app.entities.app_invoke_entities import (
-    CompletionAppGenerateEntity,
-)
-from core.callback_handler.index_tool_callback_handler import DatasetIndexToolCallbackHandler
-from core.db.session_factory import create_session
-from core.model_manager import ModelInstance
-from core.moderation.base import ModerationError
-from core.rag.retrieval.dataset_retrieval import DatasetRetrieval
-from graphon.file import File
-from graphon.model_runtime.entities.message_entities import ImagePromptMessageContent
-from models.model import App, Message
-
-logger = logging.getLogger(__name__)
-
-
-class CompletionAppRunner(AppRunner):
-    """
-    Completion Application Runner
-    """
-
-    def run(
-        self,
-        application_generate_entity: CompletionAppGenerateEntity,
-        queue_manager: AppQueueManager,
-        message: Message,
-        session: Session,
-    ):
-        """Run the application without retaining ``session`` during model I/O.
-
-        Database preparation is committed and the connection is released before
-        the provider response is requested or consumed.
-
-        :param application_generate_entity: application generate entity
-        :param queue_manager: application queue manager
-        :param message: message
-        :return:
-        """
-        app_config = application_generate_entity.app_config
-        app_config = cast(CompletionAppConfig, app_config)
-        stmt = select(App).where(App.id == app_config.app_id)
-        with create_session() as read_session:
-            app_record = read_session.scalar(stmt)
-            if app_record:
-                read_session.expunge(app_record)
-        if not app_record:
-            raise ValueError("App not found")
-
-        inputs = application_generate_entity.inputs
-        query = application_generate_entity.query
-        files = application_generate_entity.files
-
-        image_detail_config = (
-            application_generate_entity.file_upload_config.image_config.detail
-            if (
-                application_generate_entity.file_upload_config
-                and application_generate_entity.file_upload_config.image_config
-            )
-            else None
-        )
-        image_detail_config = image_detail_config or ImagePromptMessageContent.DETAIL.LOW
-
-        # organize all inputs and template to prompt messages
-        # Include: prompt template, inputs, query(optional), files(optional)
-        prompt_messages, stop = self.organize_prompt_messages(
-            app_record=app_record,
-            model_config=application_generate_entity.model_conf,
-            prompt_template_entity=app_config.prompt_template,
-            inputs=inputs,
-            files=files,
-            query=query,
-            image_detail_config=image_detail_config,
-        )
-
-        # moderation
-        try:
-            # process sensitive_word_avoidance
-            _, inputs, query = self.moderation_for_inputs(
-                app_id=app_record.id,
-                tenant_id=app_config.tenant_id,
-                app_generate_entity=application_generate_entity,
-                inputs=inputs,
-                query=query or "",
-                message_id=message.id,
-            )
-        except ModerationError as e:
-            self.direct_output(
-                queue_manager=queue_manager,
-                app_generate_entity=application_generate_entity,
-                prompt_messages=prompt_messages,
-                text=str(e),
-                stream=application_generate_entity.stream,
-            )
-            return
-
-        # fill in variable inputs from external data tools if exists
-        external_data_tools = app_config.external_data_variables
-        if external_data_tools:
-            inputs = self.fill_in_inputs_from_external_data_tools(
-                tenant_id=app_record.tenant_id,
-                app_id=app_record.id,
-                external_data_tools=external_data_tools,
-                inputs=inputs,
-                query=query,
-            )
-
-        # get context from datasets
-        context = None
-        context_files: list[File] = []
-        if app_config.dataset and app_config.dataset.dataset_ids:
-            hit_callback = DatasetIndexToolCallbackHandler(
-                queue_manager,
-                app_record.id,
-                message.id,
-                application_generate_entity.user_id,
-                application_generate_entity.invoke_from,
-            )
-
-            dataset_config = app_config.dataset
-            if dataset_config and dataset_config.retrieve_config.query_variable:
-                query = inputs.get(dataset_config.retrieve_config.query_variable, "")
-
-            dataset_retrieval = DatasetRetrieval(application_generate_entity)
-            context, retrieved_files = dataset_retrieval.retrieve(
-                session=session,
-                app_id=app_record.id,
-                user_id=application_generate_entity.user_id,
-                tenant_id=app_record.tenant_id,
-                model_config=application_generate_entity.model_conf,
-                config=dataset_config,
-                query=query or "",
-                invoke_from=application_generate_entity.invoke_from,
-                show_retrieve_source=app_config.additional_features.show_retrieve_source
-                if app_config.additional_features
-                else False,
-                hit_callback=hit_callback,
-                message_id=message.id,
-                inputs=inputs,
-                vision_enabled=bool(
-                    application_generate_entity.app_config.app_model_config_dict.get("file_upload", {})
-                    .get("image", {})
-                    .get("enabled", False)
-                ),
-            )
-            context_files = retrieved_files or []
-
-        session.commit()
-        session.close()
-
-        # reorganize all inputs and template to prompt messages
-        # Include: prompt template, inputs, query(optional), files(optional)
-        #          memory(optional), external data, dataset context(optional)
-        prompt_messages, stop = self.organize_prompt_messages(
-            app_record=app_record,
-            model_config=application_generate_entity.model_conf,
-            prompt_template_entity=app_config.prompt_template,
-            inputs=inputs,
-            files=files,
-            query=query,
-            context=context,
-            image_detail_config=image_detail_config,
-            context_files=context_files,
-        )
-
-        # check hosting moderation
-        hosting_moderation_result = self.check_hosting_moderation(
-            application_generate_entity=application_generate_entity,
-            queue_manager=queue_manager,
-            prompt_messages=prompt_messages,
-        )
-
-        if hosting_moderation_result:
-            return
-
-        # Re-calculate the max tokens if sum(prompt_token +  max_tokens) over model token limit
-        self.recalc_llm_max_tokens(model_config=application_generate_entity.model_conf, prompt_messages=prompt_messages)
-
-        # Invoke model
-        model_instance = ModelInstance(
-            provider_model_bundle=application_generate_entity.model_conf.provider_model_bundle,
-            model=application_generate_entity.model_conf.model,
-        )
-
-        invoke_result = model_instance.invoke_llm(
-            prompt_messages=prompt_messages,
-            model_parameters=application_generate_entity.model_conf.parameters,
-            stop=stop,
-            stream=application_generate_entity.stream,
-            request_metadata={"app_id": app_config.app_id},
-        )
-
-        # handle invoke result
-        self._handle_invoke_result(
-            invoke_result=invoke_result,
-            queue_manager=queue_manager,
-            stream=application_generate_entity.stream,
-            message_id=message.id,
-            user_id=application_generate_entity.user_id,
-            tenant_id=app_config.tenant_id,
-        )

api/core/app/apps/completion/graph_event_adapter.py

@@ -0,0 +1,144 @@
+from collections.abc import Mapping, Sequence
+
+from core.app.apps.base_app_queue_manager import AppQueueManager, PublishFrom
+from core.app.entities.app_invoke_entities import CompletionAppGenerateEntity
+from core.app.entities.queue_entities import (
+    QueueErrorEvent,
+    QueueLLMChunkEvent,
+    QueueMessageEndEvent,
+    QueueRetrieverResourcesEvent,
+    QueueStopEvent,
+)
+from core.rag.entities import RetrievalSourceMetadata
+from graphon.graph_events import (
+    GraphEngineEvent,
+    GraphRunAbortedEvent,
+    GraphRunFailedEvent,
+    GraphRunSucceededEvent,
+    NodeRunRetrieverResourceEvent,
+    NodeRunStreamChunkEvent,
+    NodeRunSucceededEvent,
+)
+from graphon.model_runtime.entities.llm_entities import LLMResult, LLMResultChunk, LLMResultChunkDelta, LLMUsage
+from graphon.model_runtime.entities.message_entities import AssistantPromptMessage, PromptMessage
+
+_LLM_TEXT_SELECTOR_PREFIX = ("llm", "text")
+
+
+class CompletionGraphEventAdapter:
+    """Translate one runtime graph run into legacy Completion queue events."""
+
+    _application_generate_entity: CompletionAppGenerateEntity
+    _queue_manager: AppQueueManager
+    _answer: str
+    _usage: LLMUsage
+    _prompt_messages: list[PromptMessage]
+    _chunk_index: int
+
+    def __init__(
+        self,
+        *,
+        application_generate_entity: CompletionAppGenerateEntity,
+        queue_manager: AppQueueManager,
+    ) -> None:
+        self._application_generate_entity = application_generate_entity
+        self._queue_manager = queue_manager
+        self._answer = ""
+        self._usage = LLMUsage.empty_usage()
+        self._prompt_messages = []
+        self._chunk_index = 0
+
+    def set_prompt_messages(self, prompt_messages: Sequence[PromptMessage]) -> None:
+        """Capture the final GraphOn prompt for legacy chunks and message persistence."""
+        self._prompt_messages = list(prompt_messages)
+
+    def handle_event(self, event: GraphEngineEvent) -> None:
+        match event:
+            case NodeRunStreamChunkEvent():
+                self._handle_stream_chunk(event)
+            case NodeRunRetrieverResourceEvent():
+                self._handle_retriever_resource(event)
+            case NodeRunSucceededEvent():
+                self._handle_node_succeeded(event)
+            case GraphRunSucceededEvent():
+                self._publish_message_end(event.outputs)
+            case GraphRunFailedEvent():
+                self._publish_error(event.error)
+            case GraphRunAbortedEvent():
+                self._queue_manager.publish(
+                    QueueStopEvent(stopped_by=QueueStopEvent.StopBy.USER_MANUAL),
+                    PublishFrom.APPLICATION_MANAGER,
+                )
+            case _:
+                return
+
+    def _handle_stream_chunk(self, event: NodeRunStreamChunkEvent) -> None:
+        if tuple(event.selector)[:2] != _LLM_TEXT_SELECTOR_PREFIX:
+            return
+        if event.is_final and not event.chunk:
+            return
+
+        self._answer += event.chunk
+        self._queue_manager.publish(
+            QueueLLMChunkEvent(
+                chunk=LLMResultChunk(
+                    model=self._application_generate_entity.model_conf.model,
+                    prompt_messages=self._prompt_messages,
+                    delta=LLMResultChunkDelta(
+                        index=self._chunk_index,
+                        message=AssistantPromptMessage(content=event.chunk),
+                    ),
+                )
+            ),
+            PublishFrom.APPLICATION_MANAGER,
+        )
+        self._chunk_index += 1
+
+    def _handle_retriever_resource(self, event: NodeRunRetrieverResourceEvent) -> None:
+        additional_features = self._application_generate_entity.app_config.additional_features
+        if not additional_features or not additional_features.show_retrieve_source:
+            return
+
+        self._queue_manager.publish(
+            QueueRetrieverResourcesEvent(
+                retriever_resources=[
+                    RetrievalSourceMetadata.model_validate(resource) for resource in event.retriever_resources
+                ],
+                in_iteration_id=event.in_iteration_id,
+                in_loop_id=event.in_loop_id,
+            ),
+            PublishFrom.APPLICATION_MANAGER,
+        )
+
+    def _handle_node_succeeded(self, event: NodeRunSucceededEvent) -> None:
+        if event.node_id != "llm":
+            return
+
+        result = event.node_run_result
+        text = result.outputs.get("text")
+        if isinstance(text, str):
+            self._answer = text
+        self._usage = result.llm_usage
+
+    def _publish_message_end(self, outputs: Mapping[str, object]) -> None:
+        result = outputs.get("result")
+        if isinstance(result, str) and not self._answer:
+            self._answer = result
+
+        self._queue_manager.publish(
+            QueueMessageEndEvent(
+                llm_result=LLMResult(
+                    model=self._application_generate_entity.model_conf.model,
+                    prompt_messages=self._prompt_messages,
+                    message=AssistantPromptMessage(content=self._answer),
+                    usage=self._usage,
+                )
+            ),
+            PublishFrom.APPLICATION_MANAGER,
+        )
+
+    def _publish_error(self, error: object) -> None:
+        self._queue_manager.publish(
+            QueueErrorEvent(error=ValueError(str(error))),
+            PublishFrom.APPLICATION_MANAGER,
+        )

api/core/app/apps/completion/runtime_workflow_builder.py

@@ -0,0 +1,69 @@
+import json
+from dataclasses import dataclass
+from typing import Any
+from uuid import uuid4
+
+from sqlalchemy.orm import Session
+
+from core.app.apps.completion.app_config_manager import CompletionAppConfig
+from graphon.nodes import BuiltinNodeTypes
+from models.model import App, AppMode
+from services.workflow.workflow_converter import WorkflowConverter, WorkflowGraph
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeCompletionWorkflow:
+    workflow_id: str
+    root_node_id: str
+    graph_dict: WorkflowGraph
+
+
+def build_runtime_completion_workflow(
+    *,
+    app_model: App,
+    app_config: CompletionAppConfig,
+    session: Session,
+    workflow_converter: WorkflowConverter | None = None,
+) -> RuntimeCompletionWorkflow:
+    """Build the transient WorkflowEntry graph used by Completion execution."""
+    converter = workflow_converter or WorkflowConverter()
+    graph, _ = converter.build_graph_from_app_config(
+        app_model=app_model,
+        app_config=app_config,
+        target_app_mode=AppMode.WORKFLOW,
+        session=session,
+    )
+    _route_external_data_query_to_sys_query(graph)
+    return RuntimeCompletionWorkflow(
+        workflow_id=f"completion-runtime-{uuid4()}",
+        root_node_id="start",
+        graph_dict=graph,
+    )
+
+
+def _route_external_data_query_to_sys_query(graph: WorkflowGraph) -> None:
+    """Preserve Completion API-based variable behavior in the runtime graph."""
+    for node in graph["nodes"]:
+        data = node.get("data", {})
+        if data.get("type") != BuiltinNodeTypes.HTTP_REQUEST:
+            continue
+
+        body = data.get("body")
+        if not isinstance(body, dict) or body.get("type") != "json":
+            continue
+
+        raw_body_data = body.get("data")
+        if not isinstance(raw_body_data, str):
+            continue
+
+        try:
+            body_data: dict[str, Any] = json.loads(raw_body_data)
+        except json.JSONDecodeError:
+            continue
+
+        params = body_data.get("params")
+        if not isinstance(params, dict) or params.get("query") != "":
+            continue
+
+        params["query"] = "{{#sys.query#}}"
+        body["data"] = json.dumps(body_data)

api/core/app/apps/completion/workflow_runner.py

@@ -0,0 +1,242 @@
+import time
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any, cast
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from core.app.apps.base_app_queue_manager import AppQueueManager
+from core.app.apps.base_app_runner import AppRunner
+from core.app.apps.completion.app_config_manager import CompletionAppConfig
+from core.app.apps.completion.graph_event_adapter import CompletionGraphEventAdapter
+from core.app.apps.completion.runtime_workflow_builder import build_runtime_completion_workflow
+from core.app.apps.exc import GenerateTaskStoppedError
+from core.app.apps.workflow_app_runner import init_graph
+from core.app.entities.app_invoke_entities import CompletionAppGenerateEntity, UserFrom
+from core.moderation.base import ModerationError
+from core.workflow.node_runtime import DIFY_BEFORE_LLM_INVOKE_KEY
+from core.workflow.system_variables import build_bootstrap_variables, build_system_variables
+from core.workflow.variable_pool_initializer import add_node_inputs_to_pool, add_variables_to_pool
+from core.workflow.workflow_entry import WorkflowEntry
+from extensions.ext_redis import redis_client
+from graphon.graph_engine.command_channels import RedisChannel
+from graphon.model_runtime.entities.message_entities import ImagePromptMessageContent, PromptMessage
+from graphon.runtime import GraphRuntimeState, VariablePool
+from models.model import App, Message
+
+
+@dataclass(frozen=True, slots=True)
+class ModeratedCompletionInputs:
+    stopped: bool
+    inputs: Mapping[str, Any]
+    query: str
+
+
+class CompletionWorkflowRunner(AppRunner):
+    """Run a transient WorkflowEntry graph while the legacy task pipeline owns persistence."""
+
+    def run(
+        self,
+        application_generate_entity: CompletionAppGenerateEntity,
+        queue_manager: AppQueueManager,
+        message: Message,
+        session: Session,
+    ) -> None:
+        app_config = cast(CompletionAppConfig, application_generate_entity.app_config)
+        app_record = self._get_app(app_id=app_config.app_id, tenant_id=app_config.tenant_id, session=session)
+
+        moderation_result = self._run_input_moderation(
+            app_record=app_record,
+            application_generate_entity=application_generate_entity,
+            queue_manager=queue_manager,
+            message=message,
+        )
+        if moderation_result.stopped:
+            return
+
+        runtime_workflow = build_runtime_completion_workflow(
+            app_model=app_record,
+            app_config=app_config,
+            session=session,
+        )
+        variable_pool = self._build_variable_pool(
+            application_generate_entity=application_generate_entity,
+            message=message,
+            workflow_id=runtime_workflow.workflow_id,
+            root_node_id=runtime_workflow.root_node_id,
+            inputs=moderation_result.inputs,
+            query=moderation_result.query,
+        )
+        graph_runtime_state = GraphRuntimeState(variable_pool=variable_pool, start_at=time.perf_counter())
+        user_from = self._resolve_user_from(application_generate_entity)
+        adapter = CompletionGraphEventAdapter(
+            application_generate_entity=application_generate_entity,
+            queue_manager=queue_manager,
+        )
+        extra_context = {
+            DIFY_BEFORE_LLM_INVOKE_KEY: self._build_before_llm_invoke_hook(
+                application_generate_entity=application_generate_entity,
+                queue_manager=queue_manager,
+                adapter=adapter,
+            )
+        }
+
+        graph = init_graph(
+            app_id=app_config.app_id,
+            graph_config=runtime_workflow.graph_dict,
+            graph_runtime_state=graph_runtime_state,
+            user_from=user_from,
+            invoke_from=application_generate_entity.invoke_from,
+            workflow_id=runtime_workflow.workflow_id,
+            tenant_id=app_config.tenant_id,
+            user_id=application_generate_entity.user_id,
+            root_node_id=runtime_workflow.root_node_id,
+            trace_session_id=application_generate_entity.extras.get("trace_session_id"),
+            call_depth=application_generate_entity.call_depth,
+            extra_context=extra_context,
+        )
+
+        queue_manager.graph_runtime_state = graph_runtime_state
+        command_channel = RedisChannel(redis_client, f"workflow:{application_generate_entity.task_id}:commands")
+        workflow_entry = WorkflowEntry(
+            tenant_id=app_config.tenant_id,
+            app_id=app_config.app_id,
+            workflow_id=runtime_workflow.workflow_id,
+            graph_config=runtime_workflow.graph_dict,
+            graph=graph,
+            user_id=application_generate_entity.user_id,
+            user_from=user_from,
+            invoke_from=application_generate_entity.invoke_from,
+            call_depth=application_generate_entity.call_depth,
+            variable_pool=variable_pool,
+            graph_runtime_state=graph_runtime_state,
+            command_channel=command_channel,
+        )
+        # Do not hold a database connection during graph execution or provider streaming.
+        session.commit()
+        session.close()
+        for event in workflow_entry.run():
+            adapter.handle_event(event)
+
+    def _get_app(self, *, app_id: str, tenant_id: str, session: Session) -> App:
+        app_record = session.scalar(select(App).where(App.id == app_id, App.tenant_id == tenant_id))
+        if not app_record:
+            raise ValueError("App not found")
+        return app_record
+
+    def _run_input_moderation(
+        self,
+        *,
+        app_record: App,
+        application_generate_entity: CompletionAppGenerateEntity,
+        queue_manager: AppQueueManager,
+        message: Message,
+    ) -> ModeratedCompletionInputs:
+        app_config = cast(CompletionAppConfig, application_generate_entity.app_config)
+        prompt_messages, _ = self.organize_prompt_messages(
+            app_record=app_record,
+            model_config=application_generate_entity.model_conf,
+            prompt_template_entity=app_config.prompt_template,
+            inputs=application_generate_entity.inputs,
+            files=application_generate_entity.files,
+            query=application_generate_entity.query,
+            image_detail_config=self._resolve_image_detail_config(application_generate_entity),
+        )
+
+        try:
+            _, inputs, query = self.moderation_for_inputs(
+                app_id=app_record.id,
+                tenant_id=app_config.tenant_id,
+                app_generate_entity=application_generate_entity,
+                inputs=application_generate_entity.inputs,
+                query=application_generate_entity.query or "",
+                message_id=message.id,
+            )
+        except ModerationError as exc:
+            self.direct_output(
+                queue_manager=queue_manager,
+                app_generate_entity=application_generate_entity,
+                prompt_messages=prompt_messages,
+                text=str(exc),
+                stream=application_generate_entity.stream,
+            )
+            return ModeratedCompletionInputs(
+                stopped=True,
+                inputs=application_generate_entity.inputs,
+                query=application_generate_entity.query or "",
+            )
+
+        return ModeratedCompletionInputs(stopped=False, inputs=inputs, query=query)
+
+    def _build_before_llm_invoke_hook(
+        self,
+        *,
+        application_generate_entity: CompletionAppGenerateEntity,
+        queue_manager: AppQueueManager,
+        adapter: CompletionGraphEventAdapter,
+    ) -> Callable[[Sequence[PromptMessage], Mapping[str, Any]], Mapping[str, Any]]:
+        def check(
+            prompt_messages: Sequence[PromptMessage],
+            model_parameters: Mapping[str, Any],
+        ) -> Mapping[str, Any]:
+            adapter.set_prompt_messages(prompt_messages)
+            if self.check_hosting_moderation(
+                application_generate_entity=application_generate_entity,
+                queue_manager=queue_manager,
+                prompt_messages=list(prompt_messages),
+            ):
+                raise GenerateTaskStoppedError()
+
+            adjusted_parameters = dict(model_parameters)
+            self.recalc_llm_max_tokens(
+                model_config=application_generate_entity.model_conf,
+                prompt_messages=list(prompt_messages),
+                model_parameters=adjusted_parameters,
+            )
+            return adjusted_parameters
+
+        return check
+
+    def _build_variable_pool(
+        self,
+        *,
+        application_generate_entity: CompletionAppGenerateEntity,
+        message: Message,
+        workflow_id: str,
+        root_node_id: str,
+        inputs: Mapping[str, Any],
+        query: str,
+    ) -> VariablePool:
+        variable_pool = VariablePool()
+        system_inputs = build_system_variables(
+            files=application_generate_entity.files,
+            user_id=application_generate_entity.user_id,
+            app_id=application_generate_entity.app_config.app_id,
+            workflow_id=workflow_id,
+            workflow_execution_id=application_generate_entity.task_id,
+            timestamp=int(time.time()),
+            query=query,
+            conversation_id=message.conversation_id,
+        )
+        add_variables_to_pool(
+            variable_pool,
+            build_bootstrap_variables(system_variables=system_inputs, environment_variables=[]),
+        )
+        add_node_inputs_to_pool(variable_pool, node_id=root_node_id, inputs=inputs)
+        return variable_pool
+
+    @staticmethod
+    def _resolve_user_from(application_generate_entity: CompletionAppGenerateEntity) -> UserFrom:
+        if application_generate_entity.invoke_from.runs_as_account():
+            return UserFrom.ACCOUNT
+        return UserFrom.END_USER
+
+    @staticmethod
+    def _resolve_image_detail_config(
+        application_generate_entity: CompletionAppGenerateEntity,
+    ) -> ImagePromptMessageContent.DETAIL:
+        file_upload_config = application_generate_entity.file_upload_config
+        if file_upload_config and file_upload_config.image_config:
+            return file_upload_config.image_config.detail or ImagePromptMessageContent.DETAIL.LOW
+        return ImagePromptMessageContent.DETAIL.LOW

api/core/app/apps/workflow_app_runner.py

@@ -93,6 +93,60 @@ from tasks.mail_human_input_delivery_task import dispatch_human_input_email_task
 logger = logging.getLogger(__name__)
 
 
+def init_graph(
+    *,
+    app_id: str,
+    graph_config: Mapping[str, Any],
+    graph_runtime_state: GraphRuntimeState,
+    user_from: UserFrom,
+    invoke_from: InvokeFrom,
+    workflow_id: str = "",
+    tenant_id: str = "",
+    user_id: str = "",
+    root_node_id: str | None = None,
+    trace_session_id: str | None = None,
+    call_depth: int = 0,
+    extra_context: Mapping[str, Any] | None = None,
+) -> Graph:
+    if "nodes" not in graph_config or "edges" not in graph_config:
+        raise ValueError("nodes or edges not found in workflow graph")
+
+    if not isinstance(graph_config.get("nodes"), list):
+        raise ValueError("nodes in workflow graph must be a list")
+
+    if not isinstance(graph_config.get("edges"), list):
+        raise ValueError("edges in workflow graph must be a list")
+
+    run_context = build_dify_run_context(
+        tenant_id=tenant_id or "",
+        app_id=app_id,
+        user_id=user_id,
+        user_from=user_from,
+        invoke_from=invoke_from,
+        trace_session_id=trace_session_id,
+        extra_context=extra_context,
+    )
+    graph_init_context = DifyGraphInitContext(
+        workflow_id=workflow_id,
+        graph_config=graph_config,
+        run_context=run_context,
+        call_depth=call_depth,
+    )
+    node_factory = DifyNodeFactory.from_graph_init_context(
+        graph_init_context=graph_init_context,
+        graph_runtime_state=graph_runtime_state,
+    )
+
+    if root_node_id is None:
+        root_node_id = get_default_root_node_id(graph_config)
+
+    graph = Graph.init(graph_config=graph_config, node_factory=node_factory, root_node_id=root_node_id)
+    if not graph:
+        raise ValueError("graph not found in workflow")
+
+    return graph
+
+
 class WorkflowBasedAppRunner:
     def __init__(
         self,
@@ -128,48 +182,18 @@ class WorkflowBasedAppRunner:
         """
         Init graph
         """
-        if "nodes" not in graph_config or "edges" not in graph_config:
-            raise ValueError("nodes or edges not found in workflow graph")
-
-        if not isinstance(graph_config.get("nodes"), list):
-            raise ValueError("nodes in workflow graph must be a list")
-
-        if not isinstance(graph_config.get("edges"), list):
-            raise ValueError("edges in workflow graph must be a list")
-
-        # Create explicit graph init context for Graph.init.
-        run_context = build_dify_run_context(
-            tenant_id=tenant_id or "",
+        return init_graph(
             app_id=self._app_id,
-            user_id=user_id,
+            graph_config=graph_config,
+            graph_runtime_state=graph_runtime_state,
             user_from=user_from,
             invoke_from=invoke_from,
+            workflow_id=workflow_id,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            root_node_id=root_node_id,
             trace_session_id=trace_session_id,
         )
-        graph_init_context = DifyGraphInitContext(
-            workflow_id=workflow_id,
-            graph_config=graph_config,
-            run_context=run_context,
-            call_depth=0,
-        )
-
-        # Use the provided graph_runtime_state for consistent state management
-
-        node_factory = DifyNodeFactory.from_graph_init_context(
-            graph_init_context=graph_init_context,
-            graph_runtime_state=graph_runtime_state,
-        )
-
-        if root_node_id is None:
-            root_node_id = get_default_root_node_id(graph_config)
-
-        # init graph
-        graph = Graph.init(graph_config=graph_config, node_factory=node_factory, root_node_id=root_node_id)
-
-        if not graph:
-            raise ValueError("graph not found in workflow")
-
-        return graph
 
     def _prepare_single_node_execution(
         self,

api/core/plugin/plugin_service.py

@@ -66,7 +66,7 @@ from services.enterprise.plugin_manager_service import (
     PreUninstallPluginRequest,
 )
 from services.errors.plugin import PluginInstallationForbiddenError
-from services.feature_service import FeatureService, PluginInstallationScope
+from services.feature_service import FeatureService, PluginInstallationPermissionModel, PluginInstallationScope
 
 logger = logging.getLogger(__name__)
 _provider_entities_adapter: TypeAdapter[list[ProviderEntity]] = TypeAdapter(list[ProviderEntity])
@@ -604,22 +604,30 @@ class PluginService:
             return result
 
     @staticmethod
-    def _check_marketplace_only_permission():
+    def _check_marketplace_only_permission() -> None:
         """
         Check if the marketplace only permission is enabled
         """
-        features = FeatureService.get_system_features()
-        if features.plugin_installation_permission.restrict_to_marketplace_only:
+        permission = PluginService._get_plugin_installation_permission()
+        if permission.restrict_to_marketplace_only:
             raise PluginInstallationForbiddenError("Plugin installation is restricted to marketplace only")
 
     @staticmethod
-    def _check_plugin_installation_scope(plugin_verification: PluginVerification | None):
+    def _get_plugin_installation_permission() -> PluginInstallationPermissionModel:
+        """Resolve the validated policy and reject deny-all before any installation side effect."""
+        permission = FeatureService.get_plugin_installation_permission()
+        if permission.plugin_installation_scope == PluginInstallationScope.NONE:
+            raise PluginInstallationForbiddenError("Installing plugins is not allowed")
+        return permission
+
+    @staticmethod
+    def _check_plugin_installation_scope(plugin_verification: PluginVerification | None) -> None:
         """
         Check the plugin installation scope
         """
-        features = FeatureService.get_system_features()
+        permission = PluginService._get_plugin_installation_permission()
 
-        match features.plugin_installation_permission.plugin_installation_scope:
+        match permission.plugin_installation_scope:
             case PluginInstallationScope.OFFICIAL_ONLY:
                 if (
                     plugin_verification is None
@@ -634,10 +642,10 @@ class PluginService:
                     raise PluginInstallationForbiddenError(
                         "Plugin installation is restricted to official and specific partners"
                     )
-            case PluginInstallationScope.NONE:
-                raise PluginInstallationForbiddenError("Installing plugins is not allowed")
             case PluginInstallationScope.ALL:
                 pass
+            case _:
+                raise PluginInstallationForbiddenError("Plugin installation policy is invalid")
 
     @staticmethod
     def get_debugging_key(tenant_id: str) -> str:
@@ -907,7 +915,7 @@ class PluginService:
         # check if plugin pkg is already downloaded
         manager = PluginInstaller()
 
-        features = FeatureService.get_system_features()
+        permission = PluginService._get_plugin_installation_permission()
 
         try:
             manager.fetch_plugin_manifest(tenant_id, new_plugin_unique_identifier)
@@ -919,7 +927,7 @@ class PluginService:
             response = manager.upload_pkg(
                 tenant_id,
                 pkg,
-                verify_signature=features.plugin_installation_permission.restrict_to_marketplace_only,
+                verify_signature=permission.restrict_to_marketplace_only,
             )
 
             # check if the plugin is available to install
@@ -974,11 +982,11 @@ class PluginService:
         """
         PluginService._check_marketplace_only_permission()
         manager = PluginInstaller()
-        features = FeatureService.get_system_features()
+        permission = PluginService._get_plugin_installation_permission()
         response = manager.upload_pkg(
             tenant_id,
             pkg,
-            verify_signature=features.plugin_installation_permission.restrict_to_marketplace_only,
+            verify_signature=permission.restrict_to_marketplace_only,
         )
         PluginService._check_plugin_installation_scope(response.verification)
 
@@ -996,13 +1004,13 @@ class PluginService:
         pkg = download_with_size_limit(
             f"https://github.com/{repo}/releases/download/{version}/{package}", dify_config.PLUGIN_MAX_PACKAGE_SIZE
         )
-        features = FeatureService.get_system_features()
+        permission = PluginService._get_plugin_installation_permission()
 
         manager = PluginInstaller()
         response = manager.upload_pkg(
             tenant_id,
             pkg,
-            verify_signature=features.plugin_installation_permission.restrict_to_marketplace_only,
+            verify_signature=permission.restrict_to_marketplace_only,
         )
         PluginService._check_plugin_installation_scope(response.verification)
 
@@ -1076,7 +1084,7 @@ class PluginService:
         if not dify_config.MARKETPLACE_ENABLED:
             raise ValueError("marketplace is not enabled")
 
-        features = FeatureService.get_system_features()
+        permission = PluginService._get_plugin_installation_permission()
 
         manager = PluginInstaller()
         try:
@@ -1086,7 +1094,7 @@ class PluginService:
             response = manager.upload_pkg(
                 tenant_id,
                 pkg,
-                verify_signature=features.plugin_installation_permission.restrict_to_marketplace_only,
+                verify_signature=permission.restrict_to_marketplace_only,
             )
             # check if the plugin is available to install
             PluginService._check_plugin_installation_scope(response.verification)
@@ -1108,7 +1116,7 @@ class PluginService:
         # collect actual plugin_unique_identifiers
         actual_plugin_unique_identifiers = []
         metas = []
-        features = FeatureService.get_system_features()
+        permission = PluginService._get_plugin_installation_permission()
 
         # check if already downloaded
         for plugin_unique_identifier in plugin_unique_identifiers:
@@ -1126,7 +1134,7 @@ class PluginService:
                 response = manager.upload_pkg(
                     tenant_id,
                     pkg,
-                    verify_signature=features.plugin_installation_permission.restrict_to_marketplace_only,
+                    verify_signature=permission.restrict_to_marketplace_only,
                 )
                 # check if the plugin is available to install
                 PluginService._check_plugin_installation_scope(response.verification)

api/core/tools/mcp_tool/tool.py

@@ -107,6 +107,8 @@ class MCPTool(Tool):
         if self.entity.output_schema and result.structuredContent:
             for k, v in result.structuredContent.items():
                 yield self.create_variable_message(k, v)
+        elif result.structuredContent:
+            yield self.create_json_message(result.structuredContent)
 
     def _process_text_content(self, content: TextContent) -> Generator[ToolInvokeMessage, None, None]:
         """Process text content and yield appropriate messages."""

api/core/workflow/node_factory.py

@@ -23,6 +23,8 @@ from core.prompt.entities.advanced_prompt_entities import MemoryConfig
 from core.trigger.constants import TRIGGER_NODE_TYPES
 from core.workflow.human_input_adapter import adapt_node_config_for_graph
 from core.workflow.node_runtime import (
+    DIFY_BEFORE_LLM_INVOKE_KEY,
+    BeforeLLMInvoke,
     DifyFileReferenceFactory,
     DifyHumanInputNodeRuntime,
     DifyPreparedLLM,
@@ -549,6 +551,10 @@ class DifyNodeFactory(NodeFactory):
     ) -> dict[str, object]:
         validated_node_data = cast(LLMCompatibleNodeData, node_data)
         model_instance = self._build_model_instance_for_llm_node(validated_node_data)
+        before_llm_invoke = cast(
+            BeforeLLMInvoke | None,
+            self.graph_init_params.run_context.get(DIFY_BEFORE_LLM_INVOKE_KEY),
+        )
         node_init_kwargs: dict[str, object] = {
             "credentials_provider": self._llm_credentials_provider,
             "model_factory": self._llm_model_factory,
@@ -557,6 +563,7 @@ class DifyNodeFactory(NodeFactory):
                     node_data=validated_node_data,
                     model_instance=model_instance,
                     request_metadata={"app_id": self._dify_context.app_id},
+                    before_invoke=before_llm_invoke,
                 )
                 if wrap_model_instance
                 else model_instance
@@ -590,13 +597,22 @@ class DifyNodeFactory(NodeFactory):
         node_data: LLMCompatibleNodeData,
         model_instance: ModelInstance,
         request_metadata: Mapping[str, object] | None = None,
+        before_invoke: BeforeLLMInvoke | None = None,
     ) -> DifyPreparedLLM:
         # Only graphon's LLM node consumes the polling protocol. Keep classifier
         # and extractor nodes on the existing wrapper even if the same model
         # advertises polling support.
         if node_data.type == BuiltinNodeTypes.LLM and DifyNodeFactory._supports_plugin_llm_polling(model_instance):
-            return DifyPreparedPollingLLM(model_instance, request_metadata=request_metadata)
-        return DifyPreparedLLM(model_instance, request_metadata=request_metadata)
+            return DifyPreparedPollingLLM(
+                model_instance,
+                request_metadata=request_metadata,
+                before_invoke=before_invoke,
+            )
+        return DifyPreparedLLM(
+            model_instance,
+            request_metadata=request_metadata,
+            before_invoke=before_invoke,
+        )
 
     @staticmethod
     def _supports_plugin_llm_polling(model_instance: ModelInstance) -> bool:

api/core/workflow/node_runtime.py

@@ -94,6 +94,8 @@ if TYPE_CHECKING:
     from graphon.nodes.tool.entities import ToolNodeData
 
 
+DIFY_BEFORE_LLM_INVOKE_KEY = "_dify_before_llm_invoke"
+BeforeLLMInvoke = Callable[[Sequence[PromptMessage], Mapping[str, Any]], Mapping[str, Any]]
 _file_access_controller = DatabaseFileAccessController()
 
 
@@ -150,9 +152,15 @@ class DifyFileReferenceFactory(FileReferenceFactoryProtocol):
 class DifyPreparedLLM(LLMProtocol):
     """Workflow-layer adapter that hides the full `ModelInstance` API from `graphon` nodes."""
 
-    def __init__(self, model_instance: ModelInstance, request_metadata: Mapping[str, object] | None = None) -> None:
+    def __init__(
+        self,
+        model_instance: ModelInstance,
+        request_metadata: Mapping[str, object] | None = None,
+        before_invoke: BeforeLLMInvoke | None = None,
+    ) -> None:
         self._model_instance = model_instance
         self._request_metadata = request_metadata
+        self._before_invoke = before_invoke
 
     @property
     @override
@@ -193,6 +201,15 @@ class DifyPreparedLLM(LLMProtocol):
     def get_llm_num_tokens(self, prompt_messages: Sequence[PromptMessage]) -> int:
         return self._model_instance.get_llm_num_tokens(prompt_messages)
 
+    def _run_before_invoke(
+        self,
+        prompt_messages: Sequence[PromptMessage],
+        model_parameters: Mapping[str, Any],
+    ) -> Mapping[str, Any]:
+        if self._before_invoke is None:
+            return model_parameters
+        return self._before_invoke(prompt_messages, model_parameters)
+
     @overload
     def invoke_llm(
         self,
@@ -225,6 +242,7 @@ class DifyPreparedLLM(LLMProtocol):
         stop: Sequence[str] | None,
         stream: bool,
     ) -> LLMResult | Generator[LLMResultChunk, None, None]:
+        model_parameters = self._run_before_invoke(prompt_messages, model_parameters)
         return self._model_instance.invoke_llm(
             prompt_messages=list(prompt_messages),
             model_parameters=dict(model_parameters),
@@ -266,6 +284,7 @@ class DifyPreparedLLM(LLMProtocol):
         stop: Sequence[str] | None,
         stream: bool,
     ) -> LLMResultWithStructuredOutput | Generator[LLMResultChunkWithStructuredOutput, None, None]:
+        model_parameters = self._run_before_invoke(prompt_messages, model_parameters)
         return invoke_llm_with_structured_output(
             provider=self.provider,
             model_schema=self.get_model_schema(),
@@ -285,10 +304,15 @@ class DifyPreparedLLM(LLMProtocol):
 class DifyPreparedPollingLLM(DifyPreparedLLM, LLMPollingCapableProtocol):
     """Prepared workflow LLM adapter that exposes Graphon's polling protocol."""
 
-    def __init__(self, model_instance: ModelInstance, request_metadata: Mapping[str, object] | None = None) -> None:
+    def __init__(
+        self,
+        model_instance: ModelInstance,
+        request_metadata: Mapping[str, object] | None = None,
+        before_invoke: BeforeLLMInvoke | None = None,
+    ) -> None:
         from core.plugin.impl.model_runtime import PluginModelRuntime
 
-        super().__init__(model_instance, request_metadata=request_metadata)
+        super().__init__(model_instance, request_metadata=request_metadata, before_invoke=before_invoke)
         model_type_instance = model_instance.model_type_instance
         if not isinstance(model_type_instance, LargeLanguageModel):
             raise TypeError("Polling wrapper requires a large-language-model instance.")
@@ -309,6 +333,7 @@ class DifyPreparedPollingLLM(DifyPreparedLLM, LLMPollingCapableProtocol):
         stop: Sequence[str] | None,
         json_schema: Mapping[str, Any] | None,
     ) -> LLMPollingResult:
+        model_parameters = self._run_before_invoke(prompt_messages, model_parameters)
         return self._plugin_model_runtime.start_llm_polling(
             provider=self.provider,
             model=self.model_name,

api/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dify-api"
-version = "1.16.0"
+version = "1.16.1"
 requires-python = "~=3.12.0"
 
 dependencies = [

api/services/app_task_service.py

@@ -40,7 +40,7 @@ class AppTaskService:
         # Legacy mechanism: Set stop flag in Redis
         AppQueueManager.set_stop_flag(task_id, invoke_from, user_id)
 
-        # New mechanism: Send stop command via GraphEngine for workflow-based apps
-        # This ensures proper workflow status recording in the persistence layer
-        if app_mode in (AppMode.ADVANCED_CHAT, AppMode.WORKFLOW):
+        # New mechanism: send stop command via GraphEngine for graph-backed apps.
+        # Completion uses WorkflowEntry at runtime but keeps legacy message persistence.
+        if app_mode in (AppMode.ADVANCED_CHAT, AppMode.WORKFLOW, AppMode.COMPLETION):
             GraphEngineManager(redis_client).send_stop_command(task_id)

api/services/feature_service.py

@@ -1,6 +1,8 @@
+import logging
+from collections.abc import Mapping
 from enum import StrEnum
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, ValidationError
 
 from configs import dify_config
 from constants.dsl_version import CURRENT_APP_DSL_VERSION
@@ -10,6 +12,8 @@ from enums.hosted_provider import HostedTrialProvider
 from services.billing_service import BillingInfo, BillingService
 from services.enterprise.enterprise_service import EnterpriseService
 
+logger = logging.getLogger(__name__)
+
 
 class FeatureResponseModel(BaseModel):
     model_config = ConfigDict(json_schema_serialization_defaults_required=True, protected_namespaces=())
@@ -131,6 +135,13 @@ class PluginInstallationPermissionModel(FeatureResponseModel):
     restrict_to_marketplace_only: bool = False
 
 
+class _EnterprisePluginInstallationPermission(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    plugin_installation_scope: PluginInstallationScope = Field(alias="pluginInstallationScope")
+    restrict_to_marketplace_only: bool = Field(alias="restrictToMarketplaceOnly", strict=True)
+
+
 class FeatureModel(FeatureResponseModel):
     billing: BillingModel = BillingModel()
     education: EducationModel = EducationModel()
@@ -285,6 +296,14 @@ class FeatureService:
         """Return whether Enterprise plugin credential policies must be enforced."""
         return dify_config.ENTERPRISE_ENABLED
 
+    @classmethod
+    def get_plugin_installation_permission(cls) -> PluginInstallationPermissionModel:
+        """Resolve the validated deployment-wide plugin installation policy."""
+        if not dify_config.ENTERPRISE_ENABLED:
+            return PluginInstallationPermissionModel()
+
+        return cls._resolve_plugin_installation_permission(EnterpriseService.get_info())
+
     @classmethod
     def get_license(cls) -> LicenseModel:
         """Return full license detail. Enterprise-only; requires an authenticated caller.
@@ -452,6 +471,33 @@ class FeatureService:
                 )
         return license_model
 
+    @classmethod
+    def _resolve_plugin_installation_permission(
+        cls, enterprise_info: Mapping[str, object]
+    ) -> PluginInstallationPermissionModel:
+        if "PluginInstallationPermission" not in enterprise_info:
+            return PluginInstallationPermissionModel()
+
+        try:
+            permission = _EnterprisePluginInstallationPermission.model_validate(
+                enterprise_info["PluginInstallationPermission"]
+            )
+        except ValidationError as exc:
+            # Do not attach the exception because it may contain raw Enterprise configuration values.
+            logger.error(  # noqa: TRY400
+                "Invalid Enterprise plugin installation permission; denying all plugin installations: %s",
+                exc.errors(include_input=False),
+            )
+            return PluginInstallationPermissionModel(
+                plugin_installation_scope=PluginInstallationScope.NONE,
+                restrict_to_marketplace_only=True,
+            )
+
+        return PluginInstallationPermissionModel(
+            plugin_installation_scope=permission.plugin_installation_scope,
+            restrict_to_marketplace_only=permission.restrict_to_marketplace_only,
+        )
+
     @classmethod
     def _fulfill_params_from_enterprise(cls, features: SystemFeatureModel):
         enterprise_info = EnterpriseService.get_info()
@@ -499,11 +545,4 @@ class FeatureService:
                 status=LicenseStatus(license_info.get("status", LicenseStatus.INACTIVE))
             )
 
-        if "PluginInstallationPermission" in enterprise_info:
-            plugin_installation_info = enterprise_info["PluginInstallationPermission"]
-            features.plugin_installation_permission.plugin_installation_scope = plugin_installation_info[
-                "pluginInstallationScope"
-            ]
-            features.plugin_installation_permission.restrict_to_marketplace_only = plugin_installation_info[
-                "restrictToMarketplaceOnly"
-            ]
+        features.plugin_installation_permission = cls._resolve_plugin_installation_permission(enterprise_info)

api/services/workflow/workflow_converter.py

@@ -135,7 +135,45 @@ class WorkflowConverter:
             app_model=app_model, app_model_config=app_model_config, session=session
         )
 
-        # init workflow graph
+        graph, features = self.build_graph_from_app_config(
+            app_model=app_model,
+            app_config=app_config,
+            target_app_mode=new_app_mode,
+            session=session,
+        )
+
+        # create workflow record
+        workflow = Workflow(
+            tenant_id=app_model.tenant_id,
+            app_id=app_model.id,
+            type=WorkflowType.from_app_mode(new_app_mode).value,
+            version=Workflow.VERSION_DRAFT,
+            graph=json.dumps(graph),
+            features=json.dumps(features),
+            created_by=account_id,
+            environment_variables=[],
+            conversation_variables=[],
+        )
+
+        session.add(workflow)
+        session.commit()
+
+        return workflow
+
+    def build_graph_from_app_config(
+        self,
+        *,
+        app_model: App,
+        app_config: EasyUIBasedAppConfig,
+        target_app_mode: AppMode,
+        session: Session,
+    ) -> tuple[WorkflowGraph, dict[str, Any]]:
+        """
+        Build a workflow graph from an EasyUI app config without persisting it.
+
+        This is shared by the persisted app-conversion flow and runtime-only
+        execution paths that need a graph but must not create a Workflow row.
+        """
         graph: WorkflowGraph = {"nodes": [], "edges": []}
 
         # Convert list:
@@ -168,7 +206,7 @@ class WorkflowConverter:
         # convert to knowledge retrieval node
         if app_config.dataset:
             knowledge_retrieval_node = self._convert_to_knowledge_retrieval_node(
-                new_app_mode=new_app_mode, dataset_config=app_config.dataset, model_config=app_config.model
+                new_app_mode=target_app_mode, dataset_config=app_config.dataset, model_config=app_config.model
             )
 
             if knowledge_retrieval_node:
@@ -177,7 +215,7 @@ class WorkflowConverter:
         # convert to llm node
         llm_node = self._convert_to_llm_node(
             original_app_mode=AppMode.value_of(app_model.mode),
-            new_app_mode=new_app_mode,
+            new_app_mode=target_app_mode,
             graph=graph,
             model_config=app_config.model,
             prompt_template=app_config.prompt_template,
@@ -189,7 +227,7 @@ class WorkflowConverter:
 
         app_model_config_dict = app_config.app_model_config_dict
 
-        match new_app_mode:
+        match target_app_mode:
             case AppMode.WORKFLOW:
                 end_node = self._convert_to_end_node()
                 graph = self._append_node(graph, end_node)
@@ -220,23 +258,7 @@ class WorkflowConverter:
                     "sensitive_word_avoidance": app_model_config_dict.get("sensitive_word_avoidance"),
                 }
 
-        # create workflow record
-        workflow = Workflow(
-            tenant_id=app_model.tenant_id,
-            app_id=app_model.id,
-            type=WorkflowType.from_app_mode(new_app_mode).value,
-            version=Workflow.VERSION_DRAFT,
-            graph=json.dumps(graph),
-            features=json.dumps(features),
-            created_by=account_id,
-            environment_variables=[],
-            conversation_variables=[],
-        )
-
-        session.add(workflow)
-        session.commit()
-
-        return workflow
+        return graph, features
 
     def _convert_to_app_config(
         self, app_model: App, app_model_config: AppModelConfig, *, session: Session
@@ -573,8 +595,7 @@ class WorkflowConverter:
         if new_app_mode == AppMode.ADVANCED_CHAT:
             memory = {"role_prefix": role_prefix, "window": {"enabled": False}}
 
-        completion_params = model_config.parameters
-        completion_params.update({"stop": model_config.stop})
+        completion_params = {**model_config.parameters, "stop": model_config.stop}
         return {
             "id": "llm",
             "position": None,

api/tests/test_containers_integration_tests/controllers/console/datasets/test_data_source.py

@@ -1,494 +1,85 @@
-"""Testcontainers integration tests for controllers.console.datasets.data_source endpoints."""
+"""Integration coverage for Notion page bindings backed by persisted documents."""
 
-from __future__ import annotations
-
-import inspect
-from collections.abc import Iterator
-from datetime import UTC, datetime
-from unittest.mock import MagicMock, PropertyMock, patch
+from inspect import unwrap
+from unittest.mock import MagicMock, patch
 from uuid import uuid4
 
-import pytest
 from flask import Flask
 from sqlalchemy.orm import Session
-from werkzeug.exceptions import NotFound
 
-from controllers.console.datasets import data_source
-from controllers.console.datasets.data_source import (
-    DataSourceApi,
-    DataSourceNotionDatasetSyncApi,
-    DataSourceNotionDocumentSyncApi,
-    DataSourceNotionIndexingEstimateApi,
-    DataSourceNotionListApi,
-    DataSourceNotionPreviewApi,
-)
-from core.rag.index_processor.constant.index_type import IndexStructureType
-from models import Account, DataSourceOauthBinding
+from controllers.console.datasets.data_source import DataSourceNotionListApi
+from models import Account
 from models.dataset import Document
 from models.enums import DataSourceType, DocumentCreatedFrom, IndexingStatus
 
 
-@pytest.fixture
-def current_user() -> Account:
-    account = Account(name="Test User", email="u1@example.com")
-    account.id = "u1"
-    return account
+def test_notion_page_is_marked_bound_from_persisted_document(
+    flask_app_with_containers: Flask,
+    db_session_with_containers: Session,
+) -> None:
+    tenant_id = str(uuid4())
+    dataset_id = str(uuid4())
+    account = Account(name="Test User", email="user@example.com")
+    account.id = str(uuid4())
+    document = Document(
+        tenant_id=tenant_id,
+        dataset_id=dataset_id,
+        position=1,
+        data_source_type=DataSourceType.NOTION_IMPORT,
+        data_source_info='{"notion_page_id": "page-1"}',
+        batch=f"batch-{uuid4()}",
+        name="Notion Page",
+        created_from=DocumentCreatedFrom.WEB,
+        created_by=str(uuid4()),
+        indexing_status=IndexingStatus.COMPLETED,
+        enabled=True,
+    )
+    db_session_with_containers.add(document)
+    db_session_with_containers.commit()
+    runtime = MagicMock(
+        get_online_document_pages=lambda **_kwargs: iter(
+            [
+                MagicMock(
+                    result=[
+                        MagicMock(
+                            workspace_id="workspace-1",
+                            workspace_name="Workspace",
+                            workspace_icon=None,
+                            pages=[
+                                MagicMock(
+                                    page_id="page-1",
+                                    page_name="Page",
+                                    type="page",
+                                    parent_id="parent",
+                                    page_icon=None,
+                                )
+                            ],
+                        )
+                    ]
+                )
+            ]
+        ),
+        datasource_provider_type=lambda: None,
+    )
 
-
-@pytest.fixture
-def mock_engine() -> Iterator[None]:
-    with patch.object(
-        type(data_source.db),
-        "engine",
-        new_callable=PropertyMock,
-        return_value=MagicMock(),
+    with (
+        flask_app_with_containers.test_request_context(f"/?credential_id=c1&dataset_id={dataset_id}"),
+        patch(
+            "controllers.console.datasets.data_source.DatasourceProviderService.get_datasource_credentials",
+            return_value={"token": "token"},
+        ),
+        patch(
+            "controllers.console.datasets.data_source.DatasetService.get_dataset",
+            return_value=MagicMock(data_source_type="notion_import"),
+        ),
+        patch(
+            "core.datasource.datasource_manager.DatasourceManager.get_datasource_runtime",
+            return_value=runtime,
+        ),
     ):
-        yield
-
-
-class TestDataSourceApi:
-    @pytest.fixture
-    def app(self, flask_app_with_containers: Flask) -> Flask:
-        return flask_app_with_containers
-
-    def test_get_success(self, app: Flask) -> None:
-        api = DataSourceApi()
-        method = inspect.unwrap(api.get)
-
-        binding = DataSourceOauthBinding(
-            tenant_id="tenant-1",
-            access_token="token",
-            provider="notion",
-            source_info={
-                "workspace_name": "Workspace",
-                "workspace_id": "workspace-1",
-                "workspace_icon": None,
-                "total": 1,
-                "pages": [
-                    {
-                        "page_id": "page-1",
-                        "page_name": "Page",
-                        "page_icon": {"type": "emoji", "emoji": "P", "url": None},
-                        "parent_id": "parent-1",
-                        "type": "page",
-                    }
-                ],
-            },
-        )
-        binding.id = "b1"
-        binding.created_at = datetime(2026, 5, 25, 1, 2, 3, tzinfo=UTC)
-        binding.disabled = False
-
-        with (
-            app.test_request_context("/"),
-            patch(
-                "controllers.console.datasets.data_source.db.session.scalars",
-                return_value=MagicMock(all=lambda: [binding]),
-            ),
-        ):
-            response, status = method(api, "tenant-1")
-
-        assert status == 200
-        assert response["data"][0] == {
-            "id": "b1",
-            "provider": "notion",
-            "created_at": 1779670923,
-            "is_bound": True,
-            "disabled": False,
-            "source_info": {
-                "workspace_name": "Workspace",
-                "workspace_id": "workspace-1",
-                "workspace_icon": None,
-                "pages": [
-                    {
-                        "page_name": "Page",
-                        "page_id": "page-1",
-                        "page_icon": {"type": "emoji", "url": None, "emoji": "P"},
-                        "parent_id": "parent-1",
-                        "type": "page",
-                    }
-                ],
-                "total": 1,
-            },
-            "link": "http://localhost/console/api/oauth/data-source/notion",
-        }
-
-    def test_get_no_bindings(self, app: Flask) -> None:
-        api = DataSourceApi()
-        method = inspect.unwrap(api.get)
-
-        with (
-            app.test_request_context("/"),
-            patch(
-                "controllers.console.datasets.data_source.db.session.scalars",
-                return_value=MagicMock(all=lambda: []),
-            ),
-        ):
-            response, status = method(api, "tenant-1")
-
-        assert status == 200
-        assert response["data"] == []
-
-    def test_patch_enable_binding(self, app: Flask) -> None:
-        api = DataSourceApi()
-        method = inspect.unwrap(api.patch)
-
-        binding = MagicMock(id="b1", disabled=True)
-        session = MagicMock()
-        session.scalar.return_value = binding
-
-        with app.test_request_context("/"):
-            response, status = method(api, session, "tenant-1", "b1", "enable")
-
-        assert status == 200
-        assert binding.disabled is False
-
-    def test_patch_disable_binding(self, app: Flask) -> None:
-        api = DataSourceApi()
-        method = inspect.unwrap(api.patch)
-
-        binding = MagicMock(id="b1", disabled=False)
-        session = MagicMock()
-        session.scalar.return_value = binding
-
-        with app.test_request_context("/"):
-            response, status = method(api, session, "tenant-1", "b1", "disable")
-
-        assert status == 200
-        assert binding.disabled is True
-
-    def test_patch_binding_not_found(self, app: Flask) -> None:
-        api = DataSourceApi()
-        method = inspect.unwrap(api.patch)
-        session = MagicMock()
-        session.scalar.return_value = None
-
-        with app.test_request_context("/"):
-            with pytest.raises(NotFound):
-                method(api, session, "tenant-1", "b1", "enable")
-
-    def test_patch_enable_already_enabled(self, app: Flask) -> None:
-        api = DataSourceApi()
-        method = inspect.unwrap(api.patch)
-
-        binding = MagicMock(id="b1", disabled=False)
-        session = MagicMock()
-        session.scalar.return_value = binding
-
-        with app.test_request_context("/"):
-            with pytest.raises(ValueError):
-                method(api, session, "tenant-1", "b1", "enable")
-
-    def test_patch_disable_already_disabled(self, app: Flask) -> None:
-        api = DataSourceApi()
-        method = inspect.unwrap(api.patch)
-
-        binding = MagicMock(id="b1", disabled=True)
-        session = MagicMock()
-        session.scalar.return_value = binding
-
-        with app.test_request_context("/"):
-            with pytest.raises(ValueError):
-                method(api, session, "tenant-1", "b1", "disable")
-
-
-class TestDataSourceNotionListApi:
-    @pytest.fixture
-    def app(self, flask_app_with_containers: Flask) -> Flask:
-        return flask_app_with_containers
-
-    def test_get_credential_not_found(self, app: Flask, current_user: Account) -> None:
-        api = DataSourceNotionListApi()
-        method = inspect.unwrap(api.get)
-
-        with (
-            app.test_request_context("/?credential_id=c1"),
-            patch(
-                "controllers.console.datasets.data_source.DatasourceProviderService.get_datasource_credentials",
-                return_value=None,
-            ),
-        ):
-            with pytest.raises(NotFound):
-                method(api, MagicMock(), "tenant-1", current_user)
-
-    def test_get_success_no_dataset_id(self, app: Flask, current_user: Account, mock_engine: None) -> None:
-        api = DataSourceNotionListApi()
-        method = inspect.unwrap(api.get)
-
-        page = MagicMock(
-            page_id="p1",
-            page_name="Page 1",
-            type="page",
-            parent_id="parent",
-            page_icon=None,
+        response, status = unwrap(DataSourceNotionListApi().get)(
+            DataSourceNotionListApi(), db_session_with_containers, tenant_id, account
         )
 
-        online_document_message = MagicMock(
-            result=[
-                MagicMock(
-                    workspace_id="w1",
-                    workspace_name="My Workspace",
-                    workspace_icon="icon",
-                    pages=[page],
-                )
-            ]
-        )
-
-        with (
-            app.test_request_context("/?credential_id=c1"),
-            patch(
-                "controllers.console.datasets.data_source.DatasourceProviderService.get_datasource_credentials",
-                return_value={"token": "t"},
-            ),
-            patch(
-                "core.datasource.datasource_manager.DatasourceManager.get_datasource_runtime",
-                return_value=MagicMock(
-                    get_online_document_pages=lambda **kw: iter([online_document_message]),
-                    datasource_provider_type=lambda: None,
-                ),
-            ),
-        ):
-            response, status = method(api, MagicMock(), "tenant-1", current_user)
-
-        assert status == 200
-
-    def test_get_success_with_dataset_id(
-        self, app: Flask, current_user: Account, mock_engine: None, db_session_with_containers: Session
-    ) -> None:
-        api = DataSourceNotionListApi()
-        method = inspect.unwrap(api.get)
-        tenant_id = str(uuid4())
-        dataset_id = str(uuid4())
-
-        page = MagicMock(
-            page_id="p1",
-            page_name="Page 1",
-            type="page",
-            parent_id="parent",
-            page_icon=None,
-        )
-
-        online_document_message = MagicMock(
-            result=[
-                MagicMock(
-                    workspace_id="w1",
-                    workspace_name="My Workspace",
-                    workspace_icon="icon",
-                    pages=[page],
-                )
-            ]
-        )
-
-        dataset = MagicMock(data_source_type="notion_import")
-        document = Document(
-            tenant_id=tenant_id,
-            dataset_id=dataset_id,
-            position=1,
-            data_source_type=DataSourceType.NOTION_IMPORT,
-            data_source_info='{"notion_page_id": "p1"}',
-            batch=f"batch-{uuid4()}",
-            name="Notion Page",
-            created_from=DocumentCreatedFrom.WEB,
-            created_by=str(uuid4()),
-            indexing_status=IndexingStatus.COMPLETED,
-            enabled=True,
-        )
-        db_session_with_containers.add(document)
-        db_session_with_containers.commit()
-
-        with (
-            app.test_request_context(f"/?credential_id=c1&dataset_id={dataset_id}"),
-            patch(
-                "controllers.console.datasets.data_source.DatasourceProviderService.get_datasource_credentials",
-                return_value={"token": "t"},
-            ),
-            patch(
-                "controllers.console.datasets.data_source.DatasetService.get_dataset",
-                return_value=dataset,
-            ),
-            patch(
-                "core.datasource.datasource_manager.DatasourceManager.get_datasource_runtime",
-                return_value=MagicMock(
-                    get_online_document_pages=lambda **kw: iter([online_document_message]),
-                    datasource_provider_type=lambda: None,
-                ),
-            ),
-        ):
-            response, status = method(api, db_session_with_containers, tenant_id, current_user)
-
-        assert status == 200
-
-    def test_get_invalid_dataset_type(self, app: Flask, current_user: Account, mock_engine: None) -> None:
-        api = DataSourceNotionListApi()
-        method = inspect.unwrap(api.get)
-
-        dataset = MagicMock(data_source_type="other_type")
-
-        with (
-            app.test_request_context("/?credential_id=c1&dataset_id=ds1"),
-            patch(
-                "controllers.console.datasets.data_source.DatasourceProviderService.get_datasource_credentials",
-                return_value={"token": "t"},
-            ),
-            patch(
-                "controllers.console.datasets.data_source.DatasetService.get_dataset",
-                return_value=dataset,
-            ),
-        ):
-            with pytest.raises(ValueError):
-                method(api, MagicMock(), "tenant-1", current_user)
-
-
-class TestDataSourceNotionPreviewApi:
-    @pytest.fixture
-    def app(self, flask_app_with_containers: Flask) -> Flask:
-        return flask_app_with_containers
-
-    def test_get_preview_success(self, app: Flask) -> None:
-        api = DataSourceNotionPreviewApi()
-        method = inspect.unwrap(api.get)
-
-        extractor = MagicMock(extract=lambda: [MagicMock(page_content="hello")])
-
-        with (
-            app.test_request_context("/?credential_id=c1"),
-            patch(
-                "controllers.console.datasets.data_source.DatasourceProviderService.get_datasource_credentials",
-                return_value={"integration_secret": "t"},
-            ),
-            patch(
-                "controllers.console.datasets.data_source.NotionExtractor",
-                return_value=extractor,
-            ),
-        ):
-            response, status = method(api, "tenant-1", "p1", "page")
-
-        assert status == 200
-
-
-class TestDataSourceNotionIndexingEstimateApi:
-    @pytest.fixture
-    def app(self, flask_app_with_containers: Flask) -> Flask:
-        return flask_app_with_containers
-
-    def test_post_indexing_estimate_success(self, app: Flask) -> None:
-        api = DataSourceNotionIndexingEstimateApi()
-        method = inspect.unwrap(api.post)
-
-        empty_rules: dict[str, object] = {}
-        payload: dict[str, object] = {
-            "notion_info_list": [
-                {
-                    "workspace_id": "w1",
-                    "credential_id": "c1",
-                    "pages": [{"page_id": "p1", "type": "page"}],
-                }
-            ],
-            "process_rule": {"rules": empty_rules},
-            "doc_form": IndexStructureType.PARAGRAPH_INDEX,
-            "doc_language": "English",
-        }
-
-        with (
-            app.test_request_context("/", method="POST", json=payload, headers={"Content-Type": "application/json"}),
-            patch(
-                "controllers.console.datasets.data_source.DocumentService.estimate_args_validate",
-            ),
-            patch(
-                "controllers.console.datasets.data_source.IndexingRunner.indexing_estimate",
-                return_value=MagicMock(model_dump=lambda: {"total_pages": 1}),
-            ),
-        ):
-            response, status = method(api, MagicMock(), "tenant-1")
-
-        assert status == 200
-
-
-class TestDataSourceNotionDatasetSyncApi:
-    @pytest.fixture
-    def app(self, flask_app_with_containers: Flask) -> Flask:
-        return flask_app_with_containers
-
-    def test_get_success(self, app: Flask) -> None:
-        api = DataSourceNotionDatasetSyncApi()
-        method = inspect.unwrap(api.get)
-
-        with (
-            app.test_request_context("/"),
-            patch(
-                "controllers.console.datasets.data_source.DatasetService.get_dataset",
-                return_value=MagicMock(),
-            ),
-            patch(
-                "controllers.console.datasets.data_source.DocumentService.get_document_by_dataset_id",
-                return_value=[MagicMock(id="d1")],
-            ),
-            patch(
-                "controllers.console.datasets.data_source.document_indexing_sync_task.delay",
-                return_value=None,
-            ),
-        ):
-            response, status = method(api, MagicMock(), "ds-1")
-
-        assert status == 200
-
-    def test_get_dataset_not_found(self, app: Flask) -> None:
-        api = DataSourceNotionDatasetSyncApi()
-        method = inspect.unwrap(api.get)
-
-        with (
-            app.test_request_context("/"),
-            patch(
-                "controllers.console.datasets.data_source.DatasetService.get_dataset",
-                return_value=None,
-            ),
-        ):
-            with pytest.raises(NotFound):
-                method(api, MagicMock(), "ds-1")
-
-
-class TestDataSourceNotionDocumentSyncApi:
-    @pytest.fixture
-    def app(self, flask_app_with_containers: Flask) -> Flask:
-        return flask_app_with_containers
-
-    def test_get_success(self, app: Flask) -> None:
-        api = DataSourceNotionDocumentSyncApi()
-        method = inspect.unwrap(api.get)
-
-        with (
-            app.test_request_context("/"),
-            patch(
-                "controllers.console.datasets.data_source.DatasetService.get_dataset",
-                return_value=MagicMock(),
-            ),
-            patch(
-                "controllers.console.datasets.data_source.DocumentService.get_document",
-                return_value=MagicMock(),
-            ),
-            patch(
-                "controllers.console.datasets.data_source.document_indexing_sync_task.delay",
-                return_value=None,
-            ),
-        ):
-            response, status = method(api, MagicMock(), "ds-1", "doc-1")
-
-        assert status == 200
-
-    def test_get_document_not_found(self, app: Flask) -> None:
-        api = DataSourceNotionDocumentSyncApi()
-        method = inspect.unwrap(api.get)
-
-        with (
-            app.test_request_context("/"),
-            patch(
-                "controllers.console.datasets.data_source.DatasetService.get_dataset",
-                return_value=MagicMock(),
-            ),
-            patch(
-                "controllers.console.datasets.data_source.DocumentService.get_document",
-                return_value=None,
-            ),
-        ):
-            with pytest.raises(NotFound):
-                method(api, MagicMock(), "ds-1", "doc-1")
+    assert status == 200
+    assert response["notion_info"][0]["pages"][0]["is_bound"] is True

api/tests/test_containers_integration_tests/services/test_messages_clean_service.py

@@ -4,7 +4,7 @@ import datetime
 import json
 import uuid
 from decimal import Decimal
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
 
 import pytest
 from faker import Faker
@@ -1172,65 +1172,8 @@ class TestMessagesCleanServiceIntegration:
         # Verify all messages were deleted
         assert db_session_with_containers.query(Message).where(Message.id.in_(msg_ids)).count() == 0
 
-    def test_from_time_range_validation(self):
-        """Test that from_time_range raises ValueError for invalid inputs."""
-        policy = MagicMock(spec=BillingDisabledPolicy)
-        now = datetime.datetime.now()
-
-        with pytest.raises(ValueError, match="start_from .* must be less than end_before"):
-            MessagesCleanService.from_time_range(policy, now, now)
-
-        with pytest.raises(ValueError, match="batch_size .* must be greater than 0"):
-            MessagesCleanService.from_time_range(policy, now - datetime.timedelta(days=1), now, batch_size=0)
-
-    def test_from_time_range_success(self):
-        """Test that from_time_range creates a service with correct parameters."""
-        policy = MagicMock(spec=BillingDisabledPolicy)
-        start = datetime.datetime(2024, 1, 1)
-        end = datetime.datetime(2024, 2, 1)
-
-        service = MessagesCleanService.from_time_range(policy, start, end)
-        assert service._start_from == start
-        assert service._end_before == end
-
-    def test_from_days_validation(self):
-        """Test that from_days raises ValueError for invalid inputs."""
-        policy = MagicMock(spec=BillingDisabledPolicy)
-
-        with pytest.raises(ValueError, match="days .* must be greater than or equal to 0"):
-            MessagesCleanService.from_days(policy, days=-1)
-
-        with pytest.raises(ValueError, match="batch_size .* must be greater than 0"):
-            MessagesCleanService.from_days(policy, days=30, batch_size=0)
-
-    def test_from_days_success(self):
-        """Test that from_days creates a service with correct parameters."""
-        policy = MagicMock(spec=BillingDisabledPolicy)
-
-        with patch("services.retention.conversation.messages_clean_service.naive_utc_now") as mock_now:
-            fixed_now = datetime.datetime(2024, 6, 1)
-            mock_now.return_value = fixed_now
-
-            service = MessagesCleanService.from_days(policy, days=10)
-            assert service._start_from is None
-            assert service._end_before == fixed_now - datetime.timedelta(days=10)
-
     def test_batch_delete_message_relations_empty(self, db_session_with_containers: Session):
         """Test that batch_delete_message_relations with empty list does nothing."""
         # Get execute call count before
         MessagesCleanService._batch_delete_message_relations(db_session_with_containers, [])
         # No exception means success — empty list is a no-op
-
-    def test_run_calls_clean_messages(self):
-        """Test that run() delegates to _clean_messages_by_time_range."""
-        policy = MagicMock(spec=BillingDisabledPolicy)
-        service = MessagesCleanService(
-            policy=policy,
-            end_before=datetime.datetime.now(),
-            batch_size=10,
-        )
-        with patch.object(service, "_clean_messages_by_time_range") as mock_clean:
-            mock_clean.return_value = {"total_deleted": 5}
-            result = service.run()
-            assert result == {"total_deleted": 5}
-            mock_clean.assert_called_once()

api/tests/unit_tests/commands/test_legacy_model_type_migration.py

@@ -6,6 +6,7 @@ import json
 import os
 import threading
 import time
+from collections.abc import Iterator
 from datetime import datetime, timedelta
 from pathlib import Path
 from types import SimpleNamespace
@@ -15,9 +16,12 @@ import pytest
 import sqlalchemy as sa
 from click.testing import CliRunner
 from sqlalchemy.exc import OperationalError
+from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
 
 from graphon.model_runtime.entities.model_entities import ModelType
+from models import Dataset, DatasetPermission, DatasetPermissionEnum
 from models.account import Tenant
+from models.base import TypeBase
 from models.enums import CredentialSourceType
 from models.provider import ProviderModel
 from tests.helpers.legacy_model_type_migration import (
@@ -59,6 +63,40 @@ def command_module():
         )
 
 
+@pytest.fixture
+def rbac_session(sqlite_engine: sa.Engine, monkeypatch: pytest.MonkeyPatch) -> Iterator[Session]:
+    """Bind RBAC command reads to persisted SQLite dataset rows."""
+
+    TypeBase.metadata.create_all(
+        sqlite_engine,
+        tables=[Dataset.__table__, DatasetPermission.__table__],
+    )
+    factory = sessionmaker(bind=sqlite_engine, expire_on_commit=False)
+    monkeypatch.setattr("commands.rbac.session_factory.create_session", factory)
+    with factory() as session:
+        yield session
+
+
+def _persist_dataset(
+    session: Session,
+    *,
+    dataset_id: str = "dataset-1",
+    tenant_id: str = "tenant-1",
+    permission: DatasetPermissionEnum = DatasetPermissionEnum.ONLY_ME,
+    created_by: str = "creator-account-1",
+) -> Dataset:
+    dataset = Dataset(
+        id=dataset_id,
+        tenant_id=tenant_id,
+        name=f"Dataset {dataset_id}",
+        permission=permission,
+        created_by=created_by,
+    )
+    session.add(dataset)
+    session.commit()
+    return dataset
+
+
 def _parse_json_lines(output: io.StringIO) -> list[dict[str, object]]:
     return [json.loads(line) for line in output.getvalue().splitlines() if line.strip()]
 
@@ -363,56 +401,35 @@ def test_dataset_permission_rbac_migration_maps_legacy_permissions_to_enum_scope
 
 def test_dataset_permission_rbac_migration_uses_dataset_creator_as_operator(
     command_module,
+    rbac_session: Session,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     rbac_module = importlib.import_module("commands.rbac")
-    dataset_row = SimpleNamespace(
-        id="dataset-1",
-        tenant_id="tenant-1",
-        permission="only_me",
-        created_by="creator-account-1",
-    )
-    execute_results = [[dataset_row], [], []]
+    _persist_dataset(rbac_session)
     calls: list[dict[str, object]] = []
-    session_closed = False
-
-    class FakeExecuteResult:
-        def __init__(self, rows: list[object]) -> None:
-            self._rows = rows
-
-        def all(self) -> list[object]:
-            return self._rows
-
-    class FakeSession:
-        def __enter__(self):
-            return self
-
-        def __exit__(self, exc_type, exc, traceback) -> None:
-            nonlocal session_closed
-            session_closed = True
-            pass
-
-        def execute(self, stmt):
-            return FakeExecuteResult(execute_results.pop(0))
-
-    class FakeSessionFactory:
-        @staticmethod
-        def create_session() -> FakeSession:
-            return FakeSession()
+    read_transaction_ended = False
 
     def fake_replace_whitelist(**kwargs):
-        assert session_closed is True
+        assert read_transaction_ended is True
         calls.append(kwargs)
 
-    monkeypatch.setattr(rbac_module, "session_factory", FakeSessionFactory)
-    monkeypatch.setattr(rbac_module.RBACService.DatasetAccess, "replace_whitelist", fake_replace_whitelist)
+    def _record_transaction_end(session: Session, transaction: object) -> None:
+        nonlocal read_transaction_ended
+        del transaction
+        if session.get_bind() is rbac_session.get_bind():
+            read_transaction_ended = True
 
-    command_module.migrate_dataset_permissions_to_rbac.callback(
-        tenant_id=None,
-        dataset_id=None,
-        batch_size=500,
-        dry_run=False,
-    )
+    sa.event.listen(Session, "after_transaction_end", _record_transaction_end)
+    monkeypatch.setattr(rbac_module.RBACService.DatasetAccess, "replace_whitelist", fake_replace_whitelist)
+    try:
+        command_module.migrate_dataset_permissions_to_rbac.callback(
+            tenant_id=None,
+            dataset_id=None,
+            batch_size=500,
+            dry_run=False,
+        )
+    finally:
+        sa.event.remove(Session, "after_transaction_end", _record_transaction_end)
 
     assert calls[0]["tenant_id"] == "tenant-1"
     assert calls[0]["account_id"] == "creator-account-1"
@@ -422,41 +439,19 @@ def test_dataset_permission_rbac_migration_uses_dataset_creator_as_operator(
 
 def test_dataset_permission_rbac_migration_dry_run_outputs_structured_proposed_changes(
     command_module,
+    rbac_session: Session,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     rbac_module = importlib.import_module("commands.rbac")
-    dataset_row = SimpleNamespace(
-        id="dataset-1",
-        tenant_id="tenant-1",
-        permission="partial_members",
-        created_by="creator-account-1",
+    dataset = _persist_dataset(rbac_session, permission=DatasetPermissionEnum.PARTIAL_TEAM)
+    rbac_session.add(
+        DatasetPermission(
+            dataset_id=dataset.id,
+            account_id="member-account-1",
+            tenant_id=dataset.tenant_id,
+        )
     )
-    permission_row = SimpleNamespace(dataset_id="dataset-1", account_id="member-account-1")
-    execute_results = [[dataset_row], [permission_row], []]
-
-    class FakeExecuteResult:
-        def __init__(self, rows: list[object]) -> None:
-            self._rows = rows
-
-        def all(self) -> list[object]:
-            return self._rows
-
-    class FakeSession:
-        def __enter__(self):
-            return self
-
-        def __exit__(self, exc_type, exc, traceback) -> None:
-            pass
-
-        def execute(self, stmt):
-            return FakeExecuteResult(execute_results.pop(0))
-
-    class FakeSessionFactory:
-        @staticmethod
-        def create_session() -> FakeSession:
-            return FakeSession()
-
-    monkeypatch.setattr(rbac_module, "session_factory", FakeSessionFactory)
+    rbac_session.commit()
     monkeypatch.setattr(
         rbac_module.RBACService.DatasetAccess,
         "replace_whitelist",
@@ -1306,50 +1301,36 @@ def test_provider_models_processing_uses_same_plan_locking_and_transaction_entry
     begin_calls: list[str] = []
     configure_calls: list[str] = []
 
-    class _FakeBeginContext:
-        def __init__(self, phase: str) -> None:
-            self._phase = phase
+    def _record_begin(session: Session, transaction: SessionTransaction) -> None:
+        if session.get_bind() is sqlite_engine and transaction.parent is None:
+            begin_calls.append(current_phase["name"])
 
-        def __enter__(self) -> None:
-            begin_calls.append(self._phase)
-
-        def __exit__(self, exc_type, exc, tb) -> bool:
-            return False
-
-    class _FakeSession:
-        def __init__(self, phase: str) -> None:
-            self._phase = phase
-
-        def __enter__(self):
-            return self
-
-        def __exit__(self, exc_type, exc, tb) -> bool:
-            return False
-
-        def begin(self) -> _FakeBeginContext:
-            return _FakeBeginContext(self._phase)
-
-    def _fake_session_factory(engine: sa.Engine) -> _FakeSession:
-        return _FakeSession(current_phase["name"])
-
-    def _fake_build_plan(self, session, candidate, *, lock_rows: bool):
+    def _fake_build_plan(self, session: Session, candidate, *, lock_rows: bool):
+        assert session.get_bind() is sqlite_engine
         lock_rows_seen.append((current_phase["name"], lock_rows))
-        return SimpleNamespace(group_row_ids=[str(candidate.row.id)], winner=None, loser_rows=[])
+        return migration_module._ProviderModelGroupPlan(
+            group_row_ids=[str(candidate.row.id)],
+            winner=None,
+            loser_rows=[],
+        )
 
     def _fake_emit_plan(self, plan, *, session, tx_id: str, business_key: dict[str, object]) -> None:
         return None
 
-    def _fake_configure(self, session) -> None:
+    def _fake_configure(self, session: Session) -> None:
+        assert session.get_bind() is sqlite_engine
         configure_calls.append(current_phase["name"])
 
-    monkeypatch.setattr(migration_module, "_session_factory", _fake_session_factory)
     monkeypatch.setattr(migration_module.Migration, "_build_provider_model_group_plan", _fake_build_plan)
     monkeypatch.setattr(migration_module.Migration, "_emit_provider_model_group_plan", _fake_emit_plan)
     monkeypatch.setattr(migration_module.Migration, "_configure_lock_timeout", _fake_configure)
-
-    dry_migration._process_provider_model_group(candidate, business_key)
-    current_phase["name"] = "apply"
-    apply_migration._process_provider_model_group(candidate, business_key)
+    sa.event.listen(Session, "after_transaction_create", _record_begin)
+    try:
+        dry_migration._process_provider_model_group(candidate, business_key)
+        current_phase["name"] = "apply"
+        apply_migration._process_provider_model_group(candidate, business_key)
+    finally:
+        sa.event.remove(Session, "after_transaction_create", _record_begin)
 
     assert [phase for phase, _ in lock_rows_seen] == ["dry", "apply"]
     assert lock_rows_seen[0][1] == lock_rows_seen[1][1]
@@ -1392,6 +1373,22 @@ def test_process_load_balancing_model_config_row_logs_stacktrace_for_lock_timeou
     sqlite_engine: sa.Engine,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
+    create_minimal_legacy_model_type_schema(sqlite_engine)
+    created_at = datetime(2025, 1, 1, 12, 0, 0)
+    _insert_load_balancing_model_config(
+        sqlite_engine,
+        row_id="40000000-0000-0000-0000-000000000001",
+        tenant_id="tenant-1",
+        provider_name="openai",
+        model_name="gpt-4o-mini",
+        model_type="text-generation",
+        name="credential",
+        encrypted_config="{}",
+        credential_id="50000000-0000-0000-0000-000000000001",
+        enabled=True,
+        created_at=created_at,
+        updated_at=created_at,
+    )
     output = io.StringIO()
     migration = migration_module.Migration(
         tenant_id="tenant-1",
@@ -1401,37 +1398,18 @@ def test_process_load_balancing_model_config_row_logs_stacktrace_for_lock_timeou
         model_types=(ModelType.LLM,),
         orm_models=(migration_module.LoadBalancingModelConfig,),
     )
-    candidate = migration_module._RowWithRawModelType(
-        row=SimpleNamespace(id="lb-row-1"),
-        raw_model_type="text-generation",
-        canonical_model_type=ModelType.LLM,
-    )
+    candidate = migration._load_load_balancing_model_config_candidates(None)[0]
     lock_timeout_exc = OperationalError("SELECT 1", {}, SimpleNamespace(pgcode="55P03"))
+    transaction_begins = 0
 
-    class _FakeBeginContext:
-        def __enter__(self) -> None:
-            return None
-
-        def __exit__(self, exc_type, exc, tb) -> bool:
-            return False
-
-    class _FakeSession:
-        def __enter__(self):
-            return self
-
-        def __exit__(self, exc_type, exc, tb) -> bool:
-            return False
-
-        def begin(self) -> _FakeBeginContext:
-            return _FakeBeginContext()
-
-    def _fake_session_factory(engine: sa.Engine) -> _FakeSession:
-        return _FakeSession()
+    def _record_begin(session: Session, transaction: SessionTransaction) -> None:
+        nonlocal transaction_begins
+        if session.get_bind() is sqlite_engine and transaction.parent is None:
+            transaction_begins += 1
 
     def _fake_reload(self, session, original_candidate, *, lock_rows: bool):
         raise lock_timeout_exc
 
-    monkeypatch.setattr(migration_module, "_session_factory", _fake_session_factory)
     monkeypatch.setattr(migration_module.Migration, "_configure_lock_timeout", lambda self, session: None)
     monkeypatch.setattr(
         migration_module.Migration,
@@ -1439,17 +1417,22 @@ def test_process_load_balancing_model_config_row_logs_stacktrace_for_lock_timeou
         _fake_reload,
     )
 
-    migration._process_load_balancing_model_config_row(candidate)
+    sa.event.listen(Session, "after_transaction_create", _record_begin)
+    try:
+        migration._process_load_balancing_model_config_row(candidate)
+    finally:
+        sa.event.remove(Session, "after_transaction_create", _record_begin)
 
     lines = _parse_json_lines(output)
     assert len(lines) == 1
     assert lines[0]["event"] == "lock_timeout_skipped"
     attrs = cast(dict[str, object], lines[0]["attrs"])
     assert attrs["table_name"] == "load_balancing_model_configs"
-    assert attrs["id"] == "lb-row-1"
+    assert attrs["id"] == str(candidate.row.id)
     assert attrs["error"] == str(lock_timeout_exc)
     assert isinstance(attrs["stacktrace"], str)
     assert "OperationalError" in attrs["stacktrace"]
+    assert transaction_begins == 1
 
 
 def test_process_load_balancing_model_config_row_logs_update_after_sql_execution(
@@ -1457,6 +1440,23 @@ def test_process_load_balancing_model_config_row_logs_update_after_sql_execution
     sqlite_engine: sa.Engine,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
+    create_minimal_legacy_model_type_schema(sqlite_engine)
+    created_at = datetime(2025, 1, 1, 12, 0, 0)
+    row_id = "40000000-0000-0000-0000-000000000002"
+    _insert_load_balancing_model_config(
+        sqlite_engine,
+        row_id=row_id,
+        tenant_id="tenant-1",
+        provider_name="openai",
+        model_name="gpt-4o-mini",
+        model_type="text-generation",
+        name="credential",
+        encrypted_config="{}",
+        credential_id="50000000-0000-0000-0000-000000000002",
+        enabled=True,
+        created_at=created_at,
+        updated_at=created_at,
+    )
     migration = migration_module.Migration(
         tenant_id="tenant-1",
         engine=sqlite_engine,
@@ -1465,42 +1465,33 @@ def test_process_load_balancing_model_config_row_logs_update_after_sql_execution
         model_types=(ModelType.LLM,),
         orm_models=(migration_module.LoadBalancingModelConfig,),
     )
-    candidate = migration_module._RowWithRawModelType(
-        row=SimpleNamespace(id="lb-row-1"),
-        raw_model_type="text-generation",
-        canonical_model_type=ModelType.LLM,
-    )
+    candidate = migration._load_load_balancing_model_config_candidates(None)[0]
     action_log: list[str] = []
 
-    class _FakeBeginContext:
-        def __enter__(self) -> None:
+    def _record_begin(session: Session, transaction: SessionTransaction) -> None:
+        if session.get_bind() is sqlite_engine and transaction.parent is None:
             action_log.append("begin")
 
-        def __exit__(self, exc_type, exc, tb) -> bool:
-            return False
-
-    class _FakeSession:
-        def __enter__(self):
-            return self
-
-        def __exit__(self, exc_type, exc, tb) -> bool:
-            return False
-
-        def begin(self) -> _FakeBeginContext:
-            return _FakeBeginContext()
-
-        def execute(self, stmt) -> None:
+    def _record_sql(
+        connection: sa.Connection,
+        cursor: object,
+        statement: str,
+        parameters: object,
+        context: object,
+        executemany: bool,
+    ) -> None:
+        del connection, cursor, parameters, context, executemany
+        if statement.lstrip().upper().startswith("UPDATE"):
             action_log.append("sql_execute")
 
-    def _fake_session_factory(engine: sa.Engine) -> _FakeSession:
-        return _FakeSession()
-
     def _fake_configure(self, session) -> None:
         action_log.append("configure_lock_timeout")
 
-    def _fake_reload(self, session, original_candidate, *, lock_rows: bool):
+    original_reload = migration_module.Migration._reload_load_balancing_model_config_candidate
+
+    def _record_reload(self, session: Session, original_candidate, *, lock_rows: bool):
         action_log.append(f"reload_candidate:{lock_rows}")
-        return candidate
+        return original_reload(self, session, original_candidate, lock_rows=lock_rows)
 
     def _fake_log_row_updated(self, *args, **kwargs) -> None:
         action_log.append("log_row_updated")
@@ -1508,12 +1499,11 @@ def test_process_load_balancing_model_config_row_logs_update_after_sql_execution
     def _fake_cache_cleanup(self, *, row_id: str, tx_id: str) -> None:
         action_log.append("cache_cleanup")
 
-    monkeypatch.setattr(migration_module, "_session_factory", _fake_session_factory)
     monkeypatch.setattr(migration_module.Migration, "_configure_lock_timeout", _fake_configure)
     monkeypatch.setattr(
         migration_module.Migration,
         "_reload_load_balancing_model_config_candidate",
-        _fake_reload,
+        _record_reload,
     )
     monkeypatch.setattr(migration_module.Migration, "_log_row_updated", _fake_log_row_updated)
     monkeypatch.setattr(
@@ -1522,7 +1512,13 @@ def test_process_load_balancing_model_config_row_logs_update_after_sql_execution
         _fake_cache_cleanup,
     )
 
-    migration._process_load_balancing_model_config_row(candidate)
+    sa.event.listen(Session, "after_transaction_create", _record_begin)
+    sa.event.listen(sqlite_engine, "before_cursor_execute", _record_sql)
+    try:
+        migration._process_load_balancing_model_config_row(candidate)
+    finally:
+        sa.event.remove(sqlite_engine, "before_cursor_execute", _record_sql)
+        sa.event.remove(Session, "after_transaction_create", _record_begin)
 
     assert action_log == [
         "begin",
@@ -1532,6 +1528,10 @@ def test_process_load_balancing_model_config_row_logs_update_after_sql_execution
         "log_row_updated",
         "cache_cleanup",
     ]
+    with Session(sqlite_engine) as session:
+        persisted = session.get(migration_module.LoadBalancingModelConfig, row_id)
+        assert persisted is not None
+        assert persisted.model_type == ModelType.LLM
 
 
 def test_load_balancing_model_config_cache_delete_failure_logs_stacktrace(

api/tests/unit_tests/controllers/console/app/test_audio.py

@@ -321,6 +321,33 @@ def test_console_text_api_builds_message_ref(app: Flask, monkeypatch: pytest.Mon
     assert calls["message_ref"] == MessageRef(AppRef("tenant-1", "app-1"), "message-1", account_id="account-1")
 
 
+def test_console_text_api_accepts_message_id_without_text(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
+    calls = {}
+    monkeypatch.setattr(AudioService, "transcript_tts", lambda **kwargs: calls.update(kwargs) or {"audio": "ok"})
+
+    api = ChatMessageTextApi()
+    handler = unwrap(api.post)
+    app_model = SimpleNamespace(id="app-1", tenant_id="tenant-1")
+
+    with (
+        app.test_request_context(
+            "/console/api/apps/app/text-to-audio",
+            method="POST",
+            json={"message_id": "0f67f8c5-8f7c-4ebd-b549-7ac8e972d37e", "streaming": True},
+        ),
+        patch("controllers.console.app.audio.current_user", SimpleNamespace(id="account-1")),
+    ):
+        response = handler(api, app_model=app_model)
+
+    assert response == {"audio": "ok"}
+    assert calls["text"] == ""
+    assert calls["message_ref"] == MessageRef(
+        AppRef("tenant-1", "app-1"),
+        "0f67f8c5-8f7c-4ebd-b549-7ac8e972d37e",
+        account_id="account-1",
+    )
+
+
 def test_console_text_api_error_mapping(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr(AudioService, "transcript_tts", lambda **_kwargs: (_ for _ in ()).throw(QuotaExceededError()))
 

api/tests/unit_tests/controllers/console/datasets/test_data_source.py

@@ -1,18 +1,22 @@
 from __future__ import annotations
 
 import inspect
-from collections.abc import Callable
+from collections.abc import Callable, Iterator
 from datetime import UTC, datetime
-from typing import cast
+from typing import Literal, cast
 from unittest.mock import MagicMock, PropertyMock, patch
-from uuid import uuid4
+from uuid import UUID
 
 import pytest
 from flask import Flask
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+from werkzeug.exceptions import NotFound
 
 from controllers.console.datasets import data_source as module
 from controllers.console.datasets.data_source import DataSourceApi, DataSourceNotionListApi
 from models import Account, DataSourceOauthBinding
+from models.engine import db
 
 ControllerMethod = Callable[..., tuple[dict[str, object], int]]
 
@@ -22,10 +26,15 @@ def unwrap(func: object) -> ControllerMethod:
 
 
 @pytest.fixture
-def flask_app() -> Flask:
+def flask_app() -> Iterator[Flask]:
     app = Flask(__name__)
     app.config["TESTING"] = True
-    return app
+    app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:"
+    db.init_app(app)
+
+    with app.app_context():
+        DataSourceOauthBinding.__table__.create(db.engine)
+        yield app
 
 
 @pytest.fixture
@@ -35,9 +44,13 @@ def current_user() -> Account:
     return account
 
 
-def test_get_data_source_integrates_serializes_orm_binding(flask_app: Flask) -> None:
+TENANT_ID = "11111111-1111-1111-1111-111111111111"
+BINDING_ID = "22222222-2222-2222-2222-222222222222"
+
+
+def _add_binding(session: Session, *, disabled: bool) -> DataSourceOauthBinding:
     binding = DataSourceOauthBinding(
-        tenant_id="tenant-1",
+        tenant_id=TENANT_ID,
         access_token="token",
         provider="notion",
         source_info={
@@ -55,24 +68,31 @@ def test_get_data_source_integrates_serializes_orm_binding(flask_app: Flask) ->
                 }
             ],
         },
+        disabled=disabled,
     )
-    binding.id = "binding-1"
+    binding.id = BINDING_ID
     binding.created_at = datetime(2026, 5, 25, 1, 2, 3, tzinfo=UTC)
-    binding.disabled = False
+    session.add(binding)
+    session.commit()
+    return binding
 
-    with (
-        flask_app.test_request_context("/"),
-        patch.object(module.db.session, "scalars", return_value=MagicMock(all=lambda: [binding])),
-    ):
-        response, status = unwrap(DataSourceApi().get)(DataSourceApi(), "tenant-1")
+
+def test_get_data_source_integrates_serializes_orm_binding(
+    flask_app: Flask,
+) -> None:
+    binding = _add_binding(db.session, disabled=False)
+    expected_created_at = int(binding.created_at.timestamp())
+
+    with flask_app.test_request_context("/"):
+        response, status = unwrap(DataSourceApi().get)(DataSourceApi(), TENANT_ID)
 
     assert status == 200
     assert response == {
         "data": [
             {
-                "id": "binding-1",
+                "id": BINDING_ID,
                 "provider": "notion",
-                "created_at": 1779670923,
+                "created_at": expected_created_at,
                 "is_bound": True,
                 "disabled": False,
                 "source_info": {
@@ -96,34 +116,75 @@ def test_get_data_source_integrates_serializes_orm_binding(flask_app: Flask) ->
     }
 
 
-def test_get_data_source_integrates_preserves_empty_list_when_no_binding(flask_app: Flask) -> None:
-    with (
-        flask_app.test_request_context("/"),
-        patch.object(module.db.session, "scalars", return_value=MagicMock(all=lambda: [])),
-    ):
-        response, status = unwrap(DataSourceApi().get)(DataSourceApi(), "tenant-1")
+def test_get_data_source_integrates_preserves_empty_list_when_no_binding(
+    flask_app: Flask,
+) -> None:
+    with flask_app.test_request_context("/"):
+        response, status = unwrap(DataSourceApi().get)(DataSourceApi(), TENANT_ID)
 
     assert status == 200
     assert response == {"data": []}
 
 
-def test_patch_data_source_binding_uses_injected_session(flask_app: Flask) -> None:
-    binding = MagicMock(disabled=True)
-    session = MagicMock()
-    session.scalar.return_value = binding
+@pytest.mark.parametrize(
+    ("disabled", "action", "expected_disabled"),
+    [(True, "enable", False), (False, "disable", True)],
+)
+@pytest.mark.parametrize("sqlite_session", [(DataSourceOauthBinding,)], indirect=True)
+def test_patch_data_source_binding_updates_state(
+    flask_app: Flask,
+    sqlite_session: Session,
+    disabled: bool,
+    action: Literal["enable", "disable"],
+    expected_disabled: bool,
+) -> None:
+    _add_binding(sqlite_session, disabled=disabled)
+    sqlite_session.expunge_all()
 
     with flask_app.test_request_context("/"):
-        response, status = unwrap(DataSourceApi().patch)(DataSourceApi(), session, "tenant-1", uuid4(), "enable")
+        response, status = unwrap(DataSourceApi().patch)(
+            DataSourceApi(), sqlite_session, TENANT_ID, UUID(BINDING_ID), action
+        )
 
+    sqlite_session.flush()
+    sqlite_session.expire_all()
+    binding = sqlite_session.scalar(select(DataSourceOauthBinding).where(DataSourceOauthBinding.id == BINDING_ID))
     assert status == 200
     assert response == {"result": "success"}
-    assert binding.disabled is False
-    session.scalar.assert_called_once()
-    session.add.assert_not_called()
-    session.commit.assert_not_called()
+    assert binding is not None
+    assert binding.disabled is expected_disabled
 
 
-def test_notion_pre_import_pages_serializes_frontend_list_shape(flask_app: Flask, current_user: Account) -> None:
+@pytest.mark.parametrize("sqlite_session", [(DataSourceOauthBinding,)], indirect=True)
+def test_patch_data_source_binding_rejects_unknown_binding(
+    flask_app: Flask,
+    sqlite_session: Session,
+) -> None:
+    with flask_app.test_request_context("/"), pytest.raises(NotFound, match="Data source binding not found"):
+        unwrap(DataSourceApi().patch)(DataSourceApi(), sqlite_session, TENANT_ID, UUID(BINDING_ID), "enable")
+
+
+@pytest.mark.parametrize(("disabled", "action"), [(False, "enable"), (True, "disable")])
+@pytest.mark.parametrize("sqlite_session", [(DataSourceOauthBinding,)], indirect=True)
+def test_patch_data_source_binding_rejects_current_state(
+    flask_app: Flask,
+    sqlite_session: Session,
+    disabled: bool,
+    action: Literal["enable", "disable"],
+) -> None:
+    _add_binding(sqlite_session, disabled=disabled)
+    sqlite_session.expunge_all()
+
+    with flask_app.test_request_context("/"), pytest.raises(ValueError):
+        unwrap(DataSourceApi().patch)(DataSourceApi(), sqlite_session, TENANT_ID, UUID(BINDING_ID), action)
+
+
+@pytest.mark.parametrize("sqlite_session", [()], indirect=True)
+def test_notion_pre_import_pages_serializes_frontend_list_shape(
+    flask_app: Flask,
+    current_user: Account,
+    sqlite_session: Session,
+) -> None:
     page = MagicMock(
         page_id="page-1",
         page_name="Page",
@@ -145,8 +206,6 @@ def test_notion_pre_import_pages_serializes_frontend_list_shape(flask_app: Flask
         get_online_document_pages=MagicMock(return_value=iter([online_document_message])),
         datasource_provider_type=MagicMock(return_value="online_document"),
     )
-    session = MagicMock()
-
     with (
         flask_app.test_request_context("/?credential_id=credential-1"),
         patch.object(
@@ -158,7 +217,7 @@ def test_notion_pre_import_pages_serializes_frontend_list_shape(flask_app: Flask
         patch("core.datasource.datasource_manager.DatasourceManager.get_datasource_runtime", return_value=runtime),
     ):
         response, status = unwrap(DataSourceNotionListApi().get)(
-            DataSourceNotionListApi(), session, "tenant-1", current_user
+            DataSourceNotionListApi(), sqlite_session, "tenant-1", current_user
         )
 
     assert status == 200
@@ -183,3 +242,38 @@ def test_notion_pre_import_pages_serializes_frontend_list_shape(flask_app: Flask
     }
     runtime.get_online_document_pages.assert_called_once()
     assert runtime.get_online_document_pages.call_args.kwargs["datasource_parameters"] == {}
+
+
+@pytest.mark.parametrize("sqlite_session", [()], indirect=True)
+def test_notion_pre_import_pages_rejects_missing_credential(
+    flask_app: Flask,
+    current_user: Account,
+    sqlite_session: Session,
+) -> None:
+    with (
+        flask_app.test_request_context("/?credential_id=credential-1"),
+        patch.object(module.DatasourceProviderService, "get_datasource_credentials", return_value=None),
+        pytest.raises(NotFound, match="Credential not found"),
+    ):
+        unwrap(DataSourceNotionListApi().get)(DataSourceNotionListApi(), sqlite_session, TENANT_ID, current_user)
+
+
+@pytest.mark.parametrize("sqlite_session", [()], indirect=True)
+def test_notion_pre_import_pages_rejects_non_notion_dataset(
+    flask_app: Flask,
+    current_user: Account,
+    sqlite_session: Session,
+) -> None:
+    dataset = MagicMock(data_source_type="other_type")
+
+    with (
+        flask_app.test_request_context("/?credential_id=credential-1&dataset_id=dataset-1"),
+        patch.object(
+            module.DatasourceProviderService,
+            "get_datasource_credentials",
+            return_value={"token": "token"},
+        ),
+        patch.object(module.DatasetService, "get_dataset", return_value=dataset),
+        pytest.raises(ValueError, match="Dataset is not notion type"),
+    ):
+        unwrap(DataSourceNotionListApi().get)(DataSourceNotionListApi(), sqlite_session, TENANT_ID, current_user)

api/tests/unit_tests/controllers/console/datasets/test_data_source_notion_apis.py

@@ -0,0 +1,171 @@
+"""Unit tests for controllers.console.datasets.data_source Notion endpoints."""
+
+from __future__ import annotations
+
+import inspect
+from unittest.mock import MagicMock, patch
+
+import pytest
+from flask import Flask
+from sqlalchemy.orm import Session
+from werkzeug.exceptions import NotFound
+
+from controllers.console.datasets.data_source import (
+    DataSourceNotionDatasetSyncApi,
+    DataSourceNotionDocumentSyncApi,
+    DataSourceNotionIndexingEstimateApi,
+    DataSourceNotionPreviewApi,
+)
+from core.rag.index_processor.constant.index_type import IndexStructureType
+from models import Account
+
+
+@pytest.fixture
+def current_user() -> Account:
+    account = Account(name="Test User", email="u1@example.com")
+    account.id = "u1"
+    return account
+
+
+class TestDataSourceNotionPreviewApi:
+    def test_get_preview_success(self, app: Flask) -> None:
+        api = DataSourceNotionPreviewApi()
+        method = inspect.unwrap(api.get)
+
+        extractor = MagicMock(extract=lambda: [MagicMock(page_content="hello")])
+
+        with (
+            app.test_request_context("/?credential_id=c1"),
+            patch(
+                "controllers.console.datasets.data_source.DatasourceProviderService.get_datasource_credentials",
+                return_value={"integration_secret": "t"},
+            ),
+            patch(
+                "controllers.console.datasets.data_source.NotionExtractor",
+                return_value=extractor,
+            ),
+        ):
+            response, status = method(api, "tenant-1", "p1", "page")
+
+        assert status == 200
+
+
+class TestDataSourceNotionIndexingEstimateApi:
+    @pytest.mark.parametrize("sqlite_session", [()], indirect=True)
+    def test_post_indexing_estimate_success(self, app: Flask, sqlite_session: Session) -> None:
+        api = DataSourceNotionIndexingEstimateApi()
+        method = inspect.unwrap(api.post)
+
+        empty_rules: dict[str, object] = {}
+        payload: dict[str, object] = {
+            "notion_info_list": [
+                {
+                    "workspace_id": "w1",
+                    "credential_id": "c1",
+                    "pages": [{"page_id": "p1", "type": "page"}],
+                }
+            ],
+            "process_rule": {"rules": empty_rules},
+            "doc_form": IndexStructureType.PARAGRAPH_INDEX,
+            "doc_language": "English",
+        }
+
+        with (
+            app.test_request_context("/", method="POST", json=payload, headers={"Content-Type": "application/json"}),
+            patch(
+                "controllers.console.datasets.data_source.DocumentService.estimate_args_validate",
+            ),
+            patch(
+                "controllers.console.datasets.data_source.IndexingRunner.indexing_estimate",
+                return_value=MagicMock(model_dump=lambda: {"total_pages": 1}),
+            ),
+        ):
+            response, status = method(api, sqlite_session, "tenant-1")
+
+        assert status == 200
+
+
+class TestDataSourceNotionDatasetSyncApi:
+    @pytest.mark.parametrize("sqlite_session", [()], indirect=True)
+    def test_get_success(self, app: Flask, sqlite_session: Session) -> None:
+        api = DataSourceNotionDatasetSyncApi()
+        method = inspect.unwrap(api.get)
+
+        with (
+            app.test_request_context("/"),
+            patch(
+                "controllers.console.datasets.data_source.DatasetService.get_dataset",
+                return_value=MagicMock(),
+            ),
+            patch(
+                "controllers.console.datasets.data_source.DocumentService.get_document_by_dataset_id",
+                return_value=[MagicMock(id="d1")],
+            ),
+            patch(
+                "controllers.console.datasets.data_source.document_indexing_sync_task.delay",
+                return_value=None,
+            ),
+        ):
+            response, status = method(api, sqlite_session, "ds-1")
+
+        assert status == 200
+
+    @pytest.mark.parametrize("sqlite_session", [()], indirect=True)
+    def test_get_dataset_not_found(self, app: Flask, sqlite_session: Session) -> None:
+        api = DataSourceNotionDatasetSyncApi()
+        method = inspect.unwrap(api.get)
+
+        with (
+            app.test_request_context("/"),
+            patch(
+                "controllers.console.datasets.data_source.DatasetService.get_dataset",
+                return_value=None,
+            ),
+        ):
+            with pytest.raises(NotFound):
+                method(api, sqlite_session, "ds-1")
+
+
+class TestDataSourceNotionDocumentSyncApi:
+    @pytest.mark.parametrize("sqlite_session", [()], indirect=True)
+    def test_get_success(self, app: Flask, sqlite_session: Session) -> None:
+        api = DataSourceNotionDocumentSyncApi()
+        method = inspect.unwrap(api.get)
+
+        with (
+            app.test_request_context("/"),
+            patch(
+                "controllers.console.datasets.data_source.DatasetService.get_dataset",
+                return_value=MagicMock(),
+            ),
+            patch(
+                "controllers.console.datasets.data_source.DocumentService.get_document",
+                return_value=MagicMock(),
+            ),
+            patch(
+                "controllers.console.datasets.data_source.document_indexing_sync_task.delay",
+                return_value=None,
+            ),
+        ):
+            response, status = method(api, sqlite_session, "ds-1", "doc-1")
+
+        assert status == 200
+
+    @pytest.mark.parametrize("sqlite_session", [()], indirect=True)
+    def test_get_document_not_found(self, app: Flask, sqlite_session: Session) -> None:
+        api = DataSourceNotionDocumentSyncApi()
+        method = inspect.unwrap(api.get)
+
+        with (
+            app.test_request_context("/"),
+            patch(
+                "controllers.console.datasets.data_source.DatasetService.get_dataset",
+                return_value=MagicMock(),
+            ),
+            patch(
+                "controllers.console.datasets.data_source.DocumentService.get_document",
+                return_value=None,
+            ),
+        ):
+            with pytest.raises(NotFound):
+                method(api, sqlite_session, "ds-1", "doc-1")

api/tests/unit_tests/controllers/service_api/app/test_message.py

@@ -15,12 +15,15 @@ Focus on:
 """
 
 import uuid
+from collections.abc import Iterator
 from inspect import unwrap
 from types import SimpleNamespace
 from unittest.mock import Mock, patch
 
 import pytest
 from flask import Flask
+from sqlalchemy import Engine
+from sqlalchemy.orm import Session
 from werkzeug.exceptions import BadRequest, InternalServerError, NotFound
 
 from controllers.service_api.app.error import NotChatAppError
@@ -44,6 +47,14 @@ from services.errors.message import (
 from services.message_service import MessageService
 
 
+@pytest.fixture
+def orm_session(sqlite_engine: Engine) -> Iterator[Session]:
+    """Provide a real caller-owned session for MessageService interface tests."""
+
+    with Session(sqlite_engine, expire_on_commit=False) as session:
+        yield session
+
+
 class TestMessageListQuery:
     """Test suite for MessageListQuery Pydantic model."""
 
@@ -253,7 +264,7 @@ class TestMessageService:
         assert callable(MessageService.get_suggested_questions_after_answer)
 
     @patch.object(MessageService, "pagination_by_first_id")
-    def test_pagination_by_first_id_returns_pagination_result(self, mock_pagination):
+    def test_pagination_by_first_id_returns_pagination_result(self, mock_pagination, orm_session: Session):
         """Test pagination_by_first_id returns expected format."""
         mock_result = Mock()
         mock_result.data = []
@@ -267,7 +278,7 @@ class TestMessageService:
             conversation_id=str(uuid.uuid4()),
             first_id=None,
             limit=20,
-            session=Mock(),
+            session=orm_session,
         )
 
         assert hasattr(result, "data")
@@ -275,7 +286,7 @@ class TestMessageService:
         assert hasattr(result, "has_more")
 
     @patch.object(MessageService, "pagination_by_first_id")
-    def test_pagination_raises_conversation_not_exists_error(self, mock_pagination):
+    def test_pagination_raises_conversation_not_exists_error(self, mock_pagination, orm_session: Session):
         """Test pagination raises ConversationNotExistsError."""
         import services.errors.conversation
 
@@ -288,11 +299,11 @@ class TestMessageService:
                 conversation_id="invalid_id",
                 first_id=None,
                 limit=20,
-                session=Mock(),
+                session=orm_session,
             )
 
     @patch.object(MessageService, "pagination_by_first_id")
-    def test_pagination_raises_first_message_not_exists_error(self, mock_pagination):
+    def test_pagination_raises_first_message_not_exists_error(self, mock_pagination, orm_session: Session):
         """Test pagination raises FirstMessageNotExistsError."""
         mock_pagination.side_effect = FirstMessageNotExistsError()
 
@@ -303,11 +314,11 @@ class TestMessageService:
                 conversation_id=str(uuid.uuid4()),
                 first_id="invalid_first_id",
                 limit=20,
-                session=Mock(),
+                session=orm_session,
             )
 
     @patch.object(MessageService, "create_feedback")
-    def test_create_feedback_with_rating_and_content(self, mock_create_feedback):
+    def test_create_feedback_with_rating_and_content(self, mock_create_feedback, orm_session: Session):
         """Test create_feedback with rating and content."""
         mock_create_feedback.return_value = None
 
@@ -317,13 +328,13 @@ class TestMessageService:
             user=Mock(spec=EndUser),
             rating=FeedbackRating.LIKE,
             content="Great response!",
-            session=Mock(),
+            session=orm_session,
         )
 
         mock_create_feedback.assert_called_once()
 
     @patch.object(MessageService, "create_feedback")
-    def test_create_feedback_raises_message_not_exists_error(self, mock_create_feedback):
+    def test_create_feedback_raises_message_not_exists_error(self, mock_create_feedback, orm_session: Session):
         """Test create_feedback raises MessageNotExistsError."""
         mock_create_feedback.side_effect = MessageNotExistsError()
 
@@ -334,11 +345,11 @@ class TestMessageService:
                 user=Mock(spec=EndUser),
                 rating=FeedbackRating.LIKE,
                 content=None,
-                session=Mock(),
+                session=orm_session,
             )
 
     @patch.object(MessageService, "get_all_messages_feedbacks")
-    def test_get_all_messages_feedbacks_returns_list(self, mock_get_feedbacks):
+    def test_get_all_messages_feedbacks_returns_list(self, mock_get_feedbacks, orm_session: Session):
         """Test get_all_messages_feedbacks returns list of feedbacks."""
         mock_feedbacks = [
             {"message_id": str(uuid.uuid4()), "rating": "like"},
@@ -346,13 +357,15 @@ class TestMessageService:
         ]
         mock_get_feedbacks.return_value = mock_feedbacks
 
-        result = MessageService.get_all_messages_feedbacks(app_model=Mock(spec=App), page=1, limit=20, session=Mock())
+        result = MessageService.get_all_messages_feedbacks(
+            app_model=Mock(spec=App), page=1, limit=20, session=orm_session
+        )
 
         assert len(result) == 2
         assert result[0]["rating"] == "like"
 
     @patch.object(MessageService, "get_suggested_questions_after_answer")
-    def test_get_suggested_questions_returns_questions_list(self, mock_get_questions):
+    def test_get_suggested_questions_returns_questions_list(self, mock_get_questions, orm_session: Session):
         """Test get_suggested_questions_after_answer returns list of questions."""
         mock_questions = ["What about this aspect?", "Can you elaborate on that?", "How does this relate to...?"]
         mock_get_questions.return_value = mock_questions
@@ -362,14 +375,14 @@ class TestMessageService:
             user=Mock(spec=EndUser),
             message_id=str(uuid.uuid4()),
             invoke_from=Mock(),
-            session=Mock(),
+            session=orm_session,
         )
 
         assert len(result) == 3
         assert isinstance(result[0], str)
 
     @patch.object(MessageService, "get_suggested_questions_after_answer")
-    def test_get_suggested_questions_raises_disabled_error(self, mock_get_questions):
+    def test_get_suggested_questions_raises_disabled_error(self, mock_get_questions, orm_session: Session):
         """Test get_suggested_questions_after_answer raises SuggestedQuestionsAfterAnswerDisabledError."""
         mock_get_questions.side_effect = SuggestedQuestionsAfterAnswerDisabledError()
 
@@ -379,11 +392,11 @@ class TestMessageService:
                 user=Mock(spec=EndUser),
                 message_id=str(uuid.uuid4()),
                 invoke_from=Mock(),
-                session=Mock(),
+                session=orm_session,
             )
 
     @patch.object(MessageService, "get_suggested_questions_after_answer")
-    def test_get_suggested_questions_raises_message_not_exists_error(self, mock_get_questions):
+    def test_get_suggested_questions_raises_message_not_exists_error(self, mock_get_questions, orm_session: Session):
         """Test get_suggested_questions_after_answer raises MessageNotExistsError."""
         mock_get_questions.side_effect = MessageNotExistsError()
 
@@ -393,7 +406,7 @@ class TestMessageService:
                 user=Mock(spec=EndUser),
                 message_id="invalid_message_id",
                 invoke_from=Mock(),
-                session=Mock(),
+                session=orm_session,
             )
 
 

api/tests/unit_tests/controllers/service_api/dataset/rag_pipeline/test_rag_pipeline_workflow.py

@@ -24,6 +24,7 @@ from unittest.mock import Mock, patch
 
 import pytest
 from flask import Flask
+from sqlalchemy.orm import Session
 from werkzeug.datastructures import FileStorage
 from werkzeug.exceptions import Forbidden, NotFound
 
@@ -38,6 +39,7 @@ from controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow import (
 )
 from core.app.entities.app_invoke_entities import InvokeFrom
 from models.account import Account
+from models.dataset import Dataset
 from services.errors.file import FileTooLargeError, UnsupportedFileTypeError
 from services.rag_pipeline.entity.pipeline_service_api_entities import (
     DatasourceNodeRunApiEntity,
@@ -46,6 +48,20 @@ from services.rag_pipeline.entity.pipeline_service_api_entities import (
 from services.rag_pipeline.rag_pipeline import RagPipelineService
 
 
+def _persist_dataset(session: Session, *, tenant_id: str, dataset_id: str) -> Dataset:
+    dataset = Dataset(
+        id=dataset_id,
+        tenant_id=tenant_id,
+        name="Pipeline dataset",
+        created_by="account-1",
+        data_source_type=None,
+        indexing_technique=None,
+    )
+    session.add(dataset)
+    session.commit()
+    return dataset
+
+
 class TestDatasourceNodeRunPayload:
     """Test suite for DatasourceNodeRunPayload Pydantic model."""
 
@@ -550,13 +566,15 @@ class TestPipelineRunApiPost:
     )
     @patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.RagPipelineService")
     @patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.service_api_ns")
-    def test_post_success_streaming(self, mock_ns, mock_svc_cls, mock_current_user, mock_gen_svc, mock_helper, app):
+    @pytest.mark.parametrize("sqlite_session", [(Dataset,)], indirect=True)
+    def test_post_success_streaming(
+        self, mock_ns, mock_svc_cls, mock_current_user, mock_gen_svc, mock_helper, app, sqlite_session: Session
+    ):
         """Test successful pipeline run with streaming response."""
         tenant_id = str(uuid.uuid4())
         dataset_id = str(uuid.uuid4())
 
-        session = Mock()
-        session.scalar.return_value = Mock()
+        _persist_dataset(sqlite_session, tenant_id=tenant_id, dataset_id=dataset_id)
 
         mock_ns.payload = {
             "inputs": {"key": "val"},
@@ -577,33 +595,33 @@ class TestPipelineRunApiPost:
 
         with app.test_request_context("/datasets/test/pipeline/run", method="POST"):
             api = PipelineRunApi()
-            response = api.post.__wrapped__(api, session, tenant_id=tenant_id, dataset_id=dataset_id)
+            response = api.post.__wrapped__(api, sqlite_session, tenant_id=tenant_id, dataset_id=dataset_id)
 
         assert response == {"result": "ok"}
-        mock_svc_cls.assert_called_once_with(session)
+        mock_svc_cls.assert_called_once_with(sqlite_session)
         mock_gen_svc.generate.assert_called_once()
 
-    def test_post_not_found(self, app: Flask):
+    @pytest.mark.parametrize("sqlite_session", [(Dataset,)], indirect=True)
+    def test_post_not_found(self, app: Flask, sqlite_session: Session):
         """Test NotFound when dataset check fails."""
-        session = Mock()
-        session.scalar.return_value = None
-
         with app.test_request_context("/datasets/test/pipeline/run", method="POST"):
             api = PipelineRunApi()
             with pytest.raises(NotFound):
                 api.post.__wrapped__(
                     api,
-                    session,
+                    sqlite_session,
                     tenant_id=str(uuid.uuid4()),
                     dataset_id=str(uuid.uuid4()),
                 )
 
     @patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.current_user", new="not_account")
     @patch("controllers.service_api.dataset.rag_pipeline.rag_pipeline_workflow.service_api_ns")
-    def test_post_forbidden_non_account_user(self, mock_ns, app: Flask):
+    @pytest.mark.parametrize("sqlite_session", [(Dataset,)], indirect=True)
+    def test_post_forbidden_non_account_user(self, mock_ns, app: Flask, sqlite_session: Session):
         """Test Forbidden when current_user is not an Account."""
-        session = Mock()
-        session.scalar.return_value = Mock()
+        tenant_id = str(uuid.uuid4())
+        dataset_id = str(uuid.uuid4())
+        _persist_dataset(sqlite_session, tenant_id=tenant_id, dataset_id=dataset_id)
         mock_ns.payload = {
             "inputs": {},
             "datasource_type": "online_document",
@@ -618,9 +636,9 @@ class TestPipelineRunApiPost:
             with pytest.raises(Forbidden):
                 api.post.__wrapped__(
                     api,
-                    session,
-                    tenant_id=str(uuid.uuid4()),
-                    dataset_id=str(uuid.uuid4()),
+                    sqlite_session,
+                    tenant_id=tenant_id,
+                    dataset_id=dataset_id,
                 )
 
 

api/tests/unit_tests/controllers/service_api/test_wraps.py

@@ -3,10 +3,13 @@ Unit tests for Service API wraps (authentication decorators)
 """
 
 import uuid
+from types import SimpleNamespace
 from unittest.mock import MagicMock, Mock, patch
 
 import pytest
 from flask import Flask
+from sqlalchemy import select
+from sqlalchemy.orm import Session
 from werkzeug.exceptions import Forbidden, NotFound, Unauthorized
 
 from controllers.service_api.wraps import (
@@ -21,12 +24,11 @@ from controllers.service_api.wraps import (
     validate_dataset_token,
 )
 from enums.cloud_plan import CloudPlan
-from models.account import TenantStatus
-from models.model import ApiToken
-from tests.unit_tests.conftest import (
-    setup_mock_dataset_owner_execute_result,
-    setup_mock_tenant_owner_execute_result,
-)
+from models import Account, Tenant, TenantAccountJoin
+from models.account import TenantAccountRole
+from models.dataset import Dataset, RateLimitLog
+from models.enums import ApiTokenType
+from models.model import ApiToken, App, AppMode, IconType
 
 
 def _configure_current_app_mock(mock_current_app):
@@ -34,6 +36,51 @@ def _configure_current_app_mock(mock_current_app):
     mock_current_app._get_current_object = Mock(return_value=Mock())
 
 
+def _session_proxy(session: Session) -> MagicMock:
+    """Emulate Flask-SQLAlchemy's callable scoped-session proxy around a test session."""
+    proxy = MagicMock(wraps=session)
+    proxy.return_value = session
+    return proxy
+
+
+def _api_token(*, tenant_id: str, app_id: str | None = None, token_type: ApiTokenType) -> ApiToken:
+    return ApiToken(
+        id=str(uuid.uuid4()),
+        tenant_id=tenant_id,
+        app_id=app_id,
+        type=token_type,
+        token="test_token",
+    )
+
+
+def _persist_workspace(session: Session) -> tuple[Tenant, Account, TenantAccountJoin]:
+    tenant = Tenant(name="Workspace")
+    account = Account(name="Owner", email=f"owner-{uuid.uuid4()}@example.com")
+    membership = TenantAccountJoin(
+        tenant_id=tenant.id,
+        account_id=account.id,
+        current=True,
+        role=TenantAccountRole.OWNER,
+    )
+    session.add_all([tenant, account, membership])
+    session.commit()
+    return tenant, account, membership
+
+
+def _app_model(*, tenant_id: str, enable_api: bool = True) -> App:
+    return App(
+        id=str(uuid.uuid4()),
+        tenant_id=tenant_id,
+        name="Service API App",
+        mode=AppMode.CHAT,
+        icon_type=IconType.EMOJI,
+        icon="chat",
+        icon_background="#FFFFFF",
+        enable_site=False,
+        enable_api=enable_api,
+    )
+
+
 class TestValidateAndGetApiToken:
     """Test suite for validate_and_get_api_token function"""
 
@@ -70,21 +117,24 @@ class TestValidateAndGetApiToken:
     def test_valid_token_returns_api_token(self, mock_fetch_token, mock_cache_cls, mock_record_usage, app: Flask):
         """Test that valid token returns the ApiToken object."""
         # Arrange
-        mock_api_token = Mock(spec=ApiToken)
-        mock_api_token.token = "valid_token_123"
-        mock_api_token.type = "app"
+        api_token = _api_token(
+            tenant_id=str(uuid.uuid4()),
+            app_id=str(uuid.uuid4()),
+            token_type=ApiTokenType.APP,
+        )
+        api_token.token = "valid_token_123"
 
         mock_cache_instance = Mock()
         mock_cache_instance.get.return_value = None  # Cache miss
         mock_cache_cls.get = mock_cache_instance.get
-        mock_fetch_token.return_value = mock_api_token
+        mock_fetch_token.return_value = api_token
 
         # Act
         with app.test_request_context("/", method="GET", headers={"Authorization": "Bearer valid_token_123"}):
             result = validate_and_get_api_token("app")
 
         # Assert
-        assert result == mock_api_token
+        assert result == api_token
 
     @patch("controllers.service_api.wraps.record_token_usage")
     @patch("controllers.service_api.wraps.ApiTokenCache")
@@ -117,116 +167,124 @@ class TestValidateAppToken:
         return app
 
     @patch("controllers.service_api.wraps.user_logged_in")
-    @patch("controllers.service_api.wraps.db")
     @patch("controllers.service_api.wraps.validate_and_get_api_token")
     @patch("controllers.service_api.wraps.current_app")
+    @pytest.mark.parametrize(
+        "sqlite_session",
+        [(App, ApiToken, Tenant, Account, TenantAccountJoin)],
+        indirect=True,
+    )
     def test_valid_app_token_allows_access(
-        self, mock_current_app, mock_validate_token, mock_db, mock_user_logged_in, app
+        self,
+        mock_current_app,
+        mock_validate_token,
+        mock_user_logged_in,
+        app: Flask,
+        sqlite_session: Session,
     ):
         """Test that valid app token allows access to decorated view."""
         # Arrange
         _configure_current_app_mock(mock_current_app)
 
-        mock_api_token = Mock()
-        mock_api_token.app_id = str(uuid.uuid4())
-        mock_api_token.tenant_id = str(uuid.uuid4())
-        mock_validate_token.return_value = mock_api_token
-
-        mock_app = Mock()
-        mock_app.id = mock_api_token.app_id
-        mock_app.status = "normal"
-        mock_app.enable_api = True
-        mock_app.tenant_id = mock_api_token.tenant_id
-
-        mock_tenant = Mock()
-        mock_tenant.status = TenantStatus.NORMAL
-        mock_tenant.id = mock_api_token.tenant_id
-
-        mock_account = Mock()
-        mock_account.id = str(uuid.uuid4())
-
-        # Use side_effect to return app first, then tenant via session.get()
-        mock_db.session.get.side_effect = [mock_app, mock_tenant]
-
-        # Mock the tenant owner execute result (execute(select(...)).one_or_none())
-        setup_mock_tenant_owner_execute_result(mock_db, mock_tenant, mock_account)
+        tenant, account, _ = _persist_workspace(sqlite_session)
+        app_model = _app_model(tenant_id=tenant.id)
+        api_token = _api_token(tenant_id=tenant.id, app_id=app_model.id, token_type=ApiTokenType.APP)
+        sqlite_session.add_all([app_model, api_token])
+        sqlite_session.commit()
+        mock_validate_token.return_value = api_token
 
         @validate_app_token
         def protected_view(app_model):
             return {"success": True, "app_id": app_model.id}
 
         # Act
-        with app.test_request_context("/", method="GET", headers={"Authorization": "Bearer test_token"}):
+        with (
+            app.test_request_context("/", method="GET", headers={"Authorization": "Bearer test_token"}),
+            patch("controllers.service_api.wraps.db.session", _session_proxy(sqlite_session)),
+        ):
             result = protected_view()
 
         # Assert
         assert result["success"] is True
-        assert result["app_id"] == mock_app.id
+        assert result["app_id"] == app_model.id
+        assert account.current_tenant_id == tenant.id
 
-    @patch("controllers.service_api.wraps.db")
     @patch("controllers.service_api.wraps.validate_and_get_api_token")
-    def test_app_not_found_raises_forbidden(self, mock_validate_token, mock_db, app: Flask):
+    @pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
+    def test_app_not_found_raises_forbidden(self, mock_validate_token, app: Flask, sqlite_session: Session):
         """Test that Forbidden is raised when app no longer exists."""
         # Arrange
-        mock_api_token = Mock()
-        mock_api_token.app_id = str(uuid.uuid4())
-        mock_validate_token.return_value = mock_api_token
-
-        mock_db.session.get.return_value = None
+        api_token = _api_token(
+            tenant_id=str(uuid.uuid4()),
+            app_id=str(uuid.uuid4()),
+            token_type=ApiTokenType.APP,
+        )
+        mock_validate_token.return_value = api_token
 
         @validate_app_token
         def protected_view(**kwargs):
             return {"success": True}
 
         # Act & Assert
-        with app.test_request_context("/", method="GET"):
+        with (
+            app.test_request_context("/", method="GET"),
+            patch("controllers.service_api.wraps.db.session", sqlite_session),
+        ):
             with pytest.raises(Forbidden) as exc_info:
                 protected_view()
             assert "no longer exists" in str(exc_info.value)
 
-    @patch("controllers.service_api.wraps.db")
     @patch("controllers.service_api.wraps.validate_and_get_api_token")
-    def test_app_status_abnormal_raises_forbidden(self, mock_validate_token, mock_db, app: Flask):
+    @pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
+    def test_app_status_abnormal_raises_forbidden(self, mock_validate_token, app: Flask, sqlite_session: Session):
         """Test that Forbidden is raised when app status is abnormal."""
         # Arrange
-        mock_api_token = Mock()
-        mock_api_token.app_id = str(uuid.uuid4())
-        mock_validate_token.return_value = mock_api_token
-
-        mock_app = Mock()
-        mock_app.status = "abnormal"
-        mock_db.session.get.return_value = mock_app
+        app_model = _app_model(tenant_id=str(uuid.uuid4()))
+        sqlite_session.add(app_model)
+        sqlite_session.commit()
+        app_model.status = "abnormal"
+        mock_validate_token.return_value = _api_token(
+            tenant_id=app_model.tenant_id,
+            app_id=app_model.id,
+            token_type=ApiTokenType.APP,
+        )
 
         @validate_app_token
         def protected_view(**kwargs):
             return {"success": True}
 
         # Act & Assert
-        with app.test_request_context("/", method="GET"):
+        with (
+            app.test_request_context("/", method="GET"),
+            patch("controllers.service_api.wraps.db.session", sqlite_session),
+        ):
             with pytest.raises(Forbidden) as exc_info:
                 protected_view()
             assert "status is abnormal" in str(exc_info.value)
 
-    @patch("controllers.service_api.wraps.db")
     @patch("controllers.service_api.wraps.validate_and_get_api_token")
-    def test_app_api_disabled_raises_forbidden(self, mock_validate_token, mock_db, app: Flask):
+    @pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
+    def test_app_api_disabled_raises_forbidden(self, mock_validate_token, app: Flask, sqlite_session: Session):
         """Test that Forbidden is raised when app API is disabled."""
         # Arrange
-        mock_api_token = Mock()
-        mock_api_token.app_id = str(uuid.uuid4())
-        mock_validate_token.return_value = mock_api_token
-
-        mock_app = Mock()
-        mock_app.status = "normal"
-        mock_app.enable_api = False
-        mock_db.session.get.return_value = mock_app
+        app_model = _app_model(tenant_id=str(uuid.uuid4()), enable_api=False)
+        sqlite_session.add(app_model)
+        sqlite_session.commit()
+        mock_validate_token.return_value = _api_token(
+            tenant_id=app_model.tenant_id,
+            app_id=app_model.id,
+            token_type=ApiTokenType.APP,
+        )
 
         @validate_app_token
         def protected_view(**kwargs):
             return {"success": True}
 
         # Act & Assert
-        with app.test_request_context("/", method="GET"):
+        with (
+            app.test_request_context("/", method="GET"),
+            patch("controllers.service_api.wraps.db.session", sqlite_session),
+        ):
             with pytest.raises(Forbidden) as exc_info:
                 protected_view()
             assert "API service has been disabled" in str(exc_info.value)
@@ -468,26 +526,35 @@ class TestCloudEditionBillingRateLimitCheck:
 
     @patch("controllers.service_api.wraps.validate_and_get_api_token")
     @patch("controllers.service_api.wraps.FeatureService.get_knowledge_rate_limit")
-    @patch("controllers.service_api.wraps.db")
-    @patch("controllers.service_api.wraps.sessionmaker")
+    @pytest.mark.parametrize("sqlite_session", [(RateLimitLog,)], indirect=True)
     def test_rejects_over_rate_limit(
-        self, mock_sessionmaker, mock_db, mock_get_rate_limit, mock_validate_token, app: Flask
+        self,
+        mock_get_rate_limit,
+        mock_validate_token,
+        app: Flask,
+        sqlite_session: Session,
     ):
         """Test that Forbidden is raised when over rate limit."""
         # Arrange
-        mock_validate_token.return_value = Mock(tenant_id="tenant123")
+        tenant_id = str(uuid.uuid4())
+        mock_validate_token.return_value = _api_token(
+            tenant_id=tenant_id,
+            token_type=ApiTokenType.DATASET,
+        )
 
         mock_rate_limit = Mock()
         mock_rate_limit.enabled = True
         mock_rate_limit.limit = 10
         mock_rate_limit.subscription_plan = "pro"
         mock_get_rate_limit.return_value = mock_rate_limit
-        rate_limit_log_session = MagicMock()
-        session_factory = MagicMock()
-        session_factory.begin.return_value.__enter__.return_value = rate_limit_log_session
-        mock_sessionmaker.return_value = session_factory
 
-        with patch("controllers.service_api.wraps.redis_client") as mock_redis:
+        with (
+            patch("controllers.service_api.wraps.redis_client") as mock_redis,
+            patch(
+                "controllers.service_api.wraps.db",
+                SimpleNamespace(engine=sqlite_session.get_bind()),
+            ),
+        ):
             mock_redis.zcard.return_value = 15  # Over limit
 
             @cloud_edition_billing_rate_limit_check("knowledge", "dataset")
@@ -499,9 +566,12 @@ class TestCloudEditionBillingRateLimitCheck:
                 with pytest.raises(Forbidden) as exc_info:
                     knowledge_request()
                 assert "rate limit" in str(exc_info.value)
-            mock_sessionmaker.assert_called_once_with(bind=mock_db.engine, expire_on_commit=False)
-            rate_limit_log_session.add.assert_called_once()
-            mock_db.session.commit.assert_not_called()
+
+        persisted_logs = sqlite_session.scalars(select(RateLimitLog)).all()
+        assert len(persisted_logs) == 1
+        assert persisted_logs[0].tenant_id == tenant_id
+        assert persisted_logs[0].subscription_plan == "pro"
+        assert persisted_logs[0].operation == "knowledge"
 
 
 class TestValidateDatasetToken:
@@ -515,65 +585,62 @@ class TestValidateDatasetToken:
         return app
 
     @patch("controllers.service_api.wraps.user_logged_in")
-    @patch("controllers.service_api.wraps.db")
     @patch("controllers.service_api.wraps.validate_and_get_api_token")
     @patch("controllers.service_api.wraps.current_app")
-    def test_valid_dataset_token(self, mock_current_app, mock_validate_token, mock_db, mock_user_logged_in, app: Flask):
+    @pytest.mark.parametrize(
+        "sqlite_session",
+        [(Tenant, Account, TenantAccountJoin)],
+        indirect=True,
+    )
+    def test_valid_dataset_token(
+        self,
+        mock_current_app,
+        mock_validate_token,
+        mock_user_logged_in,
+        app: Flask,
+        sqlite_session: Session,
+    ):
         """Test that valid dataset token allows access."""
         # Arrange
         _configure_current_app_mock(mock_current_app)
 
-        tenant_id = str(uuid.uuid4())
-        mock_api_token = Mock()
-        mock_api_token.tenant_id = tenant_id
-        mock_validate_token.return_value = mock_api_token
-
-        mock_tenant = Mock()
-        mock_tenant.id = tenant_id
-        mock_tenant.status = TenantStatus.NORMAL
-
-        mock_ta = Mock()
-        mock_ta.account_id = str(uuid.uuid4())
-
-        mock_account = Mock()
-        mock_account.id = mock_ta.account_id
-        mock_account.current_tenant = mock_tenant
-
-        # Mock the tenant account join query (execute(select(...)).one_or_none())
-        setup_mock_dataset_owner_execute_result(mock_db, mock_tenant, mock_ta)
-
-        # Mock the account lookup via session.get()
-        mock_db.session.get.return_value = mock_account
+        tenant, account, _ = _persist_workspace(sqlite_session)
+        api_token = _api_token(tenant_id=tenant.id, token_type=ApiTokenType.DATASET)
+        mock_validate_token.return_value = api_token
 
         @validate_dataset_token
         def protected_view(tenant_id):
             return {"success": True, "tenant_id": tenant_id}
 
         # Act
-        with app.test_request_context("/", method="GET", headers={"Authorization": "Bearer test_token"}):
+        with (
+            app.test_request_context("/", method="GET", headers={"Authorization": "Bearer test_token"}),
+            patch("controllers.service_api.wraps.db.session", _session_proxy(sqlite_session)),
+        ):
             result = protected_view()
 
         # Assert
         assert result["success"] is True
-        assert result["tenant_id"] == tenant_id
+        assert result["tenant_id"] == tenant.id
+        assert account.current_tenant_id == tenant.id
 
-    @patch("controllers.service_api.wraps.db")
     @patch("controllers.service_api.wraps.validate_and_get_api_token")
-    def test_dataset_not_found_raises_not_found(self, mock_validate_token, mock_db, app: Flask):
+    @pytest.mark.parametrize("sqlite_session", [(Dataset,)], indirect=True)
+    def test_dataset_not_found_raises_not_found(self, mock_validate_token, app: Flask, sqlite_session: Session):
         """Test that NotFound is raised when dataset doesn't exist."""
         # Arrange
-        mock_api_token = Mock()
-        mock_api_token.tenant_id = str(uuid.uuid4())
-        mock_validate_token.return_value = mock_api_token
-
-        mock_db.session.scalar.return_value = None
+        api_token = _api_token(tenant_id=str(uuid.uuid4()), token_type=ApiTokenType.DATASET)
+        mock_validate_token.return_value = api_token
 
         @validate_dataset_token
         def protected_view(dataset_id=None, **kwargs):
             return {"success": True}
 
         # Act & Assert
-        with app.test_request_context("/", method="GET"):
+        with (
+            app.test_request_context("/", method="GET"),
+            patch("controllers.service_api.wraps.db.session", sqlite_session),
+        ):
             with pytest.raises(NotFound) as exc_info:
                 protected_view(dataset_id=str(uuid.uuid4()))
             assert "Dataset not found" in str(exc_info.value)

api/tests/unit_tests/core/app/apps/completion/test_app_runner.py

@@ -1,21 +1,11 @@
-from contextlib import contextmanager
 from types import SimpleNamespace
-from unittest.mock import ANY, MagicMock, patch
+from unittest.mock import MagicMock
 
-import pytest
-from pytest_mock import MockerFixture
-
-import core.app.apps.completion.app_runner as module
-from core.app.apps.completion.app_runner import CompletionAppRunner
+from core.app.apps.completion.workflow_runner import CompletionWorkflowRunner
 from core.moderation.base import ModerationError
 from graphon.model_runtime.entities.message_entities import ImagePromptMessageContent
 
 
-@pytest.fixture
-def runner():
-    return CompletionAppRunner()
-
-
 def _build_app_config(dataset=None, external_tools=None, additional_features=None):
     app_config = MagicMock()
     app_config.app_id = "app1"
@@ -24,7 +14,7 @@ def _build_app_config(dataset=None, external_tools=None, additional_features=Non
     app_config.dataset = dataset
     app_config.external_data_variables = external_tools or []
     app_config.additional_features = additional_features
-    app_config.app_model_config_dict = {"file_upload": {"enabled": True}}
+    app_config.app_model_config_dict = {"file_upload": {"image": {"enabled": True}}}
     return app_config
 
 
@@ -38,163 +28,40 @@ def _build_generate_entity(app_config, file_upload_config=None):
     return SimpleNamespace(
         app_config=app_config,
         model_conf=model_conf,
-        inputs={"qvar": "query_from_input"},
+        inputs={"qvar": "original_query_from_input"},
         query="original_query",
         files=[],
         file_upload_config=file_upload_config,
         stream=True,
         user_id="user",
         invoke_from=MagicMock(),
+        trace_manager=None,
     )
 
 
-@contextmanager
-def patched_create_session(*, return_value=None):
-    session = MagicMock()
-    session.scalar.return_value = return_value
-    session_context = MagicMock()
-    session_context.__enter__.return_value = session
-    with patch.object(module, "create_session", return_value=session_context):
-        yield session
+def test_workflow_runner_direct_outputs_on_input_moderation() -> None:
+    runner = CompletionWorkflowRunner()
+    app_record = MagicMock(id="app1", tenant_id="tenant")
+    app_generate_entity = _build_generate_entity(_build_app_config())
+    queue_manager = MagicMock()
+    message = MagicMock(id="msg")
+    runner.organize_prompt_messages = MagicMock(return_value=([], None))
+    runner.moderation_for_inputs = MagicMock(side_effect=ModerationError("blocked"))
+    runner.direct_output = MagicMock()
+
+    result = runner._run_input_moderation(
+        app_record=app_record,
+        application_generate_entity=app_generate_entity,
+        queue_manager=queue_manager,
+        message=message,
+    )
+
+    assert result.stopped is True
+    runner.direct_output.assert_called_once()
 
 
-class TestCompletionAppRunner:
-    def test_run_app_not_found(self, runner, mocker: MockerFixture):
-        app_config = _build_app_config()
-        app_generate_entity = _build_generate_entity(app_config)
+def test_workflow_runner_uses_low_image_detail_default() -> None:
+    runner = CompletionWorkflowRunner()
+    app_generate_entity = _build_generate_entity(_build_app_config(), file_upload_config=None)
 
-        with patched_create_session(return_value=None):
-            with pytest.raises(ValueError):
-                runner.run(app_generate_entity, MagicMock(), MagicMock(), MagicMock())
-
-    def test_run_moderation_error_outputs_direct(self, runner, mocker: MockerFixture):
-        app_record = MagicMock(id="app1", tenant_id="tenant")
-
-        app_config = _build_app_config()
-        app_generate_entity = _build_generate_entity(app_config)
-
-        runner.organize_prompt_messages = MagicMock(return_value=([], None))
-        runner.moderation_for_inputs = MagicMock(side_effect=ModerationError("blocked"))
-        runner.direct_output = MagicMock()
-        runner._handle_invoke_result = MagicMock()
-
-        with patched_create_session(return_value=app_record):
-            runner.run(app_generate_entity, MagicMock(), MagicMock(id="msg"), MagicMock())
-
-        runner.direct_output.assert_called_once()
-        runner._handle_invoke_result.assert_not_called()
-
-    def test_run_hosting_moderation_stops(self, runner, mocker: MockerFixture):
-        app_record = MagicMock(id="app1", tenant_id="tenant")
-
-        app_config = _build_app_config()
-        app_generate_entity = _build_generate_entity(app_config)
-
-        runner.organize_prompt_messages = MagicMock(return_value=([], None))
-        runner.moderation_for_inputs = MagicMock(return_value=(None, app_generate_entity.inputs, "query"))
-        runner.check_hosting_moderation = MagicMock(return_value=True)
-        runner._handle_invoke_result = MagicMock()
-
-        with patched_create_session(return_value=app_record):
-            runner.run(app_generate_entity, MagicMock(), MagicMock(id="msg"), MagicMock())
-
-        runner._handle_invoke_result.assert_not_called()
-
-    def test_run_dataset_and_external_tools_flow(self, runner, mocker: MockerFixture):
-        app_record = MagicMock(id="app1", tenant_id="tenant")
-
-        retrieve_config = MagicMock(query_variable="qvar")
-        dataset_config = MagicMock(dataset_ids=["ds"], retrieve_config=retrieve_config)
-        additional_features = MagicMock(show_retrieve_source=True)
-        app_config = _build_app_config(
-            dataset=dataset_config,
-            external_tools=["tool"],
-            additional_features=additional_features,
-        )
-
-        file_upload_config = MagicMock()
-        file_upload_config.image_config.detail = ImagePromptMessageContent.DETAIL.HIGH
-
-        app_generate_entity = _build_generate_entity(app_config, file_upload_config=file_upload_config)
-
-        runner.organize_prompt_messages = MagicMock(side_effect=[(["pm1"], ["stop"]), (["pm2"], ["stop"])])
-        runner.moderation_for_inputs = MagicMock(return_value=(None, app_generate_entity.inputs, "query"))
-        runner.fill_in_inputs_from_external_data_tools = MagicMock(return_value=app_generate_entity.inputs)
-        runner.check_hosting_moderation = MagicMock(return_value=False)
-        runner.recalc_llm_max_tokens = MagicMock()
-        runner._handle_invoke_result = MagicMock()
-
-        dataset_retrieval = MagicMock()
-        dataset_retrieval.retrieve.return_value = ("ctx", ["file1"])
-        mocker.patch.object(module, "DatasetRetrieval", return_value=dataset_retrieval)
-
-        model_instance = MagicMock()
-        model_instance.invoke_llm.return_value = "invoke_result"
-        mocker.patch.object(module, "ModelInstance", return_value=model_instance)
-
-        with patched_create_session(return_value=app_record):
-            runner.run(app_generate_entity, MagicMock(), MagicMock(id="msg", tenant_id="tenant"), MagicMock())
-
-        dataset_retrieval.retrieve.assert_called_once()
-        assert dataset_retrieval.retrieve.call_args.kwargs["query"] == "query_from_input"
-        runner._handle_invoke_result.assert_called_once()
-
-    def test_run_closes_explicit_session_before_stream_consumption(self, runner, mocker: MockerFixture):
-        app_record = MagicMock(id="app1", tenant_id="tenant")
-        app_config = _build_app_config()
-        app_generate_entity = _build_generate_entity(app_config)
-        queue_manager = MagicMock()
-
-        events = []
-        session = MagicMock()
-        session.commit.side_effect = lambda: events.append("commit")
-        session.close.side_effect = lambda: events.append("close")
-        runner.organize_prompt_messages = MagicMock(return_value=([], None))
-        runner.moderation_for_inputs = MagicMock(return_value=(None, app_generate_entity.inputs, "query"))
-        runner.check_hosting_moderation = MagicMock(return_value=False)
-        runner.recalc_llm_max_tokens = MagicMock()
-        runner._handle_invoke_result = MagicMock(side_effect=lambda invoke_result, **kwargs: list(invoke_result))
-
-        model_instance = MagicMock()
-
-        def invoke_stream():
-            events.append("first-chunk")
-            yield "chunk"
-
-        def invoke_llm(**kwargs):
-            events.append("invoke")
-            return invoke_stream()
-
-        model_instance.invoke_llm.side_effect = invoke_llm
-        mocker.patch.object(module, "ModelInstance", return_value=model_instance)
-
-        with patched_create_session(return_value=app_record):
-            runner.run(app_generate_entity, queue_manager, MagicMock(id="msg"), session)
-
-        assert events == ["commit", "close", "invoke", "first-chunk"]
-        runner._handle_invoke_result.assert_called_once_with(
-            invoke_result=ANY,
-            queue_manager=queue_manager,
-            stream=True,
-            message_id="msg",
-            user_id="user",
-            tenant_id="tenant",
-        )
-
-    def test_run_uses_low_image_detail_default(self, runner, mocker: MockerFixture):
-        app_record = MagicMock(id="app1", tenant_id="tenant")
-
-        app_config = _build_app_config()
-        app_generate_entity = _build_generate_entity(app_config, file_upload_config=None)
-
-        runner.organize_prompt_messages = MagicMock(return_value=([], None))
-        runner.moderation_for_inputs = MagicMock(return_value=(None, app_generate_entity.inputs, "query"))
-        runner.check_hosting_moderation = MagicMock(return_value=True)
-
-        with patched_create_session(return_value=app_record):
-            runner.run(app_generate_entity, MagicMock(), MagicMock(id="msg"), MagicMock())
-
-        assert (
-            runner.organize_prompt_messages.call_args.kwargs["image_detail_config"]
-            == ImagePromptMessageContent.DETAIL.LOW
-        )
+    assert runner._resolve_image_detail_config(app_generate_entity) == ImagePromptMessageContent.DETAIL.LOW

api/tests/unit_tests/core/app/apps/completion/test_completion_completion_app_generator.py

@@ -376,18 +376,26 @@ class TestCompletionAppGenerator:
         create_session.return_value = session_context
         mocker.patch.object(module.db, "session")
 
-        mocker.patch.object(generator, "_get_message", return_value=MagicMock())
+        message = MagicMock()
+        mocker.patch.object(generator, "_get_message", return_value=message)
 
         runner_instance = MagicMock()
         runner_instance.run.side_effect = error
-        mocker.patch.object(module, "CompletionAppRunner", return_value=runner_instance)
+        mocker.patch.object(module, "CompletionWorkflowRunner", return_value=runner_instance)
 
         queue_manager = MagicMock()
+        application_generate_entity = MagicMock()
         generator._generate_worker(
             flask_app=flask_app,
-            application_generate_entity=MagicMock(),
+            application_generate_entity=application_generate_entity,
             queue_manager=queue_manager,
             message_id="msg",
         )
 
+        runner_instance.run.assert_called_once_with(
+            application_generate_entity=application_generate_entity,
+            queue_manager=queue_manager,
+            message=message,
+            session=session,
+        )
         assert queue_manager.publish_error.called is should_publish

api/tests/unit_tests/core/app/apps/completion/test_completion_runtime_workflow_builder.py

@@ -0,0 +1,70 @@
+import json
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+from core.app.apps.completion.runtime_workflow_builder import build_runtime_completion_workflow
+from graphon.nodes import BuiltinNodeTypes
+from models.model import AppMode
+
+
+def test_builder_returns_runtime_graph_without_workflow_record() -> None:
+    app_model = SimpleNamespace(mode=AppMode.COMPLETION)
+    app_config = MagicMock()
+    workflow_converter = MagicMock(
+        build_graph_from_app_config=MagicMock(return_value=({"nodes": [{"id": "start"}], "edges": []}, {}))
+    )
+    session = MagicMock()
+
+    result = build_runtime_completion_workflow(
+        app_model=app_model,
+        app_config=app_config,
+        session=session,
+        workflow_converter=workflow_converter,
+    )
+
+    assert result.workflow_id.startswith("completion-runtime-")
+    assert result.root_node_id == "start"
+    assert result.graph_dict == {"nodes": [{"id": "start"}], "edges": []}
+    workflow_converter.build_graph_from_app_config.assert_called_once_with(
+        app_model=app_model,
+        app_config=app_config,
+        target_app_mode=AppMode.WORKFLOW,
+        session=session,
+    )
+
+
+def test_builder_routes_api_based_variable_query_to_runtime_sys_query() -> None:
+    app_model = SimpleNamespace(mode=AppMode.COMPLETION)
+    app_config = MagicMock()
+    request_body = {"params": {"query": ""}}
+    workflow_converter = MagicMock(
+        build_graph_from_app_config=MagicMock(
+            return_value=(
+                {
+                    "nodes": [
+                        {
+                            "id": "http_request_1",
+                            "data": {
+                                "type": BuiltinNodeTypes.HTTP_REQUEST,
+                                "body": {"type": "json", "data": json.dumps(request_body)},
+                            },
+                        }
+                    ],
+                    "edges": [],
+                },
+                {},
+            )
+        )
+    )
+    session = MagicMock()
+
+    result = build_runtime_completion_workflow(
+        app_model=app_model,
+        app_config=app_config,
+        session=session,
+        workflow_converter=workflow_converter,
+    )
+
+    http_node = result.graph_dict["nodes"][0]
+    body = json.loads(http_node["data"]["body"]["data"])
+    assert body["params"]["query"] == "{{#sys.query#}}"

api/tests/unit_tests/core/app/apps/completion/test_graph_event_adapter.py

@@ -0,0 +1,172 @@
+from datetime import UTC, datetime
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+from core.app.apps.base_app_queue_manager import PublishFrom
+from core.app.apps.completion.graph_event_adapter import CompletionGraphEventAdapter
+from core.app.entities.queue_entities import (
+    QueueErrorEvent,
+    QueueLLMChunkEvent,
+    QueueMessageEndEvent,
+    QueueRetrieverResourcesEvent,
+    QueueStopEvent,
+)
+from graphon.enums import BuiltinNodeTypes, WorkflowNodeExecutionStatus
+from graphon.graph_events import (
+    GraphRunAbortedEvent,
+    GraphRunFailedEvent,
+    GraphRunSucceededEvent,
+    NodeRunRetrieverResourceEvent,
+    NodeRunStreamChunkEvent,
+    NodeRunSucceededEvent,
+)
+from graphon.model_runtime.entities.llm_entities import LLMUsage
+from graphon.model_runtime.entities.message_entities import UserPromptMessage
+from graphon.node_events import NodeRunResult
+
+
+def _adapter(*, show_retrieve_source: bool = True) -> tuple[CompletionGraphEventAdapter, MagicMock]:
+    queue_manager = MagicMock()
+    entity = SimpleNamespace(
+        model_conf=SimpleNamespace(model="model"),
+        app_config=SimpleNamespace(
+            additional_features=SimpleNamespace(show_retrieve_source=show_retrieve_source),
+        ),
+    )
+    return (
+        CompletionGraphEventAdapter(application_generate_entity=entity, queue_manager=queue_manager),
+        queue_manager,
+    )
+
+
+def test_stream_chunk_event_publishes_llm_chunk() -> None:
+    adapter, queue_manager = _adapter()
+    prompt_message = UserPromptMessage(content="prompt")
+    adapter.set_prompt_messages([prompt_message])
+
+    adapter.handle_event(
+        NodeRunStreamChunkEvent(
+            id="run",
+            node_id="llm",
+            node_type=BuiltinNodeTypes.LLM,
+            selector=["llm", "text"],
+            chunk="hello",
+        )
+    )
+
+    event = queue_manager.publish.call_args.args[0]
+    assert isinstance(event, QueueLLMChunkEvent)
+    assert event.chunk.delta.message.content == "hello"
+    assert event.chunk.prompt_messages == [prompt_message]
+    assert queue_manager.publish.call_args.args[1] == PublishFrom.APPLICATION_MANAGER
+
+
+def test_stream_chunk_event_skips_final_empty_chunk() -> None:
+    adapter, queue_manager = _adapter()
+
+    adapter.handle_event(
+        NodeRunStreamChunkEvent(
+            id="run",
+            node_id="llm",
+            node_type=BuiltinNodeTypes.LLM,
+            selector=["llm", "text"],
+            chunk="",
+            is_final=True,
+        )
+    )
+
+    queue_manager.publish.assert_not_called()
+
+
+def test_retriever_resource_event_publishes_legacy_retriever_resources() -> None:
+    adapter, queue_manager = _adapter()
+
+    adapter.handle_event(
+        NodeRunRetrieverResourceEvent(
+            id="run",
+            node_id="knowledge_retrieval",
+            node_type=BuiltinNodeTypes.KNOWLEDGE_RETRIEVAL,
+            retriever_resources=[{"dataset_id": "dataset", "content": "hit"}],
+            context="hit",
+        )
+    )
+
+    event = queue_manager.publish.call_args.args[0]
+    assert isinstance(event, QueueRetrieverResourcesEvent)
+    assert event.retriever_resources[0].dataset_id == "dataset"
+
+
+def test_retriever_resource_event_is_hidden_when_feature_is_disabled() -> None:
+    adapter, queue_manager = _adapter(show_retrieve_source=False)
+
+    adapter.handle_event(
+        NodeRunRetrieverResourceEvent(
+            id="run",
+            node_id="knowledge_retrieval",
+            node_type=BuiltinNodeTypes.KNOWLEDGE_RETRIEVAL,
+            retriever_resources=[{"dataset_id": "dataset", "content": "hit"}],
+            context="hit",
+        )
+    )
+
+    queue_manager.publish.assert_not_called()
+
+
+def test_llm_success_then_graph_success_publishes_message_end() -> None:
+    adapter, queue_manager = _adapter()
+    usage = LLMUsage.empty_usage()
+    prompt_message = UserPromptMessage(content="prompt")
+    adapter.set_prompt_messages([prompt_message])
+    adapter.handle_event(
+        NodeRunSucceededEvent(
+            id="run",
+            node_id="llm",
+            node_type=BuiltinNodeTypes.LLM,
+            start_at=datetime.now(UTC),
+            node_run_result=NodeRunResult(
+                status=WorkflowNodeExecutionStatus.SUCCEEDED,
+                outputs={"text": "final"},
+                llm_usage=usage,
+            ),
+        )
+    )
+
+    adapter.handle_event(GraphRunSucceededEvent(outputs={"result": "final"}))
+
+    event = queue_manager.publish.call_args.args[0]
+    assert isinstance(event, QueueMessageEndEvent)
+    assert event.llm_result is not None
+    assert event.llm_result.message.content == "final"
+    assert event.llm_result.prompt_messages == [prompt_message]
+    assert event.llm_result.usage is usage
+
+
+def test_graph_success_uses_outputs_result_when_llm_success_was_not_seen() -> None:
+    adapter, queue_manager = _adapter()
+
+    adapter.handle_event(GraphRunSucceededEvent(outputs={"result": "final from graph"}))
+
+    event = queue_manager.publish.call_args.args[0]
+    assert isinstance(event, QueueMessageEndEvent)
+    assert event.llm_result is not None
+    assert event.llm_result.message.content == "final from graph"
+
+
+def test_failed_graph_publishes_error() -> None:
+    adapter, queue_manager = _adapter()
+
+    adapter.handle_event(GraphRunFailedEvent(error="boom"))
+
+    event = queue_manager.publish.call_args.args[0]
+    assert isinstance(event, QueueErrorEvent)
+    assert str(event.error) == "boom"
+
+
+def test_user_abort_publishes_legacy_stop() -> None:
+    adapter, queue_manager = _adapter()
+
+    adapter.handle_event(GraphRunAbortedEvent(reason="Stopped by user."))
+
+    event = queue_manager.publish.call_args.args[0]
+    assert isinstance(event, QueueStopEvent)
+    assert event.stopped_by == QueueStopEvent.StopBy.USER_MANUAL

api/tests/unit_tests/core/app/apps/completion/test_workflow_runner.py

@@ -0,0 +1,278 @@
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import pytest
+
+from core.app.apps.completion.workflow_runner import CompletionWorkflowRunner, ModeratedCompletionInputs
+from core.app.apps.exc import GenerateTaskStoppedError
+from core.app.entities.app_invoke_entities import InvokeFrom, UserFrom
+from core.moderation.base import ModerationError
+from core.workflow.node_runtime import DIFY_BEFORE_LLM_INVOKE_KEY
+from graphon.model_runtime.entities.message_entities import ImagePromptMessageContent
+from models.model import AppMode
+
+
+def _entity() -> SimpleNamespace:
+    return SimpleNamespace(
+        app_config=SimpleNamespace(app_id="app", tenant_id="tenant", prompt_template=MagicMock()),
+        model_conf=SimpleNamespace(model="model"),
+        user_id="user",
+        invoke_from=InvokeFrom.SERVICE_API,
+        task_id="task",
+        call_depth=2,
+        inputs={"name": "Ada"},
+        query="question",
+        files=[],
+        file_upload_config=None,
+        extras={"trace_session_id": "trace"},
+        stream=True,
+        trace_manager=None,
+    )
+
+
+def test_runner_builds_workflow_entry_and_adapts_events(monkeypatch) -> None:
+    from core.app.apps.completion import workflow_runner as module
+
+    app = SimpleNamespace(id="app", tenant_id="tenant", mode=AppMode.COMPLETION)
+    entity = _entity()
+    message = SimpleNamespace(id="message", conversation_id="conv")
+    queue_manager = SimpleNamespace(graph_runtime_state=None)
+    runtime_workflow = SimpleNamespace(
+        workflow_id="completion-runtime-1",
+        root_node_id="start",
+        graph_dict={"nodes": [{"id": "start", "data": {"type": "start"}}], "edges": []},
+    )
+    build_runtime_workflow = MagicMock(return_value=runtime_workflow)
+    graph = MagicMock()
+    adapter = MagicMock()
+    workflow_entry = MagicMock()
+    session = MagicMock()
+    lifecycle_events: list[str] = []
+    session.commit.side_effect = lambda: lifecycle_events.append("commit")
+    session.close.side_effect = lambda: lifecycle_events.append("close")
+
+    def run_workflow():
+        lifecycle_events.append("run")
+        yield "event"
+
+    workflow_entry.run.return_value = run_workflow()
+
+    init_graph = MagicMock(return_value=graph)
+    workflow_entry_class = MagicMock(return_value=workflow_entry)
+    adapter_class = MagicMock(return_value=adapter)
+    build_system_variables = MagicMock(return_value=["sys"])
+    build_bootstrap_variables = MagicMock(return_value=["boot"])
+    add_variables_to_pool = MagicMock()
+    add_node_inputs_to_pool = MagicMock()
+
+    monkeypatch.setattr(module, "init_graph", init_graph)
+    monkeypatch.setattr(module, "build_runtime_completion_workflow", build_runtime_workflow)
+    monkeypatch.setattr(module, "WorkflowEntry", workflow_entry_class)
+    monkeypatch.setattr(module, "CompletionGraphEventAdapter", adapter_class)
+    monkeypatch.setattr(module, "RedisChannel", MagicMock())
+    monkeypatch.setattr(module, "redis_client", MagicMock())
+    monkeypatch.setattr(module, "build_system_variables", build_system_variables)
+    monkeypatch.setattr(module, "build_bootstrap_variables", build_bootstrap_variables)
+    monkeypatch.setattr(module, "add_variables_to_pool", add_variables_to_pool)
+    monkeypatch.setattr(module, "add_node_inputs_to_pool", add_node_inputs_to_pool)
+
+    runner = CompletionWorkflowRunner()
+    monkeypatch.setattr(runner, "_get_app", MagicMock(return_value=app))
+    before_llm_invoke_hook = MagicMock()
+    build_before_llm_invoke_hook = MagicMock(return_value=before_llm_invoke_hook)
+    monkeypatch.setattr(runner, "_build_before_llm_invoke_hook", build_before_llm_invoke_hook)
+    monkeypatch.setattr(
+        runner,
+        "_run_input_moderation",
+        MagicMock(return_value=ModeratedCompletionInputs(stopped=False, inputs={"name": "Grace"}, query="moderated")),
+    )
+
+    runner.run(
+        application_generate_entity=entity,
+        queue_manager=queue_manager,
+        message=message,
+        session=session,
+    )
+
+    build_runtime_workflow.assert_called_once_with(
+        app_model=app,
+        app_config=entity.app_config,
+        session=session,
+    )
+    assert lifecycle_events == ["commit", "close", "run"]
+    add_node_inputs_to_pool.assert_called_once()
+    assert add_node_inputs_to_pool.call_args.kwargs["node_id"] == "start"
+    assert add_node_inputs_to_pool.call_args.kwargs["inputs"] == {"name": "Grace"}
+    build_system_variables.assert_called_once()
+    assert build_system_variables.call_args.kwargs["query"] == "moderated"
+    assert build_system_variables.call_args.kwargs["conversation_id"] == "conv"
+    workflow_entry_class.assert_called_once()
+    assert workflow_entry_class.call_args.kwargs["workflow_id"] == "completion-runtime-1"
+    assert workflow_entry_class.call_args.kwargs["user_from"] == UserFrom.END_USER
+    assert workflow_entry_class.call_args.kwargs["call_depth"] == 2
+    build_before_llm_invoke_hook.assert_called_once_with(
+        application_generate_entity=entity,
+        queue_manager=queue_manager,
+        adapter=adapter,
+    )
+    init_graph.assert_called_once()
+    assert init_graph.call_args.kwargs["app_id"] == "app"
+    assert init_graph.call_args.kwargs["graph_config"] == runtime_workflow.graph_dict
+    assert init_graph.call_args.kwargs["root_node_id"] == "start"
+    assert init_graph.call_args.kwargs["call_depth"] == 2
+    assert init_graph.call_args.kwargs["extra_context"][DIFY_BEFORE_LLM_INVOKE_KEY] is before_llm_invoke_hook
+    workflow_entry.graph_engine.layer.assert_not_called()
+    adapter_class.assert_called_once_with(application_generate_entity=entity, queue_manager=queue_manager)
+    adapter.handle_event.assert_called_once_with("event")
+
+
+def test_runner_returns_when_input_moderation_stops(monkeypatch) -> None:
+    app = SimpleNamespace(id="app", tenant_id="tenant", mode=AppMode.COMPLETION)
+    entity = _entity()
+    build_runtime_workflow = MagicMock()
+    runner = CompletionWorkflowRunner()
+    monkeypatch.setattr(
+        "core.app.apps.completion.workflow_runner.build_runtime_completion_workflow",
+        build_runtime_workflow,
+    )
+    monkeypatch.setattr(runner, "_get_app", MagicMock(return_value=app))
+    monkeypatch.setattr(
+        runner,
+        "_run_input_moderation",
+        MagicMock(return_value=ModeratedCompletionInputs(stopped=True, inputs={}, query="")),
+    )
+
+    runner.run(
+        application_generate_entity=entity,
+        queue_manager=MagicMock(),
+        message=SimpleNamespace(id="message"),
+        session=MagicMock(),
+    )
+
+    build_runtime_workflow.assert_not_called()
+
+
+def test_runner_get_app_raises_when_record_is_missing() -> None:
+    runner = CompletionWorkflowRunner()
+    session = MagicMock()
+    session.scalar.return_value = None
+
+    with pytest.raises(ValueError, match="App not found"):
+        runner._get_app(app_id="missing-app", tenant_id="tenant", session=session)
+
+
+def test_runner_get_app_returns_record() -> None:
+    app = SimpleNamespace(id="app")
+    runner = CompletionWorkflowRunner()
+    session = MagicMock()
+    session.scalar.return_value = app
+
+    assert runner._get_app(app_id="app", tenant_id="tenant", session=session) is app
+
+
+def test_runner_direct_outputs_on_input_moderation() -> None:
+    runner = CompletionWorkflowRunner()
+    app_record = SimpleNamespace(id="app", tenant_id="tenant")
+    entity = _entity()
+    message = SimpleNamespace(id="message")
+    queue_manager = MagicMock()
+    runner.organize_prompt_messages = MagicMock(return_value=(["prompt"], None))
+    runner.moderation_for_inputs = MagicMock(side_effect=ModerationError("blocked"))
+    runner.direct_output = MagicMock()
+
+    result = runner._run_input_moderation(
+        app_record=app_record,
+        application_generate_entity=entity,
+        queue_manager=queue_manager,
+        message=message,
+    )
+
+    assert result.stopped is True
+    assert result.inputs == {"name": "Ada"}
+    assert result.query == "question"
+    runner.direct_output.assert_called_once()
+
+
+def test_runner_returns_moderated_inputs_when_input_moderation_passes() -> None:
+    runner = CompletionWorkflowRunner()
+    app_record = SimpleNamespace(id="app", tenant_id="tenant")
+    entity = _entity()
+    message = SimpleNamespace(id="message")
+    runner.organize_prompt_messages = MagicMock(return_value=(["prompt"], None))
+    runner.moderation_for_inputs = MagicMock(return_value=(None, {"name": "Grace"}, "moderated query"))
+
+    result = runner._run_input_moderation(
+        app_record=app_record,
+        application_generate_entity=entity,
+        queue_manager=MagicMock(),
+        message=message,
+    )
+
+    assert result == ModeratedCompletionInputs(stopped=False, inputs={"name": "Grace"}, query="moderated query")
+
+
+def test_runner_before_llm_invoke_hook_captures_and_moderates_final_prompt() -> None:
+    runner = CompletionWorkflowRunner()
+    entity = _entity()
+    queue_manager = MagicMock()
+    adapter = MagicMock()
+    runner.check_hosting_moderation = MagicMock(return_value=True)
+
+    hook = runner._build_before_llm_invoke_hook(
+        application_generate_entity=entity,
+        queue_manager=queue_manager,
+        adapter=adapter,
+    )
+
+    with pytest.raises(GenerateTaskStoppedError):
+        hook(["final prompt"], {"max_tokens": 128})
+
+    adapter.set_prompt_messages.assert_called_once_with(["final prompt"])
+    runner.check_hosting_moderation.assert_called_once_with(
+        application_generate_entity=entity,
+        queue_manager=queue_manager,
+        prompt_messages=["final prompt"],
+    )
+
+
+def test_runner_before_llm_invoke_hook_recalculates_graph_model_parameters() -> None:
+    runner = CompletionWorkflowRunner()
+    entity = _entity()
+    queue_manager = MagicMock()
+    adapter = MagicMock()
+    runner.check_hosting_moderation = MagicMock(return_value=False)
+
+    def recalc(*, model_parameters, **kwargs) -> None:
+        model_parameters["max_tokens"] = 64
+
+    runner.recalc_llm_max_tokens = MagicMock(side_effect=recalc)
+    hook = runner._build_before_llm_invoke_hook(
+        application_generate_entity=entity,
+        queue_manager=queue_manager,
+        adapter=adapter,
+    )
+
+    result = hook(["final prompt"], {"max_tokens": 128, "temperature": 0.2})
+
+    assert result == {"max_tokens": 64, "temperature": 0.2}
+    runner.recalc_llm_max_tokens.assert_called_once_with(
+        model_config=entity.model_conf,
+        prompt_messages=["final prompt"],
+        model_parameters=result,
+    )
+
+
+def test_runner_resolves_account_user_from() -> None:
+    entity = _entity()
+    entity.invoke_from = InvokeFrom.EXPLORE
+
+    assert CompletionWorkflowRunner._resolve_user_from(entity) == UserFrom.ACCOUNT
+
+
+def test_runner_resolves_configured_image_detail() -> None:
+    entity = _entity()
+    entity.file_upload_config = SimpleNamespace(
+        image_config=SimpleNamespace(detail=ImagePromptMessageContent.DETAIL.HIGH),
+    )
+
+    assert CompletionWorkflowRunner._resolve_image_detail_config(entity) == ImagePromptMessageContent.DETAIL.HIGH

api/tests/unit_tests/core/app/apps/test_base_app_runner.py

@@ -133,6 +133,33 @@ class TestAppRunner:
 
         assert runner.recalc_llm_max_tokens(model_config, prompt_messages=[]) == -1
 
+    def test_recalc_llm_max_tokens_can_update_runtime_parameters(self, monkeypatch: pytest.MonkeyPatch):
+        runner = AppRunner()
+        model_schema = AIModelEntity.model_construct(
+            model_properties={ModelPropertyKey.CONTEXT_SIZE: 100},
+            parameter_rules=[_DummyParameterRule("max_tokens")],
+        )
+        model_config = ModelConfigWithCredentialsEntity.model_construct(
+            provider_model_bundle=object(),
+            model="mock",
+            model_schema=model_schema,
+            parameters={"max_tokens": 30},
+        )
+        runtime_parameters = {"max_tokens": 40}
+        monkeypatch.setattr(
+            "core.app.apps.base_app_runner.ModelInstance",
+            lambda provider_model_bundle, model: _TokenCountingModel(80),
+        )
+
+        runner.recalc_llm_max_tokens(
+            model_config,
+            prompt_messages=[AssistantPromptMessage(content="hi")],
+            model_parameters=runtime_parameters,
+        )
+
+        assert runtime_parameters["max_tokens"] == 20
+        assert model_config.parameters["max_tokens"] == 30
+
     def test_direct_output_streaming_publishes_chunks_and_end(self):
         runner = AppRunner()
         queue = _queue_manager()

api/tests/unit_tests/core/app/apps/test_workflow_app_runner_core.py

@@ -5,7 +5,7 @@ from types import SimpleNamespace
 
 import pytest
 
-from core.app.apps.workflow_app_runner import WorkflowBasedAppRunner
+from core.app.apps.workflow_app_runner import WorkflowBasedAppRunner, init_graph
 from core.app.entities.app_invoke_entities import DIFY_RUN_CONTEXT_KEY, InvokeFrom, UserFrom
 from core.app.entities.queue_entities import (
     QueueAgentLogEvent,
@@ -119,6 +119,40 @@ class TestWorkflowBasedAppRunner:
 
         assert captured["run_context"][DIFY_RUN_CONTEXT_KEY].trace_session_id == "session-1"
 
+    def test_init_graph_accepts_call_depth_and_extra_context(self, monkeypatch: pytest.MonkeyPatch):
+        runtime_state = GraphRuntimeState(
+            variable_pool=VariablePool.from_bootstrap(system_variables=default_system_variables()),
+            start_at=0.0,
+        )
+        hook = object()
+        captured = {}
+
+        def fake_from_graph_init_context(**kwargs):
+            graph_init_context = kwargs["graph_init_context"]
+            captured["run_context"] = graph_init_context.run_context
+            captured["call_depth"] = graph_init_context.call_depth
+            return SimpleNamespace()
+
+        monkeypatch.setattr(
+            "core.app.apps.workflow_app_runner.DifyNodeFactory.from_graph_init_context",
+            fake_from_graph_init_context,
+        )
+        monkeypatch.setattr("core.app.apps.workflow_app_runner.Graph.init", lambda **_kwargs: SimpleNamespace())
+
+        init_graph(
+            app_id="app",
+            graph_config={"nodes": [], "edges": []},
+            graph_runtime_state=runtime_state,
+            user_from=UserFrom.ACCOUNT,
+            invoke_from=InvokeFrom.DEBUGGER,
+            root_node_id="root",
+            call_depth=2,
+            extra_context={"hook": hook},
+        )
+
+        assert captured["call_depth"] == 2
+        assert captured["run_context"]["hook"] is hook
+
     def test_prepare_single_node_execution_requires_run(self):
         runner = WorkflowBasedAppRunner(queue_manager=SimpleNamespace(), app_id="app")
 

api/tests/unit_tests/core/workflow/test_node_factory.py

@@ -461,6 +461,7 @@ class TestDifyNodeFactoryCreateNode:
     def factory(self):
         factory = object.__new__(node_factory.DifyNodeFactory)
         factory.graph_init_params = sentinel.graph_init_params
+        factory.graph_init_params.run_context = {}
         factory.graph_runtime_state = SimpleNamespace(variable_pool=MagicMock())
         factory._dify_context = SimpleNamespace(
             tenant_id="tenant-id",
@@ -702,6 +703,44 @@ class TestDifyNodeFactoryCreateNode:
             node_data=node_data,
             model_instance=sentinel.model_instance,
             request_metadata={"app_id": "app-id"},
+            before_invoke=None,
+        )
+        assert kwargs["model_instance"] is wrapped_model_instance
+
+    def test_build_llm_compatible_node_init_kwargs_passes_before_llm_hook(self, factory):
+        before_llm_invoke = MagicMock()
+        factory.graph_init_params.run_context[node_factory.DIFY_BEFORE_LLM_INVOKE_KEY] = before_llm_invoke
+        node_data = LLMNodeData.model_validate(
+            {
+                "type": BuiltinNodeTypes.LLM,
+                "title": "LLM",
+                "model": {"provider": "provider", "name": "model", "mode": "chat", "completion_params": {}},
+                "prompt_template": [{"role": "system", "text": "x"}],
+                "context": {"enabled": False, "variable_selector": []},
+                "vision": {"enabled": False},
+            }
+        )
+        wrapped_model_instance = sentinel.wrapped_model_instance
+        factory._build_model_instance_for_llm_node = MagicMock(return_value=sentinel.model_instance)
+        factory._build_memory_for_llm_node = MagicMock(return_value=sentinel.memory)
+
+        with patch.object(factory, "_wrap_model_instance_for_node", return_value=wrapped_model_instance) as wrap_model:
+            kwargs = factory._build_llm_compatible_node_init_kwargs(
+                node_class=sentinel.node_class,
+                node_data=node_data,
+                wrap_model_instance=True,
+                include_http_client=False,
+                include_llm_file_saver=False,
+                include_prompt_message_serializer=False,
+                include_retriever_attachment_loader=False,
+                include_jinja2_template_renderer=False,
+            )
+
+        wrap_model.assert_called_once_with(
+            node_data=node_data,
+            model_instance=sentinel.model_instance,
+            request_metadata={"app_id": "app-id"},
+            before_invoke=before_llm_invoke,
         )
         assert kwargs["model_instance"] is wrapped_model_instance
 

api/tests/unit_tests/core/workflow/test_node_runtime.py

@@ -228,7 +228,12 @@ def test_dify_prepared_llm_wraps_model_instance_calls() -> None:
     model_schema = _build_model_schema()
     model_instance = _ModelInstanceStub(model_schema=model_schema)
     model_type_instance = model_instance.model_type_instance
-    prepared = DifyPreparedLLM(model_instance, request_metadata={"app_id": "app-id"})
+    before_invoke = Mock(return_value={"temperature": 0.05})
+    prepared = DifyPreparedLLM(
+        model_instance,
+        request_metadata={"app_id": "app-id"},
+        before_invoke=before_invoke,
+    )
 
     assert prepared.provider == "langgenius/openai/openai"
     assert prepared.model_name == "gpt-4o-mini"
@@ -248,9 +253,10 @@ def test_dify_prepared_llm_wraps_model_instance_calls() -> None:
     )
 
     model_type_instance.get_model_schema.assert_called_once_with("gpt-4o-mini", {"api_key": "secret"})
+    before_invoke.assert_called_once_with([], {"temperature": 0.1})
     model_instance.invoke_llm.assert_called_once_with(
         prompt_messages=[],
-        model_parameters={"temperature": 0.1},
+        model_parameters={"temperature": 0.05},
         tools=[],
         stop=[],
         stream=False,
@@ -269,7 +275,8 @@ def test_dify_prepared_llm_requires_model_schema() -> None:
 
 def test_dify_prepared_llm_delegates_structured_output_helper(monkeypatch: pytest.MonkeyPatch) -> None:
     model_instance = _ModelInstanceStub(model_schema=_build_model_schema())
-    prepared = DifyPreparedLLM(model_instance)
+    before_invoke = Mock(return_value={"temperature": 0.15})
+    prepared = DifyPreparedLLM(model_instance, before_invoke=before_invoke)
     invoke_structured = MagicMock(return_value=sentinel.structured)
     monkeypatch.setattr(node_runtime, "invoke_llm_with_structured_output", invoke_structured)
 
@@ -282,13 +289,14 @@ def test_dify_prepared_llm_delegates_structured_output_helper(monkeypatch: pytes
     )
 
     assert result is sentinel.structured
+    before_invoke.assert_called_once_with([], {"temperature": 0.2})
     invoke_structured.assert_called_once_with(
         provider="langgenius/openai/openai",
         model_schema=prepared.get_model_schema(),
         model_instance=model_instance,
         prompt_messages=[],
         json_schema={"type": "object"},
-        model_parameters={"temperature": 0.2},
+        model_parameters={"temperature": 0.15},
         stop=["done"],
         stream=True,
     )
@@ -320,7 +328,8 @@ def test_dify_prepared_polling_llm_delegates_to_plugin_runtime() -> None:
         model_runtime=plugin_runtime,
     )
 
-    prepared = DifyPreparedPollingLLM(model_instance)
+    before_invoke = Mock(return_value={"temperature": 0.05})
+    prepared = DifyPreparedPollingLLM(model_instance, before_invoke=before_invoke)
 
     assert isinstance(prepared, LLMPollingCapableProtocol)
     assert (
@@ -333,6 +342,7 @@ def test_dify_prepared_polling_llm_delegates_to_plugin_runtime() -> None:
         )
         == polling_result
     )
+    before_invoke.assert_called_once_with([], {"temperature": 0.1})
     assert (
         prepared.check_llm_polling(
             plugin_state={"task_id": "poll-1"},
@@ -344,7 +354,7 @@ def test_dify_prepared_polling_llm_delegates_to_plugin_runtime() -> None:
         model="gpt-4o-mini",
         credentials={"api_key": "secret"},
         prompt_messages=[],
-        model_parameters={"temperature": 0.1},
+        model_parameters={"temperature": 0.05},
         tools=[],
         stop=("END",),
         json_schema={"type": "object"},

api/tests/unit_tests/services/plugin/test_plugin_auto_upgrade_service.py

@@ -1,89 +1,105 @@
 import logging
 from types import SimpleNamespace
 from unittest.mock import MagicMock, patch
+from uuid import uuid4
 
 import pytest
+from sqlalchemy import select
+from sqlalchemy.orm import Session
 
 from models.account import (
     TenantPluginAutoUpgradeCategory,
     TenantPluginAutoUpgradeMode,
+    TenantPluginAutoUpgradeStrategy,
     TenantPluginAutoUpgradeStrategySetting,
 )
+from services.plugin.plugin_auto_upgrade_service import PluginAutoUpgradeService
 
 MODULE = "services.plugin.plugin_auto_upgrade_service"
 PLUGIN_CATEGORY = TenantPluginAutoUpgradeCategory.TOOL
+STRATEGY_MODELS = (TenantPluginAutoUpgradeStrategy,)
 
 
-def _patched_session():
-    """Return a mock SQLAlchemy session for service calls."""
-    session = MagicMock()
-    return session
+def _strategy(
+    tenant_id: str,
+    *,
+    category: TenantPluginAutoUpgradeCategory = PLUGIN_CATEGORY,
+    setting: TenantPluginAutoUpgradeStrategySetting = TenantPluginAutoUpgradeStrategySetting.FIX_ONLY,
+    mode: TenantPluginAutoUpgradeMode = TenantPluginAutoUpgradeMode.EXCLUDE,
+    exclude: list[str] | None = None,
+    include: list[str] | None = None,
+    upgrade_time: int = 0,
+) -> TenantPluginAutoUpgradeStrategy:
+    return TenantPluginAutoUpgradeStrategy(
+        tenant_id=tenant_id,
+        category=category,
+        strategy_setting=setting,
+        upgrade_time_of_day=upgrade_time,
+        upgrade_mode=mode,
+        exclude_plugins=exclude or [],
+        include_plugins=include or [],
+    )
 
 
 class TestGetStrategy:
-    def test_returns_strategy_when_found(self):
-        session = _patched_session()
-        strategy = MagicMock()
-        session.scalar.return_value = strategy
+    @pytest.mark.parametrize("sqlite_session", [STRATEGY_MODELS], indirect=True)
+    def test_returns_strategy_when_found(self, sqlite_session: Session) -> None:
+        tenant_id = str(uuid4())
+        strategy = _strategy(tenant_id)
+        sqlite_session.add(strategy)
+        sqlite_session.commit()
 
-        from services.plugin.plugin_auto_upgrade_service import PluginAutoUpgradeService
-
-        result = PluginAutoUpgradeService.get_strategy("t1", PLUGIN_CATEGORY, session=session)
+        result = PluginAutoUpgradeService.get_strategy(tenant_id, PLUGIN_CATEGORY, session=sqlite_session)
 
         assert result is strategy
 
-    def test_returns_none_when_not_found(self):
-        session = _patched_session()
-        session.scalar.return_value = None
-
-        from services.plugin.plugin_auto_upgrade_service import PluginAutoUpgradeService
-
-        result = PluginAutoUpgradeService.get_strategy("t1", PLUGIN_CATEGORY, session=session)
-
-        assert result is None
+    @pytest.mark.parametrize("sqlite_session", [STRATEGY_MODELS], indirect=True)
+    def test_returns_none_when_not_found(self, sqlite_session: Session) -> None:
+        assert PluginAutoUpgradeService.get_strategy(str(uuid4()), PLUGIN_CATEGORY, session=sqlite_session) is None
 
 
 class TestChangeStrategy:
-    def test_creates_new_strategy(self):
-        session = _patched_session()
-        session.scalar.return_value = None
-
-        with patch(f"{MODULE}.select"), patch(f"{MODULE}.TenantPluginAutoUpgradeStrategy") as strat_cls:
-            strat_cls.return_value = MagicMock()
-            from services.plugin.plugin_auto_upgrade_service import PluginAutoUpgradeService
-
-            result = PluginAutoUpgradeService.change_strategy(
-                "t1",
-                TenantPluginAutoUpgradeStrategySetting.FIX_ONLY,
-                3,
-                TenantPluginAutoUpgradeMode.ALL,
-                [],
-                [],
-                category=PLUGIN_CATEGORY,
-                session=session,
-            )
-
-        assert result is True
-        session.add.assert_called_once()
-
-    def test_updates_existing_strategy(self):
-        session = _patched_session()
-        existing = MagicMock()
-        session.scalar.return_value = existing
-
-        from services.plugin.plugin_auto_upgrade_service import PluginAutoUpgradeService
+    @pytest.mark.parametrize("sqlite_session", [STRATEGY_MODELS], indirect=True)
+    def test_creates_new_strategy(self, sqlite_session: Session) -> None:
+        tenant_id = str(uuid4())
 
         result = PluginAutoUpgradeService.change_strategy(
-            "t1",
+            tenant_id,
+            TenantPluginAutoUpgradeStrategySetting.FIX_ONLY,
+            3,
+            TenantPluginAutoUpgradeMode.ALL,
+            [],
+            [],
+            category=PLUGIN_CATEGORY,
+            session=sqlite_session,
+        )
+
+        strategy = sqlite_session.scalar(select(TenantPluginAutoUpgradeStrategy))
+        assert result is True
+        assert strategy is not None
+        assert strategy.tenant_id == tenant_id
+        assert strategy.upgrade_time_of_day == 3
+        assert strategy.upgrade_mode == TenantPluginAutoUpgradeMode.ALL
+
+    @pytest.mark.parametrize("sqlite_session", [STRATEGY_MODELS], indirect=True)
+    def test_updates_existing_strategy(self, sqlite_session: Session) -> None:
+        tenant_id = str(uuid4())
+        existing = _strategy(tenant_id)
+        sqlite_session.add(existing)
+        sqlite_session.commit()
+
+        result = PluginAutoUpgradeService.change_strategy(
+            tenant_id,
             TenantPluginAutoUpgradeStrategySetting.LATEST,
             5,
             TenantPluginAutoUpgradeMode.PARTIAL,
             ["p1"],
             ["p2"],
             category=PLUGIN_CATEGORY,
-            session=session,
+            session=sqlite_session,
         )
 
+        sqlite_session.refresh(existing)
         assert result is True
         assert existing.strategy_setting == TenantPluginAutoUpgradeStrategySetting.LATEST
         assert existing.upgrade_time_of_day == 5
@@ -93,157 +109,115 @@ class TestChangeStrategy:
 
 
 class TestExcludePlugin:
-    def test_creates_default_strategy_when_none_exists(self):
-        session = _patched_session()
-        session.scalar.return_value = None
+    @pytest.mark.parametrize("sqlite_session", [STRATEGY_MODELS], indirect=True)
+    def test_creates_default_strategy_when_none_exists(self, sqlite_session: Session) -> None:
+        tenant_id = str(uuid4())
 
-        with (
-            patch(f"{MODULE}.select"),
-            patch(f"{MODULE}.TenantPluginAutoUpgradeStrategy"),
-        ):
-            from services.plugin.plugin_auto_upgrade_service import PluginAutoUpgradeService
-
-            result = PluginAutoUpgradeService.exclude_plugin(
-                "t1",
-                "plugin-1",
-                PLUGIN_CATEGORY,
-                session=session,
-            )
+        result = PluginAutoUpgradeService.exclude_plugin(tenant_id, "plugin-1", PLUGIN_CATEGORY, session=sqlite_session)
 
+        strategy = sqlite_session.scalar(select(TenantPluginAutoUpgradeStrategy))
         assert result is True
-        session.add.assert_called_once()
+        assert strategy is not None
+        assert strategy.exclude_plugins == ["plugin-1"]
 
-    def test_appends_to_exclude_list_in_exclude_mode(self):
-        session = _patched_session()
-        existing = MagicMock()
-        existing.upgrade_mode = TenantPluginAutoUpgradeMode.EXCLUDE
-        existing.exclude_plugins = ["p-existing"]
-        session.scalar.return_value = existing
+    @pytest.mark.parametrize("sqlite_session", [STRATEGY_MODELS], indirect=True)
+    def test_appends_to_exclude_list_in_exclude_mode(self, sqlite_session: Session) -> None:
+        tenant_id = str(uuid4())
+        existing = _strategy(tenant_id, exclude=["p-existing"])
+        sqlite_session.add(existing)
+        sqlite_session.commit()
 
-        with patch(f"{MODULE}.select"), patch(f"{MODULE}.TenantPluginAutoUpgradeStrategy") as strat_cls:
-            strat_cls.UpgradeMode.EXCLUDE = "exclude"
-            strat_cls.UpgradeMode.PARTIAL = "partial"
-            strat_cls.UpgradeMode.ALL = "all"
-            from services.plugin.plugin_auto_upgrade_service import PluginAutoUpgradeService
+        PluginAutoUpgradeService.exclude_plugin(tenant_id, "p-new", PLUGIN_CATEGORY, session=sqlite_session)
 
-            result = PluginAutoUpgradeService.exclude_plugin("t1", "p-new", PLUGIN_CATEGORY, session=session)
-
-        assert result is True
+        sqlite_session.refresh(existing)
         assert existing.exclude_plugins == ["p-existing", "p-new"]
 
-    def test_removes_from_include_list_in_partial_mode(self):
-        session = _patched_session()
-        existing = MagicMock()
-        existing.upgrade_mode = TenantPluginAutoUpgradeMode.PARTIAL
-        existing.include_plugins = ["p1", "p2"]
-        session.scalar.return_value = existing
+    @pytest.mark.parametrize("sqlite_session", [STRATEGY_MODELS], indirect=True)
+    def test_removes_from_include_list_in_partial_mode(self, sqlite_session: Session) -> None:
+        tenant_id = str(uuid4())
+        existing = _strategy(tenant_id, mode=TenantPluginAutoUpgradeMode.PARTIAL, include=["p1", "p2"])
+        sqlite_session.add(existing)
+        sqlite_session.commit()
 
-        with patch(f"{MODULE}.select"), patch(f"{MODULE}.TenantPluginAutoUpgradeStrategy") as strat_cls:
-            strat_cls.UpgradeMode.EXCLUDE = "exclude"
-            strat_cls.UpgradeMode.PARTIAL = "partial"
-            strat_cls.UpgradeMode.ALL = "all"
-            from services.plugin.plugin_auto_upgrade_service import PluginAutoUpgradeService
+        PluginAutoUpgradeService.exclude_plugin(tenant_id, "p1", PLUGIN_CATEGORY, session=sqlite_session)
 
-            result = PluginAutoUpgradeService.exclude_plugin("t1", "p1", PLUGIN_CATEGORY, session=session)
-
-        assert result is True
+        sqlite_session.refresh(existing)
         assert existing.include_plugins == ["p2"]
 
-    def test_switches_to_exclude_mode_from_all(self):
-        session = _patched_session()
-        existing = MagicMock()
-        existing.upgrade_mode = TenantPluginAutoUpgradeMode.ALL
-        session.scalar.return_value = existing
+    @pytest.mark.parametrize("sqlite_session", [STRATEGY_MODELS], indirect=True)
+    def test_switches_to_exclude_mode_from_all(self, sqlite_session: Session) -> None:
+        tenant_id = str(uuid4())
+        existing = _strategy(tenant_id, mode=TenantPluginAutoUpgradeMode.ALL)
+        sqlite_session.add(existing)
+        sqlite_session.commit()
 
-        with patch(f"{MODULE}.select"), patch(f"{MODULE}.TenantPluginAutoUpgradeStrategy") as strat_cls:
-            strat_cls.UpgradeMode.EXCLUDE = "exclude"
-            strat_cls.UpgradeMode.PARTIAL = "partial"
-            strat_cls.UpgradeMode.ALL = "all"
-            from services.plugin.plugin_auto_upgrade_service import PluginAutoUpgradeService
+        PluginAutoUpgradeService.exclude_plugin(tenant_id, "p1", PLUGIN_CATEGORY, session=sqlite_session)
 
-            result = PluginAutoUpgradeService.exclude_plugin("t1", "p1", PLUGIN_CATEGORY, session=session)
-
-        assert result is True
+        sqlite_session.refresh(existing)
         assert existing.upgrade_mode == TenantPluginAutoUpgradeMode.EXCLUDE
         assert existing.exclude_plugins == ["p1"]
 
-    def test_no_duplicate_in_exclude_list(self):
-        session = _patched_session()
-        existing = MagicMock()
-        existing.upgrade_mode = TenantPluginAutoUpgradeMode.EXCLUDE
-        existing.exclude_plugins = ["p1"]
-        session.scalar.return_value = existing
+    @pytest.mark.parametrize("sqlite_session", [STRATEGY_MODELS], indirect=True)
+    def test_no_duplicate_in_exclude_list(self, sqlite_session: Session) -> None:
+        tenant_id = str(uuid4())
+        existing = _strategy(tenant_id, exclude=["p1"])
+        sqlite_session.add(existing)
+        sqlite_session.commit()
 
-        with patch(f"{MODULE}.select"), patch(f"{MODULE}.TenantPluginAutoUpgradeStrategy") as strat_cls:
-            strat_cls.UpgradeMode.EXCLUDE = "exclude"
-            strat_cls.UpgradeMode.PARTIAL = "partial"
-            strat_cls.UpgradeMode.ALL = "all"
-            from services.plugin.plugin_auto_upgrade_service import PluginAutoUpgradeService
-
-            PluginAutoUpgradeService.exclude_plugin("t1", "p1", PLUGIN_CATEGORY, session=session)
+        PluginAutoUpgradeService.exclude_plugin(tenant_id, "p1", PLUGIN_CATEGORY, session=sqlite_session)
 
+        sqlite_session.refresh(existing)
         assert existing.exclude_plugins == ["p1"]
 
 
 class TestBackfillStrategyCategories:
-    def test_creates_default_missing_categories_without_fetching_daemon(self):
-        session = _patched_session()
-        tool_strategy = SimpleNamespace(
-            category=TenantPluginAutoUpgradeCategory.TOOL,
-            strategy_setting=TenantPluginAutoUpgradeStrategySetting.FIX_ONLY,
-            upgrade_time_of_day=0,
-            upgrade_mode=TenantPluginAutoUpgradeMode.EXCLUDE,
-            exclude_plugins=[],
-            include_plugins=[],
-        )
-        session.scalars.return_value.all.return_value = [tool_strategy]
+    @pytest.mark.parametrize("sqlite_session", [STRATEGY_MODELS], indirect=True)
+    def test_creates_default_missing_categories_without_fetching_daemon(self, sqlite_session: Session) -> None:
+        tenant_id = str(uuid4())
+        tool_strategy = _strategy(tenant_id)
+        sqlite_session.add(tool_strategy)
+        sqlite_session.commit()
         installer = MagicMock()
 
         with patch(f"{MODULE}.PluginInstaller", return_value=installer):
-            from services.plugin.plugin_auto_upgrade_service import PluginAutoUpgradeService
-
-            result = PluginAutoUpgradeService.backfill_strategy_categories("t1", session=session)
-            expected_time = PluginAutoUpgradeService.default_upgrade_time_of_day("t1")
+            result = PluginAutoUpgradeService.backfill_strategy_categories(tenant_id, session=sqlite_session)
+            expected_time = PluginAutoUpgradeService.default_upgrade_time_of_day(tenant_id)
 
+        strategies = list(sqlite_session.scalars(select(TenantPluginAutoUpgradeStrategy)).all())
         assert result.created_count == len(TenantPluginAutoUpgradeCategory) - 1
         assert result.normalized is False
         installer.list_plugins.assert_not_called()
+        assert len(strategies) == len(TenantPluginAutoUpgradeCategory)
         assert tool_strategy.upgrade_time_of_day == expected_time
-        created_strategies = [call.args[0] for call in session.add.call_args_list]
         model_strategy = next(
-            strategy for strategy in created_strategies if strategy.category == TenantPluginAutoUpgradeCategory.MODEL
+            strategy for strategy in strategies if strategy.category == TenantPluginAutoUpgradeCategory.MODEL
         )
         assert model_strategy.strategy_setting == TenantPluginAutoUpgradeStrategySetting.LATEST
         assert model_strategy.upgrade_time_of_day == expected_time
 
-    def test_default_upgrade_time_is_aligned_to_fifteen_minutes(self):
-        from services.plugin.plugin_auto_upgrade_service import PluginAutoUpgradeService
-
-        default_time = PluginAutoUpgradeService.default_upgrade_time_of_day("t1")
-
+    def test_default_upgrade_time_is_aligned_to_fifteen_minutes(self) -> None:
+        default_time = PluginAutoUpgradeService.default_upgrade_time_of_day(str(uuid4()))
         assert default_time % (15 * 60) == 0
         assert 0 <= default_time < 24 * 60 * 60
 
-    def test_creates_missing_categories_and_splits_known_plugins(self, caplog: pytest.LogCaptureFixture):
-        session = _patched_session()
-        tool_strategy = SimpleNamespace(
-            category=TenantPluginAutoUpgradeCategory.TOOL,
-            strategy_setting=TenantPluginAutoUpgradeStrategySetting.FIX_ONLY,
-            upgrade_time_of_day=0,
-            upgrade_mode=TenantPluginAutoUpgradeMode.EXCLUDE,
-            exclude_plugins=["tool-plugin", "model-plugin", "unknown-plugin"],
-            include_plugins=["model-plugin", "tool-plugin"],
+    @pytest.mark.parametrize("sqlite_session", [STRATEGY_MODELS], indirect=True)
+    def test_creates_missing_categories_and_splits_known_plugins(
+        self, sqlite_session: Session, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        tenant_id = str(uuid4())
+        tool_strategy = _strategy(
+            tenant_id,
+            exclude=["tool-plugin", "model-plugin", "unknown-plugin"],
+            include=["model-plugin", "tool-plugin"],
         )
-        model_strategy = SimpleNamespace(
+        model_strategy = _strategy(
+            tenant_id,
             category=TenantPluginAutoUpgradeCategory.MODEL,
-            strategy_setting=TenantPluginAutoUpgradeStrategySetting.FIX_ONLY,
-            upgrade_time_of_day=0,
-            upgrade_mode=TenantPluginAutoUpgradeMode.EXCLUDE,
-            exclude_plugins=["tool-plugin", "model-plugin", "unknown-plugin"],
-            include_plugins=["model-plugin", "tool-plugin"],
+            exclude=["tool-plugin", "model-plugin", "unknown-plugin"],
+            include=["model-plugin", "tool-plugin"],
         )
-        session.scalars.return_value.all.return_value = [tool_strategy, model_strategy]
-
+        sqlite_session.add_all([tool_strategy, model_strategy])
+        sqlite_session.commit()
         installed_plugins = [
             SimpleNamespace(
                 plugin_id="tool-plugin",
@@ -261,18 +235,17 @@ class TestBackfillStrategyCategories:
             patch(f"{MODULE}.PluginInstaller", return_value=installer),
             caplog.at_level(logging.WARNING, logger=MODULE),
         ):
-            from services.plugin.plugin_auto_upgrade_service import PluginAutoUpgradeService
-
-            result = PluginAutoUpgradeService.backfill_strategy_categories("t1", session=session)
+            result = PluginAutoUpgradeService.backfill_strategy_categories(tenant_id, session=sqlite_session)
 
+        strategies = list(sqlite_session.scalars(select(TenantPluginAutoUpgradeStrategy)).all())
         assert result.created_count == len(TenantPluginAutoUpgradeCategory) - 2
         assert result.normalized is True
-        assert session.add.call_count == len(TenantPluginAutoUpgradeCategory) - 2
+        assert len(strategies) == len(TenantPluginAutoUpgradeCategory)
         assert tool_strategy.exclude_plugins == ["tool-plugin"]
         assert tool_strategy.include_plugins == ["tool-plugin"]
         assert model_strategy.exclude_plugins == ["model-plugin"]
         assert model_strategy.include_plugins == ["model-plugin"]
         assert (
             "Skipped unknown plugin IDs while backfilling plugin auto-upgrade strategies: "
-            "tenant_id=t1, field=exclude_plugins, plugin_ids=['unknown-plugin']" in caplog.messages
+            f"tenant_id={tenant_id}, field=exclude_plugins, plugin_ids=['unknown-plugin']" in caplog.messages
         )

api/tests/unit_tests/services/plugin/test_plugin_service.py

@@ -7,28 +7,19 @@ import pytest
 import zstandard
 from pydantic import TypeAdapter
 from redis import RedisError
+from sqlalchemy.orm import Session
 
+from core.helper.model_provider_cache import ProviderCredentialsCacheType
 from core.plugin.entities.plugin import PluginCategory, PluginInstallationSource
 from core.plugin.entities.plugin_daemon import PluginInstallTask, PluginInstallTaskStatus, PluginModelProviderEntity
 from graphon.model_runtime.entities.common_entities import I18nObject
 from graphon.model_runtime.entities.provider_entities import ConfigurateMethod, ProviderEntity
+from models.provider import Provider, ProviderCredential, ProviderType, TenantPreferredModelProvider
 
 MODULE = "core.plugin.plugin_service"
-
-
-class _FakeSession:
-    def __init__(self) -> None:
-        self.execute = Mock()
-        self.scalars = Mock(return_value=SimpleNamespace(all=Mock(return_value=[])))
-
-    def __enter__(self) -> "_FakeSession":
-        return self
-
-    def __exit__(self, exc_type, exc, traceback) -> None:
-        return None
-
-    def begin(self) -> "_FakeSession":
-        return self
+TENANT_ID = "11111111-1111-1111-1111-111111111111"
+OTHER_TENANT_ID = "22222222-2222-2222-2222-222222222222"
+USER_ID = "33333333-3333-3333-3333-333333333333"
 
 
 def _build_provider_entity(provider: str = "openai") -> ProviderEntity:
@@ -1166,19 +1157,72 @@ class TestPluginModelProviderCacheInvalidation:
         assert result is True
         invalidate_cache.assert_called_once_with("tenant-1")
 
-    def test_uninstall_existing_plugin_invalidates_cache_after_credential_cleanup(self) -> None:
+    @pytest.mark.parametrize(
+        "sqlite_session", [(Provider, ProviderCredential, TenantPreferredModelProvider)], indirect=True
+    )
+    def test_uninstall_existing_plugin_invalidates_cache_after_credential_cleanup(
+        self, sqlite_session: Session
+    ) -> None:
         """Successful uninstall with plugin metadata also invalidates the mutated tenant provider cache."""
+        plugin_id = "langgenius/openai"
+        provider_name = f"{plugin_id}/openai"
         plugin = SimpleNamespace(
             installation_id="installation-1",
-            plugin_id="langgenius/openai",
+            plugin_id=plugin_id,
             plugin_unique_identifier="langgenius/openai:1.0.0",
         )
-        session = _FakeSession()
+        credential = ProviderCredential(
+            tenant_id=TENANT_ID,
+            provider_name=provider_name,
+            credential_name="Target credential",
+            encrypted_config="{}",
+            user_id=USER_ID,
+        )
+        other_credential = ProviderCredential(
+            tenant_id=OTHER_TENANT_ID,
+            provider_name=provider_name,
+            credential_name="Other credential",
+            encrypted_config="{}",
+            user_id=USER_ID,
+        )
+        sqlite_session.add_all([credential, other_credential])
+        sqlite_session.flush()
+        provider = Provider(
+            tenant_id=TENANT_ID,
+            provider_name=provider_name,
+            provider_type=ProviderType.CUSTOM,
+            credential_id=credential.id,
+        )
+        other_provider = Provider(
+            tenant_id=OTHER_TENANT_ID,
+            provider_name=provider_name,
+            provider_type=ProviderType.CUSTOM,
+            credential_id=other_credential.id,
+        )
+        preferred_provider = TenantPreferredModelProvider(
+            tenant_id=TENANT_ID,
+            provider_name=provider_name,
+            preferred_provider_type=ProviderType.CUSTOM,
+        )
+        other_preferred_provider = TenantPreferredModelProvider(
+            tenant_id=OTHER_TENANT_ID,
+            provider_name=provider_name,
+            preferred_provider_type=ProviderType.CUSTOM,
+        )
+        sqlite_session.add_all([provider, other_provider, preferred_provider, other_preferred_provider])
+        sqlite_session.commit()
+        credential_id = credential.id
+        other_credential_id = other_credential.id
+        provider_id = provider.id
+        other_provider_id = other_provider.id
+        preferred_provider_id = preferred_provider.id
+        other_preferred_provider_id = other_preferred_provider.id
+
         with (
-            patch(f"{MODULE}.db", SimpleNamespace(engine=object())),
+            patch(f"{MODULE}.db", SimpleNamespace(engine=sqlite_session.get_bind())),
             patch(f"{MODULE}.dify_config") as mock_config,
             patch(f"{MODULE}.PluginInstaller") as installer_cls,
-            patch(f"{MODULE}.Session", return_value=session),
+            patch(f"{MODULE}.ProviderCredentialsCache") as credentials_cache,
             patch(f"{MODULE}.PluginService.invalidate_plugin_model_providers_cache") as invalidate_cache,
         ):
             mock_config.ENTERPRISE_ENABLED = False
@@ -1188,8 +1232,26 @@ class TestPluginModelProviderCacheInvalidation:
 
             from core.plugin.plugin_service import PluginService
 
-            result = PluginService.uninstall("tenant-1", "installation-1")
+            result = PluginService.uninstall(TENANT_ID, "installation-1")
 
         assert result is True
-        installer.uninstall.assert_called_once_with("tenant-1", "installation-1")
-        invalidate_cache.assert_called_once_with("tenant-1")
+        installer.uninstall.assert_called_once_with(TENANT_ID, "installation-1")
+        invalidate_cache.assert_called_once_with(TENANT_ID)
+        credentials_cache.assert_called_once_with(
+            tenant_id=TENANT_ID,
+            identity_id=provider_id,
+            cache_type=ProviderCredentialsCacheType.PROVIDER,
+        )
+        credentials_cache.return_value.delete.assert_called_once_with()
+
+        sqlite_session.expunge_all()
+        assert sqlite_session.get(ProviderCredential, credential_id) is None
+        persisted_provider = sqlite_session.get(Provider, provider_id)
+        assert persisted_provider is not None
+        assert persisted_provider.credential_id is None
+        assert sqlite_session.get(TenantPreferredModelProvider, preferred_provider_id) is None
+        assert sqlite_session.get(ProviderCredential, other_credential_id) is not None
+        persisted_other_provider = sqlite_session.get(Provider, other_provider_id)
+        assert persisted_other_provider is not None
+        assert persisted_other_provider.credential_id == other_credential_id
+        assert sqlite_session.get(TenantPreferredModelProvider, other_preferred_provider_id) is not None

api/tests/unit_tests/services/plugin/test_plugin_service_installation.py

@@ -8,6 +8,7 @@ verification, marketplace upgrade flows, and uninstall with credential cleanup.
 from __future__ import annotations
 
 from collections.abc import Iterator
+from typing import cast
 from unittest.mock import MagicMock, patch
 from uuid import uuid4
 
@@ -19,7 +20,6 @@ from sqlalchemy.orm import Session
 from core.plugin.entities.plugin import PluginInstallationSource
 from core.plugin.entities.plugin_daemon import PluginVerification
 from core.plugin.plugin_service import PluginService
-from enums.deployment_edition import DeploymentEdition
 from models import ProviderType
 from models.engine import db
 from models.provider import Provider, ProviderCredential, TenantPreferredModelProvider
@@ -27,20 +27,16 @@ from services.errors.plugin import PluginInstallationForbiddenError
 from services.feature_service import (
     PluginInstallationPermissionModel,
     PluginInstallationScope,
-    SystemFeatureModel,
 )
 
 
-def _make_features(
+def _make_permission(
     restrict_to_marketplace: bool = False,
     scope: PluginInstallationScope = PluginInstallationScope.ALL,
-) -> SystemFeatureModel:
-    return SystemFeatureModel(
-        deployment_edition=DeploymentEdition.COMMUNITY,
-        plugin_installation_permission=PluginInstallationPermissionModel(
-            restrict_to_marketplace_only=restrict_to_marketplace,
-            plugin_installation_scope=scope,
-        ),
+) -> PluginInstallationPermissionModel:
+    return PluginInstallationPermissionModel(
+        restrict_to_marketplace_only=restrict_to_marketplace,
+        plugin_installation_scope=scope,
     )
 
 
@@ -119,22 +115,31 @@ class TestFetchLatestPluginVersion:
 class TestCheckMarketplaceOnlyPermission:
     @patch("core.plugin.plugin_service.FeatureService")
     def test_raises_when_restricted(self, mock_fs):
-        mock_fs.get_system_features.return_value = _make_features(restrict_to_marketplace=True)
+        mock_fs.get_plugin_installation_permission.return_value = _make_permission(restrict_to_marketplace=True)
 
         with pytest.raises(PluginInstallationForbiddenError):
             PluginService._check_marketplace_only_permission()
 
     @patch("core.plugin.plugin_service.FeatureService")
     def test_passes_when_not_restricted(self, mock_fs):
-        mock_fs.get_system_features.return_value = _make_features(restrict_to_marketplace=False)
+        mock_fs.get_plugin_installation_permission.return_value = _make_permission(restrict_to_marketplace=False)
 
         PluginService._check_marketplace_only_permission()  # should not raise
 
+    @patch("core.plugin.plugin_service.FeatureService")
+    def test_raises_when_scope_denies_all(self, mock_fs):
+        mock_fs.get_plugin_installation_permission.return_value = _make_permission(scope=PluginInstallationScope.NONE)
+
+        with pytest.raises(PluginInstallationForbiddenError, match="not allowed"):
+            PluginService._check_marketplace_only_permission()
+
 
 class TestCheckPluginInstallationScope:
     @patch("core.plugin.plugin_service.FeatureService")
     def test_official_only_allows_langgenius(self, mock_fs):
-        mock_fs.get_system_features.return_value = _make_features(scope=PluginInstallationScope.OFFICIAL_ONLY)
+        mock_fs.get_plugin_installation_permission.return_value = _make_permission(
+            scope=PluginInstallationScope.OFFICIAL_ONLY
+        )
         verification = MagicMock()
         verification.authorized_category = PluginVerification.AuthorizedCategory.Langgenius
 
@@ -142,14 +147,16 @@ class TestCheckPluginInstallationScope:
 
     @patch("core.plugin.plugin_service.FeatureService")
     def test_official_only_rejects_third_party(self, mock_fs):
-        mock_fs.get_system_features.return_value = _make_features(scope=PluginInstallationScope.OFFICIAL_ONLY)
+        mock_fs.get_plugin_installation_permission.return_value = _make_permission(
+            scope=PluginInstallationScope.OFFICIAL_ONLY
+        )
 
         with pytest.raises(PluginInstallationForbiddenError):
             PluginService._check_plugin_installation_scope(None)
 
     @patch("core.plugin.plugin_service.FeatureService")
     def test_official_and_partners_allows_partner(self, mock_fs):
-        mock_fs.get_system_features.return_value = _make_features(
+        mock_fs.get_plugin_installation_permission.return_value = _make_permission(
             scope=PluginInstallationScope.OFFICIAL_AND_SPECIFIC_PARTNERS
         )
         verification = MagicMock()
@@ -159,7 +166,7 @@ class TestCheckPluginInstallationScope:
 
     @patch("core.plugin.plugin_service.FeatureService")
     def test_official_and_partners_rejects_none(self, mock_fs):
-        mock_fs.get_system_features.return_value = _make_features(
+        mock_fs.get_plugin_installation_permission.return_value = _make_permission(
             scope=PluginInstallationScope.OFFICIAL_AND_SPECIFIC_PARTNERS
         )
 
@@ -168,7 +175,7 @@ class TestCheckPluginInstallationScope:
 
     @patch("core.plugin.plugin_service.FeatureService")
     def test_none_scope_always_raises(self, mock_fs):
-        mock_fs.get_system_features.return_value = _make_features(scope=PluginInstallationScope.NONE)
+        mock_fs.get_plugin_installation_permission.return_value = _make_permission(scope=PluginInstallationScope.NONE)
         verification = MagicMock()
         verification.authorized_category = PluginVerification.AuthorizedCategory.Langgenius
 
@@ -177,10 +184,19 @@ class TestCheckPluginInstallationScope:
 
     @patch("core.plugin.plugin_service.FeatureService")
     def test_all_scope_passes_any(self, mock_fs):
-        mock_fs.get_system_features.return_value = _make_features(scope=PluginInstallationScope.ALL)
+        mock_fs.get_plugin_installation_permission.return_value = _make_permission(scope=PluginInstallationScope.ALL)
 
         PluginService._check_plugin_installation_scope(None)  # should not raise
 
+    @patch("core.plugin.plugin_service.FeatureService")
+    def test_unknown_scope_always_raises(self, mock_fs):
+        permission = _make_permission()
+        permission.plugin_installation_scope = cast(PluginInstallationScope, "unknown-scope")
+        mock_fs.get_plugin_installation_permission.return_value = permission
+
+        with pytest.raises(PluginInstallationForbiddenError, match="policy is invalid"):
+            PluginService._check_plugin_installation_scope(None)
+
 
 class TestGetPluginIconUrl:
     @patch("core.plugin.plugin_service.dify_config")
@@ -248,7 +264,7 @@ class TestUpgradePluginWithMarketplace:
     @patch("core.plugin.plugin_service.dify_config")
     def test_skips_download_when_already_installed(self, mock_config, mock_installer_cls, mock_fs, mock_marketplace):
         mock_config.MARKETPLACE_ENABLED = True
-        mock_fs.get_system_features.return_value = _make_features()
+        mock_fs.get_plugin_installation_permission.return_value = _make_permission()
         installer = mock_installer_cls.return_value
         installer.fetch_plugin_manifest.return_value = MagicMock()
         installer.upgrade_plugin.return_value = MagicMock()
@@ -264,7 +280,7 @@ class TestUpgradePluginWithMarketplace:
     @patch("core.plugin.plugin_service.dify_config")
     def test_downloads_when_not_installed(self, mock_config, mock_installer_cls, mock_fs, mock_download):
         mock_config.MARKETPLACE_ENABLED = True
-        mock_fs.get_system_features.return_value = _make_features()
+        mock_fs.get_plugin_installation_permission.return_value = _make_permission()
         installer = mock_installer_cls.return_value
         installer.fetch_plugin_manifest.side_effect = RuntimeError("not found")
         mock_download.return_value = b"pkg-bytes"
@@ -283,7 +299,7 @@ class TestUpgradePluginWithGithub:
     @patch("core.plugin.plugin_service.FeatureService")
     @patch("core.plugin.plugin_service.PluginInstaller")
     def test_checks_marketplace_permission_and_delegates(self, mock_installer_cls: MagicMock, mock_fs: MagicMock):
-        mock_fs.get_system_features.return_value = _make_features()
+        mock_fs.get_plugin_installation_permission.return_value = _make_permission()
         installer = mock_installer_cls.return_value
         installer.upgrade_plugin.return_value = MagicMock()
 
@@ -298,7 +314,7 @@ class TestUploadPkg:
     @patch("core.plugin.plugin_service.FeatureService")
     @patch("core.plugin.plugin_service.PluginInstaller")
     def test_runs_permission_and_scope_checks(self, mock_installer_cls: MagicMock, mock_fs: MagicMock):
-        mock_fs.get_system_features.return_value = _make_features()
+        mock_fs.get_plugin_installation_permission.return_value = _make_permission()
         upload_resp = MagicMock()
         upload_resp.verification = None
         mock_installer_cls.return_value.upload_pkg.return_value = upload_resp
@@ -322,7 +338,7 @@ class TestInstallFromMarketplacePkg:
     @patch("core.plugin.plugin_service.dify_config")
     def test_downloads_when_not_cached(self, mock_config, mock_installer_cls, mock_fs, mock_download):
         mock_config.MARKETPLACE_ENABLED = True
-        mock_fs.get_system_features.return_value = _make_features()
+        mock_fs.get_plugin_installation_permission.return_value = _make_permission()
         installer = mock_installer_cls.return_value
         installer.fetch_plugin_manifest.side_effect = RuntimeError("not found")
         mock_download.return_value = b"pkg"
@@ -344,7 +360,7 @@ class TestInstallFromMarketplacePkg:
     @patch("core.plugin.plugin_service.dify_config")
     def test_uses_cached_when_already_downloaded(self, mock_config, mock_installer_cls: MagicMock, mock_fs: MagicMock):
         mock_config.MARKETPLACE_ENABLED = True
-        mock_fs.get_system_features.return_value = _make_features()
+        mock_fs.get_plugin_installation_permission.return_value = _make_permission()
         installer = mock_installer_cls.return_value
         installer.fetch_plugin_manifest.return_value = MagicMock()
         decode_resp = MagicMock()

api/tests/unit_tests/services/test_app_task_service.py

@@ -14,7 +14,7 @@ class TestAppTaskService:
         ("app_mode", "should_call_graph_engine"),
         [
             (AppMode.CHAT, False),
-            (AppMode.COMPLETION, False),
+            (AppMode.COMPLETION, True),
             (AppMode.AGENT_CHAT, False),
             (AppMode.AGENT, False),
             (AppMode.CHANNEL, False),

api/tests/unit_tests/services/test_feature_service_plugin_installation_permission.py

@@ -0,0 +1,92 @@
+import logging
+
+import pytest
+
+from enums.deployment_edition import DeploymentEdition
+from services import feature_service as feature_service_module
+from services.feature_service import FeatureService, PluginInstallationScope, SystemFeatureModel
+
+
+def test_get_plugin_installation_permission_defaults_to_all_for_non_enterprise(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(feature_service_module.dify_config, "ENTERPRISE_ENABLED", False)
+
+    permission = FeatureService.get_plugin_installation_permission()
+
+    assert permission.plugin_installation_scope is PluginInstallationScope.ALL
+    assert permission.restrict_to_marketplace_only is False
+
+
+def test_get_plugin_installation_permission_parses_enterprise_policy(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(feature_service_module.dify_config, "ENTERPRISE_ENABLED", True)
+    monkeypatch.setattr(
+        feature_service_module.EnterpriseService,
+        "get_info",
+        staticmethod(
+            lambda: {
+                "PluginInstallationPermission": {
+                    "pluginInstallationScope": "official_only",
+                    "restrictToMarketplaceOnly": True,
+                }
+            }
+        ),
+    )
+
+    permission = FeatureService.get_plugin_installation_permission()
+
+    assert permission.plugin_installation_scope is PluginInstallationScope.OFFICIAL_ONLY
+    assert permission.restrict_to_marketplace_only is True
+
+
+@pytest.mark.parametrize(
+    "invalid_permission",
+    [
+        {
+            "pluginInstallationScope": "unknown-scope",
+            "restrictToMarketplaceOnly": False,
+        },
+        {
+            "pluginInstallationScope": "all",
+            "restrictToMarketplaceOnly": "false",
+        },
+    ],
+    ids=["unknown_scope", "non_boolean_marketplace_restriction"],
+)
+def test_invalid_enterprise_policy_denies_all_plugin_installations(
+    caplog: pytest.LogCaptureFixture,
+    invalid_permission: dict[str, object],
+) -> None:
+    with caplog.at_level(logging.ERROR, logger="services.feature_service"):
+        permission = FeatureService._resolve_plugin_installation_permission(
+            {"PluginInstallationPermission": invalid_permission}
+        )
+
+    assert permission.plugin_installation_scope is PluginInstallationScope.NONE
+    assert permission.restrict_to_marketplace_only is True
+    assert "denying all plugin installations" in caplog.text
+
+
+def test_system_features_exposes_only_validated_plugin_installation_policy(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        feature_service_module.EnterpriseService,
+        "get_info",
+        staticmethod(
+            lambda: {
+                "PluginInstallationPermission": {
+                    "pluginInstallationScope": "unknown-scope",
+                    "restrictToMarketplaceOnly": False,
+                }
+            }
+        ),
+    )
+    features = SystemFeatureModel(deployment_edition=DeploymentEdition.ENTERPRISE)
+
+    FeatureService._fulfill_params_from_enterprise(features)
+
+    assert features.plugin_installation_permission.plugin_installation_scope is PluginInstallationScope.NONE
+    assert features.plugin_installation_permission.restrict_to_marketplace_only is True

api/tests/unit_tests/services/test_file_service.py

@@ -1,6 +1,8 @@
 import base64
 import hashlib
 import os
+from collections.abc import Iterator
+from datetime import UTC, datetime
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -9,6 +11,8 @@ from sqlalchemy.orm import Session, sessionmaker
 from werkzeug.exceptions import NotFound
 
 from configs import dify_config
+from extensions.storage.storage_type import StorageType
+from models.base import TypeBase
 from models.enums import CreatorUserRole
 from models.model import Account, EndUser, UploadFile
 from services.errors.file import BlockedFileExtensionError, FileTooLargeError, UnsupportedFileTypeError
@@ -17,31 +21,54 @@ from services.file_service import FileService
 
 class TestFileService:
     @pytest.fixture
-    def mock_db_session(self):
-        session = MagicMock(spec=Session)
-        # Mock context manager behavior
-        session.__enter__.return_value = session
-        return session
+    def sqlite_session_maker(self, sqlite_engine: Engine) -> sessionmaker[Session]:
+        TypeBase.metadata.create_all(sqlite_engine, tables=[TypeBase.metadata.tables[UploadFile.__tablename__]])
+        return sessionmaker(bind=sqlite_engine, expire_on_commit=False)
 
     @pytest.fixture
-    def mock_session_maker(self, mock_db_session):
-        maker = MagicMock(spec=sessionmaker)
-        maker.return_value = mock_db_session
-        return maker
+    def db_session(self, sqlite_session_maker: sessionmaker[Session]) -> Iterator[Session]:
+        with sqlite_session_maker() as session:
+            yield session
 
     @pytest.fixture
-    def file_service(self, mock_session_maker):
-        return FileService(session_factory=mock_session_maker)
+    def file_service(self, sqlite_session_maker: sessionmaker[Session]) -> FileService:
+        return FileService(session_factory=sqlite_session_maker)
 
-    def test_init_with_engine(self):
-        engine = MagicMock(spec=Engine)
-        service = FileService(session_factory=engine)
+    @staticmethod
+    def _persist_upload_file(
+        session: Session,
+        *,
+        file_id: str = "file_id",
+        tenant_id: str = "tenant_id",
+        extension: str = "txt",
+        mime_type: str = "text/plain",
+        key: str = "key",
+    ) -> UploadFile:
+        upload_file = UploadFile(
+            tenant_id=tenant_id,
+            storage_type=StorageType.LOCAL,
+            key=key,
+            name=f"test.{extension}",
+            size=10,
+            extension=extension,
+            mime_type=mime_type,
+            created_by_role=CreatorUserRole.ACCOUNT,
+            created_by="user_id",
+            created_at=datetime(2024, 1, 1, tzinfo=UTC),
+            used=False,
+        )
+        upload_file.id = file_id
+        session.add(upload_file)
+        session.commit()
+        return upload_file
+
+    def test_init_with_engine(self, sqlite_engine: Engine):
+        service = FileService(session_factory=sqlite_engine)
         assert isinstance(service._session_maker, sessionmaker)
 
-    def test_init_with_sessionmaker(self):
-        maker = MagicMock(spec=sessionmaker)
-        service = FileService(session_factory=maker)
-        assert service._session_maker == maker
+    def test_init_with_sessionmaker(self, sqlite_session_maker: sessionmaker[Session]):
+        service = FileService(session_factory=sqlite_session_maker)
+        assert service._session_maker == sqlite_session_maker
 
     def test_init_invalid_factory(self):
         with pytest.raises(AssertionError, match="must be a sessionmaker or an Engine."):
@@ -52,11 +79,11 @@ class TestFileService:
     @patch("services.file_service.extract_tenant_id")
     @patch("services.file_service.file_helpers.get_signed_file_url")
     def test_upload_file_success(
-        self, mock_get_url, mock_tenant_id, mock_now, mock_storage, file_service: FileService, mock_db_session
+        self, mock_get_url, mock_tenant_id, mock_now, mock_storage, file_service: FileService, db_session: Session
     ):
         # Setup
         mock_tenant_id.return_value = "tenant_id"
-        mock_now.return_value = "2024-01-01"
+        mock_now.return_value = datetime(2024, 1, 1, tzinfo=UTC)
         mock_get_url.return_value = "http://signed-url"
 
         user = MagicMock(spec=Account)
@@ -81,8 +108,9 @@ class TestFileService:
         assert result.source_url == "http://signed-url"
 
         mock_storage.save.assert_called_once()
-        mock_db_session.add.assert_called_once_with(result)
-        mock_db_session.commit.assert_called_once()
+        persisted = db_session.get(UploadFile, result.id)
+        assert persisted is not None
+        assert persisted.hash == result.hash
 
     def test_upload_file_uses_explicit_resource_tenant(self, file_service: FileService):
         user = MagicMock(spec=Account)
@@ -109,7 +137,7 @@ class TestFileService:
         with pytest.raises(ValueError, match="Filename contains invalid characters"):
             file_service.upload_file(filename="invalid/file.txt", content=b"", mimetype="text/plain", user=MagicMock())
 
-    def test_upload_file_long_filename(self, file_service: FileService, mock_db_session):
+    def test_upload_file_long_filename(self, file_service: FileService, db_session: Session):
         # Setup
         long_name = "a" * 210 + ".txt"
         user = MagicMock(spec=Account)
@@ -124,6 +152,7 @@ class TestFileService:
             result = file_service.upload_file(filename=long_name, content=b"test", mimetype="text/plain", user=user)
             assert len(result.name) <= 205  # 200 + . + extension
             assert result.name.endswith(".txt")
+            assert db_session.get(UploadFile, result.id) is not None
 
     def test_upload_file_blocked_extension(self, file_service):
         with patch.object(dify_config, "inner_UPLOAD_FILE_EXTENSION_BLACKLIST", "exe"):
@@ -145,7 +174,7 @@ class TestFileService:
             with pytest.raises(FileTooLargeError):
                 file_service.upload_file(filename="test.jpg", content=content, mimetype="image/jpeg", user=MagicMock())
 
-    def test_upload_file_end_user(self, file_service: FileService, mock_db_session):
+    def test_upload_file_end_user(self, file_service: FileService, db_session: Session):
         user = MagicMock(spec=EndUser)
         user.id = "end_user_id"
 
@@ -157,6 +186,7 @@ class TestFileService:
             mock_tenant.return_value = "tenant"
             result = file_service.upload_file(filename="test.txt", content=b"test", mimetype="text/plain", user=user)
             assert result.created_by_role == CreatorUserRole.END_USER
+            assert db_session.get(UploadFile, result.id) is not None
 
     def test_is_file_size_within_limit(self):
         with (
@@ -181,12 +211,8 @@ class TestFileService:
             assert FileService.is_file_size_within_limit(extension="txt", file_size=5 * 1024 * 1024) is True
             assert FileService.is_file_size_within_limit(extension="pdf", file_size=6 * 1024 * 1024) is False
 
-    def test_get_file_base64_success(self, file_service: FileService, mock_db_session):
-        # Setup
-        upload_file = MagicMock(spec=UploadFile)
-        upload_file.id = "file_id"
-        upload_file.key = "test_key"
-        mock_db_session.scalar.return_value = upload_file
+    def test_get_file_base64_success(self, file_service: FileService, db_session: Session):
+        self._persist_upload_file(db_session, key="test_key")
 
         with patch("services.file_service.storage") as mock_storage:
             mock_storage.load_once.return_value = b"test content"
@@ -198,16 +224,17 @@ class TestFileService:
             assert result == base64.b64encode(b"test content").decode()
             mock_storage.load_once.assert_called_once_with("test_key")
 
-    def test_get_file_base64_not_found(self, file_service: FileService, mock_db_session):
-        mock_db_session.scalar.return_value = None
+    def test_get_file_base64_not_found(self, file_service: FileService):
         with pytest.raises(NotFound, match="File not found"):
             file_service.get_file_base64("non_existent")
 
-    def test_get_file_presigned_url_success(self, file_service: FileService, mock_db_session):
-        upload_file = MagicMock(spec=UploadFile)
-        upload_file.key = "upload_files/tenant_id/icon.png"
-        upload_file.mime_type = "image/png"
-        mock_db_session.scalar.return_value = upload_file
+    def test_get_file_presigned_url_success(self, file_service: FileService, db_session: Session):
+        self._persist_upload_file(
+            db_session,
+            extension="png",
+            mime_type="image/png",
+            key="upload_files/tenant_id/icon.png",
+        )
 
         with (
             patch.object(dify_config, "FILES_ACCESS_TIMEOUT", 300),
@@ -224,13 +251,11 @@ class TestFileService:
             content_type="image/png",
         )
 
-    def test_get_file_presigned_url_not_found(self, file_service: FileService, mock_db_session):
-        mock_db_session.scalar.return_value = None
-
+    def test_get_file_presigned_url_not_found(self, file_service: FileService):
         with pytest.raises(NotFound, match="File not found"):
             file_service.get_file_presigned_url(file_id="file_id", tenant_id="tenant_id")
 
-    def test_upload_text_success(self, file_service: FileService, mock_db_session):
+    def test_upload_text_success(self, file_service: FileService, db_session: Session):
         # Setup
         text = "sample text"
         text_name = "test.txt"
@@ -249,21 +274,17 @@ class TestFileService:
             assert result.used is True
             assert result.extension == "txt"
             mock_storage.save.assert_called_once()
-            mock_db_session.add.assert_called_once()
-            mock_db_session.commit.assert_called_once()
+            assert db_session.get(UploadFile, result.id) is not None
 
-    def test_upload_text_long_name(self, file_service: FileService, mock_db_session):
+    def test_upload_text_long_name(self, file_service: FileService, db_session: Session):
         long_name = "a" * 210
         with patch("services.file_service.storage"):
             result = file_service.upload_text("text", long_name, "user", "tenant")
             assert len(result.name) == 200
+            assert db_session.get(UploadFile, result.id) is not None
 
-    def test_get_file_preview_success(self, file_service: FileService, mock_db_session):
-        # Setup
-        upload_file = MagicMock(spec=UploadFile)
-        upload_file.id = "file_id"
-        upload_file.extension = "pdf"
-        mock_db_session.scalar.return_value = upload_file
+    def test_get_file_preview_success(self, file_service: FileService, db_session: Session):
+        self._persist_upload_file(db_session, extension="pdf", mime_type="application/pdf")
 
         with patch("services.file_service.ExtractProcessor.load_from_upload_file") as mock_extract:
             mock_extract.return_value = "Extracted text content"
@@ -274,27 +295,17 @@ class TestFileService:
             # Assert
             assert result == "Extracted text content"
 
-    def test_get_file_preview_not_found(self, file_service: FileService, mock_db_session):
-        mock_db_session.scalar.return_value = None
+    def test_get_file_preview_not_found(self, file_service: FileService):
         with pytest.raises(NotFound, match="File not found"):
             file_service.get_file_preview("non_existent", "tenant_id")
 
-    def test_get_file_preview_unsupported_type(self, file_service: FileService, mock_db_session):
-        upload_file = MagicMock(spec=UploadFile)
-        upload_file.id = "file_id"
-        upload_file.extension = "exe"
-        mock_db_session.scalar.return_value = upload_file
+    def test_get_file_preview_unsupported_type(self, file_service: FileService, db_session: Session):
+        self._persist_upload_file(db_session, extension="exe", mime_type="application/octet-stream")
         with pytest.raises(UnsupportedFileTypeError):
             file_service.get_file_preview("file_id", "tenant_id")
 
-    def test_get_image_preview_success(self, file_service: FileService, mock_db_session):
-        # Setup
-        upload_file = MagicMock(spec=UploadFile)
-        upload_file.id = "file_id"
-        upload_file.extension = "jpg"
-        upload_file.mime_type = "image/jpeg"
-        upload_file.key = "key"
-        mock_db_session.scalar.return_value = upload_file
+    def test_get_image_preview_success(self, file_service: FileService, db_session: Session):
+        self._persist_upload_file(db_session, extension="jpg", mime_type="image/jpeg")
 
         with (
             patch("services.file_service.file_helpers.verify_image_signature") as mock_verify,
@@ -316,28 +327,21 @@ class TestFileService:
             with pytest.raises(NotFound, match="File not found or signature is invalid"):
                 file_service.get_image_preview("file_id", "ts", "nonce", "sign")
 
-    def test_get_image_preview_not_found(self, file_service: FileService, mock_db_session):
-        mock_db_session.scalar.return_value = None
+    def test_get_image_preview_not_found(self, file_service: FileService):
         with patch("services.file_service.file_helpers.verify_image_signature") as mock_verify:
             mock_verify.return_value = True
             with pytest.raises(NotFound, match="File not found or signature is invalid"):
                 file_service.get_image_preview("file_id", "ts", "nonce", "sign")
 
-    def test_get_image_preview_unsupported_type(self, file_service: FileService, mock_db_session):
-        upload_file = MagicMock(spec=UploadFile)
-        upload_file.id = "file_id"
-        upload_file.extension = "txt"
-        mock_db_session.scalar.return_value = upload_file
+    def test_get_image_preview_unsupported_type(self, file_service: FileService, db_session: Session):
+        self._persist_upload_file(db_session)
         with patch("services.file_service.file_helpers.verify_image_signature") as mock_verify:
             mock_verify.return_value = True
             with pytest.raises(UnsupportedFileTypeError):
                 file_service.get_image_preview("file_id", "ts", "nonce", "sign")
 
-    def test_get_file_generator_by_file_id_success(self, file_service: FileService, mock_db_session):
-        upload_file = MagicMock(spec=UploadFile)
-        upload_file.id = "file_id"
-        upload_file.key = "key"
-        mock_db_session.scalar.return_value = upload_file
+    def test_get_file_generator_by_file_id_success(self, file_service: FileService, db_session: Session):
+        upload_file = self._persist_upload_file(db_session)
 
         with (
             patch("services.file_service.file_helpers.verify_file_signature") as mock_verify,
@@ -348,7 +352,8 @@ class TestFileService:
 
             gen, file = file_service.get_file_generator_by_file_id("file_id", "ts", "nonce", "sign")
             assert list(gen) == [b"chunk"]
-            assert file == upload_file
+            assert file.id == upload_file.id
+            assert file.key == upload_file.key
 
     def test_get_file_generator_by_file_id_invalid_sig(self, file_service):
         with patch("services.file_service.file_helpers.verify_file_signature") as mock_verify:
@@ -356,20 +361,14 @@ class TestFileService:
             with pytest.raises(NotFound, match="File not found or signature is invalid"):
                 file_service.get_file_generator_by_file_id("file_id", "ts", "nonce", "sign")
 
-    def test_get_file_generator_by_file_id_not_found(self, file_service: FileService, mock_db_session):
-        mock_db_session.scalar.return_value = None
+    def test_get_file_generator_by_file_id_not_found(self, file_service: FileService):
         with patch("services.file_service.file_helpers.verify_file_signature") as mock_verify:
             mock_verify.return_value = True
             with pytest.raises(NotFound, match="File not found or signature is invalid"):
                 file_service.get_file_generator_by_file_id("file_id", "ts", "nonce", "sign")
 
-    def test_get_public_image_preview_success(self, file_service: FileService, mock_db_session):
-        upload_file = MagicMock(spec=UploadFile)
-        upload_file.id = "file_id"
-        upload_file.extension = "png"
-        upload_file.mime_type = "image/png"
-        upload_file.key = "key"
-        mock_db_session.scalar.return_value = upload_file
+    def test_get_public_image_preview_success(self, file_service: FileService, db_session: Session):
+        self._persist_upload_file(db_session, extension="png", mime_type="image/png")
 
         with patch("services.file_service.storage") as mock_storage:
             mock_storage.load.return_value = b"image content"
@@ -377,66 +376,56 @@ class TestFileService:
             assert gen == b"image content"
             assert mime == "image/png"
 
-    def test_get_public_image_preview_not_found(self, file_service: FileService, mock_db_session):
-        mock_db_session.scalar.return_value = None
+    def test_get_public_image_preview_not_found(self, file_service: FileService):
         with pytest.raises(NotFound, match="File not found or signature is invalid"):
             file_service.get_public_image_preview("file_id")
 
-    def test_get_public_image_preview_unsupported_type(self, file_service: FileService, mock_db_session):
-        upload_file = MagicMock(spec=UploadFile)
-        upload_file.id = "file_id"
-        upload_file.extension = "txt"
-        mock_db_session.scalar.return_value = upload_file
+    def test_get_public_image_preview_unsupported_type(self, file_service: FileService, db_session: Session):
+        self._persist_upload_file(db_session)
         with pytest.raises(UnsupportedFileTypeError):
             file_service.get_public_image_preview("file_id")
 
-    def test_get_file_content_success(self, file_service: FileService, mock_db_session):
-        upload_file = MagicMock(spec=UploadFile)
-        upload_file.id = "file_id"
-        upload_file.key = "key"
-        mock_db_session.scalar.return_value = upload_file
+    def test_get_file_content_success(self, file_service: FileService, db_session: Session):
+        self._persist_upload_file(db_session)
 
         with patch("services.file_service.storage") as mock_storage:
             mock_storage.load.return_value = b"hello world"
             result = file_service.get_file_content("file_id")
             assert result == "hello world"
 
-    def test_get_file_content_not_found(self, file_service: FileService, mock_db_session):
-        mock_db_session.scalar.return_value = None
+    def test_get_file_content_not_found(self, file_service: FileService):
         with pytest.raises(NotFound, match="File not found"):
             file_service.get_file_content("file_id")
 
-    def test_delete_file_success(self, file_service: FileService, mock_db_session):
-        upload_file = MagicMock(spec=UploadFile)
-        upload_file.id = "file_id"
-        upload_file.key = "key"
-        # For session.scalar(select(...))
-        mock_db_session.scalar.return_value = upload_file
+    def test_delete_file_success(self, file_service: FileService, db_session: Session):
+        self._persist_upload_file(db_session)
 
         with patch("services.file_service.storage") as mock_storage:
             file_service.delete_file("file_id")
             mock_storage.delete.assert_called_once_with("key")
-            mock_db_session.delete.assert_called_once_with(upload_file)
+            db_session.expire_all()
+            assert db_session.get(UploadFile, "file_id") is None
 
-    def test_delete_file_not_found(self, file_service: FileService, mock_db_session):
-        mock_db_session.scalar.return_value = None
+    def test_delete_file_not_found(self, file_service: FileService):
         file_service.delete_file("file_id")
         # Should return without doing anything
 
-    def test_get_upload_files_by_ids_empty(self):
-        session = MagicMock()
-        result = FileService.get_upload_files_by_ids("tenant_id", [], session=session)
+    def test_get_upload_files_by_ids_empty(self, db_session: Session):
+        result = FileService.get_upload_files_by_ids("tenant_id", [], session=db_session)
         assert result == {}
 
-    def test_get_upload_files_by_ids(self):
-        upload_file = MagicMock(spec=UploadFile)
-        upload_file.id = "550e8400-e29b-41d4-a716-446655440000"
-        upload_file.tenant_id = "tenant_id"
-        session = MagicMock()
-        session.scalars().all.return_value = [upload_file]
+    def test_get_upload_files_by_ids(self, db_session: Session):
+        upload_file = self._persist_upload_file(db_session, file_id="550e8400-e29b-41d4-a716-446655440000")
+        self._persist_upload_file(
+            db_session,
+            file_id="550e8400-e29b-41d4-a716-446655440001",
+            tenant_id="other-tenant",
+        )
 
         result = FileService.get_upload_files_by_ids(
-            "tenant_id", ["550e8400-e29b-41d4-a716-446655440000"], session=session
+            "tenant_id",
+            ["550e8400-e29b-41d4-a716-446655440000", "550e8400-e29b-41d4-a716-446655440001"],
+            session=db_session,
         )
         assert result["550e8400-e29b-41d4-a716-446655440000"] == upload_file
 
@@ -453,10 +442,8 @@ class TestFileService:
         used.add("a (1).txt")
         assert FileService._dedupe_zip_entry_name("a.txt", used) == "a (2).txt"
 
-    def test_build_upload_files_zip_tempfile(self):
-        upload_file = MagicMock(spec=UploadFile)
-        upload_file.name = "test.txt"
-        upload_file.key = "key"
+    def test_build_upload_files_zip_tempfile(self, db_session: Session):
+        upload_file = self._persist_upload_file(db_session)
 
         with (
             patch("services.file_service.storage") as mock_storage,

api/tests/unit_tests/services/test_human_input_service.py

@@ -1,6 +1,5 @@
 import dataclasses
 import logging
-from collections.abc import Iterator
 from datetime import datetime, timedelta
 from unittest.mock import MagicMock
 
@@ -42,14 +41,13 @@ from services.human_input_service import (
 
 
 @pytest.fixture
-def sqlite_session_factory(sqlite_engine: Engine) -> Iterator[tuple[sessionmaker[Session], Session]]:
-    factory = sessionmaker(bind=sqlite_engine, expire_on_commit=False)
-    with factory() as session:
-        yield factory, session
+def unbound_session_factory() -> sessionmaker[Session]:
+    """Supply the required constructor dependency without enabling database access."""
+    return sessionmaker()
 
 
-def _persist_app(sqlite_session: Session, mode: AppMode) -> App:
-    app = App(
+def _make_app(mode: AppMode) -> App:
+    return App(
         id="app-id",
         tenant_id="tenant-id",
         name="Test App",
@@ -60,9 +58,6 @@ def _persist_app(sqlite_session: Session, mode: AppMode) -> App:
         enable_api=True,
         max_active_requests=0,
     )
-    sqlite_session.add(app)
-    sqlite_session.commit()
-    return app
 
 
 @pytest.fixture
@@ -97,14 +92,11 @@ def sample_form_record():
     )
 
 
-@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
 def test_enqueue_resume_dispatches_task_for_workflow(
     mocker: MockerFixture,
-    sqlite_session_factory,
-    sqlite_session: Session,
+    sqlite_session_factory: sessionmaker[Session],
 ):
-    session_factory, _ = sqlite_session_factory
-    service = HumanInputService(session_factory)
+    service = HumanInputService(sqlite_session_factory)
 
     workflow_run = MagicMock()
     workflow_run.app_id = "app-id"
@@ -116,7 +108,8 @@ def test_enqueue_resume_dispatches_task_for_workflow(
         return_value=workflow_run_repo,
     )
 
-    _persist_app(sqlite_session, AppMode.WORKFLOW)
+    with sqlite_session_factory.begin() as arrange_session:
+        arrange_session.add(_make_app(AppMode.WORKFLOW))
 
     resume_task = mocker.patch("services.human_input_service.resume_app_execution")
 
@@ -128,10 +121,9 @@ def test_enqueue_resume_dispatches_task_for_workflow(
 
 
 def test_ensure_form_active_respects_global_timeout(
-    monkeypatch, sample_form_record: HumanInputFormRecord, sqlite_session_factory
+    monkeypatch, sample_form_record: HumanInputFormRecord, unbound_session_factory
 ):
-    session_factory, _ = sqlite_session_factory
-    service = HumanInputService(session_factory)
+    service = HumanInputService(unbound_session_factory)
     expired_record = dataclasses.replace(
         sample_form_record,
         created_at=naive_utc_now() - timedelta(hours=2),
@@ -143,14 +135,11 @@ def test_ensure_form_active_respects_global_timeout(
         service.ensure_form_active(Form(expired_record))
 
 
-@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
 def test_enqueue_resume_dispatches_task_for_advanced_chat(
     mocker: MockerFixture,
-    sqlite_session_factory,
-    sqlite_session: Session,
+    sqlite_session_factory: sessionmaker[Session],
 ):
-    session_factory, _ = sqlite_session_factory
-    service = HumanInputService(session_factory)
+    service = HumanInputService(sqlite_session_factory)
 
     workflow_run = MagicMock()
     workflow_run.app_id = "app-id"
@@ -162,7 +151,8 @@ def test_enqueue_resume_dispatches_task_for_advanced_chat(
         return_value=workflow_run_repo,
     )
 
-    _persist_app(sqlite_session, AppMode.ADVANCED_CHAT)
+    with sqlite_session_factory.begin() as arrange_session:
+        arrange_session.add(_make_app(AppMode.ADVANCED_CHAT))
 
     resume_task = mocker.patch("services.human_input_service.resume_app_execution")
 
@@ -173,14 +163,11 @@ def test_enqueue_resume_dispatches_task_for_advanced_chat(
     assert call_kwargs["kwargs"]["payload"]["workflow_run_id"] == "workflow-run-id"
 
 
-@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
 def test_enqueue_resume_skips_unsupported_app_mode(
     mocker: MockerFixture,
-    sqlite_session_factory,
-    sqlite_session: Session,
+    sqlite_session_factory: sessionmaker[Session],
 ):
-    session_factory, _ = sqlite_session_factory
-    service = HumanInputService(session_factory)
+    service = HumanInputService(sqlite_session_factory)
 
     workflow_run = MagicMock()
     workflow_run.app_id = "app-id"
@@ -192,7 +179,8 @@ def test_enqueue_resume_skips_unsupported_app_mode(
         return_value=workflow_run_repo,
     )
 
-    _persist_app(sqlite_session, AppMode.COMPLETION)
+    with sqlite_session_factory.begin() as arrange_session:
+        arrange_session.add(_make_app(AppMode.COMPLETION))
 
     resume_task = mocker.patch("services.human_input_service.resume_app_execution")
 
@@ -202,14 +190,13 @@ def test_enqueue_resume_skips_unsupported_app_mode(
 
 
 def test_get_form_definition_by_token_for_console_uses_repository(
-    sample_form_record: HumanInputFormRecord, sqlite_session_factory
+    sample_form_record: HumanInputFormRecord, unbound_session_factory
 ):
-    session_factory, _ = sqlite_session_factory
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     console_record = dataclasses.replace(sample_form_record, recipient_type=RecipientType.CONSOLE)
     repo.get_by_token.return_value = console_record
 
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
     form = service.get_form_definition_by_token_for_console("token")
 
     repo.get_by_token.assert_called_once_with("token")
@@ -245,9 +232,8 @@ def _build_resumption_context_state(*, options: list[str], workflow_run_id: str)
 
 
 def test_resolve_form_inputs_uses_runtime_select_options(
-    sample_form_record: HumanInputFormRecord, sqlite_session_factory, mocker: MockerFixture
+    sample_form_record: HumanInputFormRecord, unbound_session_factory, mocker: MockerFixture
 ):
-    session_factory, _ = sqlite_session_factory
     configured_input = SelectInputConfig(
         output_variable_name="decision",
         option_source=StringListSource(
@@ -272,7 +258,7 @@ def test_resolve_form_inputs_uses_runtime_select_options(
         "services.human_input_service.DifyAPIRepositoryFactory.create_api_workflow_run_repository",
         return_value=workflow_run_repo,
     )
-    service = HumanInputService(session_factory)
+    service = HumanInputService(unbound_session_factory)
 
     resolved_inputs = service.resolve_form_inputs(Form(record))
 
@@ -284,13 +270,12 @@ def test_resolve_form_inputs_uses_runtime_select_options(
 
 
 def test_submit_form_by_token_calls_repository_and_enqueue(
-    sample_form_record: HumanInputFormRecord, sqlite_session_factory, mocker: MockerFixture
+    sample_form_record: HumanInputFormRecord, unbound_session_factory, mocker: MockerFixture
 ):
-    session_factory, _ = sqlite_session_factory
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     repo.get_by_token.return_value = sample_form_record
     repo.mark_submitted.return_value = sample_form_record
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
     enqueue_spy = mocker.patch.object(service, "enqueue_resume")
 
     service.submit_form_by_token(
@@ -313,11 +298,10 @@ def test_submit_form_by_token_calls_repository_and_enqueue(
 
 
 def test_submit_form_by_token_enqueues_agent_app_resume_for_conversation_form(
-    sample_form_record, sqlite_session_factory, mocker: MockerFixture
+    sample_form_record, unbound_session_factory, mocker: MockerFixture
 ):
     # ENG-635: a conversation-owned (Agent v2 chat) form routes to the chat
     # resume, not the workflow resume.
-    session_factory, _ = sqlite_session_factory
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     conversation_record = dataclasses.replace(
         sample_form_record,
@@ -326,7 +310,7 @@ def test_submit_form_by_token_enqueues_agent_app_resume_for_conversation_form(
     )
     repo.get_by_token.return_value = conversation_record
     repo.mark_submitted.return_value = conversation_record
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
     workflow_enqueue_spy = mocker.patch.object(service, "enqueue_resume")
     chat_enqueue_spy = mocker.patch.object(service, "enqueue_agent_app_resume")
 
@@ -343,9 +327,8 @@ def test_submit_form_by_token_enqueues_agent_app_resume_for_conversation_form(
 
 
 def test_submit_form_by_token_skips_enqueue_for_delivery_test(
-    sample_form_record: HumanInputFormRecord, sqlite_session_factory, mocker: MockerFixture
+    sample_form_record: HumanInputFormRecord, unbound_session_factory, mocker: MockerFixture
 ):
-    session_factory, _ = sqlite_session_factory
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     test_record = dataclasses.replace(
         sample_form_record,
@@ -354,7 +337,7 @@ def test_submit_form_by_token_skips_enqueue_for_delivery_test(
     )
     repo.get_by_token.return_value = test_record
     repo.mark_submitted.return_value = test_record
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
     enqueue_spy = mocker.patch.object(service, "enqueue_resume")
 
     service.submit_form_by_token(
@@ -368,13 +351,12 @@ def test_submit_form_by_token_skips_enqueue_for_delivery_test(
 
 
 def test_submit_form_by_token_passes_submission_user_id(
-    sample_form_record: HumanInputFormRecord, sqlite_session_factory, mocker: MockerFixture
+    sample_form_record: HumanInputFormRecord, unbound_session_factory, mocker: MockerFixture
 ):
-    session_factory, _ = sqlite_session_factory
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     repo.get_by_token.return_value = sample_form_record
     repo.mark_submitted.return_value = sample_form_record
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
     enqueue_spy = mocker.patch.object(service, "enqueue_resume")
 
     service.submit_form_by_token(
@@ -391,11 +373,10 @@ def test_submit_form_by_token_passes_submission_user_id(
     enqueue_spy.assert_called_once_with(sample_form_record.workflow_run_id)
 
 
-def test_submit_form_by_token_invalid_action(sample_form_record: HumanInputFormRecord, sqlite_session_factory):
-    session_factory, _ = sqlite_session_factory
+def test_submit_form_by_token_invalid_action(sample_form_record: HumanInputFormRecord, unbound_session_factory):
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     repo.get_by_token.return_value = dataclasses.replace(sample_form_record)
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
 
     with pytest.raises(InvalidFormDataError) as exc_info:
         service.submit_form_by_token(
@@ -409,8 +390,7 @@ def test_submit_form_by_token_invalid_action(sample_form_record: HumanInputFormR
     repo.mark_submitted.assert_not_called()
 
 
-def test_submit_form_by_token_missing_inputs(sample_form_record: HumanInputFormRecord, sqlite_session_factory):
-    session_factory, _ = sqlite_session_factory
+def test_submit_form_by_token_missing_inputs(sample_form_record: HumanInputFormRecord, unbound_session_factory):
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
 
     definition_with_input = FormDefinition(
@@ -422,7 +402,7 @@ def test_submit_form_by_token_missing_inputs(sample_form_record: HumanInputFormR
     )
     form_with_input = dataclasses.replace(sample_form_record, definition=definition_with_input)
     repo.get_by_token.return_value = form_with_input
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
 
     with pytest.raises(InvalidFormDataError) as exc_info:
         service.submit_form_by_token(
@@ -436,42 +416,6 @@ def test_submit_form_by_token_missing_inputs(sample_form_record: HumanInputFormR
     repo.mark_submitted.assert_not_called()
 
 
-def test_validate_human_input_submission_accepts_select_file_and_file_list(sqlite_session_factory):
-    session_factory, _ = sqlite_session_factory
-    service = HumanInputService(session_factory)
-    definition = FormDefinition.model_validate(
-        {
-            "form_content": "Pick one and upload files",
-            "inputs": [
-                {
-                    "type": "select",
-                    "output_variable_name": "decision",
-                    "option_source": {
-                        "type": "constant",
-                        "value": ["approve", "reject"],
-                    },
-                },
-                {
-                    "type": "file",
-                    "output_variable_name": "attachment",
-                    "allowed_file_types": ["document"],
-                    "allowed_file_upload_methods": ["remote_url"],
-                },
-                {
-                    "type": "file-list",
-                    "output_variable_name": "attachments",
-                    "allowed_file_types": ["document"],
-                    "allowed_file_upload_methods": ["remote_url"],
-                    "number_limits": 3,
-                },
-            ],
-            "user_actions": [{"id": "submit", "title": "Submit"}],
-            "rendered_content": "<p>Pick one and upload files</p>",
-            "expiration_time": naive_utc_now() + timedelta(hours=1),
-        }
-    )
-
-
 @pytest.mark.parametrize(
     ("input_definition", "submitted_value", "expected_message"),
     [
@@ -522,12 +466,11 @@ def test_validate_human_input_submission_accepts_select_file_and_file_list(sqlit
 )
 def test_validate_human_input_submission_rejects_invalid_select_and_file_payloads(
     sample_form_record,
-    sqlite_session_factory,
+    unbound_session_factory,
     input_definition,
     submitted_value,
     expected_message,
 ):
-    session_factory, _ = sqlite_session_factory
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     definition = FormDefinition.model_validate(
         {
@@ -539,7 +482,7 @@ def test_validate_human_input_submission_rejects_invalid_select_and_file_payload
         }
     )
     repo.get_by_token.return_value = dataclasses.replace(sample_form_record, definition=definition)
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
 
     with pytest.raises(InvalidFormDataError) as exc_info:
         service.submit_form_by_token(
@@ -569,7 +512,7 @@ def test_form_properties(sample_form_record: HumanInputFormRecord):
 
 def test_form_submitted_error_init():
     error = FormSubmittedError(form_id="test-form")
-    assert "form_id=test-form" in error.description
+    assert error.description == "This form has already been submitted by another user, form_id=test-form"
     assert error.code == 412
 
 
@@ -580,61 +523,55 @@ def test_human_input_service_init_with_engine(sqlite_engine: Engine):
     assert service._session_factory.kw["bind"] is sqlite_engine
 
 
-def test_get_form_by_token_none(sqlite_session_factory):
-    session_factory, _ = sqlite_session_factory
+def test_get_form_by_token_none(unbound_session_factory):
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     repo.get_by_token.return_value = None
 
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
     assert service.get_form_by_token("invalid") is None
 
 
-def test_get_form_definition_by_token_mismatch(sample_form_record: HumanInputFormRecord, sqlite_session_factory):
-    session_factory, _ = sqlite_session_factory
+def test_get_form_definition_by_token_mismatch(sample_form_record: HumanInputFormRecord, unbound_session_factory):
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     repo.get_by_token.return_value = sample_form_record
 
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
     # RecipientType mismatch
     assert service.get_form_definition_by_token(RecipientType.CONSOLE, "token") is None
 
 
-def test_get_form_definition_by_token_success(sample_form_record: HumanInputFormRecord, sqlite_session_factory):
-    session_factory, _ = sqlite_session_factory
+def test_get_form_definition_by_token_success(sample_form_record: HumanInputFormRecord, unbound_session_factory):
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     repo.get_by_token.return_value = sample_form_record
 
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
     form = service.get_form_definition_by_token(RecipientType.STANDALONE_WEB_APP, "token")
     assert form is not None
     assert form.id == sample_form_record.form_id
 
 
 def test_get_form_definition_by_token_for_console_mismatch(
-    sample_form_record: HumanInputFormRecord, sqlite_session_factory
+    sample_form_record: HumanInputFormRecord, unbound_session_factory
 ):
-    session_factory, _ = sqlite_session_factory
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     repo.get_by_token.return_value = sample_form_record  # is STANDALONE_WEB_APP
 
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
     assert service.get_form_definition_by_token_for_console("token") is None
 
 
-def test_submit_form_by_token_delivery_not_enabled(sqlite_session_factory):
-    session_factory, _ = sqlite_session_factory
+def test_submit_form_by_token_delivery_not_enabled(unbound_session_factory):
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     repo.get_by_token.return_value = None
 
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
     with pytest.raises(human_input_service_module.WebAppDeliveryNotEnabledError):
         service.submit_form_by_token(RecipientType.STANDALONE_WEB_APP, "token", "action", {})
 
 
 def test_submit_form_by_token_no_workflow_run_id(
-    sample_form_record: HumanInputFormRecord, sqlite_session_factory, mocker: MockerFixture
+    sample_form_record: HumanInputFormRecord, unbound_session_factory, mocker: MockerFixture
 ):
-    session_factory, _ = sqlite_session_factory
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     repo.get_by_token.return_value = sample_form_record
 
@@ -642,16 +579,15 @@ def test_submit_form_by_token_no_workflow_run_id(
     result_record = dataclasses.replace(sample_form_record, workflow_run_id=None)
     repo.mark_submitted.return_value = result_record
 
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
     enqueue_spy = mocker.patch.object(service, "enqueue_resume")
 
     service.submit_form_by_token(RecipientType.STANDALONE_WEB_APP, "token", "submit", {})
     enqueue_spy.assert_not_called()
 
 
-def test_ensure_form_active_errors(sample_form_record: HumanInputFormRecord, sqlite_session_factory):
-    session_factory, _ = sqlite_session_factory
-    service = HumanInputService(session_factory)
+def test_ensure_form_active_errors(sample_form_record: HumanInputFormRecord, unbound_session_factory):
+    service = HumanInputService(unbound_session_factory)
 
     # Submitted
     submitted_record = dataclasses.replace(sample_form_record, submitted_at=naive_utc_now())
@@ -671,18 +607,16 @@ def test_ensure_form_active_errors(sample_form_record: HumanInputFormRecord, sql
         service.ensure_form_active(Form(expired_time_record))
 
 
-def test_ensure_not_submitted_raises(sample_form_record: HumanInputFormRecord, sqlite_session_factory):
-    session_factory, _ = sqlite_session_factory
-    service = HumanInputService(session_factory)
+def test_ensure_not_submitted_raises(sample_form_record: HumanInputFormRecord, unbound_session_factory):
+    service = HumanInputService(unbound_session_factory)
     submitted_record = dataclasses.replace(sample_form_record, submitted_at=naive_utc_now())
 
     with pytest.raises(human_input_service_module.FormSubmittedError):
         service._ensure_not_submitted(Form(submitted_record))
 
 
-def test_enqueue_resume_workflow_not_found(mocker: MockerFixture, sqlite_session_factory):
-    session_factory, _ = sqlite_session_factory
-    service = HumanInputService(session_factory)
+def test_enqueue_resume_workflow_not_found(mocker: MockerFixture, unbound_session_factory):
+    service = HumanInputService(unbound_session_factory)
 
     workflow_run_repo = MagicMock()
     workflow_run_repo.get_workflow_run_by_id_without_tenant.return_value = None
@@ -696,15 +630,12 @@ def test_enqueue_resume_workflow_not_found(mocker: MockerFixture, sqlite_session
     assert "WorkflowRun not found" in str(excinfo.value)
 
 
-@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
 def test_enqueue_resume_app_not_found(
     mocker,
-    sqlite_session_factory,
-    sqlite_session: Session,
+    sqlite_session_factory: sessionmaker[Session],
     caplog: pytest.LogCaptureFixture,
 ):
-    session_factory, _ = sqlite_session_factory
-    service = HumanInputService(session_factory)
+    service = HumanInputService(sqlite_session_factory)
 
     workflow_run = MagicMock()
     workflow_run.app_id = "app-id"
@@ -715,26 +646,31 @@ def test_enqueue_resume_app_not_found(
         "services.human_input_service.DifyAPIRepositoryFactory.create_api_workflow_run_repository",
         return_value=workflow_run_repo,
     )
+    resume_task = mocker.patch("services.human_input_service.resume_app_execution")
 
     with caplog.at_level(logging.ERROR, logger="services.human_input_service"):
         service.enqueue_resume("workflow-run-id")
-        assert any(r.levelno >= logging.ERROR for r in caplog.records)
+
+    assert (
+        "services.human_input_service",
+        logging.ERROR,
+        "App not found for WorkflowRun, workflow_run_id=workflow-run-id, app_id=app-id",
+    ) in caplog.record_tuples
+    resume_task.apply_async.assert_not_called()
 
 
 def test_is_globally_expired_zero_timeout(
-    monkeypatch: pytest.MonkeyPatch, sample_form_record: HumanInputFormRecord, sqlite_session_factory
+    monkeypatch: pytest.MonkeyPatch, sample_form_record: HumanInputFormRecord, unbound_session_factory
 ):
-    session_factory, _ = sqlite_session_factory
-    service = HumanInputService(session_factory)
+    service = HumanInputService(unbound_session_factory)
 
     monkeypatch.setattr(human_input_service_module.dify_config, "HUMAN_INPUT_GLOBAL_TIMEOUT_SECONDS", 0)
     assert service._is_globally_expired(Form(sample_form_record)) is False
 
 
 def test_submit_form_by_token_normalizes_select_and_files(
-    sample_form_record: HumanInputFormRecord, sqlite_session_factory, mocker: MockerFixture
+    sample_form_record: HumanInputFormRecord, unbound_session_factory, mocker: MockerFixture
 ) -> None:
-    session_factory, _ = sqlite_session_factory
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     definition = FormDefinition(
         form_content="hello",
@@ -753,7 +689,7 @@ def test_submit_form_by_token_normalizes_select_and_files(
     form_with_inputs = dataclasses.replace(sample_form_record, definition=definition)
     repo.get_by_token.return_value = form_with_inputs
     repo.mark_submitted.return_value = form_with_inputs
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
 
     single_file = File(
         file_id="file-1",
@@ -815,9 +751,8 @@ def test_submit_form_by_token_normalizes_select_and_files(
 
 
 def test_submit_form_by_token_invalid_select_value(
-    sample_form_record: HumanInputFormRecord, sqlite_session_factory
+    sample_form_record: HumanInputFormRecord, unbound_session_factory
 ) -> None:
-    session_factory, _ = sqlite_session_factory
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     definition = FormDefinition(
         form_content="hello",
@@ -832,7 +767,7 @@ def test_submit_form_by_token_invalid_select_value(
         expiration_time=sample_form_record.expiration_time,
     )
     repo.get_by_token.return_value = dataclasses.replace(sample_form_record, definition=definition)
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
 
     with pytest.raises(InvalidFormDataError, match="Invalid value for select input 'decision'"):
         service.submit_form_by_token(
@@ -844,9 +779,8 @@ def test_submit_form_by_token_invalid_select_value(
 
 
 def test_submit_form_by_token_invalid_file_list_item(
-    sample_form_record: HumanInputFormRecord, sqlite_session_factory
+    sample_form_record: HumanInputFormRecord, unbound_session_factory
 ) -> None:
-    session_factory, _ = sqlite_session_factory
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     definition = FormDefinition(
         form_content="hello",
@@ -856,7 +790,7 @@ def test_submit_form_by_token_invalid_file_list_item(
         expiration_time=sample_form_record.expiration_time,
     )
     repo.get_by_token.return_value = dataclasses.replace(sample_form_record, definition=definition)
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
 
     with pytest.raises(
         InvalidFormDataError,
@@ -871,9 +805,8 @@ def test_submit_form_by_token_invalid_file_list_item(
 
 
 def test_submit_form_by_token_rejects_cross_tenant_file(
-    sample_form_record: HumanInputFormRecord, sqlite_session_factory, mocker: MockerFixture
+    sample_form_record: HumanInputFormRecord, unbound_session_factory, mocker: MockerFixture
 ) -> None:
-    session_factory, _ = sqlite_session_factory
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     definition = FormDefinition(
         form_content="hello",
@@ -883,7 +816,7 @@ def test_submit_form_by_token_rejects_cross_tenant_file(
         expiration_time=sample_form_record.expiration_time,
     )
     repo.get_by_token.return_value = dataclasses.replace(sample_form_record, definition=definition)
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
     mocker.patch("services.human_input_service.build_from_mapping", side_effect=ValueError("Invalid upload file"))
 
     with pytest.raises(InvalidFormDataError, match="Invalid value for file input 'attachment'"):
@@ -904,9 +837,8 @@ def test_submit_form_by_token_rejects_cross_tenant_file(
 
 
 def test_submit_form_by_token_rejects_cross_tenant_file_list(
-    sample_form_record: HumanInputFormRecord, sqlite_session_factory, mocker: MockerFixture
+    sample_form_record: HumanInputFormRecord, unbound_session_factory, mocker: MockerFixture
 ) -> None:
-    session_factory, _ = sqlite_session_factory
     repo = MagicMock(spec=HumanInputFormSubmissionRepository)
     definition = FormDefinition(
         form_content="hello",
@@ -916,7 +848,7 @@ def test_submit_form_by_token_rejects_cross_tenant_file_list(
         expiration_time=sample_form_record.expiration_time,
     )
     repo.get_by_token.return_value = dataclasses.replace(sample_form_record, definition=definition)
-    service = HumanInputService(session_factory, form_repository=repo)
+    service = HumanInputService(unbound_session_factory, form_repository=repo)
     mocker.patch("services.human_input_service.build_from_mappings", side_effect=ValueError("Invalid upload file"))
 
     with pytest.raises(

api/tests/unit_tests/services/test_oauth_server_service.py

@@ -1,16 +1,20 @@
-"""Testcontainers integration tests for OAuthServerService."""
+"""Unit tests for OAuthServerService with SQLite-backed database access."""
 
 from __future__ import annotations
 
 import uuid
+from collections.abc import Iterator
 from typing import cast
 from unittest.mock import MagicMock, patch
 from uuid import uuid4
 
 import pytest
+from flask import Flask
+from sqlalchemy import Engine
 from sqlalchemy.orm import Session
 from werkzeug.exceptions import BadRequest
 
+from models.engine import db
 from models.model import OAuthProviderApp
 from services.oauth_server import (
     OAUTH_ACCESS_TOKEN_EXPIRES_IN,
@@ -23,10 +27,24 @@ from services.oauth_server import (
 )
 
 
-class TestOAuthServerServiceGetProviderApp:
-    """DB-backed tests for get_oauth_provider_app."""
+@pytest.fixture
+def oauth_db() -> Iterator[Session]:
+    """Provide the production database extension with an isolated SQLite provider table."""
+    app = Flask(__name__)
+    app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:"
+    db.init_app(app)
 
-    def _create_oauth_provider_app(self, db_session_with_containers: Session, *, client_id: str) -> OAuthProviderApp:
+    with app.app_context():
+        OAuthProviderApp.__table__.create(db.engine)
+        with Session(db.engine, expire_on_commit=False) as session:
+            yield session
+
+
+class TestOAuthServerServiceGetProviderApp:
+    """Verify provider lookup against a real SQLAlchemy database."""
+
+    def test_get_oauth_provider_app_returns_app_when_exists(self, oauth_db: Session) -> None:
+        client_id = f"client-{uuid4()}"
         app = OAuthProviderApp(
             app_icon="icon.png",
             client_id=client_id,
@@ -35,35 +53,30 @@ class TestOAuthServerServiceGetProviderApp:
             redirect_uris=["https://example.com/callback"],
             scope="read",
         )
-        db_session_with_containers.add(app)
-        db_session_with_containers.commit()
-        return app
-
-    def test_get_oauth_provider_app_returns_app_when_exists(self, db_session_with_containers: Session):
-        client_id = f"client-{uuid4()}"
-        created = self._create_oauth_provider_app(db_session_with_containers, client_id=client_id)
+        oauth_db.add(app)
+        oauth_db.commit()
 
         result = OAuthServerService.get_oauth_provider_app(client_id)
 
         assert result is not None
         assert result.client_id == client_id
-        assert result.id == created.id
+        assert result.id == app.id
 
-    def test_get_oauth_provider_app_returns_none_when_not_exists(self, db_session_with_containers: Session):
+    def test_get_oauth_provider_app_returns_none_when_not_exists(self, oauth_db: Session) -> None:
         result = OAuthServerService.get_oauth_provider_app(f"nonexistent-{uuid4()}")
 
         assert result is None
 
 
 class TestOAuthServerServiceTokenOperations:
-    """Redis-backed tests for token sign/validate operations."""
+    """Verify Redis-backed token signing and validation branches."""
 
     @pytest.fixture
     def mock_redis(self):
         with patch("services.oauth_server.redis_client") as mock:
             yield mock
 
-    def test_sign_authorization_code_stores_and_returns_code(self, mock_redis):
+    def test_sign_authorization_code_stores_and_returns_code(self, mock_redis) -> None:
         deterministic_uuid = uuid.UUID("00000000-0000-0000-0000-000000000111")
         with patch("services.oauth_server.uuid.uuid4", return_value=deterministic_uuid):
             code = OAuthServerService.sign_oauth_authorization_code("client-1", "user-1")
@@ -75,7 +88,7 @@ class TestOAuthServerServiceTokenOperations:
             ex=600,
         )
 
-    def test_sign_access_token_raises_bad_request_for_invalid_code(self, mock_redis):
+    def test_sign_access_token_raises_bad_request_for_invalid_code(self, mock_redis) -> None:
         mock_redis.get.return_value = None
 
         with pytest.raises(BadRequest, match="invalid code"):
@@ -85,14 +98,13 @@ class TestOAuthServerServiceTokenOperations:
                 client_id="client-1",
             )
 
-    def test_sign_access_token_issues_tokens_for_valid_code(self, mock_redis):
+    def test_sign_access_token_issues_tokens_for_valid_code(self, mock_redis) -> None:
         token_uuids = [
             uuid.UUID("00000000-0000-0000-0000-000000000201"),
             uuid.UUID("00000000-0000-0000-0000-000000000202"),
         ]
         with patch("services.oauth_server.uuid.uuid4", side_effect=token_uuids):
             mock_redis.get.return_value = b"user-1"
-
             access_token, refresh_token = OAuthServerService.sign_oauth_access_token(
                 grant_type=OAuthGrantType.AUTHORIZATION_CODE,
                 code="code-1",
@@ -114,7 +126,7 @@ class TestOAuthServerServiceTokenOperations:
             ex=OAUTH_REFRESH_TOKEN_EXPIRES_IN,
         )
 
-    def test_sign_access_token_raises_bad_request_for_invalid_refresh_token(self, mock_redis):
+    def test_sign_access_token_raises_bad_request_for_invalid_refresh_token(self, mock_redis) -> None:
         mock_redis.get.return_value = None
 
         with pytest.raises(BadRequest, match="invalid refresh token"):
@@ -124,11 +136,10 @@ class TestOAuthServerServiceTokenOperations:
                 client_id="client-1",
             )
 
-    def test_sign_access_token_issues_new_token_for_valid_refresh(self, mock_redis):
+    def test_sign_access_token_issues_new_token_for_valid_refresh(self, mock_redis) -> None:
         deterministic_uuid = uuid.UUID("00000000-0000-0000-0000-000000000301")
         with patch("services.oauth_server.uuid.uuid4", return_value=deterministic_uuid):
             mock_redis.get.return_value = b"user-1"
-
             access_token, returned_refresh = OAuthServerService.sign_oauth_access_token(
                 grant_type=OAuthGrantType.REFRESH_TOKEN,
                 refresh_token="refresh-1",
@@ -138,14 +149,14 @@ class TestOAuthServerServiceTokenOperations:
         assert access_token == str(deterministic_uuid)
         assert returned_refresh == "refresh-1"
 
-    def test_sign_access_token_returns_none_for_unknown_grant_type(self, mock_redis):
+    def test_sign_access_token_returns_none_for_unknown_grant_type(self, mock_redis) -> None:
         grant_type = cast(OAuthGrantType, "invalid-grant-type")
 
         result = OAuthServerService.sign_oauth_access_token(grant_type=grant_type, client_id="client-1")
 
         assert result is None
 
-    def test_sign_refresh_token_stores_with_expected_expiry(self, mock_redis):
+    def test_sign_refresh_token_stores_with_expected_expiry(self, mock_redis) -> None:
         deterministic_uuid = uuid.UUID("00000000-0000-0000-0000-000000000401")
         with patch("services.oauth_server.uuid.uuid4", return_value=deterministic_uuid):
             refresh_token = OAuthServerService._sign_oauth_refresh_token("client-2", "user-2")
@@ -157,22 +168,21 @@ class TestOAuthServerServiceTokenOperations:
             ex=OAUTH_REFRESH_TOKEN_EXPIRES_IN,
         )
 
-    def test_validate_access_token_returns_none_when_not_found(self, mock_redis, db_session_with_containers: Session):
+    def test_validate_access_token_returns_none_when_not_found(self, mock_redis, sqlite_engine: Engine) -> None:
         mock_redis.get.return_value = None
-        session = MagicMock()
 
-        result = OAuthServerService.validate_oauth_access_token("client-1", "missing-token", db_session_with_containers)
+        with Session(sqlite_engine) as session:
+            result = OAuthServerService.validate_oauth_access_token("client-1", "missing-token", session)
 
         assert result is None
 
-    def test_validate_access_token_loads_user_when_exists(self, mock_redis, db_session_with_containers: Session):
+    def test_validate_access_token_loads_user_when_exists(self, mock_redis, sqlite_engine: Engine) -> None:
         mock_redis.get.return_value = b"user-88"
         expected_user = MagicMock()
 
-        with patch("services.oauth_server.AccountService.load_user", return_value=expected_user) as mock_load:
-            result = OAuthServerService.validate_oauth_access_token(
-                "client-1", "access-token", db_session_with_containers
-            )
+        with Session(sqlite_engine) as session:
+            with patch("services.oauth_server.AccountService.load_user", return_value=expected_user) as mock_load:
+                result = OAuthServerService.validate_oauth_access_token("client-1", "access-token", session)
+                mock_load.assert_called_once_with("user-88", session)
 
         assert result is expected_user
-        mock_load.assert_called_once_with("user-88", db_session_with_containers)

api/tests/unit_tests/services/test_workflow_run_service_pause.py

@@ -1,178 +1,57 @@
-"""Comprehensive unit tests for WorkflowRunService class.
+"""Tests for the session lifecycle owned by ``WorkflowRunService``."""
 
-This test suite covers all pause state management operations including:
-- Retrieving pause state for workflow runs
-- Saving pause state with file uploads
-- Marking paused workflows as resumed
-- Error handling and edge cases
-- Database transaction management
-- Repository-based approach testing
-"""
-
-from datetime import datetime
-from unittest.mock import MagicMock, create_autospec, patch
+from unittest.mock import create_autospec, patch
 
 import pytest
-from sqlalchemy import Engine
+from sqlalchemy import Engine, text
 from sqlalchemy.orm import Session, sessionmaker
 
-from graphon.enums import WorkflowExecutionStatus
-from models.workflow import WorkflowPause
 from repositories.api_workflow_run_repository import APIWorkflowRunRepository
-from repositories.sqlalchemy_api_workflow_run_repository import _PrivateWorkflowPauseEntity
-from services.workflow_run_service import (
-    WorkflowRunService,
-)
+from services.workflow_run_service import WorkflowRunService
 
 
-class TestDataFactory:
-    """Factory class for creating test data objects."""
-
-    @staticmethod
-    def create_workflow_run_mock(
-        id: str = "workflow-run-123",
-        tenant_id: str = "tenant-456",
-        app_id: str = "app-789",
-        workflow_id: str = "workflow-101",
-        status: str | WorkflowExecutionStatus = "paused",
-        **kwargs,
-    ) -> MagicMock:
-        """Create a mock WorkflowRun object."""
-        mock_run = MagicMock()
-        mock_run.id = id
-        mock_run.tenant_id = tenant_id
-        mock_run.app_id = app_id
-        mock_run.workflow_id = workflow_id
-        mock_run.status = status
-
-        for key, value in kwargs.items():
-            setattr(mock_run, key, value)
-
-        return mock_run
-
-    @staticmethod
-    def create_workflow_pause_mock(
-        id: str = "pause-123",
-        tenant_id: str = "tenant-456",
-        app_id: str = "app-789",
-        workflow_id: str = "workflow-101",
-        workflow_execution_id: str = "workflow-execution-123",
-        state_file_id: str = "file-456",
-        resumed_at: datetime | None = None,
-        **kwargs,
-    ) -> MagicMock:
-        """Create a mock WorkflowPauseModel object."""
-        mock_pause = MagicMock(spec=WorkflowPause)
-        mock_pause.id = id
-        mock_pause.tenant_id = tenant_id
-        mock_pause.app_id = app_id
-        mock_pause.workflow_id = workflow_id
-        mock_pause.workflow_execution_id = workflow_execution_id
-        mock_pause.state_file_id = state_file_id
-        mock_pause.resumed_at = resumed_at
-
-        for key, value in kwargs.items():
-            setattr(mock_pause, key, value)
-
-        return mock_pause
-
-    @staticmethod
-    def create_pause_entity_mock(
-        pause_model: MagicMock | None = None,
-    ) -> _PrivateWorkflowPauseEntity:
-        """Create a mock _PrivateWorkflowPauseEntity object."""
-        if pause_model is None:
-            pause_model = TestDataFactory.create_workflow_pause_mock()
-
-        return _PrivateWorkflowPauseEntity(pause_model=pause_model, reason_models=[], human_input_form=[])
+@pytest.fixture
+def sqlite_session_factory(sqlite_engine: Engine) -> sessionmaker[Session]:
+    """Return a real factory whose sessions are bound to the isolated SQLite engine."""
+    return sessionmaker(bind=sqlite_engine, expire_on_commit=False)
 
 
-class TestWorkflowRunService:
-    """Comprehensive unit tests for WorkflowRunService class."""
+@pytest.fixture
+def workflow_run_repository():
+    """Keep the repository boundary mocked while exercising real session construction."""
+    return create_autospec(APIWorkflowRunRepository)
 
-    @pytest.fixture
-    def mock_session_factory(self):
-        """Create a mock session factory with proper session management."""
-        mock_session = create_autospec(Session)
 
-        # Create a mock context manager for the session
-        mock_session_cm = MagicMock()
-        mock_session_cm.__enter__ = MagicMock(return_value=mock_session)
-        mock_session_cm.__exit__ = MagicMock(return_value=None)
+def test_init_with_session_factory(
+    sqlite_session_factory: sessionmaker[Session], workflow_run_repository: APIWorkflowRunRepository
+) -> None:
+    with patch("services.workflow_run_service.DifyAPIRepositoryFactory", autospec=True) as repository_factory:
+        repository_factory.create_api_workflow_run_repository.return_value = workflow_run_repository
 
-        # Create a mock context manager for the transaction
-        mock_transaction_cm = MagicMock()
-        mock_transaction_cm.__enter__ = MagicMock(return_value=mock_session)
-        mock_transaction_cm.__exit__ = MagicMock(return_value=None)
+        service = WorkflowRunService(sqlite_session_factory)
 
-        mock_session.begin = MagicMock(return_value=mock_transaction_cm)
+    assert service._session_factory is sqlite_session_factory
+    repository_factory.create_api_workflow_run_repository.assert_called_once_with(sqlite_session_factory)
+    with service._session_factory() as session:
+        assert session.scalar(text("SELECT 1")) == 1
 
-        # Create mock factory that returns the context manager
-        mock_factory = MagicMock(spec=sessionmaker)
-        mock_factory.return_value = mock_session_cm
 
-        return mock_factory, mock_session
+def test_init_with_engine_creates_bound_session_factory(
+    sqlite_engine: Engine, workflow_run_repository: APIWorkflowRunRepository
+) -> None:
+    with patch("services.workflow_run_service.DifyAPIRepositoryFactory", autospec=True) as repository_factory:
+        repository_factory.create_api_workflow_run_repository.return_value = workflow_run_repository
 
-    @pytest.fixture
-    def mock_workflow_run_repository(self):
-        """Create a mock APIWorkflowRunRepository."""
-        mock_repo = create_autospec(APIWorkflowRunRepository)
-        return mock_repo
+        service = WorkflowRunService(sqlite_engine)
 
-    @pytest.fixture
-    def workflow_run_service(self, mock_session_factory, mock_workflow_run_repository):
-        """Create WorkflowRunService instance with mocked dependencies."""
-        session_factory, _ = mock_session_factory
+    assert service._session_factory.kw["bind"] is sqlite_engine
+    assert service._session_factory.kw["expire_on_commit"] is False
+    repository_factory.create_api_workflow_run_repository.assert_called_once_with(service._session_factory)
+    with service._session_factory() as session:
+        assert session.scalar(text("SELECT 1")) == 1
 
-        with patch("services.workflow_run_service.DifyAPIRepositoryFactory", autospec=True) as mock_factory:
-            mock_factory.create_api_workflow_run_repository.return_value = mock_workflow_run_repository
-            service = WorkflowRunService(session_factory)
-            return service
 
-    @pytest.fixture
-    def workflow_run_service_with_engine(self, mock_session_factory, mock_workflow_run_repository):
-        """Create WorkflowRunService instance with Engine input."""
-        mock_engine = create_autospec(Engine)
-        session_factory, _ = mock_session_factory
+def test_init_with_default_repository_dependencies(sqlite_session_factory: sessionmaker[Session]) -> None:
+    service = WorkflowRunService(sqlite_session_factory)
 
-        with patch("services.workflow_run_service.DifyAPIRepositoryFactory", autospec=True) as mock_factory:
-            mock_factory.create_api_workflow_run_repository.return_value = mock_workflow_run_repository
-            service = WorkflowRunService(mock_engine)
-            return service
-
-    # ==================== Initialization Tests ====================
-
-    def test_init_with_session_factory(self, mock_session_factory, mock_workflow_run_repository):
-        """Test WorkflowRunService initialization with session_factory."""
-        session_factory, _ = mock_session_factory
-
-        with patch("services.workflow_run_service.DifyAPIRepositoryFactory", autospec=True) as mock_factory:
-            mock_factory.create_api_workflow_run_repository.return_value = mock_workflow_run_repository
-            service = WorkflowRunService(session_factory)
-
-            assert service._session_factory == session_factory
-            mock_factory.create_api_workflow_run_repository.assert_called_once_with(session_factory)
-
-    def test_init_with_engine(self, mock_session_factory, mock_workflow_run_repository):
-        """Test WorkflowRunService initialization with Engine (should convert to sessionmaker)."""
-        mock_engine = create_autospec(Engine)
-        session_factory, _ = mock_session_factory
-
-        with patch("services.workflow_run_service.DifyAPIRepositoryFactory", autospec=True) as mock_factory:
-            mock_factory.create_api_workflow_run_repository.return_value = mock_workflow_run_repository
-            with patch(
-                "services.workflow_run_service.sessionmaker", return_value=session_factory, autospec=True
-            ) as mock_sessionmaker:
-                service = WorkflowRunService(mock_engine)
-
-                mock_sessionmaker.assert_called_once_with(bind=mock_engine, expire_on_commit=False)
-                assert service._session_factory == session_factory
-                mock_factory.create_api_workflow_run_repository.assert_called_once_with(session_factory)
-
-    def test_init_with_default_dependencies(self, mock_session_factory):
-        """Test WorkflowRunService initialization with default dependencies."""
-        session_factory, _ = mock_session_factory
-
-        service = WorkflowRunService(session_factory)
-
-        assert service._session_factory == session_factory
+    assert service._session_factory is sqlite_session_factory

api/tests/unit_tests/services/workflow/test_workflow_converter_additional.py

@@ -219,7 +219,13 @@ def test__convert_to_knowledge_retrieval_node_for_workflow_app() -> None:
 def test__convert_to_llm_node_for_chatbot_simple_chat_model(default_variables: list[VariableEntity]) -> None:
     workflow_converter = WorkflowConverter()
     graph = {"nodes": [workflow_converter._convert_to_start_node(default_variables)], "edges": []}
-    model_config = ModelConfigEntity(provider="openai", model="gpt-4", mode=LLMMode.CHAT.value, parameters={}, stop=[])
+    model_config = ModelConfigEntity(
+        provider="openai",
+        model="gpt-4",
+        mode=LLMMode.CHAT.value,
+        parameters={"temperature": 0.2},
+        stop=["END"],
+    )
     prompt_template = PromptTemplateEntity(
         prompt_type=PromptTemplateEntity.PromptType.SIMPLE,
         simple_prompt_template="You are a helper for {{text_input}} and {{paragraph}}",
@@ -237,6 +243,8 @@ def test__convert_to_llm_node_for_chatbot_simple_chat_model(default_variables: l
     assert node["data"]["memory"] is not None
     assert node["data"]["prompt_template"][0]["role"] == "user"
     assert "{{#start.text_input#}}" in node["data"]["prompt_template"][0]["text"]
+    assert node["data"]["model"]["completion_params"] == {"temperature": 0.2, "stop": ["END"]}
+    assert model_config.parameters == {"temperature": 0.2}
 
 
 def test__convert_to_llm_node_for_chatbot_simple_chat_model_with_empty_template(
@@ -599,6 +607,94 @@ def test_convert_app_model_config_to_workflow_should_build_workflow_mode_with_en
     assert set(features.keys()) == {"text_to_speech", "file_upload", "sensitive_word_avoidance"}
 
 
+def test_build_graph_from_app_config_for_completion_does_not_create_workflow(
+    converter: WorkflowConverter,
+) -> None:
+    app_model = _app_model(id="app-1", tenant_id="tenant-1", mode=AppMode.COMPLETION)
+    app_config = SimpleNamespace(
+        variables=[],
+        external_data_variables=[],
+        dataset=None,
+        model=_build_model_config(mode=LLMMode.CHAT),
+        prompt_template=PromptTemplateEntity(
+            prompt_type=PromptTemplateEntity.PromptType.SIMPLE,
+            simple_prompt_template="Hello",
+        ),
+        additional_features=None,
+        app_model_config_dict={
+            "text_to_speech": {"enabled": False},
+            "file_upload": {"enabled": False},
+            "sensitive_word_avoidance": {"enabled": False},
+        },
+    )
+    db_session = SimpleNamespace(add=MagicMock(), commit=MagicMock())
+
+    graph, features = converter.build_graph_from_app_config(
+        app_model=app_model,
+        app_config=app_config,
+        target_app_mode=AppMode.WORKFLOW,
+        session=db_session,
+    )
+
+    assert [node["id"] for node in graph["nodes"]] == ["start", "llm", "end"]
+    assert features == {
+        "text_to_speech": {"enabled": False},
+        "file_upload": {"enabled": False},
+        "sensitive_word_avoidance": {"enabled": False},
+    }
+    db_session.add.assert_not_called()
+    db_session.commit.assert_not_called()
+
+
+def test_build_graph_from_app_config_preserves_api_based_variable_nodes(
+    converter: WorkflowConverter,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    app_model = _app_model(id="app-1", tenant_id="tenant-1", mode=AppMode.COMPLETION)
+    app_config = SimpleNamespace(
+        variables=[VariableEntity(variable="city", label="City", type=VariableEntityType.TEXT_INPUT)],
+        external_data_variables=[
+            ExternalDataVariableEntity(
+                variable="weather",
+                type="api",
+                config={"api_based_extension_id": "api_based_extension_id"},
+            )
+        ],
+        dataset=None,
+        model=_build_model_config(mode=LLMMode.CHAT),
+        prompt_template=PromptTemplateEntity(
+            prompt_type=PromptTemplateEntity.PromptType.SIMPLE,
+            simple_prompt_template="Weather: {{weather}}",
+        ),
+        additional_features=None,
+        app_model_config_dict={},
+    )
+    extension = SimpleNamespace(
+        name="Weather API",
+        api_endpoint="https://example.com/weather",
+        api_key="encrypted-token",
+    )
+    monkeypatch.setattr(converter, "_get_api_based_extension", MagicMock(return_value=extension))
+    monkeypatch.setattr(converter_module.encrypter, "decrypt_token", MagicMock(return_value="plain-token"))
+
+    graph, _ = converter.build_graph_from_app_config(
+        app_model=app_model,
+        app_config=app_config,
+        target_app_mode=AppMode.WORKFLOW,
+        session=MagicMock(),
+    )
+
+    assert [node["data"]["type"] for node in graph["nodes"]] == [
+        BuiltinNodeTypes.START,
+        BuiltinNodeTypes.HTTP_REQUEST,
+        BuiltinNodeTypes.CODE,
+        BuiltinNodeTypes.LLM,
+        BuiltinNodeTypes.END,
+    ]
+    llm_node = next(node for node in graph["nodes"] if node["id"] == "llm")
+    assert "{{#code_1.result#}}" in llm_node["data"]["prompt_template"][0]["text"]
+
+
 def test_convert_to_app_config_should_route_to_correct_manager(
     converter: WorkflowConverter,
     monkeypatch: pytest.MonkeyPatch,

api/tests/unit_tests/tools/test_mcp_tool.py

@@ -135,6 +135,19 @@ class TestMCPToolInvoke:
         values = {m.message.variable_name: m.message.variable_value for m in var_msgs}
         assert values == {"a": 1, "b": "x"}
 
+    def test_invoke_yields_json_when_structured_content_has_no_output_schema(self, orm_session: Session) -> None:
+        tool = _make_mcp_tool()
+        result = CallToolResult(content=[], structuredContent={"a": 1, "b": "x"})
+
+        with patch.object(tool, "invoke_remote_mcp_tool", return_value=result):
+            messages = list(tool._invoke(session=orm_session, user_id="test_user", tool_parameters={}))
+
+        assert len(messages) == 1
+        msg = messages[0]
+        assert msg.type == ToolInvokeMessage.MessageType.JSON
+        assert isinstance(msg.message, ToolInvokeMessage.JsonMessage)
+        assert msg.message.json_object == {"a": 1, "b": "x"}
+
 
 class TestMCPToolUsageExtraction:
     """Test usage metadata extraction from MCP tool results."""

api/uv.lock

@@ -1281,7 +1281,7 @@ wheels = [
 
 [[package]]
 name = "dify-agent"
-version = "1.16.0"
+version = "1.16.1"
 source = { editable = "../dify-agent" }
 dependencies = [
     { name = "httpx" },
@@ -1331,7 +1331,7 @@ docs = [
 
 [[package]]
 name = "dify-api"
-version = "1.16.0"
+version = "1.16.1"
 source = { virtual = "." }
 dependencies = [
     { name = "aliyun-log-python-sdk" },

cli/package.json

@@ -71,7 +71,7 @@
     "channel": "alpha",
     "compat": {
       "minDify": "1.16.0",
-      "maxDify": "1.16.0"
+      "maxDify": "1.16.1"
     },
     "release": {
       "tagPrefix": "difyctl-v",

dify-agent/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dify-agent"
-version = "1.16.0"
+version = "1.16.1"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12,<4.0"

dify-agent/uv.lock

@@ -581,7 +581,7 @@ wheels = [
 
 [[package]]
 name = "dify-agent"
-version = "1.16.0"
+version = "1.16.1"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },

docker/docker-compose-template.yaml

@@ -220,7 +220,7 @@ services:
   # API service
   api:
     <<: *shared-api-worker-config
-    image: langgenius/dify-api:1.16.0
+    image: langgenius/dify-api:1.16.1
     environment:
       MODE: api
       SENTRY_DSN: ${API_SENTRY_DSN:-}
@@ -271,7 +271,7 @@ services:
   # WebSocket service for workflow collaboration.
   api_websocket:
     <<: *shared-api-worker-config
-    image: langgenius/dify-api:1.16.0
+    image: langgenius/dify-api:1.16.1
     profiles:
       - collaboration
     environment:
@@ -297,7 +297,7 @@ services:
   # The Celery worker for processing all queues (dataset, workflow, mail, etc.)
   worker:
     <<: *shared-worker-config
-    image: langgenius/dify-api:1.16.0
+    image: langgenius/dify-api:1.16.1
     environment:
       MODE: worker
       SENTRY_DSN: ${API_SENTRY_DSN:-}
@@ -347,7 +347,7 @@ services:
   # Celery beat for scheduling periodic tasks.
   worker_beat:
     <<: *shared-worker-beat-config
-    image: langgenius/dify-api:1.16.0
+    image: langgenius/dify-api:1.16.1
     environment:
       MODE: beat
     depends_on:
@@ -380,7 +380,7 @@ services:
 
   # Frontend web application.
   web:
-    image: langgenius/dify-web:1.16.0
+    image: langgenius/dify-web:1.16.1
     restart: always
     env_file:
       - path: ./envs/core-services/web.env
@@ -542,7 +542,7 @@ services:
   # on port 3128, which only allows agent_backend /agent-stub/ and the Dify API
   # /files/* endpoints (see ssrf_proxy/squid-agent.conf.template).
   local_sandbox:
-    image: langgenius/dify-agent-local-sandbox:1.16.0
+    image: langgenius/dify-agent-local-sandbox:1.16.1
     restart: always
     env_file:
       - path: ./envs/core-services/local-sandbox.env
@@ -651,7 +651,7 @@ services:
 
   # Dify Agent backend service.
   agent_backend:
-    image: langgenius/dify-agent-backend:1.16.0
+    image: langgenius/dify-agent-backend:1.16.1
     restart: always
     env_file:
       - path: ./envs/core-services/dify-agent.env

docker/docker-compose.yaml

@@ -226,7 +226,7 @@ services:
   # API service
   api:
     <<: *shared-api-worker-config
-    image: langgenius/dify-api:1.16.0
+    image: langgenius/dify-api:1.16.1
     environment:
       MODE: api
       SENTRY_DSN: ${API_SENTRY_DSN:-}
@@ -277,7 +277,7 @@ services:
   # WebSocket service for workflow collaboration.
   api_websocket:
     <<: *shared-api-worker-config
-    image: langgenius/dify-api:1.16.0
+    image: langgenius/dify-api:1.16.1
     profiles:
       - collaboration
     environment:
@@ -303,7 +303,7 @@ services:
   # The Celery worker for processing all queues (dataset, workflow, mail, etc.)
   worker:
     <<: *shared-worker-config
-    image: langgenius/dify-api:1.16.0
+    image: langgenius/dify-api:1.16.1
     environment:
       MODE: worker
       SENTRY_DSN: ${API_SENTRY_DSN:-}
@@ -353,7 +353,7 @@ services:
   # Celery beat for scheduling periodic tasks.
   worker_beat:
     <<: *shared-worker-beat-config
-    image: langgenius/dify-api:1.16.0
+    image: langgenius/dify-api:1.16.1
     environment:
       MODE: beat
     depends_on:
@@ -386,7 +386,7 @@ services:
 
   # Frontend web application.
   web:
-    image: langgenius/dify-web:1.16.0
+    image: langgenius/dify-web:1.16.1
     restart: always
     env_file:
       - path: ./envs/core-services/web.env
@@ -548,7 +548,7 @@ services:
   # on port 3128, which only allows agent_backend /agent-stub/ and the Dify API
   # /files/* endpoints (see ssrf_proxy/squid-agent.conf.template).
   local_sandbox:
-    image: langgenius/dify-agent-local-sandbox:1.16.0
+    image: langgenius/dify-agent-local-sandbox:1.16.1
     restart: always
     env_file:
       - path: ./envs/core-services/local-sandbox.env
@@ -657,7 +657,7 @@ services:
 
   # Dify Agent backend service.
   agent_backend:
-    image: langgenius/dify-agent-backend:1.16.0
+    image: langgenius/dify-agent-backend:1.16.1
     restart: always
     env_file:
       - path: ./envs/core-services/dify-agent.env

web/app/components/header/account-setting/index.tsx

@@ -211,6 +211,18 @@ export default function AccountSetting({
 
   return (
     <MenuDialog show onClose={handleClose}>
+      <div className="fixed top-6 right-6 z-20 flex shrink-0 flex-col items-center">
+        <Button
+          variant="tertiary"
+          size="large"
+          className="px-2"
+          aria-label={t(($) => $['operation.close'], { ns: 'common' })}
+          onClick={handleClose}
+        >
+          <span className="i-ri-close-line size-5" />
+        </Button>
+        <div className="mt-1 system-2xs-medium-uppercase text-text-tertiary">ESC</div>
+      </div>
       <div className="flex h-screen w-full max-w-full pl-0 sm:pl-[232px]">
         <div className="flex w-[44px] shrink-0 flex-col pr-6 pl-4 sm:w-[224px]">
           <div className="mt-6 mb-8 flex h-[38px] items-center px-3 title-2xl-semi-bold whitespace-nowrap text-text-primary">
@@ -275,18 +287,6 @@ export default function AccountSetting({
                   </div>
                 )}
               </div>
-              <div className="fixed top-6 right-6 flex shrink-0 flex-col items-center">
-                <Button
-                  variant="tertiary"
-                  size="large"
-                  className="px-2"
-                  aria-label={t(($) => $['operation.close'], { ns: 'common' })}
-                  onClick={handleClose}
-                >
-                  <span className="i-ri-close-line size-5" />
-                </Button>
-                <div className="mt-1 system-2xs-medium-uppercase text-text-tertiary">ESC</div>
-              </div>
             </div>
             <div className="max-w-full min-w-0 px-4 pt-6 sm:px-8">
               {activeMenu === ACCOUNT_SETTING_TAB.PROVIDER && (

web/app/components/header/account-setting/model-provider-page/model-selector/popup.tsx

@@ -272,8 +272,10 @@ function Popup({
   return (
     <ModelSelectorPopupFrame>
       <ModelSelectorSearchHeader inputValue={inputValue} onInputValueChange={onInputValueChange} />
-      {showCreditsExhaustedAlert && <CreditsExhaustedAlert hasApiKeyFallback={hasApiKeyFallback} />}
       <ModelSelectorScrollBody label={t(($) => $['modelProvider.models'], { ns: 'common' })}>
+        {showCreditsExhaustedAlert && (
+          <CreditsExhaustedAlert hasApiKeyFallback={hasApiKeyFallback} />
+        )}
         <ComboboxList className="max-h-none overflow-visible p-0">
           <div className="pb-1">
             {filteredModelList.map((model) => (

web/app/components/plugins/install-plugin/hooks/__tests__/use-install-plugin-limit.spec.ts

@@ -4,125 +4,101 @@ import { InstallationScope } from '@/features/system-features/constants'
 import { renderHookWithConsoleQuery as renderHook } from '@/test/console/query-data'
 import { pluginInstallLimit } from '../use-install-plugin-limit'
 
+type PluginInstallCandidate = Parameters<typeof pluginInstallLimit>[0]
+type SystemFeatures = Parameters<typeof pluginInstallLimit>[1]
+
 const basePlugin = {
   from: 'marketplace' as const,
   verification: { authorized_category: 'langgenius' },
+} satisfies PluginInstallCandidate
+
+function makeSystemFeatures(
+  scope: PluginInstallationScope,
+  restrictToMarketplaceOnly = false,
+): SystemFeatures {
+  return {
+    plugin_installation_permission: {
+      restrict_to_marketplace_only: restrictToMarketplaceOnly,
+      plugin_installation_scope: scope,
+    },
+  }
 }
 
 describe('pluginInstallLimit', () => {
   it('should allow all plugins when scope is ALL', () => {
-    const features = {
-      plugin_installation_permission: {
-        restrict_to_marketplace_only: false,
-        plugin_installation_scope: InstallationScope.ALL,
-      },
-    }
+    const features = makeSystemFeatures(InstallationScope.ALL)
 
-    expect(pluginInstallLimit(basePlugin as never, features as never).canInstall).toBe(true)
+    expect(pluginInstallLimit(basePlugin, features).canInstall).toBe(true)
   })
 
   it('should deny all plugins when scope is NONE', () => {
-    const features = {
-      plugin_installation_permission: {
-        restrict_to_marketplace_only: false,
-        plugin_installation_scope: InstallationScope.NONE,
-      },
-    }
+    const features = makeSystemFeatures(InstallationScope.NONE)
 
-    expect(pluginInstallLimit(basePlugin as never, features as never).canInstall).toBe(false)
+    expect(pluginInstallLimit(basePlugin, features).canInstall).toBe(false)
   })
 
   it('should allow langgenius plugins when scope is OFFICIAL_ONLY', () => {
-    const features = {
-      plugin_installation_permission: {
-        restrict_to_marketplace_only: false,
-        plugin_installation_scope: InstallationScope.OFFICIAL_ONLY,
-      },
-    }
+    const features = makeSystemFeatures(InstallationScope.OFFICIAL_ONLY)
 
-    expect(pluginInstallLimit(basePlugin as never, features as never).canInstall).toBe(true)
+    expect(pluginInstallLimit(basePlugin, features).canInstall).toBe(true)
   })
 
   it('should deny non-official plugins when scope is OFFICIAL_ONLY', () => {
-    const features = {
-      plugin_installation_permission: {
-        restrict_to_marketplace_only: false,
-        plugin_installation_scope: InstallationScope.OFFICIAL_ONLY,
-      },
-    }
-    const plugin = { ...basePlugin, verification: { authorized_category: 'community' } }
+    const features = makeSystemFeatures(InstallationScope.OFFICIAL_ONLY)
+    const plugin = {
+      ...basePlugin,
+      verification: { authorized_category: 'community' as const },
+    } satisfies PluginInstallCandidate
 
-    expect(pluginInstallLimit(plugin as never, features as never).canInstall).toBe(false)
+    expect(pluginInstallLimit(plugin, features).canInstall).toBe(false)
   })
 
   it('should allow partner plugins when scope is OFFICIAL_AND_PARTNER', () => {
-    const features = {
-      plugin_installation_permission: {
-        restrict_to_marketplace_only: false,
-        plugin_installation_scope: InstallationScope.OFFICIAL_AND_PARTNER,
-      },
-    }
-    const plugin = { ...basePlugin, verification: { authorized_category: 'partner' } }
+    const features = makeSystemFeatures(InstallationScope.OFFICIAL_AND_PARTNER)
+    const plugin = {
+      ...basePlugin,
+      verification: { authorized_category: 'partner' as const },
+    } satisfies PluginInstallCandidate
 
-    expect(pluginInstallLimit(plugin as never, features as never).canInstall).toBe(true)
+    expect(pluginInstallLimit(plugin, features).canInstall).toBe(true)
   })
 
   it('should deny github plugins when restrict_to_marketplace_only is true', () => {
-    const features = {
-      plugin_installation_permission: {
-        restrict_to_marketplace_only: true,
-        plugin_installation_scope: InstallationScope.ALL,
-      },
-    }
-    const plugin = { ...basePlugin, from: 'github' as const }
+    const features = makeSystemFeatures(InstallationScope.ALL, true)
+    const plugin = { ...basePlugin, from: 'github' as const } satisfies PluginInstallCandidate
 
-    expect(pluginInstallLimit(plugin as never, features as never).canInstall).toBe(false)
+    expect(pluginInstallLimit(plugin, features).canInstall).toBe(false)
   })
 
   it('should deny package plugins when restrict_to_marketplace_only is true', () => {
-    const features = {
-      plugin_installation_permission: {
-        restrict_to_marketplace_only: true,
-        plugin_installation_scope: InstallationScope.ALL,
-      },
-    }
-    const plugin = { ...basePlugin, from: 'package' as const }
+    const features = makeSystemFeatures(InstallationScope.ALL, true)
+    const plugin = { ...basePlugin, from: 'package' as const } satisfies PluginInstallCandidate
 
-    expect(pluginInstallLimit(plugin as never, features as never).canInstall).toBe(false)
+    expect(pluginInstallLimit(plugin, features).canInstall).toBe(false)
   })
 
   it('should allow marketplace plugins even when restrict_to_marketplace_only is true', () => {
-    const features = {
-      plugin_installation_permission: {
-        restrict_to_marketplace_only: true,
-        plugin_installation_scope: InstallationScope.ALL,
-      },
-    }
+    const features = makeSystemFeatures(InstallationScope.ALL, true)
 
-    expect(pluginInstallLimit(basePlugin as never, features as never).canInstall).toBe(true)
+    expect(pluginInstallLimit(basePlugin, features).canInstall).toBe(true)
   })
 
   it('should default to langgenius when no verification info', () => {
-    const features = {
-      plugin_installation_permission: {
-        restrict_to_marketplace_only: false,
-        plugin_installation_scope: InstallationScope.OFFICIAL_ONLY,
-      },
-    }
-    const plugin = { from: 'marketplace' as const }
+    const features = makeSystemFeatures(InstallationScope.OFFICIAL_ONLY)
+    const plugin = { from: 'marketplace' as const } satisfies PluginInstallCandidate
 
-    expect(pluginInstallLimit(plugin as never, features as never).canInstall).toBe(true)
+    expect(pluginInstallLimit(plugin, features).canInstall).toBe(true)
   })
 
-  it('should fallback to canInstall true for unrecognized scope', () => {
+  it('should deny installation for an unrecognized runtime scope', () => {
     const features = {
       plugin_installation_permission: {
         restrict_to_marketplace_only: false,
-        plugin_installation_scope: 'unknown-scope' as unknown as PluginInstallationScope,
+        plugin_installation_scope: 'unknown-scope',
       },
-    }
+    } as unknown as SystemFeatures
 
-    expect(pluginInstallLimit(basePlugin as never, features as never).canInstall).toBe(true)
+    expect(pluginInstallLimit(basePlugin, features).canInstall).toBe(false)
   })
 })
 
@@ -132,9 +108,9 @@ describe('usePluginInstallLimit', () => {
     const plugin = {
       from: 'marketplace' as const,
       verification: { authorized_category: 'langgenius' },
-    }
+    } satisfies PluginInstallCandidate
 
-    const { result } = renderHook(() => usePluginInstallLimit(plugin as never))
+    const { result } = renderHook(() => usePluginInstallLimit(plugin))
 
     expect(result.current.canInstall).toBe(true)
   })

web/app/components/plugins/install-plugin/hooks/use-install-plugin-limit.tsx

@@ -1,68 +1,55 @@
 import type { GetSystemFeaturesResponse } from '@dify/contracts/api/console/system-features/types.gen'
-import type { Plugin, PluginManifestInMarket } from '../../types'
+import type {
+  PluginBundleDependencyType,
+  PluginVerification,
+} from '@dify/contracts/api/console/workspaces/types.gen'
 import { useSuspenseQuery } from '@tanstack/react-query'
 import { systemFeaturesQueryOptions } from '@/features/system-features/client'
 import { InstallationScope } from '@/features/system-features/constants'
 
-type PluginProps = (Plugin | PluginManifestInMarket) & {
-  from: 'github' | 'marketplace' | 'package'
+type PluginInstallCandidate = {
+  from: PluginBundleDependencyType
+  verification?: PluginVerification | null
 }
 type PluginInstallLimitResult = {
   canInstall: boolean
 }
 
+function denyUnsupportedInstallationScope(_scope: never): PluginInstallLimitResult {
+  return { canInstall: false }
+}
+
 export function pluginInstallLimit(
-  plugin: PluginProps,
+  plugin: PluginInstallCandidate,
   systemFeatures: Pick<GetSystemFeaturesResponse, 'plugin_installation_permission'>,
 ) {
-  if (systemFeatures.plugin_installation_permission.restrict_to_marketplace_only) {
+  const permission = systemFeatures.plugin_installation_permission
+  if (permission.restrict_to_marketplace_only) {
     if (plugin.from === 'github' || plugin.from === 'package') return { canInstall: false }
   }
 
-  if (
-    systemFeatures.plugin_installation_permission.plugin_installation_scope ===
-    InstallationScope.ALL
-  ) {
-    return {
-      canInstall: true,
-    }
-  }
-  if (
-    systemFeatures.plugin_installation_permission.plugin_installation_scope ===
-    InstallationScope.NONE
-  ) {
-    return {
-      canInstall: false,
-    }
-  }
-  const verification = plugin.verification || {}
-  if (!plugin.verification || !plugin.verification.authorized_category)
-    verification.authorized_category = 'langgenius'
+  const authorizedCategory = plugin.verification?.authorized_category ?? 'langgenius'
+  const scope = permission.plugin_installation_scope
 
-  if (
-    systemFeatures.plugin_installation_permission.plugin_installation_scope ===
-    InstallationScope.OFFICIAL_ONLY
-  ) {
-    return {
-      canInstall: verification.authorized_category === 'langgenius',
-    }
-  }
-  if (
-    systemFeatures.plugin_installation_permission.plugin_installation_scope ===
-    InstallationScope.OFFICIAL_AND_PARTNER
-  ) {
-    return {
-      canInstall:
-        verification.authorized_category === 'langgenius' ||
-        verification.authorized_category === 'partner',
-    }
-  }
-  return {
-    canInstall: true,
+  switch (scope) {
+    case InstallationScope.ALL:
+      return { canInstall: true }
+    case InstallationScope.NONE:
+      return { canInstall: false }
+    case InstallationScope.OFFICIAL_ONLY:
+      return { canInstall: authorizedCategory === 'langgenius' }
+    case InstallationScope.OFFICIAL_AND_PARTNER:
+      return {
+        canInstall: authorizedCategory === 'langgenius' || authorizedCategory === 'partner',
+      }
+    default:
+      return denyUnsupportedInstallationScope(scope)
   }
 }
 
-export default function usePluginInstallLimit(plugin: PluginProps): PluginInstallLimitResult {
+export default function usePluginInstallLimit(
+  plugin: PluginInstallCandidate,
+): PluginInstallLimitResult {
   const { data: systemFeatures } = useSuspenseQuery(systemFeaturesQueryOptions())
 
   return pluginInstallLimit(plugin, systemFeatures)

web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dify-web",
-  "version": "1.16.0",
+  "version": "1.16.1",
   "private": true,
   "type": "module",
   "imports": {