feat: add service api of HITL

Co-authored-by: hjlarry <hjlarry@163.com>
Co-authored-by: QuantumGhost <QuantumGhost@users.noreply.github.com>

.agents/skills/component-refactoring/SKILL.md

@@ -367,7 +367,7 @@ For each extraction:
   ┌────────────────────────────────────────┐
   │ 1. Extract code                        │
   │ 2. Run: pnpm lint:fix                  │
-  │ 3. Run: pnpm type-check                │
+  │ 3. Run: pnpm type-check:tsgo           │
   │ 4. Run: pnpm test                      │
   │ 5. Test functionality manually         │
   │ 6. PASS? → Next extraction             │

.agents/skills/frontend-testing/references/checklist.md

@@ -127,7 +127,7 @@ For the current file being tested:
 - [ ] Run full directory test: `pnpm test path/to/directory/`
 - [ ] Check coverage report: `pnpm test:coverage`
 - [ ] Run `pnpm lint:fix` on all test files
-- [ ] Run `pnpm type-check`
+- [ ] Run `pnpm type-check:tsgo`
 
 ## Common Issues to Watch
 

.gitignore

@@ -237,10 +237,6 @@ scripts/stress-test/reports/
 .playwright-mcp/
 .serena/
 
-# vitest browser mode attachments (failure screenshots, traces, etc.)
-.vitest-attachments/
-**/__screenshots__/
-
 # settings
 *.local.json
 *.local.md

AGENTS.md

@@ -30,7 +30,7 @@ The codebase is split into:
 ## Language Style
 
 - **Python**: Keep type hints on functions and attributes, and implement relevant special methods (e.g., `__repr__`, `__str__`). Prefer `TypedDict` over `dict` or `Mapping` for type safety and better code documentation.
-- **TypeScript**: Use the strict config, rely on ESLint (`pnpm lint:fix` preferred) plus `pnpm type-check`, and avoid `any` types.
+- **TypeScript**: Use the strict config, rely on ESLint (`pnpm lint:fix` preferred) plus `pnpm type-check:tsgo`, and avoid `any` types.
 
 ## General Practices
 

README.md

@@ -139,6 +139,19 @@ Star Dify on GitHub and be instantly notified of new releases.
 
 If you need to customize the configuration, please refer to the comments in our [.env.example](docker/.env.example) file and update the corresponding values in your `.env` file. Additionally, you might need to make adjustments to the `docker-compose.yaml` file itself, such as changing image versions, port mappings, or volume mounts, based on your specific deployment environment and requirements. After making any changes, please re-run `docker compose up -d`. You can find the full list of available environment variables [here](https://docs.dify.ai/getting-started/install-self-hosted/environments).
 
+#### Customizing Suggested Questions
+
+You can now customize the "Suggested Questions After Answer" feature to better fit your use case. For example, to generate longer, more technical questions:
+
+```bash
+# In your .env file
+SUGGESTED_QUESTIONS_PROMPT='Please help me predict the five most likely technical follow-up questions a developer would ask. Focus on implementation details, best practices, and architecture considerations. Keep each question between 40-60 characters. Output must be JSON array: ["question1","question2","question3","question4","question5"]'
+SUGGESTED_QUESTIONS_MAX_TOKENS=512
+SUGGESTED_QUESTIONS_TEMPERATURE=0.3
+```
+
+See the [Suggested Questions Configuration Guide](docs/suggested-questions-configuration.md) for detailed examples and usage instructions.
+
 ### Metrics Monitoring with Grafana
 
 Import the dashboard to Grafana, using Dify's PostgreSQL database as data source, to monitor metrics in granularity of apps, tenants, messages, and more.

api/.env.example

@@ -709,6 +709,22 @@ SWAGGER_UI_PATH=/swagger-ui.html
 # Set to false to export dataset IDs as plain text for easier cross-environment import
 DSL_EXPORT_ENCRYPT_DATASET_ID=true
 
+# Suggested Questions After Answer Configuration
+# These environment variables allow customization of the suggested questions feature
+#
+# Custom prompt for generating suggested questions (optional)
+# If not set, uses the default prompt that generates 3 questions under 20 characters each
+# Example: "Please help me predict the five most likely technical follow-up questions a developer would ask. Focus on implementation details, best practices, and architecture considerations. Keep each question between 40-60 characters. Output must be JSON array: [\"question1\",\"question2\",\"question3\",\"question4\",\"question5\"]"
+# SUGGESTED_QUESTIONS_PROMPT=
+
+# Maximum number of tokens for suggested questions generation (default: 256)
+# Adjust this value for longer questions or more questions
+# SUGGESTED_QUESTIONS_MAX_TOKENS=256
+
+# Temperature for suggested questions generation (default: 0.0)
+# Higher values (0.5-1.0) produce more creative questions, lower values (0.0-0.3) produce more focused questions
+# SUGGESTED_QUESTIONS_TEMPERATURE=0
+
 # Tenant isolated task queue configuration
 TENANT_ISOLATED_TASK_CONCURRENCY=1
 

api/README.md

@@ -101,11 +101,3 @@ The scripts resolve paths relative to their location, so you can run them from a
    uv run ruff format ./        # Format code
    uv run basedpyright .        # Type checking
    ```
-
-## Generate TS stub
-
-```
-uv run dev/generate_swagger_specs.py --output-dir openapi
-```
-
-use https://jsontotable.org/openapi-to-typescript to convert to typescript

api/controllers/console/human_input_form.py

@@ -20,11 +20,11 @@ from core.app.apps.base_app_generator import BaseAppGenerator
 from core.app.apps.common.workflow_response_converter import WorkflowResponseConverter
 from core.app.apps.message_generator import MessageGenerator
 from core.app.apps.workflow.app_generator import WorkflowAppGenerator
+from core.workflow.human_input_policy import HumanInputSurface, is_recipient_type_allowed_for_surface
 from extensions.ext_database import db
 from libs.login import current_account_with_tenant, login_required
 from models import App
 from models.enums import CreatorUserRole
-from models.human_input import RecipientType
 from models.model import AppMode
 from models.workflow import WorkflowRun
 from repositories.factory import DifyAPIRepositoryFactory
@@ -56,6 +56,11 @@ class ConsoleHumanInputFormApi(Resource):
         if form.tenant_id != current_tenant_id:
             raise NotFoundError("App not found")
 
+    @staticmethod
+    def _ensure_console_recipient_type(form: Form) -> None:
+        if not is_recipient_type_allowed_for_surface(form.recipient_type, HumanInputSurface.CONSOLE):
+            raise NotFoundError("form not found")
+
     @setup_required
     @login_required
     @account_initialization_required
@@ -99,10 +104,8 @@ class ConsoleHumanInputFormApi(Resource):
             raise NotFoundError(f"form not found, token={form_token}")
 
         self._ensure_console_access(form)
-
+        self._ensure_console_recipient_type(form)
         recipient_type = form.recipient_type
-        if recipient_type not in {RecipientType.CONSOLE, RecipientType.BACKSTAGE}:
-            raise NotFoundError(f"form not found, token={form_token}")
         # The type checker is not smart enought to validate the following invariant.
         # So we need to assert it manually.
         assert recipient_type is not None, "recipient_type cannot be None here."

api/controllers/console/workspace/endpoint.py

@@ -1,11 +1,3 @@
-"""Console workspace endpoint controllers.
-
-This module exposes workspace-scoped plugin endpoint management APIs. The
-canonical write routes follow resource-oriented paths, while the historical
-verb-based aliases stay available as deprecated resources so OpenAPI metadata
-marks only the legacy paths as deprecated.
-"""
-
 from typing import Any
 
 from flask import request
@@ -33,12 +25,7 @@ class EndpointIdPayload(BaseModel):
     endpoint_id: str
 
 
-class EndpointUpdatePayload(BaseModel):
-    settings: dict[str, Any]
-    name: str = Field(min_length=1)
-
-
-class LegacyEndpointUpdatePayload(EndpointIdPayload):
+class EndpointUpdatePayload(EndpointIdPayload):
     settings: dict[str, Any]
     name: str = Field(min_length=1)
 
@@ -89,7 +76,6 @@ register_schema_models(
     EndpointCreatePayload,
     EndpointIdPayload,
     EndpointUpdatePayload,
-    LegacyEndpointUpdatePayload,
     EndpointListQuery,
     EndpointListForPluginQuery,
     EndpointCreateResponse,
@@ -102,60 +88,8 @@ register_schema_models(
 )
 
 
-def _create_endpoint() -> dict[str, bool]:
-    """Create a plugin endpoint for the current workspace."""
-    user, tenant_id = current_account_with_tenant()
-
-    args = EndpointCreatePayload.model_validate(console_ns.payload)
-
-    try:
-        return {
-            "success": EndpointService.create_endpoint(
-                tenant_id=tenant_id,
-                user_id=user.id,
-                plugin_unique_identifier=args.plugin_unique_identifier,
-                name=args.name,
-                settings=args.settings,
-            )
-        }
-    except PluginPermissionDeniedError as e:
-        raise ValueError(e.description) from e
-
-
-def _update_endpoint(endpoint_id: str) -> dict[str, bool]:
-    """Update a plugin endpoint identified by the canonical path parameter."""
-    user, tenant_id = current_account_with_tenant()
-
-    args = EndpointUpdatePayload.model_validate(console_ns.payload)
-
-    return {
-        "success": EndpointService.update_endpoint(
-            tenant_id=tenant_id,
-            user_id=user.id,
-            endpoint_id=endpoint_id,
-            name=args.name,
-            settings=args.settings,
-        )
-    }
-
-
-def _delete_endpoint(endpoint_id: str) -> dict[str, bool]:
-    """Delete a plugin endpoint identified by the canonical path parameter."""
-    user, tenant_id = current_account_with_tenant()
-
-    return {
-        "success": EndpointService.delete_endpoint(
-            tenant_id=tenant_id,
-            user_id=user.id,
-            endpoint_id=endpoint_id,
-        )
-    }
-
-
-@console_ns.route("/workspaces/current/endpoints")
-class EndpointCollectionApi(Resource):
-    """Canonical collection resource for endpoint creation."""
-
+@console_ns.route("/workspaces/current/endpoints/create")
+class EndpointCreateApi(Resource):
     @console_ns.doc("create_endpoint")
     @console_ns.doc(description="Create a new plugin endpoint")
     @console_ns.expect(console_ns.models[EndpointCreatePayload.__name__])
@@ -170,33 +104,22 @@ class EndpointCollectionApi(Resource):
     @is_admin_or_owner_required
     @account_initialization_required
     def post(self):
-        return _create_endpoint()
+        user, tenant_id = current_account_with_tenant()
 
+        args = EndpointCreatePayload.model_validate(console_ns.payload)
 
-@console_ns.route("/workspaces/current/endpoints/create")
-class DeprecatedEndpointCreateApi(Resource):
-    """Deprecated verb-based alias for endpoint creation."""
-
-    @console_ns.doc("create_endpoint_deprecated")
-    @console_ns.doc(deprecated=True)
-    @console_ns.doc(
-        description=(
-            "Deprecated legacy alias for creating a plugin endpoint. Use POST /workspaces/current/endpoints instead."
-        )
-    )
-    @console_ns.expect(console_ns.models[EndpointCreatePayload.__name__])
-    @console_ns.response(
-        200,
-        "Endpoint created successfully",
-        console_ns.models[EndpointCreateResponse.__name__],
-    )
-    @console_ns.response(403, "Admin privileges required")
-    @setup_required
-    @login_required
-    @is_admin_or_owner_required
-    @account_initialization_required
-    def post(self):
-        return _create_endpoint()
+        try:
+            return {
+                "success": EndpointService.create_endpoint(
+                    tenant_id=tenant_id,
+                    user_id=user.id,
+                    plugin_unique_identifier=args.plugin_unique_identifier,
+                    name=args.name,
+                    settings=args.settings,
+                )
+            }
+        except PluginPermissionDeniedError as e:
+            raise ValueError(e.description) from e
 
 
 @console_ns.route("/workspaces/current/endpoints/list")
@@ -267,56 +190,10 @@ class EndpointListForSinglePluginApi(Resource):
         )
 
 
-@console_ns.route("/workspaces/current/endpoints/<string:id>")
-class EndpointItemApi(Resource):
-    """Canonical item resource for endpoint updates and deletion."""
-
+@console_ns.route("/workspaces/current/endpoints/delete")
+class EndpointDeleteApi(Resource):
     @console_ns.doc("delete_endpoint")
     @console_ns.doc(description="Delete a plugin endpoint")
-    @console_ns.doc(params={"id": {"description": "Endpoint ID", "type": "string", "required": True}})
-    @console_ns.response(
-        200,
-        "Endpoint deleted successfully",
-        console_ns.models[EndpointDeleteResponse.__name__],
-    )
-    @console_ns.response(403, "Admin privileges required")
-    @setup_required
-    @login_required
-    @is_admin_or_owner_required
-    @account_initialization_required
-    def delete(self, id: str):
-        return _delete_endpoint(endpoint_id=id)
-
-    @console_ns.doc("update_endpoint")
-    @console_ns.doc(description="Update a plugin endpoint")
-    @console_ns.expect(console_ns.models[EndpointUpdatePayload.__name__])
-    @console_ns.doc(params={"id": {"description": "Endpoint ID", "type": "string", "required": True}})
-    @console_ns.response(
-        200,
-        "Endpoint updated successfully",
-        console_ns.models[EndpointUpdateResponse.__name__],
-    )
-    @console_ns.response(403, "Admin privileges required")
-    @setup_required
-    @login_required
-    @is_admin_or_owner_required
-    @account_initialization_required
-    def patch(self, id: str):
-        return _update_endpoint(endpoint_id=id)
-
-
-@console_ns.route("/workspaces/current/endpoints/delete")
-class DeprecatedEndpointDeleteApi(Resource):
-    """Deprecated verb-based alias for endpoint deletion."""
-
-    @console_ns.doc("delete_endpoint_deprecated")
-    @console_ns.doc(deprecated=True)
-    @console_ns.doc(
-        description=(
-            "Deprecated legacy alias for deleting a plugin endpoint. "
-            "Use DELETE /workspaces/current/endpoints/{id} instead."
-        )
-    )
     @console_ns.expect(console_ns.models[EndpointIdPayload.__name__])
     @console_ns.response(
         200,
@@ -329,23 +206,22 @@ class DeprecatedEndpointDeleteApi(Resource):
     @is_admin_or_owner_required
     @account_initialization_required
     def post(self):
+        user, tenant_id = current_account_with_tenant()
+
         args = EndpointIdPayload.model_validate(console_ns.payload)
-        return _delete_endpoint(endpoint_id=args.endpoint_id)
+
+        return {
+            "success": EndpointService.delete_endpoint(
+                tenant_id=tenant_id, user_id=user.id, endpoint_id=args.endpoint_id
+            )
+        }
 
 
 @console_ns.route("/workspaces/current/endpoints/update")
-class DeprecatedEndpointUpdateApi(Resource):
-    """Deprecated verb-based alias for endpoint updates."""
-
-    @console_ns.doc("update_endpoint_deprecated")
-    @console_ns.doc(deprecated=True)
-    @console_ns.doc(
-        description=(
-            "Deprecated legacy alias for updating a plugin endpoint. "
-            "Use PATCH /workspaces/current/endpoints/{id} instead."
-        )
-    )
-    @console_ns.expect(console_ns.models[LegacyEndpointUpdatePayload.__name__])
+class EndpointUpdateApi(Resource):
+    @console_ns.doc("update_endpoint")
+    @console_ns.doc(description="Update a plugin endpoint")
+    @console_ns.expect(console_ns.models[EndpointUpdatePayload.__name__])
     @console_ns.response(
         200,
         "Endpoint updated successfully",
@@ -357,8 +233,19 @@ class DeprecatedEndpointUpdateApi(Resource):
     @is_admin_or_owner_required
     @account_initialization_required
     def post(self):
-        args = LegacyEndpointUpdatePayload.model_validate(console_ns.payload)
-        return _update_endpoint(endpoint_id=args.endpoint_id)
+        user, tenant_id = current_account_with_tenant()
+
+        args = EndpointUpdatePayload.model_validate(console_ns.payload)
+
+        return {
+            "success": EndpointService.update_endpoint(
+                tenant_id=tenant_id,
+                user_id=user.id,
+                endpoint_id=args.endpoint_id,
+                name=args.name,
+                settings=args.settings,
+            )
+        }
 
 
 @console_ns.route("/workspaces/current/endpoints/enable")

api/controllers/service_api/__init__.py

@@ -23,9 +23,11 @@ from .app import (
     conversation,
     file,
     file_preview,
+    human_input_form,
     message,
     site,
     workflow,
+    workflow_events,
 )
 from .dataset import (
     dataset,
@@ -50,6 +52,7 @@ __all__ = [
     "file",
     "file_preview",
     "hit_testing",
+    "human_input_form",
     "index",
     "message",
     "metadata",
@@ -58,6 +61,7 @@ __all__ = [
     "segment",
     "site",
     "workflow",
+    "workflow_events",
 ]
 
 api.add_namespace(service_api_ns)

api/controllers/service_api/app/human_input_form.py

@@ -0,0 +1,143 @@
+"""
+Service API human input form endpoints.
+
+This module exposes app-token authenticated APIs for fetching and submitting
+paused human input forms in workflow/chatflow runs.
+"""
+
+import json
+import logging
+from datetime import datetime
+from typing import Any
+
+from flask import Response
+from flask_restx import Resource
+from pydantic import BaseModel
+from werkzeug.exceptions import InternalServerError, NotFound
+
+from controllers.common.schema import register_schema_models
+from controllers.service_api import service_api_ns
+from controllers.service_api.wraps import FetchUserArg, WhereisUserArg, validate_app_token
+from core.workflow.human_input_policy import HumanInputSurface, is_recipient_type_allowed_for_surface
+from extensions.ext_database import db
+from models.model import App, EndUser
+from services.human_input_service import Form, FormNotFoundError, HumanInputService
+
+logger = logging.getLogger(__name__)
+
+
+class HumanInputFormSubmitPayload(BaseModel):
+    inputs: dict[str, Any]
+    action: str
+
+
+register_schema_models(service_api_ns, HumanInputFormSubmitPayload)
+
+
+def _stringify_default_values(values: dict[str, object]) -> dict[str, str]:
+    result: dict[str, str] = {}
+    for key, value in values.items():
+        if value is None:
+            result[key] = ""
+        elif isinstance(value, (dict, list)):
+            result[key] = json.dumps(value, ensure_ascii=False)
+        else:
+            result[key] = str(value)
+    return result
+
+
+def _to_timestamp(value: datetime) -> int:
+    return int(value.timestamp())
+
+
+def _jsonify_form_definition(form: Form) -> Response:
+    definition_payload = form.get_definition().model_dump()
+    payload = {
+        "form_content": definition_payload["rendered_content"],
+        "inputs": definition_payload["inputs"],
+        "resolved_default_values": _stringify_default_values(definition_payload["default_values"]),
+        "user_actions": definition_payload["user_actions"],
+        "expiration_time": _to_timestamp(form.expiration_time),
+    }
+    return Response(json.dumps(payload, ensure_ascii=False), mimetype="application/json")
+
+
+def _ensure_form_belongs_to_app(form: Form, app_model: App) -> None:
+    if form.app_id != app_model.id or form.tenant_id != app_model.tenant_id:
+        raise NotFound("Form not found")
+
+
+def _ensure_form_is_allowed_for_service_api(form: Form) -> None:
+    # Keep app-token callers scoped to the public web-form surface; internal HITL
+    # routes must continue to flow through console-only authentication.
+    if not is_recipient_type_allowed_for_surface(form.recipient_type, HumanInputSurface.SERVICE_API):
+        raise NotFound("Form not found")
+
+
+@service_api_ns.route("/form/human_input/<string:form_token>")
+class WorkflowHumanInputFormApi(Resource):
+    @service_api_ns.doc("get_human_input_form")
+    @service_api_ns.doc(description="Get a paused human input form by token")
+    @service_api_ns.doc(params={"form_token": "Human input form token"})
+    @service_api_ns.doc(
+        responses={
+            200: "Form retrieved successfully",
+            401: "Unauthorized - invalid API token",
+            404: "Form not found",
+            412: "Form already submitted or expired",
+        }
+    )
+    @validate_app_token
+    def get(self, app_model: App, form_token: str):
+        service = HumanInputService(db.engine)
+        form = service.get_form_by_token(form_token)
+        if form is None:
+            raise NotFound("Form not found")
+
+        _ensure_form_belongs_to_app(form, app_model)
+        _ensure_form_is_allowed_for_service_api(form)
+        service.ensure_form_active(form)
+        return _jsonify_form_definition(form)
+
+    @service_api_ns.expect(service_api_ns.models[HumanInputFormSubmitPayload.__name__])
+    @service_api_ns.doc("submit_human_input_form")
+    @service_api_ns.doc(description="Submit a paused human input form by token")
+    @service_api_ns.doc(params={"form_token": "Human input form token"})
+    @service_api_ns.doc(
+        responses={
+            200: "Form submitted successfully",
+            400: "Bad request - invalid submission data",
+            401: "Unauthorized - invalid API token",
+            404: "Form not found",
+            412: "Form already submitted or expired",
+        }
+    )
+    @validate_app_token(fetch_user_arg=FetchUserArg(fetch_from=WhereisUserArg.JSON, required=True))
+    def post(self, app_model: App, end_user: EndUser, form_token: str):
+        payload = HumanInputFormSubmitPayload.model_validate(service_api_ns.payload or {})
+
+        service = HumanInputService(db.engine)
+        form = service.get_form_by_token(form_token)
+        if form is None:
+            raise NotFound("Form not found")
+
+        _ensure_form_belongs_to_app(form, app_model)
+        _ensure_form_is_allowed_for_service_api(form)
+
+        recipient_type = form.recipient_type
+        if recipient_type is None:
+            logger.warning("Recipient type is None for form, form_id=%s", form.id)
+            raise InternalServerError("Form recipient type is invalid")
+
+        try:
+            service.submit_form_by_token(
+                recipient_type=recipient_type,
+                form_token=form_token,
+                selected_action_id=payload.action,
+                form_data=payload.inputs,
+                submission_end_user_id=end_user.id,
+            )
+        except FormNotFoundError:
+            raise NotFound("Form not found")
+
+        return {}, 200

api/controllers/service_api/app/workflow_events.py

@@ -0,0 +1,133 @@
+"""
+Service API workflow resume event stream endpoints.
+"""
+
+import json
+from collections.abc import Generator
+
+from flask import Response, request
+from flask_restx import Resource
+from sqlalchemy.orm import sessionmaker
+from werkzeug.exceptions import NotFound
+
+from controllers.service_api import service_api_ns
+from controllers.service_api.app.error import NotWorkflowAppError
+from controllers.service_api.wraps import FetchUserArg, WhereisUserArg, validate_app_token
+from core.app.apps.advanced_chat.app_generator import AdvancedChatAppGenerator
+from core.app.apps.base_app_generator import BaseAppGenerator
+from core.app.apps.common.workflow_response_converter import WorkflowResponseConverter
+from core.app.apps.message_generator import MessageGenerator
+from core.app.apps.workflow.app_generator import WorkflowAppGenerator
+from extensions.ext_database import db
+from models.enums import CreatorUserRole
+from models.model import App, AppMode, EndUser
+from repositories.factory import DifyAPIRepositoryFactory
+from services.workflow_event_snapshot_service import build_workflow_event_stream
+
+
+@service_api_ns.route("/workflow/<string:task_id>/events")
+class WorkflowEventsApi(Resource):
+    """Service API for getting workflow execution events after resume."""
+
+    @service_api_ns.doc("get_workflow_events")
+    @service_api_ns.doc(description="Get workflow execution events stream after resume")
+    @service_api_ns.doc(
+        params={
+            "task_id": "Workflow run ID",
+            "user": "End user identifier (query param)",
+            "include_state_snapshot": "Whether to replay from persisted state snapshot",
+            "continue_on_pause": "Whether to keep the stream open across workflow_paused events",
+        }
+    )
+    @service_api_ns.doc(
+        responses={
+            200: "SSE event stream",
+            401: "Unauthorized - invalid API token",
+            404: "Workflow run not found",
+        }
+    )
+    @validate_app_token(fetch_user_arg=FetchUserArg(fetch_from=WhereisUserArg.QUERY, required=True))
+    def get(self, app_model: App, end_user: EndUser, task_id: str):
+        app_mode = AppMode.value_of(app_model.mode)
+        if app_mode not in {AppMode.WORKFLOW, AppMode.ADVANCED_CHAT}:
+            raise NotWorkflowAppError()
+
+        session_maker = sessionmaker(db.engine)
+        repo = DifyAPIRepositoryFactory.create_api_workflow_run_repository(session_maker)
+        workflow_run = repo.get_workflow_run_by_id_and_tenant_id(
+            tenant_id=app_model.tenant_id,
+            run_id=task_id,
+        )
+
+        if workflow_run is None:
+            raise NotFound("Workflow run not found")
+
+        if workflow_run.app_id != app_model.id:
+            raise NotFound("Workflow run not found")
+
+        if workflow_run.created_by_role != CreatorUserRole.END_USER:
+            raise NotFound("Workflow run not found")
+
+        if workflow_run.created_by != end_user.id:
+            raise NotFound("Workflow run not found")
+
+        workflow_run_entity = workflow_run
+
+        if workflow_run_entity.finished_at is not None:
+            response = WorkflowResponseConverter.workflow_run_result_to_finish_response(
+                task_id=workflow_run_entity.id,
+                workflow_run=workflow_run_entity,
+                creator_user=end_user,
+            )
+
+            payload = response.model_dump(mode="json")
+            payload["event"] = response.event.value
+
+            def _generate_finished_events() -> Generator[str, None, None]:
+                yield f"data: {json.dumps(payload)}\n\n"
+
+            event_generator = _generate_finished_events
+        else:
+            msg_generator = MessageGenerator()
+            generator: BaseAppGenerator
+            if app_mode == AppMode.ADVANCED_CHAT:
+                generator = AdvancedChatAppGenerator()
+            elif app_mode == AppMode.WORKFLOW:
+                generator = WorkflowAppGenerator()
+            else:
+                raise NotWorkflowAppError()
+
+            include_state_snapshot = request.args.get("include_state_snapshot", "false").lower() == "true"
+            continue_on_pause = request.args.get("continue_on_pause", "false").lower() == "true"
+            terminal_events = ["workflow_finished"] if continue_on_pause else None
+
+            def _generate_stream_events():
+                if include_state_snapshot:
+                    return generator.convert_to_event_stream(
+                        build_workflow_event_stream(
+                            app_mode=app_mode,
+                            workflow_run=workflow_run_entity,
+                            tenant_id=app_model.tenant_id,
+                            app_id=app_model.id,
+                            session_maker=session_maker,
+                            close_on_pause=not continue_on_pause,
+                        )
+                    )
+                return generator.convert_to_event_stream(
+                    msg_generator.retrieve_events(
+                        app_mode,
+                        workflow_run_entity.id,
+                        terminal_events=terminal_events,
+                    ),
+                )
+
+            event_generator = _generate_stream_events
+
+        return Response(
+            event_generator(),
+            mimetype="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+            },
+        )

api/controllers/service_api/dataset/document.py

@@ -1,12 +1,4 @@
-"""Service API endpoints for dataset document management.
-
-The canonical Service API paths use hyphenated route segments. Legacy underscore
-aliases remain registered for backward compatibility, but they must stay marked
-deprecated in generated API docs so clients migrate toward the canonical paths.
-"""
-
 import json
-from collections.abc import Mapping
 from contextlib import ExitStack
 from typing import Self
 from uuid import UUID
@@ -125,137 +117,12 @@ register_schema_models(
 )
 
 
-def _create_document_by_text(tenant_id: str, dataset_id: UUID) -> tuple[Mapping[str, object], int]:
-    """Create a document from text for both canonical and legacy routes."""
-    payload = DocumentTextCreatePayload.model_validate(service_api_ns.payload or {})
-    args = payload.model_dump(exclude_none=True)
-
-    dataset_id_str = str(dataset_id)
-    tenant_id_str = str(tenant_id)
-    dataset = db.session.scalar(
-        select(Dataset).where(Dataset.tenant_id == tenant_id_str, Dataset.id == dataset_id_str).limit(1)
-    )
-
-    if not dataset:
-        raise ValueError("Dataset does not exist.")
-
-    if not dataset.indexing_technique and not args["indexing_technique"]:
-        raise ValueError("indexing_technique is required.")
-
-    embedding_model_provider = payload.embedding_model_provider
-    embedding_model = payload.embedding_model
-    if embedding_model_provider and embedding_model:
-        DatasetService.check_embedding_model_setting(tenant_id_str, embedding_model_provider, embedding_model)
-
-    retrieval_model = payload.retrieval_model
-    if (
-        retrieval_model
-        and retrieval_model.reranking_model
-        and retrieval_model.reranking_model.reranking_provider_name
-        and retrieval_model.reranking_model.reranking_model_name
-    ):
-        DatasetService.check_reranking_model_setting(
-            tenant_id_str,
-            retrieval_model.reranking_model.reranking_provider_name,
-            retrieval_model.reranking_model.reranking_model_name,
-        )
-
-    if not current_user:
-        raise ValueError("current_user is required")
-
-    upload_file = FileService(db.engine).upload_text(
-        text=payload.text, text_name=payload.name, user_id=current_user.id, tenant_id=tenant_id_str
-    )
-    data_source = {
-        "type": "upload_file",
-        "info_list": {"data_source_type": "upload_file", "file_info_list": {"file_ids": [upload_file.id]}},
-    }
-    args["data_source"] = data_source
-    knowledge_config = KnowledgeConfig.model_validate(args)
-    DocumentService.document_create_args_validate(knowledge_config)
-
-    if not current_user:
-        raise ValueError("current_user is required")
-
-    try:
-        documents, batch = DocumentService.save_document_with_dataset_id(
-            dataset=dataset,
-            knowledge_config=knowledge_config,
-            account=current_user,
-            dataset_process_rule=dataset.latest_process_rule if "process_rule" not in args else None,
-            created_from="api",
-        )
-    except ProviderTokenNotInitError as ex:
-        raise ProviderNotInitializeError(ex.description)
-    document = documents[0]
-
-    documents_and_batch_fields = {"document": marshal(document, document_fields), "batch": batch}
-    return documents_and_batch_fields, 200
-
-
-def _update_document_by_text(tenant_id: str, dataset_id: UUID, document_id: UUID) -> tuple[Mapping[str, object], int]:
-    """Update a document from text for both canonical and legacy routes."""
-    payload = DocumentTextUpdate.model_validate(service_api_ns.payload or {})
-    dataset = db.session.scalar(
-        select(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == str(dataset_id)).limit(1)
-    )
-    args = payload.model_dump(exclude_none=True)
-    if not dataset:
-        raise ValueError("Dataset does not exist.")
-
-    retrieval_model = payload.retrieval_model
-    if (
-        retrieval_model
-        and retrieval_model.reranking_model
-        and retrieval_model.reranking_model.reranking_provider_name
-        and retrieval_model.reranking_model.reranking_model_name
-    ):
-        DatasetService.check_reranking_model_setting(
-            tenant_id,
-            retrieval_model.reranking_model.reranking_provider_name,
-            retrieval_model.reranking_model.reranking_model_name,
-        )
-
-    # indexing_technique is already set in dataset since this is an update
-    args["indexing_technique"] = dataset.indexing_technique
-
-    if args.get("text"):
-        text = args.get("text")
-        name = args.get("name")
-        if not current_user:
-            raise ValueError("current_user is required")
-        upload_file = FileService(db.engine).upload_text(
-            text=str(text), text_name=str(name), user_id=current_user.id, tenant_id=tenant_id
-        )
-        data_source = {
-            "type": "upload_file",
-            "info_list": {"data_source_type": "upload_file", "file_info_list": {"file_ids": [upload_file.id]}},
-        }
-        args["data_source"] = data_source
-
-    args["original_document_id"] = str(document_id)
-    knowledge_config = KnowledgeConfig.model_validate(args)
-    DocumentService.document_create_args_validate(knowledge_config)
-
-    try:
-        documents, batch = DocumentService.save_document_with_dataset_id(
-            dataset=dataset,
-            knowledge_config=knowledge_config,
-            account=current_user,
-            dataset_process_rule=dataset.latest_process_rule if "process_rule" not in args else None,
-            created_from="api",
-        )
-    except ProviderTokenNotInitError as ex:
-        raise ProviderNotInitializeError(ex.description)
-    document = documents[0]
-
-    documents_and_batch_fields = {"document": marshal(document, document_fields), "batch": batch}
-    return documents_and_batch_fields, 200
-
-
-@service_api_ns.route("/datasets/<uuid:dataset_id>/document/create-by-text")
+@service_api_ns.route(
+    "/datasets/<uuid:dataset_id>/document/create_by_text",
+    "/datasets/<uuid:dataset_id>/document/create-by-text",
+)
 class DocumentAddByTextApi(DatasetApiResource):
-    """Resource for the canonical text document creation route."""
+    """Resource for documents."""
 
     @service_api_ns.expect(service_api_ns.models[DocumentTextCreatePayload.__name__])
     @service_api_ns.doc("create_document_by_text")
@@ -271,43 +138,81 @@ class DocumentAddByTextApi(DatasetApiResource):
     @cloud_edition_billing_resource_check("vector_space", "dataset")
     @cloud_edition_billing_resource_check("documents", "dataset")
     @cloud_edition_billing_rate_limit_check("knowledge", "dataset")
-    def post(self, tenant_id: str, dataset_id: UUID):
+    def post(self, tenant_id, dataset_id):
         """Create document by text."""
-        return _create_document_by_text(tenant_id=tenant_id, dataset_id=dataset_id)
+        payload = DocumentTextCreatePayload.model_validate(service_api_ns.payload or {})
+        args = payload.model_dump(exclude_none=True)
 
-
-@service_api_ns.route("/datasets/<uuid:dataset_id>/document/create_by_text")
-class DeprecatedDocumentAddByTextApi(DatasetApiResource):
-    """Deprecated resource alias for text document creation."""
-
-    @service_api_ns.expect(service_api_ns.models[DocumentTextCreatePayload.__name__])
-    @service_api_ns.doc("create_document_by_text_deprecated")
-    @service_api_ns.doc(deprecated=True)
-    @service_api_ns.doc(
-        description=(
-            "Deprecated legacy alias for creating a new document by providing text content. "
-            "Use /datasets/{dataset_id}/document/create-by-text instead."
+        dataset_id = str(dataset_id)
+        tenant_id = str(tenant_id)
+        dataset = db.session.scalar(
+            select(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).limit(1)
         )
-    )
-    @service_api_ns.doc(params={"dataset_id": "Dataset ID"})
-    @service_api_ns.doc(
-        responses={
-            200: "Document created successfully",
-            401: "Unauthorized - invalid API token",
-            400: "Bad request - invalid parameters",
+
+        if not dataset:
+            raise ValueError("Dataset does not exist.")
+
+        if not dataset.indexing_technique and not args["indexing_technique"]:
+            raise ValueError("indexing_technique is required.")
+
+        embedding_model_provider = payload.embedding_model_provider
+        embedding_model = payload.embedding_model
+        if embedding_model_provider and embedding_model:
+            DatasetService.check_embedding_model_setting(tenant_id, embedding_model_provider, embedding_model)
+
+        retrieval_model = payload.retrieval_model
+        if (
+            retrieval_model
+            and retrieval_model.reranking_model
+            and retrieval_model.reranking_model.reranking_provider_name
+            and retrieval_model.reranking_model.reranking_model_name
+        ):
+            DatasetService.check_reranking_model_setting(
+                tenant_id,
+                retrieval_model.reranking_model.reranking_provider_name,
+                retrieval_model.reranking_model.reranking_model_name,
+            )
+
+        if not current_user:
+            raise ValueError("current_user is required")
+
+        upload_file = FileService(db.engine).upload_text(
+            text=payload.text, text_name=payload.name, user_id=current_user.id, tenant_id=tenant_id
+        )
+        data_source = {
+            "type": "upload_file",
+            "info_list": {"data_source_type": "upload_file", "file_info_list": {"file_ids": [upload_file.id]}},
         }
-    )
-    @cloud_edition_billing_resource_check("vector_space", "dataset")
-    @cloud_edition_billing_resource_check("documents", "dataset")
-    @cloud_edition_billing_rate_limit_check("knowledge", "dataset")
-    def post(self, tenant_id: str, dataset_id: UUID):
-        """Create document by text through the deprecated underscore alias."""
-        return _create_document_by_text(tenant_id=tenant_id, dataset_id=dataset_id)
+        args["data_source"] = data_source
+        knowledge_config = KnowledgeConfig.model_validate(args)
+        # validate args
+        DocumentService.document_create_args_validate(knowledge_config)
+
+        if not current_user:
+            raise ValueError("current_user is required")
+
+        try:
+            documents, batch = DocumentService.save_document_with_dataset_id(
+                dataset=dataset,
+                knowledge_config=knowledge_config,
+                account=current_user,
+                dataset_process_rule=dataset.latest_process_rule if "process_rule" not in args else None,
+                created_from="api",
+            )
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        document = documents[0]
+
+        documents_and_batch_fields = {"document": marshal(document, document_fields), "batch": batch}
+        return documents_and_batch_fields, 200
 
 
-@service_api_ns.route("/datasets/<uuid:dataset_id>/documents/<uuid:document_id>/update-by-text")
+@service_api_ns.route(
+    "/datasets/<uuid:dataset_id>/documents/<uuid:document_id>/update_by_text",
+    "/datasets/<uuid:dataset_id>/documents/<uuid:document_id>/update-by-text",
+)
 class DocumentUpdateByTextApi(DatasetApiResource):
-    """Resource for the canonical text document update route."""
+    """Resource for update documents."""
 
     @service_api_ns.expect(service_api_ns.models[DocumentTextUpdate.__name__])
     @service_api_ns.doc("update_document_by_text")
@@ -324,35 +229,62 @@ class DocumentUpdateByTextApi(DatasetApiResource):
     @cloud_edition_billing_rate_limit_check("knowledge", "dataset")
     def post(self, tenant_id: str, dataset_id: UUID, document_id: UUID):
         """Update document by text."""
-        return _update_document_by_text(tenant_id=tenant_id, dataset_id=dataset_id, document_id=document_id)
-
-
-@service_api_ns.route("/datasets/<uuid:dataset_id>/documents/<uuid:document_id>/update_by_text")
-class DeprecatedDocumentUpdateByTextApi(DatasetApiResource):
-    """Deprecated resource alias for text document updates."""
-
-    @service_api_ns.expect(service_api_ns.models[DocumentTextUpdate.__name__])
-    @service_api_ns.doc("update_document_by_text_deprecated")
-    @service_api_ns.doc(deprecated=True)
-    @service_api_ns.doc(
-        description=(
-            "Deprecated legacy alias for updating an existing document by providing text content. "
-            "Use /datasets/{dataset_id}/documents/{document_id}/update-by-text instead."
+        payload = DocumentTextUpdate.model_validate(service_api_ns.payload or {})
+        dataset = db.session.scalar(
+            select(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == str(dataset_id)).limit(1)
         )
-    )
-    @service_api_ns.doc(params={"dataset_id": "Dataset ID", "document_id": "Document ID"})
-    @service_api_ns.doc(
-        responses={
-            200: "Document updated successfully",
-            401: "Unauthorized - invalid API token",
-            404: "Document not found",
-        }
-    )
-    @cloud_edition_billing_resource_check("vector_space", "dataset")
-    @cloud_edition_billing_rate_limit_check("knowledge", "dataset")
-    def post(self, tenant_id: str, dataset_id: UUID, document_id: UUID):
-        """Update document by text through the deprecated underscore alias."""
-        return _update_document_by_text(tenant_id=tenant_id, dataset_id=dataset_id, document_id=document_id)
+        args = payload.model_dump(exclude_none=True)
+        if not dataset:
+            raise ValueError("Dataset does not exist.")
+
+        retrieval_model = payload.retrieval_model
+        if (
+            retrieval_model
+            and retrieval_model.reranking_model
+            and retrieval_model.reranking_model.reranking_provider_name
+            and retrieval_model.reranking_model.reranking_model_name
+        ):
+            DatasetService.check_reranking_model_setting(
+                tenant_id,
+                retrieval_model.reranking_model.reranking_provider_name,
+                retrieval_model.reranking_model.reranking_model_name,
+            )
+
+        # indexing_technique is already set in dataset since this is an update
+        args["indexing_technique"] = dataset.indexing_technique
+
+        if args.get("text"):
+            text = args.get("text")
+            name = args.get("name")
+            if not current_user:
+                raise ValueError("current_user is required")
+            upload_file = FileService(db.engine).upload_text(
+                text=str(text), text_name=str(name), user_id=current_user.id, tenant_id=tenant_id
+            )
+            data_source = {
+                "type": "upload_file",
+                "info_list": {"data_source_type": "upload_file", "file_info_list": {"file_ids": [upload_file.id]}},
+            }
+            args["data_source"] = data_source
+        # validate args
+        args["original_document_id"] = str(document_id)
+        knowledge_config = KnowledgeConfig.model_validate(args)
+        DocumentService.document_create_args_validate(knowledge_config)
+
+        try:
+            documents, batch = DocumentService.save_document_with_dataset_id(
+                dataset=dataset,
+                knowledge_config=knowledge_config,
+                account=current_user,
+                dataset_process_rule=dataset.latest_process_rule if "process_rule" not in args else None,
+                created_from="api",
+            )
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        document = documents[0]
+
+        documents_and_batch_fields = {"document": marshal(document, document_fields), "batch": batch}
+        return documents_and_batch_fields, 200
 
 
 @service_api_ns.route(

api/core/app/app_config/features/suggested_questions_after_answer/manager.py

@@ -1,7 +1,5 @@
 from typing import Any
 
-CUSTOM_FOLLOW_UP_PROMPT_MAX_LENGTH = 1000
-
 
 class SuggestedQuestionsAfterAnswerConfigManager:
     @classmethod
@@ -22,11 +20,7 @@ class SuggestedQuestionsAfterAnswerConfigManager:
     @classmethod
     def validate_and_set_defaults(cls, config: dict[str, Any]) -> tuple[dict[str, Any], list[str]]:
         """
-        Validate and set defaults for suggested questions feature.
-
-        Optional fields:
-        - prompt: custom instruction prompt.
-        - model: provider/model configuration for suggested question generation.
+        Validate and set defaults for suggested questions feature
 
         :param config: app model config args
         """
@@ -45,27 +39,4 @@ class SuggestedQuestionsAfterAnswerConfigManager:
         if not isinstance(config["suggested_questions_after_answer"]["enabled"], bool):
             raise ValueError("enabled in suggested_questions_after_answer must be of boolean type")
 
-        prompt = config["suggested_questions_after_answer"].get("prompt")
-        if prompt is not None and not isinstance(prompt, str):
-            raise ValueError("prompt in suggested_questions_after_answer must be of string type")
-        if isinstance(prompt, str) and len(prompt) > CUSTOM_FOLLOW_UP_PROMPT_MAX_LENGTH:
-            raise ValueError(
-                f"prompt in suggested_questions_after_answer must be less than or equal to "
-                f"{CUSTOM_FOLLOW_UP_PROMPT_MAX_LENGTH} characters"
-            )
-
-        if "model" in config["suggested_questions_after_answer"]:
-            model_config = config["suggested_questions_after_answer"]["model"]
-            if not isinstance(model_config, dict):
-                raise ValueError("model in suggested_questions_after_answer must be of object type")
-
-            if "provider" not in model_config or not isinstance(model_config["provider"], str):
-                raise ValueError("provider in suggested_questions_after_answer.model must be of string type")
-
-            if "name" not in model_config or not isinstance(model_config["name"], str):
-                raise ValueError("name in suggested_questions_after_answer.model must be of string type")
-
-            if "completion_params" in model_config and not isinstance(model_config["completion_params"], dict):
-                raise ValueError("completion_params in suggested_questions_after_answer.model must be of object type")
-
         return config, ["suggested_questions_after_answer"]

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

@@ -34,7 +34,11 @@ 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
 from core.app.entities.app_invoke_entities import AdvancedChatAppGenerateEntity, InvokeFrom
-from core.app.entities.task_entities import ChatbotAppBlockingResponse, ChatbotAppStreamResponse
+from core.app.entities.task_entities import (
+    ChatbotAppBlockingResponse,
+    ChatbotAppPausedBlockingResponse,
+    ChatbotAppStreamResponse,
+)
 from core.app.layers.pause_state_persist_layer import PauseStateLayerConfig, PauseStatePersistenceLayer
 from core.helper.trace_id_helper import extract_external_trace_id_from_args
 from core.ops.ops_trace_manager import TraceQueueManager
@@ -655,7 +659,9 @@ class AdvancedChatAppGenerator(MessageBasedAppGenerator):
         user: Account | EndUser,
         draft_var_saver_factory: DraftVariableSaverFactory,
         stream: bool = False,
-    ) -> ChatbotAppBlockingResponse | Generator[ChatbotAppStreamResponse, None, None]:
+    ) -> (
+        ChatbotAppBlockingResponse | ChatbotAppPausedBlockingResponse | Generator[ChatbotAppStreamResponse, None, None]
+    ):
         """
         Handle response.
         :param application_generate_entity: application generate entity

api/core/app/apps/advanced_chat/generate_response_converter.py

@@ -3,9 +3,9 @@ from typing import Any, cast
 
 from core.app.apps.base_app_generate_response_converter import AppGenerateResponseConverter
 from core.app.entities.task_entities import (
-    AppBlockingResponse,
     AppStreamResponse,
     ChatbotAppBlockingResponse,
+    ChatbotAppPausedBlockingResponse,
     ChatbotAppStreamResponse,
     ErrorStreamResponse,
     MessageEndStreamResponse,
@@ -15,17 +15,34 @@ from core.app.entities.task_entities import (
 )
 
 
-class AdvancedChatAppGenerateResponseConverter(AppGenerateResponseConverter):
-    _blocking_response_type = ChatbotAppBlockingResponse
-
+class AdvancedChatAppGenerateResponseConverter(
+    AppGenerateResponseConverter[ChatbotAppBlockingResponse | ChatbotAppPausedBlockingResponse]
+):
     @classmethod
-    def convert_blocking_full_response(cls, blocking_response: AppBlockingResponse) -> dict[str, Any]:
+    def convert_blocking_full_response(
+        cls, blocking_response: ChatbotAppBlockingResponse | ChatbotAppPausedBlockingResponse
+    ) -> dict[str, Any]:
         """
         Convert blocking full response.
         :param blocking_response: blocking response
         :return:
         """
-        blocking_response = cast(ChatbotAppBlockingResponse, blocking_response)
+        if isinstance(blocking_response, ChatbotAppPausedBlockingResponse):
+            paused_data = blocking_response.data.model_dump(mode="json")
+            return {
+                "event": "workflow_paused",
+                "task_id": blocking_response.task_id,
+                "id": blocking_response.data.id,
+                "message_id": blocking_response.data.message_id,
+                "conversation_id": blocking_response.data.conversation_id,
+                "mode": blocking_response.data.mode,
+                "answer": blocking_response.data.answer,
+                "metadata": blocking_response.data.metadata,
+                "created_at": blocking_response.data.created_at,
+                "workflow_run_id": blocking_response.data.workflow_run_id,
+                "data": paused_data,
+            }
+
         response = {
             "event": "message",
             "task_id": blocking_response.task_id,
@@ -41,7 +58,9 @@ class AdvancedChatAppGenerateResponseConverter(AppGenerateResponseConverter):
         return response
 
     @classmethod
-    def convert_blocking_simple_response(cls, blocking_response: AppBlockingResponse) -> dict[str, Any]:
+    def convert_blocking_simple_response(
+        cls, blocking_response: ChatbotAppBlockingResponse | ChatbotAppPausedBlockingResponse
+    ) -> dict[str, Any]:
         """
         Convert blocking simple response.
         :param blocking_response: blocking response
@@ -50,7 +69,8 @@ class AdvancedChatAppGenerateResponseConverter(AppGenerateResponseConverter):
         response = cls.convert_blocking_full_response(blocking_response)
 
         metadata = response.get("metadata", {})
-        response["metadata"] = cls._get_simple_metadata(metadata)
+        if isinstance(metadata, dict):
+            response["metadata"] = cls._get_simple_metadata(metadata)
 
         return response
 

api/core/app/apps/advanced_chat/generate_task_pipeline.py

@@ -54,13 +54,16 @@ from core.app.entities.queue_entities import (
 )
 from core.app.entities.task_entities import (
     ChatbotAppBlockingResponse,
+    ChatbotAppPausedBlockingResponse,
     ChatbotAppStreamResponse,
     ErrorStreamResponse,
+    HumanInputRequiredResponse,
     MessageAudioEndStreamResponse,
     MessageAudioStreamResponse,
     MessageEndStreamResponse,
     PingStreamResponse,
     StreamResponse,
+    WorkflowPauseStreamResponse,
     WorkflowTaskState,
 )
 from core.app.task_pipeline.based_generate_task_pipeline import BasedGenerateTaskPipeline
@@ -71,7 +74,7 @@ from core.repositories.human_input_repository import HumanInputFormRepositoryImp
 from core.workflow.file_reference import resolve_file_record_id
 from core.workflow.system_variables import build_system_variables
 from extensions.ext_database import db
-from graphon.entities.pause_reason import HumanInputRequired
+from graphon.entities.pause_reason import HumanInputRequired, PauseReasonType
 from graphon.enums import WorkflowExecutionStatus
 from graphon.model_runtime.entities.llm_entities import LLMUsage
 from graphon.model_runtime.utils.encoders import jsonable_encoder
@@ -210,7 +213,13 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         if message.status == MessageStatus.PAUSED and message.answer:
             self._task_state.answer = message.answer
 
-    def process(self) -> Union[ChatbotAppBlockingResponse, Generator[ChatbotAppStreamResponse, None, None]]:
+    def process(
+        self,
+    ) -> Union[
+        ChatbotAppBlockingResponse,
+        ChatbotAppPausedBlockingResponse,
+        Generator[ChatbotAppStreamResponse, None, None],
+    ]:
         """
         Process generate task pipeline.
         :return:
@@ -226,14 +235,39 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         else:
             return self._to_blocking_response(generator)
 
-    def _to_blocking_response(self, generator: Generator[StreamResponse, None, None]) -> ChatbotAppBlockingResponse:
+    def _to_blocking_response(
+        self, generator: Generator[StreamResponse, None, None]
+    ) -> Union[ChatbotAppBlockingResponse, ChatbotAppPausedBlockingResponse]:
         """
         Process blocking response.
         :return:
         """
+        human_input_responses: list[HumanInputRequiredResponse] = []
         for stream_response in generator:
             if isinstance(stream_response, ErrorStreamResponse):
                 raise stream_response.err
+            elif isinstance(stream_response, HumanInputRequiredResponse):
+                human_input_responses.append(stream_response)
+            elif isinstance(stream_response, WorkflowPauseStreamResponse):
+                return ChatbotAppPausedBlockingResponse(
+                    task_id=stream_response.task_id,
+                    data=ChatbotAppPausedBlockingResponse.Data(
+                        id=self._message_id,
+                        mode=self._conversation_mode,
+                        conversation_id=self._conversation_id,
+                        message_id=self._message_id,
+                        workflow_run_id=stream_response.data.workflow_run_id,
+                        answer=self._task_state.answer,
+                        metadata=self._message_end_to_stream_response().metadata,
+                        created_at=self._message_created_at,
+                        paused_nodes=stream_response.data.paused_nodes,
+                        reasons=stream_response.data.reasons,
+                        status=stream_response.data.status,
+                        elapsed_time=stream_response.data.elapsed_time,
+                        total_tokens=stream_response.data.total_tokens,
+                        total_steps=stream_response.data.total_steps,
+                    ),
+                )
             elif isinstance(stream_response, MessageEndStreamResponse):
                 extras = {}
                 if stream_response.metadata:
@@ -254,8 +288,42 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
             else:
                 continue
 
+        if human_input_responses:
+            return self._build_paused_blocking_response_from_human_input(human_input_responses)
+
         raise ValueError("queue listening stopped unexpectedly.")
 
+    def _build_paused_blocking_response_from_human_input(
+        self, human_input_responses: list[HumanInputRequiredResponse]
+    ) -> ChatbotAppPausedBlockingResponse:
+        runtime_state = self._resolve_graph_runtime_state()
+        paused_nodes = list(dict.fromkeys(response.data.node_id for response in human_input_responses))
+        reasons = []
+        for response in human_input_responses:
+            reason = response.data.model_dump(mode="json")
+            reason["type"] = PauseReasonType.HUMAN_INPUT_REQUIRED
+            reasons.append(reason)
+
+        return ChatbotAppPausedBlockingResponse(
+            task_id=self._application_generate_entity.task_id,
+            data=ChatbotAppPausedBlockingResponse.Data(
+                id=self._message_id,
+                mode=self._conversation_mode,
+                conversation_id=self._conversation_id,
+                message_id=self._message_id,
+                workflow_run_id=human_input_responses[-1].workflow_run_id,
+                answer=self._task_state.answer,
+                metadata=self._message_end_to_stream_response().metadata,
+                created_at=self._message_created_at,
+                paused_nodes=paused_nodes,
+                reasons=reasons,
+                status=WorkflowExecutionStatus.PAUSED,
+                elapsed_time=time.perf_counter() - self._base_task_pipeline.start_at,
+                total_tokens=runtime_state.total_tokens,
+                total_steps=runtime_state.node_run_steps,
+            ),
+        )
+
     def _to_stream_response(
         self, generator: Generator[StreamResponse, None, None]
     ) -> Generator[ChatbotAppStreamResponse, Any, None]:

api/core/app/apps/agent_chat/generate_response_converter.py

@@ -12,11 +12,9 @@ from core.app.entities.task_entities import (
 )
 
 
-class AgentChatAppGenerateResponseConverter(AppGenerateResponseConverter):
-    _blocking_response_type = ChatbotAppBlockingResponse
-
+class AgentChatAppGenerateResponseConverter(AppGenerateResponseConverter[ChatbotAppBlockingResponse]):
     @classmethod
-    def convert_blocking_full_response(cls, blocking_response: ChatbotAppBlockingResponse):  # type: ignore[override]
+    def convert_blocking_full_response(cls, blocking_response: ChatbotAppBlockingResponse):
         """
         Convert blocking full response.
         :param blocking_response: blocking response
@@ -37,7 +35,7 @@ class AgentChatAppGenerateResponseConverter(AppGenerateResponseConverter):
         return response
 
     @classmethod
-    def convert_blocking_simple_response(cls, blocking_response: ChatbotAppBlockingResponse):  # type: ignore[override]
+    def convert_blocking_simple_response(cls, blocking_response: ChatbotAppBlockingResponse):
         """
         Convert blocking simple response.
         :param blocking_response: blocking response

api/core/app/apps/base_app_generate_response_converter.py

@@ -1,7 +1,7 @@
 import logging
 from abc import ABC, abstractmethod
 from collections.abc import Generator, Mapping
-from typing import Any, Union
+from typing import Any, Union, cast
 
 from core.app.entities.app_invoke_entities import InvokeFrom
 from core.app.entities.task_entities import AppBlockingResponse, AppStreamResponse
@@ -11,8 +11,10 @@ from graphon.model_runtime.errors.invoke import InvokeError
 logger = logging.getLogger(__name__)
 
 
-class AppGenerateResponseConverter(ABC):
-    _blocking_response_type: type[AppBlockingResponse]
+class AppGenerateResponseConverter[TBlockingResponse: AppBlockingResponse](ABC):
+    @classmethod
+    def _cast_blocking_response(cls, response: AppBlockingResponse) -> TBlockingResponse:
+        return cast(TBlockingResponse, response)
 
     @classmethod
     def convert(
@@ -20,7 +22,7 @@ class AppGenerateResponseConverter(ABC):
     ) -> Mapping[str, Any] | Generator[str | Mapping[str, Any], Any, None]:
         if invoke_from in {InvokeFrom.DEBUGGER, InvokeFrom.SERVICE_API}:
             if isinstance(response, AppBlockingResponse):
-                return cls.convert_blocking_full_response(response)
+                return cls.convert_blocking_full_response(cls._cast_blocking_response(response))
             else:
 
                 def _generate_full_response() -> Generator[dict[str, Any] | str, Any, None]:
@@ -29,7 +31,7 @@ class AppGenerateResponseConverter(ABC):
                 return _generate_full_response()
         else:
             if isinstance(response, AppBlockingResponse):
-                return cls.convert_blocking_simple_response(response)
+                return cls.convert_blocking_simple_response(cls._cast_blocking_response(response))
             else:
 
                 def _generate_simple_response() -> Generator[dict[str, Any] | str, Any, None]:
@@ -39,12 +41,12 @@ class AppGenerateResponseConverter(ABC):
 
     @classmethod
     @abstractmethod
-    def convert_blocking_full_response(cls, blocking_response: AppBlockingResponse) -> dict[str, Any]:
+    def convert_blocking_full_response(cls, blocking_response: TBlockingResponse) -> dict[str, Any]:
         raise NotImplementedError
 
     @classmethod
     @abstractmethod
-    def convert_blocking_simple_response(cls, blocking_response: AppBlockingResponse) -> dict[str, Any]:
+    def convert_blocking_simple_response(cls, blocking_response: TBlockingResponse) -> dict[str, Any]:
         raise NotImplementedError
 
     @classmethod

api/core/app/apps/chat/generate_response_converter.py

@@ -12,11 +12,9 @@ from core.app.entities.task_entities import (
 )
 
 
-class ChatAppGenerateResponseConverter(AppGenerateResponseConverter):
-    _blocking_response_type = ChatbotAppBlockingResponse
-
+class ChatAppGenerateResponseConverter(AppGenerateResponseConverter[ChatbotAppBlockingResponse]):
     @classmethod
-    def convert_blocking_full_response(cls, blocking_response: ChatbotAppBlockingResponse):  # type: ignore[override]
+    def convert_blocking_full_response(cls, blocking_response: ChatbotAppBlockingResponse):
         """
         Convert blocking full response.
         :param blocking_response: blocking response
@@ -37,7 +35,7 @@ class ChatAppGenerateResponseConverter(AppGenerateResponseConverter):
         return response
 
     @classmethod
-    def convert_blocking_simple_response(cls, blocking_response: ChatbotAppBlockingResponse):  # type: ignore[override]
+    def convert_blocking_simple_response(cls, blocking_response: ChatbotAppBlockingResponse):
         """
         Convert blocking simple response.
         :param blocking_response: blocking response

api/core/app/apps/common/pause_reason_serializer.py

@@ -0,0 +1,17 @@
+from collections.abc import Mapping
+from typing import Any
+
+from graphon.entities.pause_reason import PauseReason
+
+
+def pause_reason_to_public_dict(reason: PauseReason | Mapping[str, Any]) -> dict[str, Any]:
+    if isinstance(reason, Mapping):
+        data = dict(reason)
+    else:
+        data = dict(reason.model_dump(mode="json"))
+
+    discriminator = data.pop("TYPE", None)
+    if discriminator is not None:
+        data["type"] = discriminator
+
+    return data

api/core/app/apps/common/workflow_response_converter.py

@@ -9,7 +9,9 @@ from typing import Any, NewType, TypedDict, Union
 from sqlalchemy import select
 from sqlalchemy.orm import Session
 
+from core.app.apps.common.pause_reason_serializer import pause_reason_to_public_dict
 from core.app.entities.app_invoke_entities import AdvancedChatAppGenerateEntity, InvokeFrom, WorkflowAppGenerateEntity
+from core.workflow.human_input_policy import enrich_human_input_pause_reasons
 from core.app.entities.queue_entities import (
     QueueAgentLogEvent,
     QueueHumanInputFormFilledEvent,
@@ -317,7 +319,7 @@ class WorkflowResponseConverter:
         encoded_outputs = self._encode_outputs(event.outputs) or {}
         if self._application_generate_entity.invoke_from == InvokeFrom.SERVICE_API:
             encoded_outputs = {}
-        pause_reasons = [reason.model_dump(mode="json") for reason in event.reasons]
+        pause_reasons = [pause_reason_to_public_dict(reason) for reason in event.reasons]
         human_input_form_ids = [reason.form_id for reason in event.reasons if isinstance(reason, HumanInputRequired)]
         expiration_times_by_form_id: dict[str, datetime] = {}
         display_in_ui_by_form_id: dict[str, bool] = {}
@@ -338,6 +340,17 @@ class WorkflowResponseConverter:
                     display_in_ui_by_form_id[str(form_id)] = bool(definition_payload.get("display_in_ui"))
                 form_token_by_form_id = load_form_tokens_by_form_id(human_input_form_ids, session=session)
 
+        # Reconnect paths must preserve the same pause-reason contract as live streams;
+        # otherwise clients see schema drift after resume.
+        pause_reasons = enrich_human_input_pause_reasons(
+            pause_reasons,
+            form_tokens_by_form_id=form_token_by_form_id,
+            expiration_times_by_form_id={
+                form_id: int(expiration_time.timestamp())
+                for form_id, expiration_time in expiration_times_by_form_id.items()
+            },
+        )
+
         responses: list[StreamResponse] = []
 
         for reason in event.reasons:

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

@@ -12,11 +12,9 @@ from core.app.entities.task_entities import (
 )
 
 
-class CompletionAppGenerateResponseConverter(AppGenerateResponseConverter):
-    _blocking_response_type = CompletionAppBlockingResponse
-
+class CompletionAppGenerateResponseConverter(AppGenerateResponseConverter[CompletionAppBlockingResponse]):
     @classmethod
-    def convert_blocking_full_response(cls, blocking_response: CompletionAppBlockingResponse):  # type: ignore[override]
+    def convert_blocking_full_response(cls, blocking_response: CompletionAppBlockingResponse):
         """
         Convert blocking full response.
         :param blocking_response: blocking response
@@ -36,7 +34,7 @@ class CompletionAppGenerateResponseConverter(AppGenerateResponseConverter):
         return response
 
     @classmethod
-    def convert_blocking_simple_response(cls, blocking_response: CompletionAppBlockingResponse):  # type: ignore[override]
+    def convert_blocking_simple_response(cls, blocking_response: CompletionAppBlockingResponse):
         """
         Convert blocking simple response.
         :param blocking_response: blocking response

api/core/app/apps/message_generator.py

@@ -1,6 +1,7 @@
-from collections.abc import Callable, Generator, Mapping
+from collections.abc import Callable, Generator, Iterable, Mapping
 
 from core.app.apps.streaming_utils import stream_topic_events
+from core.app.entities.task_entities import StreamEvent
 from extensions.ext_redis import get_pubsub_broadcast_channel
 from libs.broadcast_channel.channel import Topic
 from models.model import AppMode
@@ -26,6 +27,7 @@ class MessageGenerator:
         idle_timeout=300,
         ping_interval: float = 10.0,
         on_subscribe: Callable[[], None] | None = None,
+        terminal_events: Iterable[str | StreamEvent] | None = None,
     ) -> Generator[Mapping | str, None, None]:
         topic = cls.get_response_topic(app_mode, workflow_run_id)
         return stream_topic_events(
@@ -33,4 +35,5 @@ class MessageGenerator:
             idle_timeout=idle_timeout,
             ping_interval=ping_interval,
             on_subscribe=on_subscribe,
+            terminal_events=terminal_events,
         )

api/core/app/apps/pipeline/generate_response_converter.py

@@ -13,11 +13,9 @@ from core.app.entities.task_entities import (
 )
 
 
-class WorkflowAppGenerateResponseConverter(AppGenerateResponseConverter):
-    _blocking_response_type = WorkflowAppBlockingResponse
-
+class WorkflowAppGenerateResponseConverter(AppGenerateResponseConverter[WorkflowAppBlockingResponse]):
     @classmethod
-    def convert_blocking_full_response(cls, blocking_response: WorkflowAppBlockingResponse) -> dict[str, Any]:  # type: ignore[override]
+    def convert_blocking_full_response(cls, blocking_response: WorkflowAppBlockingResponse) -> dict[str, object]:
         """
         Convert blocking full response.
         :param blocking_response: blocking response
@@ -26,7 +24,7 @@ class WorkflowAppGenerateResponseConverter(AppGenerateResponseConverter):
         return dict(blocking_response.model_dump())
 
     @classmethod
-    def convert_blocking_simple_response(cls, blocking_response: WorkflowAppBlockingResponse) -> dict[str, Any]:  # type: ignore[override]
+    def convert_blocking_simple_response(cls, blocking_response: WorkflowAppBlockingResponse) -> dict[str, object]:
         """
         Convert blocking simple response.
         :param blocking_response: blocking response

api/core/app/apps/pipeline/pipeline_generator.py

@@ -27,7 +27,11 @@ from core.app.apps.workflow.generate_response_converter import WorkflowAppGenera
 from core.app.apps.workflow.generate_task_pipeline import WorkflowAppGenerateTaskPipeline
 from core.app.entities.app_invoke_entities import InvokeFrom, RagPipelineGenerateEntity
 from core.app.entities.rag_pipeline_invoke_entities import RagPipelineInvokeEntity
-from core.app.entities.task_entities import WorkflowAppBlockingResponse, WorkflowAppStreamResponse
+from core.app.entities.task_entities import (
+    WorkflowAppBlockingResponse,
+    WorkflowAppPausedBlockingResponse,
+    WorkflowAppStreamResponse,
+)
 from core.datasource.entities.datasource_entities import (
     DatasourceProviderType,
     OnlineDriveBrowseFilesRequest,
@@ -627,7 +631,11 @@ class PipelineGenerator(BaseAppGenerator):
         user: Account | EndUser,
         draft_var_saver_factory: DraftVariableSaverFactory,
         stream: bool = False,
-    ) -> WorkflowAppBlockingResponse | Generator[WorkflowAppStreamResponse, None, None]:
+    ) -> (
+        WorkflowAppBlockingResponse
+        | WorkflowAppPausedBlockingResponse
+        | Generator[WorkflowAppStreamResponse, None, None]
+    ):
         """
         Handle response.
         :param application_generate_entity: application generate entity

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

@@ -25,7 +25,11 @@ from core.app.apps.workflow.app_runner import WorkflowAppRunner
 from core.app.apps.workflow.generate_response_converter import WorkflowAppGenerateResponseConverter
 from core.app.apps.workflow.generate_task_pipeline import WorkflowAppGenerateTaskPipeline
 from core.app.entities.app_invoke_entities import InvokeFrom, WorkflowAppGenerateEntity
-from core.app.entities.task_entities import WorkflowAppBlockingResponse, WorkflowAppStreamResponse
+from core.app.entities.task_entities import (
+    WorkflowAppBlockingResponse,
+    WorkflowAppPausedBlockingResponse,
+    WorkflowAppStreamResponse,
+)
 from core.app.layers.pause_state_persist_layer import PauseStateLayerConfig, PauseStatePersistenceLayer
 from core.db.session_factory import session_factory
 from core.helper.trace_id_helper import extract_external_trace_id_from_args
@@ -612,7 +616,11 @@ class WorkflowAppGenerator(BaseAppGenerator):
         user: Account | EndUser,
         draft_var_saver_factory: DraftVariableSaverFactory,
         stream: bool = False,
-    ) -> WorkflowAppBlockingResponse | Generator[WorkflowAppStreamResponse, None, None]:
+    ) -> (
+        WorkflowAppBlockingResponse
+        | WorkflowAppPausedBlockingResponse
+        | Generator[WorkflowAppStreamResponse, None, None]
+    ):
         """
         Handle response.
         :param application_generate_entity: application generate entity

api/core/app/apps/workflow/generate_response_converter.py

@@ -9,24 +9,29 @@ from core.app.entities.task_entities import (
     NodeStartStreamResponse,
     PingStreamResponse,
     WorkflowAppBlockingResponse,
+    WorkflowAppPausedBlockingResponse,
     WorkflowAppStreamResponse,
 )
 
 
-class WorkflowAppGenerateResponseConverter(AppGenerateResponseConverter):
-    _blocking_response_type = WorkflowAppBlockingResponse
-
+class WorkflowAppGenerateResponseConverter(
+    AppGenerateResponseConverter[WorkflowAppBlockingResponse | WorkflowAppPausedBlockingResponse]
+):
     @classmethod
-    def convert_blocking_full_response(cls, blocking_response: WorkflowAppBlockingResponse):  # type: ignore[override]
+    def convert_blocking_full_response(
+        cls, blocking_response: WorkflowAppBlockingResponse | WorkflowAppPausedBlockingResponse
+    ) -> dict[str, Any]:
         """
         Convert blocking full response.
         :param blocking_response: blocking response
         :return:
         """
-        return blocking_response.model_dump()
+        return dict(blocking_response.model_dump())
 
     @classmethod
-    def convert_blocking_simple_response(cls, blocking_response: WorkflowAppBlockingResponse):  # type: ignore[override]
+    def convert_blocking_simple_response(
+        cls, blocking_response: WorkflowAppBlockingResponse | WorkflowAppPausedBlockingResponse
+    ) -> dict[str, Any]:
         """
         Convert blocking simple response.
         :param blocking_response: blocking response
@@ -58,7 +63,7 @@ class WorkflowAppGenerateResponseConverter(AppGenerateResponseConverter):
 
             if isinstance(sub_stream_response, ErrorStreamResponse):
                 data = cls._error_to_stream_response(sub_stream_response.err)
-                response_chunk.update(data)
+                response_chunk.update(cast(dict[str, object], data))
             else:
                 response_chunk.update(sub_stream_response.model_dump(mode="json"))
             yield response_chunk
@@ -87,9 +92,9 @@ class WorkflowAppGenerateResponseConverter(AppGenerateResponseConverter):
 
             if isinstance(sub_stream_response, ErrorStreamResponse):
                 data = cls._error_to_stream_response(sub_stream_response.err)
-                response_chunk.update(data)
+                response_chunk.update(cast(dict[str, object], data))
             elif isinstance(sub_stream_response, NodeStartStreamResponse | NodeFinishStreamResponse):
-                response_chunk.update(sub_stream_response.to_ignore_detail_dict())
+                response_chunk.update(cast(dict[str, object], sub_stream_response.to_ignore_detail_dict()))
             else:
                 response_chunk.update(sub_stream_response.model_dump(mode="json"))
             yield response_chunk

api/core/app/apps/workflow/generate_task_pipeline.py

@@ -42,12 +42,14 @@ from core.app.entities.queue_entities import (
 )
 from core.app.entities.task_entities import (
     ErrorStreamResponse,
+    HumanInputRequiredResponse,
     MessageAudioEndStreamResponse,
     MessageAudioStreamResponse,
     PingStreamResponse,
     StreamResponse,
     TextChunkStreamResponse,
     WorkflowAppBlockingResponse,
+    WorkflowAppPausedBlockingResponse,
     WorkflowAppStreamResponse,
     WorkflowFinishStreamResponse,
     WorkflowPauseStreamResponse,
@@ -118,7 +120,11 @@ class WorkflowAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         )
         self._graph_runtime_state: GraphRuntimeState | None = self._base_task_pipeline.queue_manager.graph_runtime_state
 
-    def process(self) -> Union[WorkflowAppBlockingResponse, Generator[WorkflowAppStreamResponse, None, None]]:
+    def process(
+        self,
+    ) -> Union[
+        WorkflowAppBlockingResponse, WorkflowAppPausedBlockingResponse, Generator[WorkflowAppStreamResponse, None, None]
+    ]:
         """
         Process generate task pipeline.
         :return:
@@ -129,19 +135,24 @@ class WorkflowAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         else:
             return self._to_blocking_response(generator)
 
-    def _to_blocking_response(self, generator: Generator[StreamResponse, None, None]) -> WorkflowAppBlockingResponse:
+    def _to_blocking_response(
+        self, generator: Generator[StreamResponse, None, None]
+    ) -> Union[WorkflowAppBlockingResponse, WorkflowAppPausedBlockingResponse]:
         """
         To blocking response.
         :return:
         """
+        human_input_responses: list[HumanInputRequiredResponse] = []
         for stream_response in generator:
             if isinstance(stream_response, ErrorStreamResponse):
                 raise stream_response.err
+            elif isinstance(stream_response, HumanInputRequiredResponse):
+                human_input_responses.append(stream_response)
             elif isinstance(stream_response, WorkflowPauseStreamResponse):
-                response = WorkflowAppBlockingResponse(
+                return WorkflowAppPausedBlockingResponse(
                     task_id=self._application_generate_entity.task_id,
                     workflow_run_id=stream_response.data.workflow_run_id,
-                    data=WorkflowAppBlockingResponse.Data(
+                    data=WorkflowAppPausedBlockingResponse.Data(
                         id=stream_response.data.workflow_run_id,
                         workflow_id=self._workflow.id,
                         status=stream_response.data.status,
@@ -152,12 +163,13 @@ class WorkflowAppGenerateTaskPipeline(GraphRuntimeStateSupport):
                         total_steps=stream_response.data.total_steps,
                         created_at=stream_response.data.created_at,
                         finished_at=None,
+                        paused_nodes=stream_response.data.paused_nodes,
+                        reasons=stream_response.data.reasons,
                     ),
                 )
 
-                return response
             elif isinstance(stream_response, WorkflowFinishStreamResponse):
-                response = WorkflowAppBlockingResponse(
+                return WorkflowAppBlockingResponse(
                     task_id=self._application_generate_entity.task_id,
                     workflow_run_id=stream_response.data.id,
                     data=WorkflowAppBlockingResponse.Data(
@@ -174,12 +186,47 @@ class WorkflowAppGenerateTaskPipeline(GraphRuntimeStateSupport):
                     ),
                 )
 
-                return response
             else:
                 continue
 
+        if human_input_responses:
+            return self._build_paused_blocking_response_from_human_input(human_input_responses)
+
         raise ValueError("queue listening stopped unexpectedly.")
 
+    def _build_paused_blocking_response_from_human_input(
+        self, human_input_responses: list[HumanInputRequiredResponse]
+    ) -> WorkflowAppPausedBlockingResponse:
+        runtime_state = self._resolve_graph_runtime_state()
+        paused_nodes = list(dict.fromkeys(response.data.node_id for response in human_input_responses))
+        # Graph runtime `start_at` is a perf-counter value, not an epoch timestamp, so
+        # fallback API payloads need a wall-clock source for `created_at`.
+        created_at = int(time.time())
+        reasons = []
+        for response in human_input_responses:
+            reason = response.data.model_dump(mode="json")
+            reason["type"] = "human_input_required"
+            reasons.append(reason)
+
+        return WorkflowAppPausedBlockingResponse(
+            task_id=self._application_generate_entity.task_id,
+            workflow_run_id=human_input_responses[-1].workflow_run_id,
+            data=WorkflowAppPausedBlockingResponse.Data(
+                id=human_input_responses[-1].workflow_run_id,
+                workflow_id=self._workflow.id,
+                status=WorkflowExecutionStatus.PAUSED,
+                outputs={},
+                error=None,
+                elapsed_time=time.perf_counter() - self._base_task_pipeline.start_at,
+                total_tokens=runtime_state.total_tokens,
+                total_steps=runtime_state.node_run_steps,
+                created_at=created_at,
+                finished_at=None,
+                paused_nodes=paused_nodes,
+                reasons=reasons,
+            ),
+        )
+
     def _to_stream_response(
         self, generator: Generator[StreamResponse, None, None]
     ) -> Generator[WorkflowAppStreamResponse, None, None]:

api/core/app/entities/task_entities.py

@@ -774,6 +774,34 @@ class ChatbotAppBlockingResponse(AppBlockingResponse):
     data: Data
 
 
+class ChatbotAppPausedBlockingResponse(AppBlockingResponse):
+    """
+    ChatbotAppPausedBlockingResponse entity
+    """
+
+    class Data(BaseModel):
+        """
+        Data entity
+        """
+
+        id: str
+        mode: str
+        conversation_id: str
+        message_id: str
+        workflow_run_id: str
+        answer: str
+        metadata: Mapping[str, object] = Field(default_factory=dict)
+        created_at: int
+        paused_nodes: Sequence[str] = Field(default_factory=list)
+        reasons: Sequence[Mapping[str, Any]] = Field(default_factory=list)
+        status: WorkflowExecutionStatus
+        elapsed_time: float
+        total_tokens: int
+        total_steps: int
+
+    data: Data
+
+
 class CompletionAppBlockingResponse(AppBlockingResponse):
     """
     CompletionAppBlockingResponse entity
@@ -819,6 +847,33 @@ class WorkflowAppBlockingResponse(AppBlockingResponse):
     data: Data
 
 
+class WorkflowAppPausedBlockingResponse(AppBlockingResponse):
+    """
+    WorkflowAppPausedBlockingResponse entity
+    """
+
+    class Data(BaseModel):
+        """
+        Data entity
+        """
+
+        id: str
+        workflow_id: str
+        status: WorkflowExecutionStatus
+        outputs: Mapping[str, Any] | None = None
+        error: str | None = None
+        elapsed_time: float
+        total_tokens: int
+        total_steps: int
+        created_at: int
+        finished_at: int | None
+        paused_nodes: Sequence[str] = Field(default_factory=list)
+        reasons: Sequence[Mapping[str, Any]] = Field(default_factory=list)
+
+    workflow_run_id: str
+    data: Data
+
+
 class AgentLogStreamResponse(StreamResponse):
     """
     AgentLogStreamResponse entity

api/core/app/file_access/scope.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from collections.abc import Generator  # Changed from Iterator
+from collections.abc import Iterator
 from contextlib import contextmanager
 from contextvars import ContextVar
 from dataclasses import dataclass
@@ -32,7 +32,7 @@ def get_current_file_access_scope() -> FileAccessScope | None:
 
 
 @contextmanager
-def bind_file_access_scope(scope: FileAccessScope) -> Generator[None, None, None]:  # Changed from Iterator[None]
+def bind_file_access_scope(scope: FileAccessScope) -> Iterator[None]:
     token = _current_file_access_scope.set(scope)
     try:
         yield

api/core/llm_generator/llm_generator.py

@@ -2,7 +2,7 @@ import json
 import logging
 import re
 from collections.abc import Sequence
-from typing import Any, NotRequired, Protocol, TypedDict, cast
+from typing import Any, Protocol, TypedDict, cast
 
 import json_repair
 from sqlalchemy import select
@@ -13,13 +13,13 @@ from core.llm_generator.output_parser.rule_config_generator import RuleConfigGen
 from core.llm_generator.output_parser.suggested_questions_after_answer import SuggestedQuestionsAfterAnswerOutputParser
 from core.llm_generator.prompts import (
     CONVERSATION_TITLE_PROMPT,
-    DEFAULT_SUGGESTED_QUESTIONS_MAX_TOKENS,
-    DEFAULT_SUGGESTED_QUESTIONS_TEMPERATURE,
     GENERATOR_QA_PROMPT,
     JAVASCRIPT_CODE_GENERATOR_PROMPT_TEMPLATE,
     LLM_MODIFY_CODE_SYSTEM,
     LLM_MODIFY_PROMPT_SYSTEM,
     PYTHON_CODE_GENERATOR_PROMPT_TEMPLATE,
+    SUGGESTED_QUESTIONS_MAX_TOKENS,
+    SUGGESTED_QUESTIONS_TEMPERATURE,
     SYSTEM_STRUCTURED_OUTPUT_GENERATE,
     WORKFLOW_RULE_CONFIG_PROMPT_GENERATE_TEMPLATE,
 )
@@ -41,36 +41,6 @@ from models.workflow import Workflow
 logger = logging.getLogger(__name__)
 
 
-class SuggestedQuestionsModelConfig(TypedDict):
-    provider: str
-    name: str
-    completion_params: NotRequired[dict[str, object]]
-
-
-def _normalize_completion_params(completion_params: dict[str, object]) -> tuple[dict[str, object], list[str]]:
-    """
-    Normalize raw completion params into invocation parameters and stop sequences.
-
-    This mirrors the app-model access path by separating ``stop`` from provider
-    parameters before invocation, then drops non-positive token limits because
-    some plugin-backed models reject ``0`` after mapping ``max_tokens`` to their
-    provider-specific output-token field.
-    """
-    normalized_parameters = dict(completion_params)
-    stop_value = normalized_parameters.pop("stop", [])
-    if isinstance(stop_value, list) and all(isinstance(item, str) for item in stop_value):
-        stop = stop_value
-    else:
-        stop = []
-
-    for token_limit_key in ("max_tokens", "max_output_tokens"):
-        token_limit = normalized_parameters.get(token_limit_key)
-        if isinstance(token_limit, int | float) and token_limit <= 0:
-            normalized_parameters.pop(token_limit_key, None)
-
-    return normalized_parameters, stop
-
-
 class WorkflowServiceInterface(Protocol):
     def get_draft_workflow(self, app_model: App, workflow_id: str | None = None) -> Workflow | None:
         pass
@@ -153,15 +123,8 @@ class LLMGenerator:
         return name
 
     @classmethod
-    def generate_suggested_questions_after_answer(
-        cls,
-        tenant_id: str,
-        histories: str,
-        *,
-        instruction_prompt: str | None = None,
-        model_config: object | None = None,
-    ) -> Sequence[str]:
-        output_parser = SuggestedQuestionsAfterAnswerOutputParser(instruction_prompt=instruction_prompt)
+    def generate_suggested_questions_after_answer(cls, tenant_id: str, histories: str) -> Sequence[str]:
+        output_parser = SuggestedQuestionsAfterAnswerOutputParser()
         format_instructions = output_parser.get_format_instructions()
 
         prompt_template = PromptTemplateParser(template="{{histories}}\n{{format_instructions}}\nquestions:\n")
@@ -170,36 +133,10 @@ class LLMGenerator:
 
         try:
             model_manager = ModelManager.for_tenant(tenant_id=tenant_id)
-            configured_model = cast(dict[str, object], model_config) if isinstance(model_config, dict) else {}
-            provider = configured_model.get("provider")
-            model_name = configured_model.get("name")
-            use_configured_model = False
-
-            if isinstance(provider, str) and provider and isinstance(model_name, str) and model_name:
-                try:
-                    model_instance = model_manager.get_model_instance(
-                        tenant_id=tenant_id,
-                        model_type=ModelType.LLM,
-                        provider=provider,
-                        model=model_name,
-                    )
-                    use_configured_model = True
-                except Exception:
-                    logger.warning(
-                        "Failed to use configured suggested-questions model %s/%s, fallback to default model",
-                        provider,
-                        model_name,
-                        exc_info=True,
-                    )
-                    model_instance = model_manager.get_default_model_instance(
-                        tenant_id=tenant_id,
-                        model_type=ModelType.LLM,
-                    )
-            else:
-                model_instance = model_manager.get_default_model_instance(
-                    tenant_id=tenant_id,
-                    model_type=ModelType.LLM,
-                )
+            model_instance = model_manager.get_default_model_instance(
+                tenant_id=tenant_id,
+                model_type=ModelType.LLM,
+            )
         except InvokeAuthorizationError:
             return []
 
@@ -208,29 +145,19 @@ class LLMGenerator:
         questions: Sequence[str] = []
 
         try:
-            configured_completion_params = configured_model.get("completion_params")
-            if use_configured_model and isinstance(configured_completion_params, dict):
-                model_parameters, stop = _normalize_completion_params(configured_completion_params)
-            elif use_configured_model:
-                model_parameters = {}
-                stop = []
-            else:
-                # Default-model generation keeps the built-in suggested-questions tuning.
-                model_parameters = {
-                    "max_tokens": DEFAULT_SUGGESTED_QUESTIONS_MAX_TOKENS,
-                    "temperature": DEFAULT_SUGGESTED_QUESTIONS_TEMPERATURE,
-                }
-                stop = []
-
             response: LLMResult = model_instance.invoke_llm(
                 prompt_messages=list(prompt_messages),
-                model_parameters=model_parameters,
-                stop=stop,
+                model_parameters={
+                    "max_tokens": SUGGESTED_QUESTIONS_MAX_TOKENS,
+                    "temperature": SUGGESTED_QUESTIONS_TEMPERATURE,
+                },
                 stream=False,
             )
 
             text_content = response.message.get_text_content()
             questions = output_parser.parse(text_content) if text_content else []
+        except InvokeError:
+            questions = []
         except Exception:
             logger.exception("Failed to generate suggested questions after answer")
             questions = []

api/core/llm_generator/output_parser/suggested_questions_after_answer.py

@@ -3,21 +3,17 @@ import logging
 import re
 from collections.abc import Sequence
 
-from core.llm_generator.prompts import DEFAULT_SUGGESTED_QUESTIONS_AFTER_ANSWER_INSTRUCTION_PROMPT
+from core.llm_generator.prompts import SUGGESTED_QUESTIONS_AFTER_ANSWER_INSTRUCTION_PROMPT
 
 logger = logging.getLogger(__name__)
 
 
 class SuggestedQuestionsAfterAnswerOutputParser:
-    def __init__(self, instruction_prompt: str | None = None) -> None:
-        self._instruction_prompt = instruction_prompt or DEFAULT_SUGGESTED_QUESTIONS_AFTER_ANSWER_INSTRUCTION_PROMPT
-
     def get_format_instructions(self) -> str:
-        return self._instruction_prompt
+        return SUGGESTED_QUESTIONS_AFTER_ANSWER_INSTRUCTION_PROMPT
 
     def parse(self, text: str) -> Sequence[str]:
-        stripped_text = text.strip()
-        action_match = re.search(r"\[.*?\]", stripped_text, re.DOTALL)
+        action_match = re.search(r"\[.*?\]", text.strip(), re.DOTALL)
         questions: list[str] = []
         if action_match is not None:
             try:
@@ -27,6 +23,4 @@ class SuggestedQuestionsAfterAnswerOutputParser:
             else:
                 if isinstance(json_obj, list):
                     questions = [question for question in json_obj if isinstance(question, str)]
-        elif stripped_text:
-            logger.warning("Failed to find suggested questions payload array in text: %r", stripped_text[:200])
         return questions

api/core/llm_generator/prompts.py

@@ -1,4 +1,5 @@
 # Written by YORKI MINAKO🤡, Edited by Xiaoyi, Edited by yasu-oh
+import os
 
 CONVERSATION_TITLE_PROMPT = """You are asked to generate a concise chat title by decomposing the user’s input into two parts: “Intention” and “Subject”.
 
@@ -95,8 +96,8 @@ JAVASCRIPT_CODE_GENERATOR_PROMPT_TEMPLATE = (
 )
 
 
-# Default prompt and model parameters for suggested questions.
-DEFAULT_SUGGESTED_QUESTIONS_AFTER_ANSWER_INSTRUCTION_PROMPT = (
+# Default prompt for suggested questions (can be overridden by environment variable)
+_DEFAULT_SUGGESTED_QUESTIONS_AFTER_ANSWER_PROMPT = (
     "Please help me predict the three most likely questions that human would ask, "
     "and keep each question under 20 characters.\n"
     "MAKE SURE your output is the SAME language as the Assistant's latest response. "
@@ -104,8 +105,14 @@ DEFAULT_SUGGESTED_QUESTIONS_AFTER_ANSWER_INSTRUCTION_PROMPT = (
     '["question1","question2","question3"]\n'
 )
 
-DEFAULT_SUGGESTED_QUESTIONS_MAX_TOKENS = 256
-DEFAULT_SUGGESTED_QUESTIONS_TEMPERATURE = 0.0
+# Environment variable override for suggested questions prompt
+SUGGESTED_QUESTIONS_AFTER_ANSWER_INSTRUCTION_PROMPT = os.getenv(
+    "SUGGESTED_QUESTIONS_PROMPT", _DEFAULT_SUGGESTED_QUESTIONS_AFTER_ANSWER_PROMPT
+)
+
+# Configurable LLM parameters for suggested questions (can be overridden by environment variables)
+SUGGESTED_QUESTIONS_MAX_TOKENS = int(os.getenv("SUGGESTED_QUESTIONS_MAX_TOKENS", "256"))
+SUGGESTED_QUESTIONS_TEMPERATURE = float(os.getenv("SUGGESTED_QUESTIONS_TEMPERATURE", "0"))
 
 GENERATOR_QA_PROMPT = (
     "<Task> The user will send a long text. Generate a Question and Answer pairs only using the knowledge"

api/core/provider_manager.py

@@ -70,32 +70,12 @@ class ProviderManager:
     Request-bound managers may carry caller identity in that runtime, and the
     resulting ``ProviderConfiguration`` objects must reuse it for downstream
     model-type and schema lookups.
-
-    Configuration assembly is cached per manager instance so call chains that
-    share one request-scoped manager can reuse the same provider graph instead
-    of rebuilding it for every lookup. Call ``clear_configurations_cache()``
-    when a long-lived manager needs to observe writes performed within the same
-    instance scope.
     """
 
-    decoding_rsa_key: Any | None
-    decoding_cipher_rsa: Any | None
-    _model_runtime: ModelRuntime
-    _configurations_cache: dict[str, ProviderConfigurations]
-
     def __init__(self, model_runtime: ModelRuntime):
         self.decoding_rsa_key = None
         self.decoding_cipher_rsa = None
         self._model_runtime = model_runtime
-        self._configurations_cache = {}
-
-    def clear_configurations_cache(self, tenant_id: str | None = None) -> None:
-        """Drop assembled provider configurations cached on this manager instance."""
-        if tenant_id is None:
-            self._configurations_cache.clear()
-            return
-
-        self._configurations_cache.pop(tenant_id, None)
 
     def get_configurations(self, tenant_id: str) -> ProviderConfigurations:
         """
@@ -134,10 +114,6 @@ class ProviderManager:
         :param tenant_id:
         :return:
         """
-        cached_configurations = self._configurations_cache.get(tenant_id)
-        if cached_configurations is not None:
-            return cached_configurations
-
         # Get all provider records of the workspace
         provider_name_to_provider_records_dict = self._get_all_providers(tenant_id)
 
@@ -297,8 +273,6 @@ class ProviderManager:
 
             provider_configurations[str(provider_id_entity)] = provider_configuration
 
-        self._configurations_cache[tenant_id] = provider_configurations
-
         # Return the encapsulated object
         return provider_configurations
 

api/core/rag/datasource/keyword/jieba/jieba.py

@@ -139,10 +139,8 @@ class Jieba(BaseKeyword):
             "__data__": {"index_id": self.dataset.id, "summary": None, "table": keyword_table},
         }
         dataset_keyword_table = self.dataset.dataset_keyword_table
-        keyword_data_source_type = dataset_keyword_table.data_source_type if dataset_keyword_table else "file"
+        keyword_data_source_type = dataset_keyword_table.data_source_type
         if keyword_data_source_type == "database":
-            if dataset_keyword_table is None:
-                return
             dataset_keyword_table.keyword_table = dumps_with_sets(keyword_table_dict)
             db.session.commit()
         else:

api/core/rag/datasource/keyword/jieba/jieba_keyword_table_handler.py

@@ -1,5 +1,4 @@
 import re
-from collections.abc import Callable
 from operator import itemgetter
 from typing import cast
 
@@ -81,14 +80,12 @@ class JiebaKeywordTableHandler:
 
             def extract_tags(self, sentence: str, top_k: int | None = 20, **kwargs):
                 # Basic frequency-based keyword extraction as a fallback when TF-IDF is unavailable.
-                top_k = cast(int | None, kwargs.pop("topK", top_k))
-                if top_k is None:
-                    top_k = 20
+                top_k = kwargs.pop("topK", top_k)
                 cut = getattr(jieba, "cut", None)
                 if self._lcut:
                     tokens = self._lcut(sentence)
                 elif callable(cut):
-                    tokens = list(cast(Callable[[str], list[str]], cut)(sentence))
+                    tokens = list(cut(sentence))
                 else:
                     tokens = re.findall(r"\w+", sentence)
 
@@ -111,7 +108,7 @@ class JiebaKeywordTableHandler:
             sentence=text,
             topK=max_keywords_per_chunk,
         )
-        # jieba.analyse.extract_tags returns an untyped list when withFlag is False by default.
+        # jieba.analyse.extract_tags returns list[Any] when withFlag is False by default.
         keywords = cast(list[str], keywords)
 
         return set(self._expand_tokens_with_subtokens(set(keywords)))

api/core/rag/datasource/retrieval_service.py

@@ -158,7 +158,7 @@ class RetrievalService:
                     )
 
             if futures:
-                for _ in concurrent.futures.as_completed(futures, timeout=3600):
+                for future in concurrent.futures.as_completed(futures, timeout=3600):
                     if exceptions:
                         for f in futures:
                             f.cancel()

api/core/rag/extractor/extract_processor.py

@@ -94,7 +94,6 @@ class ExtractProcessor:
         cls, extract_setting: ExtractSetting, is_automatic: bool = False, file_path: str | None = None
     ) -> list[Document]:
         if extract_setting.datasource_type == DatasourceType.FILE:
-            upload_file = extract_setting.upload_file
             with tempfile.TemporaryDirectory() as temp_dir:
                 upload_file = extract_setting.upload_file
                 if not file_path:
@@ -105,7 +104,6 @@ class ExtractProcessor:
                     storage.download(upload_file.key, file_path)
                 input_file = Path(file_path)
                 file_extension = input_file.suffix.lower()
-                assert upload_file is not None, "upload_file is required"
                 etl_type = dify_config.ETL_TYPE
                 extractor: BaseExtractor | None = None
                 if etl_type == "Unstructured":

api/core/rag/retrieval/router/multi_dataset_function_call_router.py

@@ -28,7 +28,7 @@ class FunctionCallMultiDatasetRouter:
                 SystemPromptMessage(content="You are a helpful AI assistant."),
                 UserPromptMessage(content=query),
             ]
-            result: LLMResult = model_instance.invoke_llm(  # pyright: ignore[reportCallIssue, reportArgumentType]
+            result: LLMResult = model_instance.invoke_llm(
                 prompt_messages=prompt_messages,
                 tools=dataset_tools,
                 stream=False,

api/core/rag/splitter/fixed_text_splitter.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import codecs
 import re
-from collections.abc import Set as AbstractSet
+from collections.abc import Collection
 from typing import Any, Literal
 
 from core.model_manager import ModelInstance
@@ -21,8 +21,8 @@ class EnhanceRecursiveCharacterTextSplitter(RecursiveCharacterTextSplitter):
     def from_encoder[T: EnhanceRecursiveCharacterTextSplitter](
         cls: type[T],
         embedding_model_instance: ModelInstance | None,
-        allowed_special: Literal["all"] | AbstractSet[str] = frozenset(),
-        disallowed_special: Literal["all"] | AbstractSet[str] = "all",
+        allowed_special: Literal["all"] | set[str] = set(),
+        disallowed_special: Literal["all"] | Collection[str] = "all",
         **kwargs: Any,
     ) -> T:
         def _token_encoder(texts: list[str]) -> list[int]:
@@ -40,7 +40,6 @@ class EnhanceRecursiveCharacterTextSplitter(RecursiveCharacterTextSplitter):
 
             return [len(text) for text in texts]
 
-        _ = _token_encoder  # kept for future token-length wiring
         return cls(length_function=_character_encoder, **kwargs)
 
 

api/core/rag/splitter/text_splitter.py

@@ -4,8 +4,7 @@ import copy
 import logging
 import re
 from abc import ABC, abstractmethod
-from collections.abc import Callable, Iterable, Sequence
-from collections.abc import Set as AbstractSet
+from collections.abc import Callable, Collection, Iterable, Sequence, Set
 from dataclasses import dataclass
 from typing import Any, Literal
 
@@ -188,8 +187,8 @@ class TokenTextSplitter(TextSplitter):
         self,
         encoding_name: str = "gpt2",
         model_name: str | None = None,
-        allowed_special: Literal["all"] | AbstractSet[str] = frozenset(),
-        disallowed_special: Literal["all"] | AbstractSet[str] = "all",
+        allowed_special: Literal["all"] | Set[str] = set(),
+        disallowed_special: Literal["all"] | Collection[str] = "all",
         **kwargs: Any,
     ):
         """Create a new TextSplitter."""
@@ -208,8 +207,8 @@ class TokenTextSplitter(TextSplitter):
         else:
             enc = tiktoken.get_encoding(encoding_name)
         self._tokenizer = enc
-        self._allowed_special: Literal["all"] | AbstractSet[str] = allowed_special
-        self._disallowed_special: Literal["all"] | AbstractSet[str] = disallowed_special
+        self._allowed_special = allowed_special
+        self._disallowed_special = disallowed_special
 
     def split_text(self, text: str) -> list[str]:
         def _encode(_text: str) -> list[int]:

api/core/tools/utils/web_reader_tool.py

@@ -105,7 +105,7 @@ class Article:
 
 
 def extract_using_readabilipy(html: str):
-    json_article: dict[str, Any] = simple_json_from_html_string(html, use_readability=False)
+    json_article: dict[str, Any] = simple_json_from_html_string(html, use_readability=True)
     article = Article(
         title=json_article.get("title") or "",
         author=json_article.get("byline") or "",

api/core/workflow/human_input_forms.py

@@ -12,15 +12,10 @@ from collections.abc import Sequence
 from sqlalchemy import select
 from sqlalchemy.orm import Session
 
+from core.workflow.human_input_policy import get_preferred_form_token
 from extensions.ext_database import db
 from models.human_input import HumanInputFormRecipient, RecipientType
 
-_FORM_TOKEN_PRIORITY = {
-    RecipientType.BACKSTAGE: 0,
-    RecipientType.CONSOLE: 1,
-    RecipientType.STANDALONE_WEB_APP: 2,
-}
-
 
 def load_form_tokens_by_form_id(
     form_ids: Sequence[str],
@@ -40,16 +35,16 @@ def load_form_tokens_by_form_id(
 
 
 def _load_form_tokens_by_form_id(session: Session, form_ids: Sequence[str]) -> dict[str, str]:
-    tokens_by_form_id: dict[str, tuple[int, str]] = {}
+    recipients_by_form_id: dict[str, list[tuple[RecipientType, str]]] = {}
     stmt = select(HumanInputFormRecipient).where(HumanInputFormRecipient.form_id.in_(form_ids))
     for recipient in session.scalars(stmt):
-        priority = _FORM_TOKEN_PRIORITY.get(recipient.recipient_type)
-        if priority is None or not recipient.access_token:
+        if not recipient.access_token:
             continue
+        recipients_by_form_id.setdefault(recipient.form_id, []).append((recipient.recipient_type, recipient.access_token))
 
-        candidate = (priority, recipient.access_token)
-        current = tokens_by_form_id.get(recipient.form_id)
-        if current is None or candidate[0] < current[0]:
-            tokens_by_form_id[recipient.form_id] = candidate
-
-    return {form_id: token for form_id, (_, token) in tokens_by_form_id.items()}
+    tokens_by_form_id: dict[str, str] = {}
+    for form_id, recipients in recipients_by_form_id.items():
+        token = get_preferred_form_token(recipients)
+        if token is not None:
+            tokens_by_form_id[form_id] = token
+    return tokens_by_form_id

api/core/workflow/human_input_policy.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from enum import StrEnum
+from typing import Any
+
+from models.human_input import RecipientType
+
+
+class HumanInputSurface(StrEnum):
+    SERVICE_API = "service_api"
+    CONSOLE = "console"
+
+
+# Service API is intentionally narrower than other surfaces: app-token callers
+# should only be able to act on end-user web forms, not internal console flows.
+_ALLOWED_RECIPIENT_TYPES_BY_SURFACE: dict[HumanInputSurface, frozenset[RecipientType]] = {
+    HumanInputSurface.SERVICE_API: frozenset({RecipientType.STANDALONE_WEB_APP}),
+    HumanInputSurface.CONSOLE: frozenset({RecipientType.CONSOLE, RecipientType.BACKSTAGE}),
+}
+
+# A single HITL form can have multiple recipient records; this shared priority
+# keeps every API surface consistent about which resume token to expose.
+_RECIPIENT_TOKEN_PRIORITY: dict[RecipientType, int] = {
+    RecipientType.BACKSTAGE: 0,
+    RecipientType.CONSOLE: 1,
+    RecipientType.STANDALONE_WEB_APP: 2,
+}
+
+
+def is_recipient_type_allowed_for_surface(
+    recipient_type: RecipientType | None,
+    surface: HumanInputSurface,
+) -> bool:
+    if recipient_type is None:
+        return False
+    return recipient_type in _ALLOWED_RECIPIENT_TYPES_BY_SURFACE[surface]
+
+
+def get_preferred_form_token(
+    recipients: Sequence[tuple[RecipientType, str]],
+) -> str | None:
+    chosen_token: str | None = None
+    chosen_priority: int | None = None
+    for recipient_type, token in recipients:
+        priority = _RECIPIENT_TOKEN_PRIORITY.get(recipient_type)
+        if priority is None or not token:
+            continue
+        if chosen_priority is None or priority < chosen_priority:
+            chosen_priority = priority
+            chosen_token = token
+    return chosen_token
+
+
+def enrich_human_input_pause_reasons(
+    reasons: Sequence[Mapping[str, Any]],
+    *,
+    form_tokens_by_form_id: Mapping[str, str],
+    expiration_times_by_form_id: Mapping[str, int],
+) -> list[dict[str, Any]]:
+    enriched: list[dict[str, Any]] = []
+    for reason in reasons:
+        updated = dict(reason)
+        if updated.get("type") == "human_input_required":
+            form_id = updated.get("form_id")
+            if isinstance(form_id, str):
+                updated["form_token"] = form_tokens_by_form_id.get(form_id)
+                expiration_time = expiration_times_by_form_id.get(form_id)
+                if expiration_time is not None:
+                    updated["expiration_time"] = expiration_time
+        enriched.append(updated)
+    return enriched

api/dev/generate_swagger_specs.py

@@ -1,172 +0,0 @@
-"""Generate Flask-RESTX Swagger 2.0 specs without booting the full backend.
-
-This helper intentionally avoids `app_factory.create_app()`. The normal backend
-startup eagerly initializes database, Redis, Celery, and storage extensions,
-which is unnecessary when the goal is only to serialize the Flask-RESTX
-`/swagger.json` documents.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import logging
-import os
-import sys
-from dataclasses import dataclass
-from pathlib import Path
-
-from flask import Flask
-from flask_restx.swagger import Swagger
-
-logger = logging.getLogger(__name__)
-
-API_ROOT = Path(__file__).resolve().parents[1]
-if str(API_ROOT) not in sys.path:
-    sys.path.insert(0, str(API_ROOT))
-
-
-@dataclass(frozen=True)
-class SpecTarget:
-    route: str
-    filename: str
-
-
-SPEC_TARGETS: tuple[SpecTarget, ...] = (
-    SpecTarget(route="/console/api/swagger.json", filename="console-swagger.json"),
-    SpecTarget(route="/api/swagger.json", filename="web-swagger.json"),
-    SpecTarget(route="/v1/swagger.json", filename="service-swagger.json"),
-)
-
-_ORIGINAL_REGISTER_MODEL = Swagger.register_model
-_ORIGINAL_REGISTER_FIELD = Swagger.register_field
-
-
-def _apply_runtime_defaults() -> None:
-    """Force the small config surface required for Swagger generation."""
-
-    os.environ.setdefault("SECRET_KEY", "spec-export")
-    os.environ.setdefault("STORAGE_TYPE", "local")
-    os.environ.setdefault("STORAGE_LOCAL_PATH", "/tmp/dify-storage")
-    os.environ.setdefault("SWAGGER_UI_ENABLED", "true")
-
-    from configs import dify_config
-
-    dify_config.SECRET_KEY = os.environ["SECRET_KEY"]
-    dify_config.STORAGE_TYPE = "local"
-    dify_config.STORAGE_LOCAL_PATH = os.environ["STORAGE_LOCAL_PATH"]
-    dify_config.SWAGGER_UI_ENABLED = os.environ["SWAGGER_UI_ENABLED"].lower() == "true"
-
-
-def _patch_swagger_for_inline_nested_dicts() -> None:
-    """Teach Flask-RESTX Swagger generation to tolerate inline nested field maps.
-
-    Some existing controllers use `fields.Nested({...})` with a raw field mapping
-    instead of a named `api.model(...)`. Flask-RESTX crashes on those anonymous
-    dicts during schema registration, so this helper upgrades them into temporary
-    named models at export time.
-    """
-
-    if getattr(Swagger, "_dify_inline_nested_dict_patch", False):
-        return
-
-    def get_or_create_inline_model(self: Swagger, nested_fields: dict[object, object]) -> object:
-        anonymous_models = getattr(self, "_anonymous_inline_models", None)
-        if anonymous_models is None:
-            anonymous_models = {}
-            self._anonymous_inline_models = anonymous_models
-
-        anonymous_name = anonymous_models.get(id(nested_fields))
-        if anonymous_name is None:
-            anonymous_name = f"_AnonymousInlineModel{len(anonymous_models) + 1}"
-            anonymous_models[id(nested_fields)] = anonymous_name
-            self.api.model(anonymous_name, nested_fields)
-
-        return self.api.models[anonymous_name]
-
-    def register_model_with_inline_dict_support(self: Swagger, model: object) -> dict[str, str]:
-        if isinstance(model, dict):
-            model = get_or_create_inline_model(self, model)
-
-        return _ORIGINAL_REGISTER_MODEL(self, model)
-
-    def register_field_with_inline_dict_support(self: Swagger, field: object) -> None:
-        nested = getattr(field, "nested", None)
-        if isinstance(nested, dict):
-            field.model = get_or_create_inline_model(self, nested)  # type: ignore
-
-        _ORIGINAL_REGISTER_FIELD(self, field)
-
-    Swagger.register_model = register_model_with_inline_dict_support
-    Swagger.register_field = register_field_with_inline_dict_support
-    Swagger._dify_inline_nested_dict_patch = True
-
-
-def create_spec_app() -> Flask:
-    """Build a minimal Flask app that only mounts the Swagger-producing blueprints."""
-
-    _apply_runtime_defaults()
-    _patch_swagger_for_inline_nested_dicts()
-
-    app = Flask(__name__)
-
-    from controllers.console import bp as console_bp
-    from controllers.service_api import bp as service_api_bp
-    from controllers.web import bp as web_bp
-
-    app.register_blueprint(console_bp)
-    app.register_blueprint(web_bp)
-    app.register_blueprint(service_api_bp)
-
-    return app
-
-
-def generate_specs(output_dir: Path) -> list[Path]:
-    """Write all Swagger specs to `output_dir` and return the written paths."""
-
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    app = create_spec_app()
-    client = app.test_client()
-
-    written_paths: list[Path] = []
-    for target in SPEC_TARGETS:
-        response = client.get(target.route)
-        if response.status_code != 200:
-            raise RuntimeError(f"failed to fetch {target.route}: {response.status_code}")
-
-        payload = response.get_json()
-        if not isinstance(payload, dict):
-            raise RuntimeError(f"unexpected response payload for {target.route}")
-
-        output_path = output_dir / target.filename
-        output_path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
-        written_paths.append(output_path)
-
-    return written_paths
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument(
-        "-o",
-        "--output-dir",
-        type=Path,
-        default=Path("openapi"),
-        help="Directory where the Swagger JSON files will be written.",
-    )
-    return parser.parse_args()
-
-
-def main() -> int:
-    args = parse_args()
-    written_paths = generate_specs(args.output_dir)
-
-    for path in written_paths:
-        logger.debug(path)
-
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

api/libs/flask_utils.py

@@ -1,5 +1,5 @@
 import contextvars
-from collections.abc import Generator  # Changed from Iterator
+from collections.abc import Iterator
 from contextlib import contextmanager
 from typing import TYPE_CHECKING
 
@@ -13,7 +13,7 @@ if TYPE_CHECKING:
 def preserve_flask_contexts(
     flask_app: Flask,
     context_vars: contextvars.Context,
-) -> Generator[None, None, None]:  # Changed from Iterator[None]
+) -> Iterator[None]:
     """
     A context manager that handles:
     1. flask-login's UserProxy copy

api/models/comment.py

@@ -8,7 +8,7 @@ from sqlalchemy import Index, func
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from .account import Account
-from .base import Base, gen_uuidv7_string
+from .base import Base
 from .engine import db
 from .types import StringUUID
 
@@ -42,7 +42,7 @@ class WorkflowComment(Base):
         Index("workflow_comments_created_at_idx", "created_at"),
     )
 
-    id: Mapped[str] = mapped_column(StringUUID, default=gen_uuidv7_string)
+    id: Mapped[str] = mapped_column(StringUUID, server_default=sa.text("uuidv7()"))
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
     app_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
     position_x: Mapped[float] = mapped_column(sa.Float)
@@ -149,7 +149,7 @@ class WorkflowCommentReply(Base):
         Index("comment_replies_created_at_idx", "created_at"),
     )
 
-    id: Mapped[str] = mapped_column(StringUUID, default=gen_uuidv7_string)
+    id: Mapped[str] = mapped_column(StringUUID, server_default=sa.text("uuidv7()"))
     comment_id: Mapped[str] = mapped_column(
         StringUUID, sa.ForeignKey("workflow_comments.id", ondelete="CASCADE"), nullable=False
     )
@@ -194,7 +194,7 @@ class WorkflowCommentMention(Base):
         Index("comment_mentions_user_idx", "mentioned_user_id"),
     )
 
-    id: Mapped[str] = mapped_column(StringUUID, default=gen_uuidv7_string)
+    id: Mapped[str] = mapped_column(StringUUID, server_default=sa.text("uuidv7()"))
     comment_id: Mapped[str] = mapped_column(
         StringUUID, sa.ForeignKey("workflow_comments.id", ondelete="CASCADE"), nullable=False
     )

api/models/model.py

@@ -91,19 +91,6 @@ class EnabledConfig(TypedDict):
     enabled: bool
 
 
-class SuggestedQuestionsAfterAnswerModelConfig(TypedDict):
-    provider: str
-    name: str
-    mode: NotRequired[str]
-    completion_params: NotRequired[dict[str, Any]]
-
-
-class SuggestedQuestionsAfterAnswerConfig(TypedDict):
-    enabled: bool
-    model: NotRequired[SuggestedQuestionsAfterAnswerModelConfig]
-    prompt: NotRequired[str]
-
-
 class EmbeddingModelInfo(TypedDict):
     embedding_provider_name: str
     embedding_model_name: str
@@ -233,7 +220,7 @@ class ModelConfig(TypedDict):
 class AppModelConfigDict(TypedDict):
     opening_statement: str | None
     suggested_questions: list[str]
-    suggested_questions_after_answer: SuggestedQuestionsAfterAnswerConfig
+    suggested_questions_after_answer: EnabledConfig
     speech_to_text: EnabledConfig
     text_to_speech: EnabledConfig
     retriever_resource: EnabledConfig
@@ -693,13 +680,8 @@ class AppModelConfig(TypeBase):
         return cast(EnabledConfig, json.loads(value) if value else {"enabled": default_enabled})
 
     @property
-    def suggested_questions_after_answer_dict(self) -> SuggestedQuestionsAfterAnswerConfig:
-        return cast(
-            SuggestedQuestionsAfterAnswerConfig,
-            json.loads(self.suggested_questions_after_answer)
-            if self.suggested_questions_after_answer
-            else {"enabled": False},
-        )
+    def suggested_questions_after_answer_dict(self) -> EnabledConfig:
+        return self._get_enabled_config(self.suggested_questions_after_answer)
 
     @property
     def speech_to_text_dict(self) -> EnabledConfig:

api/providers/vdb/vdb-analyticdb/src/dify_vdb_analyticdb/analyticdb_vector_sql.py

@@ -1,6 +1,6 @@
 import json
 import uuid
-from collections.abc import Generator  # Added Generator
+from collections.abc import Iterator
 from contextlib import contextmanager
 from typing import Any
 
@@ -75,7 +75,7 @@ class AnalyticdbVectorBySql:
         )
 
     @contextmanager
-    def _get_cursor(self) -> Generator[Any, None, None]:  # Changed from Iterator[Any]
+    def _get_cursor(self) -> Iterator[Any]:
         assert self.pool is not None, "Connection pool is not initialized"
         conn = self.pool.getconn()
         cur = conn.cursor()

api/pyproject.toml

@@ -114,10 +114,10 @@ override-dependencies = [
 dev = [
     "coverage>=7.13.4",
     "dotenv-linter>=0.7.0",
-    "faker>=40.15.0",
+    "faker>=20.1.0",
     "lxml-stubs>=0.5.1",
-    "basedpyright>=1.39.3",
-    "ruff>=0.15.11",
+    "basedpyright>=1.39.0",
+    "ruff>=0.15.10",
     "pytest>=9.0.3",
     "pytest-benchmark>=5.2.3",
     "pytest-cov>=7.1.0",
@@ -157,14 +157,14 @@ dev = [
     "types-tensorflow>=2.18.0.20260408",
     "types-tqdm>=4.67.3.20260408",
     "types-ujson>=5.10.0",
-    "boto3-stubs>=1.42.92",
+    "boto3-stubs>=1.42.88",
     "types-jmespath>=1.1.0.20260408",
-    "hypothesis>=6.152.1",
+    "hypothesis>=6.151.12",
     "types_pyOpenSSL>=24.1.0",
     "types_cffi>=2.0.0.20260408",
     "types_setuptools>=82.0.0.20260408",
     "pandas-stubs>=3.0.0",
-    "scipy-stubs>=1.17.1.4",
+    "scipy-stubs>=1.15.3.0",
     "types-python-http-client>=3.3.7.20260408",
     "import-linter>=2.3",
     "types-redis>=4.6.0.20241004",
@@ -173,7 +173,7 @@ dev = [
     # "locust>=2.40.4",  # Temporarily removed due to compatibility issues. Uncomment when resolved.
     "pytest-timeout>=2.4.0",
     "pytest-xdist>=3.8.0",
-    "pyrefly>=0.62.0",
+    "pyrefly>=0.61.1",
     "xinference-client>=2.5.0",
 ]
 

api/repositories/sqlalchemy_api_workflow_run_repository.py

@@ -42,7 +42,7 @@ from libs.helper import convert_datetime_to_date
 from libs.infinite_scroll_pagination import InfiniteScrollPagination
 from libs.time_parser import get_time_threshold
 from models.enums import WorkflowRunTriggeredFrom
-from models.human_input import HumanInputForm
+from models.human_input import HumanInputForm, HumanInputFormRecipient
 from models.workflow import WorkflowAppLog, WorkflowArchiveLog, WorkflowPause, WorkflowPauseReason, WorkflowRun
 from repositories.api_workflow_run_repository import APIWorkflowRunRepository, RunsWithRelatedCountsDict
 from repositories.entities.workflow_pause import WorkflowPauseEntity
@@ -63,6 +63,7 @@ class _WorkflowRunError(Exception):
 def _build_human_input_required_reason(
     reason_model: WorkflowPauseReason,
     form_model: HumanInputForm | None,
+    recipients: Sequence[HumanInputFormRecipient] = (),
 ) -> HumanInputRequired:
     form_content = ""
     inputs = []
@@ -89,7 +90,7 @@ def _build_human_input_required_reason(
             resolved_default_values = dict(definition.default_values)
             node_title = definition.node_title or node_title
 
-    return HumanInputRequired(
+    reason = HumanInputRequired(
         form_id=form_id,
         form_content=form_content,
         inputs=inputs,
@@ -98,6 +99,7 @@ def _build_human_input_required_reason(
         node_title=node_title,
         resolved_default_values=resolved_default_values,
     )
+    return reason
 
 
 class DifyAPISQLAlchemyWorkflowRunRepository(APIWorkflowRunRepository):
@@ -804,12 +806,23 @@ class DifyAPISQLAlchemyWorkflowRunRepository(APIWorkflowRunRepository):
             form_stmt = select(HumanInputForm).where(HumanInputForm.id.in_(form_ids))
             for form in session.scalars(form_stmt).all():
                 form_models[form.id] = form
+        recipients_by_form_id: dict[str, list[HumanInputFormRecipient]] = {}
+        if form_ids:
+            recipient_stmt = select(HumanInputFormRecipient).where(HumanInputFormRecipient.form_id.in_(form_ids))
+            for recipient in session.scalars(recipient_stmt).all():
+                recipients_by_form_id.setdefault(recipient.form_id, []).append(recipient)
 
         pause_reasons: list[PauseReason] = []
         for reason in pause_reason_models:
             if reason.type_ == PauseReasonType.HUMAN_INPUT_REQUIRED:
                 form_model = form_models.get(reason.form_id)
-                pause_reasons.append(_build_human_input_required_reason(reason, form_model))
+                pause_reasons.append(
+                    _build_human_input_required_reason(
+                        reason,
+                        form_model,
+                        recipients_by_form_id.get(reason.form_id, ()),
+                    )
+                )
             else:
                 pause_reasons.append(reason.to_entity())
         return pause_reasons

api/services/app_generate_service.py

@@ -162,6 +162,7 @@ class AppGenerateService:
                                 invoke_from=invoke_from,
                                 streaming=True,
                                 call_depth=0,
+                                workflow_run_id=str(uuid.uuid4()),
                             )
                             payload_json = payload.model_dump_json()
 
@@ -183,6 +184,10 @@ class AppGenerateService:
                     else:
                         # Blocking mode: run synchronously and return JSON instead of SSE
                         # Keep behaviour consistent with WORKFLOW blocking branch.
+                        pause_config = PauseStateLayerConfig(
+                            session_factory=session_factory.get_session_maker(),
+                            state_owner_user_id=workflow.created_by,
+                        )
                         advanced_generator = AdvancedChatAppGenerator()
                         return rate_limit.generate(
                             advanced_generator.convert_to_event_stream(
@@ -194,6 +199,7 @@ class AppGenerateService:
                                     invoke_from=invoke_from,
                                     workflow_run_id=str(uuid.uuid4()),
                                     streaming=False,
+                                    pause_state_config=pause_config,
                                 )
                             ),
                             request_id=request_id,

api/services/file_service.py

@@ -2,7 +2,7 @@ import base64
 import hashlib
 import os
 import uuid
-from collections.abc import Generator, Sequence  # Changed Iterator to Generator
+from collections.abc import Iterator, Sequence
 from contextlib import contextmanager, suppress
 from tempfile import NamedTemporaryFile
 from typing import Literal
@@ -324,7 +324,7 @@ class FileService:
     def build_upload_files_zip_tempfile(
         *,
         upload_files: Sequence[UploadFile],
-    ) -> Generator[str, None, None]:  # Changed from Iterator[str]
+    ) -> Iterator[str]:
         """
         Build a ZIP from `UploadFile`s and yield a tempfile path.
 

api/services/hit_testing_service.py

@@ -1,10 +1,10 @@
 import json
 import logging
 import time
-from typing import Any, TypedDict, cast
+from typing import Any, TypedDict
 
 from core.app.app_config.entities import ModelConfig
-from core.rag.datasource.retrieval_service import DefaultRetrievalModelDict, RetrievalService
+from core.rag.datasource.retrieval_service import RetrievalService
 from core.rag.index_processor.constant.query_type import QueryType
 from core.rag.models.document import Document
 from core.rag.retrieval.dataset_retrieval import DatasetRetrieval
@@ -36,10 +36,6 @@ default_retrieval_model = {
 }
 
 
-class HitTestingRetrievalModelDict(DefaultRetrievalModelDict, total=False):
-    metadata_filtering_conditions: dict[str, Any]
-
-
 class HitTestingService:
     @classmethod
     def retrieve(
@@ -55,18 +51,17 @@ class HitTestingService:
         start = time.perf_counter()
 
         # get retrieval model , if the model is not setting , using default
-        resolved_retrieval_model = cast(
-            HitTestingRetrievalModelDict,
-            retrieval_model or dataset.retrieval_model or default_retrieval_model,
-        )
+        if not retrieval_model:
+            retrieval_model = dataset.retrieval_model or default_retrieval_model
+        assert isinstance(retrieval_model, dict)
         document_ids_filter = None
-        metadata_filtering_conditions_raw = resolved_retrieval_model.get("metadata_filtering_conditions", {})
-        if metadata_filtering_conditions_raw and query:
+        metadata_filtering_conditions = retrieval_model.get("metadata_filtering_conditions", {})
+        if metadata_filtering_conditions and query:
             dataset_retrieval = DatasetRetrieval()
 
             from core.rag.entities import MetadataFilteringCondition
 
-            metadata_filtering_conditions = MetadataFilteringCondition.model_validate(metadata_filtering_conditions_raw)
+            metadata_filtering_conditions = MetadataFilteringCondition.model_validate(metadata_filtering_conditions)
 
             metadata_filter_document_ids, metadata_condition = dataset_retrieval.get_metadata_filter_condition(
                 dataset_ids=[dataset.id],
@@ -83,21 +78,19 @@ class HitTestingService:
             if metadata_condition and not document_ids_filter:
                 return cls.compact_retrieve_response(query, [])
         all_documents = RetrievalService.retrieve(
-            retrieval_method=RetrievalMethod(
-                resolved_retrieval_model.get("search_method", RetrievalMethod.SEMANTIC_SEARCH)
-            ),
+            retrieval_method=RetrievalMethod(retrieval_model.get("search_method", RetrievalMethod.SEMANTIC_SEARCH)),
             dataset_id=dataset.id,
             query=query,
             attachment_ids=attachment_ids,
-            top_k=resolved_retrieval_model.get("top_k", 4),
-            score_threshold=resolved_retrieval_model.get("score_threshold", 0.0)
-            if resolved_retrieval_model["score_threshold_enabled"]
+            top_k=retrieval_model.get("top_k", 4),
+            score_threshold=retrieval_model.get("score_threshold", 0.0)
+            if retrieval_model["score_threshold_enabled"]
             else 0.0,
-            reranking_model=resolved_retrieval_model.get("reranking_model", None)
-            if resolved_retrieval_model["reranking_enable"]
+            reranking_model=retrieval_model.get("reranking_model", None)
+            if retrieval_model["reranking_enable"]
             else None,
-            reranking_mode=resolved_retrieval_model.get("reranking_mode") or "reranking_model",
-            weights=resolved_retrieval_model.get("weights", None),
+            reranking_mode=retrieval_model.get("reranking_mode") or "reranking_model",
+            weights=retrieval_model.get("weights", None),
             document_ids_filter=document_ids_filter,
         )
 

api/services/message_service.py

@@ -1,6 +1,4 @@
-import logging
 from collections.abc import Sequence
-from typing import cast
 
 from pydantic import TypeAdapter
 from sqlalchemy import select
@@ -19,16 +17,7 @@ from graphon.model_runtime.entities.model_entities import ModelType
 from libs.infinite_scroll_pagination import InfiniteScrollPagination
 from models import Account
 from models.enums import FeedbackFromSource, FeedbackRating
-from models.model import (
-    App,
-    AppMode,
-    AppModelConfig,
-    AppModelConfigDict,
-    EndUser,
-    Message,
-    MessageFeedback,
-    SuggestedQuestionsAfterAnswerConfig,
-)
+from models.model import App, AppMode, AppModelConfig, AppModelConfigDict, EndUser, Message, MessageFeedback
 from repositories.execution_extra_content_repository import ExecutionExtraContentRepository
 from repositories.sqlalchemy_execution_extra_content_repository import (
     SQLAlchemyExecutionExtraContentRepository,
@@ -43,7 +32,6 @@ from services.errors.message import (
 from services.workflow_service import WorkflowService
 
 _app_model_config_adapter: TypeAdapter[AppModelConfigDict] = TypeAdapter(AppModelConfigDict)
-logger = logging.getLogger(__name__)
 
 
 def _create_execution_extra_content_repository() -> ExecutionExtraContentRepository:
@@ -264,7 +252,6 @@ class MessageService:
         )
 
         model_manager = ModelManager.for_tenant(tenant_id=app_model.tenant_id)
-        suggested_questions_after_answer_config: SuggestedQuestionsAfterAnswerConfig = {"enabled": False}
 
         if app_model.mode == AppMode.ADVANCED_CHAT:
             workflow_service = WorkflowService()
@@ -284,11 +271,9 @@ class MessageService:
             if not app_config.additional_features.suggested_questions_after_answer:
                 raise SuggestedQuestionsAfterAnswerDisabledError()
 
-            suggested_questions_after_answer = workflow.features_dict.get("suggested_questions_after_answer")
-            if isinstance(suggested_questions_after_answer, dict):
-                suggested_questions_after_answer_config = cast(
-                    SuggestedQuestionsAfterAnswerConfig, suggested_questions_after_answer
-                )
+            model_instance = model_manager.get_default_model_instance(
+                tenant_id=app_model.tenant_id, model_type=ModelType.LLM
+            )
         else:
             if not conversation.override_model_configs:
                 app_model_config = db.session.scalar(
@@ -308,14 +293,16 @@ class MessageService:
             if not app_model_config:
                 raise ValueError("did not find app model config")
 
-            suggested_questions_after_answer_config = app_model_config.suggested_questions_after_answer_dict
-            if suggested_questions_after_answer_config.get("enabled", False) is False:
+            suggested_questions_after_answer = app_model_config.suggested_questions_after_answer_dict
+            if suggested_questions_after_answer.get("enabled", False) is False:
                 raise SuggestedQuestionsAfterAnswerDisabledError()
 
-        model_instance = model_manager.get_default_model_instance(
-            tenant_id=app_model.tenant_id,
-            model_type=ModelType.LLM,
-        )
+            model_instance = model_manager.get_model_instance(
+                tenant_id=app_model.tenant_id,
+                provider=app_model_config.model_dict["provider"],
+                model_type=ModelType.LLM,
+                model=app_model_config.model_dict["name"],
+            )
 
         # get memory of conversation (read-only)
         memory = TokenBufferMemory(conversation=conversation, model_instance=model_instance)
@@ -325,17 +312,9 @@ class MessageService:
             message_limit=3,
         )
 
-        instruction_prompt = suggested_questions_after_answer_config.get("prompt")
-        if not isinstance(instruction_prompt, str) or not instruction_prompt.strip():
-            instruction_prompt = None
-
-        configured_model = suggested_questions_after_answer_config.get("model")
         with measure_time() as timer:
             questions_sequence = LLMGenerator.generate_suggested_questions_after_answer(
-                tenant_id=app_model.tenant_id,
-                histories=histories,
-                instruction_prompt=instruction_prompt,
-                model_config=configured_model,
+                tenant_id=app_model.tenant_id, histories=histories
             )
             questions: list[str] = list(questions_sequence)
 

api/services/plugin/plugin_auto_upgrade_service.py

@@ -23,7 +23,7 @@ class PluginAutoUpgradeService:
         exclude_plugins: list[str],
         include_plugins: list[str],
     ) -> bool:
-        with session_factory.create_session() as session, session.begin():
+        with session_factory.create_session() as session:
             exist_strategy = session.scalar(
                 select(TenantPluginAutoUpgradeStrategy)
                 .where(TenantPluginAutoUpgradeStrategy.tenant_id == tenant_id)
@@ -50,7 +50,7 @@ class PluginAutoUpgradeService:
 
     @staticmethod
     def exclude_plugin(tenant_id: str, plugin_id: str) -> bool:
-        with session_factory.create_session() as session, session.begin():
+        with session_factory.create_session() as session:
             exist_strategy = session.scalar(
                 select(TenantPluginAutoUpgradeStrategy)
                 .where(TenantPluginAutoUpgradeStrategy.tenant_id == tenant_id)

api/services/workflow_event_snapshot_service.py

@@ -12,8 +12,10 @@ from typing import Any
 from sqlalchemy import desc, select
 from sqlalchemy.orm import Session, sessionmaker
 
+from core.app.apps.common.pause_reason_serializer import pause_reason_to_public_dict
 from core.app.apps.message_generator import MessageGenerator
 from core.app.entities.task_entities import (
+    HumanInputRequiredResponse,
     MessageReplaceStreamResponse,
     NodeFinishStreamResponse,
     NodeStartStreamResponse,
@@ -22,10 +24,13 @@ from core.app.entities.task_entities import (
     WorkflowStartStreamResponse,
 )
 from core.app.layers.pause_state_persist_layer import WorkflowResumptionContext
+from core.workflow.human_input_forms import load_form_tokens_by_form_id
+from core.workflow.human_input_policy import enrich_human_input_pause_reasons
 from graphon.entities import WorkflowStartReason
 from graphon.enums import WorkflowExecutionStatus, WorkflowNodeExecutionStatus
 from graphon.runtime import GraphRuntimeState
 from graphon.workflow_type_encoder import WorkflowRuntimeTypeConverter
+from models.human_input import HumanInputForm
 from models.model import AppMode, Message
 from models.workflow import WorkflowNodeExecutionTriggeredFrom, WorkflowRun
 from repositories.api_workflow_node_execution_repository import WorkflowNodeExecutionSnapshot
@@ -61,6 +66,7 @@ def build_workflow_event_stream(
     session_maker: sessionmaker[Session],
     idle_timeout: float = 300,
     ping_interval: float = 10.0,
+    close_on_pause: bool = True,
 ) -> Generator[Mapping[str, Any] | str, None, None]:
     topic = MessageGenerator.get_response_topic(app_mode, workflow_run.id)
     workflow_run_repo = DifyAPIRepositoryFactory.create_api_workflow_run_repository(session_maker)
@@ -115,13 +121,14 @@ def build_workflow_event_stream(
                     message_context=message_context,
                     pause_entity=pause_entity,
                     resumption_context=resumption_context,
+                    session_maker=session_maker,
                 )
 
                 for event in snapshot_events:
                     last_msg_time = time.time()
                     last_ping_time = last_msg_time
                     yield event
-                    if _is_terminal_event(event, include_paused=True):
+                    if _is_terminal_event(event, close_on_pause=close_on_pause):
                         return
 
                 while True:
@@ -146,7 +153,7 @@ def build_workflow_event_stream(
                     last_msg_time = time.time()
                     last_ping_time = last_msg_time
                     yield event
-                    if _is_terminal_event(event, include_paused=True):
+                    if _is_terminal_event(event, close_on_pause=close_on_pause):
                         return
             finally:
                 buffer_state.stop_event.set()
@@ -207,6 +214,7 @@ def _build_snapshot_events(
     message_context: MessageContext | None,
     pause_entity: WorkflowPauseEntity | None,
     resumption_context: WorkflowResumptionContext | None,
+    session_maker: sessionmaker[Session] | None = None,
 ) -> list[Mapping[str, Any]]:
     events: list[Mapping[str, Any]] = []
 
@@ -241,12 +249,22 @@ def _build_snapshot_events(
             events.append(node_finished)
 
     if workflow_run.status == WorkflowExecutionStatus.PAUSED and pause_entity is not None:
+        for human_input_event in _build_human_input_required_events(
+            workflow_run_id=workflow_run.id,
+            task_id=task_id,
+            pause_entity=pause_entity,
+            session_maker=session_maker,
+        ):
+            _apply_message_context(human_input_event, message_context)
+            events.append(human_input_event)
+
         pause_event = _build_pause_event(
             workflow_run=workflow_run,
             workflow_run_id=workflow_run.id,
             task_id=task_id,
             pause_entity=pause_entity,
             resumption_context=resumption_context,
+            session_maker=session_maker,
         )
         if pause_event is not None:
             _apply_message_context(pause_event, message_context)
@@ -314,6 +332,92 @@ def _build_node_started_event(
     return response.to_ignore_detail_dict()
 
 
+def _build_human_input_required_events(
+    *,
+    workflow_run_id: str,
+    task_id: str,
+    pause_entity: WorkflowPauseEntity,
+    session_maker: sessionmaker[Session] | None,
+) -> list[dict[str, Any]]:
+    reasons = [pause_reason_to_public_dict(reason) for reason in pause_entity.get_pause_reasons()]
+    human_input_form_ids = [
+        form_id
+        for reason in reasons
+        if reason.get("type") == "human_input_required"
+        for form_id in [reason.get("form_id")]
+        if isinstance(form_id, str)
+    ]
+
+    expiration_times_by_form_id: dict[str, int] = {}
+    display_in_ui_by_form_id: dict[str, bool] = {}
+    form_tokens_by_form_id: dict[str, str] = {}
+    if human_input_form_ids and session_maker is not None:
+        stmt = select(HumanInputForm.id, HumanInputForm.expiration_time, HumanInputForm.form_definition).where(
+            HumanInputForm.id.in_(human_input_form_ids)
+        )
+        with session_maker() as session:
+            for form_id, expiration_time, form_definition in session.execute(stmt):
+                expiration_times_by_form_id[str(form_id)] = int(expiration_time.timestamp())
+                try:
+                    definition_payload = json.loads(form_definition) if form_definition else {}
+                except (TypeError, json.JSONDecodeError):
+                    definition_payload = {}
+                display_in_ui_by_form_id[str(form_id)] = bool(definition_payload.get("display_in_ui"))
+            form_tokens_by_form_id = load_form_tokens_by_form_id(human_input_form_ids, session=session)
+
+    events: list[dict[str, Any]] = []
+    for reason in reasons:
+        if reason.get("type") != "human_input_required":
+            continue
+
+        form_id_raw = reason.get("form_id")
+        node_id_raw = reason.get("node_id")
+        node_title_raw = reason.get("node_title")
+        form_content_raw = reason.get("form_content")
+        if not isinstance(form_id_raw, str):
+            continue
+        if not isinstance(node_id_raw, str):
+            continue
+        if not isinstance(node_title_raw, str):
+            continue
+        if not isinstance(form_content_raw, str):
+            continue
+        form_id = form_id_raw
+        node_id = node_id_raw
+        node_title = node_title_raw
+        form_content = form_content_raw
+
+        inputs = reason.get("inputs")
+        actions = reason.get("actions")
+        resolved_default_values = reason.get("resolved_default_values")
+
+        expiration_time = expiration_times_by_form_id.get(form_id)
+        if expiration_time is None:
+            continue
+
+        response = HumanInputRequiredResponse(
+            task_id=task_id,
+            workflow_run_id=workflow_run_id,
+            data=HumanInputRequiredResponse.Data(
+                form_id=form_id,
+                node_id=node_id,
+                node_title=node_title,
+                form_content=form_content,
+                inputs=inputs if isinstance(inputs, list) else [],
+                actions=actions if isinstance(actions, list) else [],
+                display_in_ui=display_in_ui_by_form_id.get(form_id, False),
+                form_token=form_tokens_by_form_id.get(form_id),
+                resolved_default_values=(resolved_default_values if isinstance(resolved_default_values, dict) else {}),
+                expiration_time=expiration_time,
+            ),
+        )
+        payload = response.model_dump(mode="json")
+        payload["event"] = response.event.value
+        events.append(payload)
+
+    return events
+
+
 def _build_node_finished_event(
     *,
     workflow_run_id: str,
@@ -356,6 +460,7 @@ def _build_pause_event(
     task_id: str,
     pause_entity: WorkflowPauseEntity,
     resumption_context: WorkflowResumptionContext | None,
+    session_maker: sessionmaker[Session] | None,
 ) -> dict[str, Any] | None:
     paused_nodes: list[str] = []
     outputs: dict[str, Any] = {}
@@ -364,7 +469,31 @@ def _build_pause_event(
         paused_nodes = state.get_paused_nodes()
         outputs = dict(WorkflowRuntimeTypeConverter().to_json_encodable(state.outputs or {}))
 
-    reasons = [reason.model_dump(mode="json") for reason in pause_entity.get_pause_reasons()]
+    reasons = [pause_reason_to_public_dict(reason) for reason in pause_entity.get_pause_reasons()]
+    human_input_form_ids = [
+        form_id
+        for reason in reasons
+        if reason.get("type") == "human_input_required"
+        for form_id in [reason.get("form_id")]
+        if isinstance(form_id, str)
+    ]
+    form_tokens_by_form_id: dict[str, str] = {}
+    expiration_times_by_form_id: dict[str, int] = {}
+    if human_input_form_ids and session_maker is not None:
+        with session_maker() as session:
+            form_tokens_by_form_id = load_form_tokens_by_form_id(human_input_form_ids, session=session)
+            stmt = select(HumanInputForm.id, HumanInputForm.expiration_time).where(HumanInputForm.id.in_(human_input_form_ids))
+            for row in session.execute(stmt):
+                form_id, expiration_time, *_rest = row
+                expiration_times_by_form_id[str(form_id)] = int(expiration_time.timestamp())
+        # Reconnect paths must preserve the same pause-reason contract as live streams;
+        # otherwise clients see schema drift after resume.
+        reasons = enrich_human_input_pause_reasons(
+            reasons,
+            form_tokens_by_form_id=form_tokens_by_form_id,
+            expiration_times_by_form_id=expiration_times_by_form_id,
+        )
+
     response = WorkflowPauseStreamResponse(
         task_id=task_id,
         workflow_run_id=workflow_run_id,
@@ -449,12 +578,19 @@ def _parse_event_message(message: bytes) -> Mapping[str, Any] | None:
     return event
 
 
-def _is_terminal_event(event: Mapping[str, Any] | str, include_paused=False) -> bool:
+def _is_terminal_event(
+    event: Mapping[str, Any] | str,
+    close_on_pause: bool = True,
+    *,
+    include_paused: bool | None = None,
+) -> bool:
+    if include_paused is not None:
+        close_on_pause = include_paused
     if not isinstance(event, Mapping):
         return False
     event_type = event.get("event")
     if event_type == StreamEvent.WORKFLOW_FINISHED.value:
         return True
-    if include_paused:
+    if close_on_pause:
         return event_type == StreamEvent.WORKFLOW_PAUSED.value
     return False

api/tasks/app_generate/workflow_execute_task.py

@@ -399,6 +399,8 @@ def _resume_advanced_chat(
     workflow_run_id: str,
     workflow_run: WorkflowRun,
 ) -> None:
+    resumed_generate_entity = generate_entity.model_copy(update={"stream": True})
+
     try:
         triggered_from = WorkflowRunTriggeredFrom(workflow_run.triggered_from)
     except ValueError:
@@ -426,7 +428,7 @@ def _resume_advanced_chat(
             user=user,
             conversation=conversation,
             message=message,
-            application_generate_entity=generate_entity,
+            application_generate_entity=resumed_generate_entity,
             workflow_execution_repository=workflow_execution_repository,
             workflow_node_execution_repository=workflow_node_execution_repository,
             graph_runtime_state=graph_runtime_state,
@@ -436,9 +438,8 @@ def _resume_advanced_chat(
         logger.exception("Failed to resume chatflow execution for workflow run %s", workflow_run_id)
         raise
 
-    if generate_entity.stream:
-        assert isinstance(response, Generator)
-        _publish_streaming_response(response, workflow_run_id, AppMode.ADVANCED_CHAT)
+    assert isinstance(response, Generator)
+    _publish_streaming_response(response, workflow_run_id, AppMode.ADVANCED_CHAT)
 
 
 def _resume_workflow(
@@ -455,6 +456,8 @@ def _resume_workflow(
     workflow_run_repo,
     pause_entity,
 ) -> None:
+    resumed_generate_entity = generate_entity.model_copy(update={"stream": True})
+
     try:
         triggered_from = WorkflowRunTriggeredFrom(workflow_run.triggered_from)
     except ValueError:
@@ -480,7 +483,7 @@ def _resume_workflow(
             app_model=app_model,
             workflow=workflow,
             user=user,
-            application_generate_entity=generate_entity,
+            application_generate_entity=resumed_generate_entity,
             graph_runtime_state=graph_runtime_state,
             workflow_execution_repository=workflow_execution_repository,
             workflow_node_execution_repository=workflow_node_execution_repository,
@@ -490,9 +493,8 @@ def _resume_workflow(
         logger.exception("Failed to resume workflow execution for workflow run %s", workflow_run_id)
         raise
 
-    if generate_entity.stream:
-        assert isinstance(response, Generator)
-        _publish_streaming_response(response, workflow_run_id, AppMode.WORKFLOW)
+    assert isinstance(response, Generator)
+    _publish_streaming_response(response, workflow_run_id, AppMode.WORKFLOW)
 
     workflow_run_repo.delete_workflow_pause(pause_entity)
 

api/tests/test_containers_integration_tests/repositories/test_sqlalchemy_api_workflow_run_repository.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import secrets
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
 from unittest.mock import Mock
@@ -11,6 +12,7 @@ import pytest
 from sqlalchemy import Engine, delete, select
 from sqlalchemy.orm import Session, sessionmaker
 
+from core.workflow.human_input_adapter import DeliveryMethodType
 from extensions.ext_storage import storage
 from graphon.entities import WorkflowExecution
 from graphon.entities.pause_reason import HumanInputRequired, PauseReasonType
@@ -20,9 +22,11 @@ from graphon.nodes.human_input.enums import FormInputType, HumanInputFormStatus
 from libs.datetime_utils import naive_utc_now
 from models.enums import CreatorUserRole, WorkflowRunTriggeredFrom
 from models.human_input import (
+    BackstageRecipientPayload,
     HumanInputDelivery,
     HumanInputForm,
     HumanInputFormRecipient,
+    RecipientType,
 )
 from models.workflow import WorkflowAppLog, WorkflowAppLogCreatedFrom, WorkflowPause, WorkflowPauseReason, WorkflowRun
 from repositories.entities.workflow_pause import WorkflowPauseEntity
@@ -628,12 +632,12 @@ class TestPrivateWorkflowPauseEntity:
 class TestBuildHumanInputRequiredReason:
     """Integration tests for _build_human_input_required_reason using real DB models."""
 
-    def test_builds_reason_from_form_definition(
+    def test_prefers_standalone_web_app_token_when_available(
         self,
         db_session_with_containers: Session,
         test_scope: _TestScope,
     ) -> None:
-        """Build the graph pause reason from the stored form definition."""
+        """Use the public standalone web-app token for service API payloads."""
 
         expiration_time = naive_utc_now()
         form_definition = FormDefinition(
@@ -660,6 +664,40 @@ class TestBuildHumanInputRequiredReason:
         db_session_with_containers.add(form_model)
         db_session_with_containers.flush()
 
+        delivery = HumanInputDelivery(
+            form_id=form_model.id,
+            delivery_method_type=DeliveryMethodType.WEBAPP,
+            channel_payload="{}",
+        )
+        db_session_with_containers.add(delivery)
+        db_session_with_containers.flush()
+
+        backstage_access_token = secrets.token_urlsafe(8)
+        backstage_recipient = HumanInputFormRecipient(
+            form_id=form_model.id,
+            delivery_id=delivery.id,
+            recipient_type=RecipientType.BACKSTAGE,
+            recipient_payload=BackstageRecipientPayload().model_dump_json(),
+            access_token=backstage_access_token,
+        )
+        console_access_token = secrets.token_urlsafe(8)
+        console_recipient = HumanInputFormRecipient(
+            form_id=form_model.id,
+            delivery_id=delivery.id,
+            recipient_type=RecipientType.CONSOLE,
+            recipient_payload="{}",
+            access_token=console_access_token,
+        )
+        web_app_access_token = secrets.token_urlsafe(8)
+        web_app_recipient = HumanInputFormRecipient(
+            form_id=form_model.id,
+            delivery_id=delivery.id,
+            recipient_type=RecipientType.STANDALONE_WEB_APP,
+            recipient_payload="{}",
+            access_token=web_app_access_token,
+        )
+        db_session_with_containers.add_all([backstage_recipient, console_recipient, web_app_recipient])
+        db_session_with_containers.flush()
         # Create a pause so the reason has a valid pause_id
         workflow_run = _create_workflow_run(
             db_session_with_containers,
@@ -688,8 +726,15 @@ class TestBuildHumanInputRequiredReason:
         # Refresh to ensure we have DB-round-tripped objects
         db_session_with_containers.refresh(form_model)
         db_session_with_containers.refresh(reason_model)
+        db_session_with_containers.refresh(backstage_recipient)
+        db_session_with_containers.refresh(console_recipient)
+        db_session_with_containers.refresh(web_app_recipient)
 
-        reason = _build_human_input_required_reason(reason_model, form_model)
+        reason = _build_human_input_required_reason(
+            reason_model,
+            form_model,
+            [backstage_recipient, console_recipient, web_app_recipient],
+        )
 
         assert isinstance(reason, HumanInputRequired)
         assert reason.node_title == "Ask Name"
@@ -697,3 +742,92 @@ class TestBuildHumanInputRequiredReason:
         assert reason.inputs[0].output_variable_name == "name"
         assert reason.actions[0].id == "approve"
         assert reason.resolved_default_values == {"name": "Alice"}
+        assert not hasattr(reason, "form_token")
+
+    def test_falls_back_to_console_token_when_web_app_token_missing(
+        self,
+        db_session_with_containers: Session,
+        test_scope: _TestScope,
+    ) -> None:
+        """Use the console token only when no standalone web-app token exists."""
+
+        expiration_time = naive_utc_now()
+        form_definition = FormDefinition(
+            form_content="content",
+            inputs=[FormInput(type=FormInputType.TEXT_INPUT, output_variable_name="name")],
+            user_actions=[UserAction(id="approve", title="Approve")],
+            rendered_content="rendered",
+            expiration_time=expiration_time,
+            default_values={"name": "Alice"},
+            node_title="Ask Name",
+            display_in_ui=True,
+        )
+
+        form_model = HumanInputForm(
+            tenant_id=test_scope.tenant_id,
+            app_id=test_scope.app_id,
+            workflow_run_id=str(uuid4()),
+            node_id="node-1",
+            form_definition=form_definition.model_dump_json(),
+            rendered_content="rendered",
+            status=HumanInputFormStatus.WAITING,
+            expiration_time=expiration_time,
+        )
+        db_session_with_containers.add(form_model)
+        db_session_with_containers.flush()
+
+        delivery = HumanInputDelivery(
+            form_id=form_model.id,
+            delivery_method_type=DeliveryMethodType.WEBAPP,
+            channel_payload="{}",
+        )
+        db_session_with_containers.add(delivery)
+        db_session_with_containers.flush()
+
+        backstage_access_token = secrets.token_urlsafe(8)
+        backstage_recipient = HumanInputFormRecipient(
+            form_id=form_model.id,
+            delivery_id=delivery.id,
+            recipient_type=RecipientType.BACKSTAGE,
+            recipient_payload=BackstageRecipientPayload().model_dump_json(),
+            access_token=backstage_access_token,
+        )
+        console_access_token = secrets.token_urlsafe(8)
+        console_recipient = HumanInputFormRecipient(
+            form_id=form_model.id,
+            delivery_id=delivery.id,
+            recipient_type=RecipientType.CONSOLE,
+            recipient_payload="{}",
+            access_token=console_access_token,
+        )
+        db_session_with_containers.add_all([backstage_recipient, console_recipient])
+        db_session_with_containers.flush()
+
+        workflow_run = _create_workflow_run(
+            db_session_with_containers,
+            test_scope,
+            status=WorkflowExecutionStatus.RUNNING,
+        )
+        pause = WorkflowPause(
+            workflow_id=test_scope.workflow_id,
+            workflow_run_id=workflow_run.id,
+            state_object_key=f"workflow-state-{uuid4()}.json",
+        )
+        db_session_with_containers.add(pause)
+        db_session_with_containers.flush()
+        test_scope.state_keys.add(pause.state_object_key)
+
+        reason_model = WorkflowPauseReason(
+            pause_id=pause.id,
+            type_=PauseReasonType.HUMAN_INPUT_REQUIRED,
+            form_id=form_model.id,
+            node_id="node-1",
+            message="",
+        )
+        db_session_with_containers.add(reason_model)
+        db_session_with_containers.commit()
+
+        reason = _build_human_input_required_reason(reason_model, form_model, [backstage_recipient, console_recipient])
+
+        assert isinstance(reason, HumanInputRequired)
+        assert not hasattr(reason, "form_token")

api/tests/unit_tests/commands/test_generate_swagger_specs.py

@@ -1,37 +0,0 @@
-"""Unit tests for the standalone Swagger export helper."""
-
-import importlib.util
-import json
-import sys
-from pathlib import Path
-
-
-def _load_generate_swagger_specs_module():
-    api_dir = Path(__file__).resolve().parents[3]
-    script_path = api_dir / "dev" / "generate_swagger_specs.py"
-
-    spec = importlib.util.spec_from_file_location("generate_swagger_specs", script_path)
-    assert spec
-    assert spec.loader
-
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[spec.name] = module
-    spec.loader.exec_module(module)  # type: ignore[attr-defined]
-    return module
-
-
-def test_generate_specs_writes_console_web_and_service_swagger_files(tmp_path):
-    module = _load_generate_swagger_specs_module()
-
-    written_paths = module.generate_specs(tmp_path)
-
-    assert [path.name for path in written_paths] == [
-        "console-swagger.json",
-        "web-swagger.json",
-        "service-swagger.json",
-    ]
-
-    for path in written_paths:
-        payload = json.loads(path.read_text(encoding="utf-8"))
-        assert payload["swagger"] == "2.0"
-        assert "paths" in payload

api/tests/unit_tests/controllers/console/test_human_input_form.py

@@ -122,6 +122,35 @@ def test_post_form_invalid_recipient_type(app, monkeypatch: pytest.MonkeyPatch)
             handler(api, form_token="token")
 
 
+def test_post_form_rejects_webapp_recipient_type(app, monkeypatch: pytest.MonkeyPatch) -> None:
+    form = SimpleNamespace(tenant_id="tenant-1", recipient_type=RecipientType.STANDALONE_WEB_APP)
+
+    class _ServiceStub:
+        def __init__(self, *_args, **_kwargs):
+            pass
+
+        def get_form_by_token(self, _token):
+            return form
+
+    monkeypatch.setattr("controllers.console.human_input_form.HumanInputService", _ServiceStub)
+    monkeypatch.setattr(
+        "controllers.console.human_input_form.current_account_with_tenant",
+        lambda: (SimpleNamespace(id="user-1"), "tenant-1"),
+    )
+    monkeypatch.setattr("controllers.console.human_input_form.db", SimpleNamespace(engine=object()))
+
+    api = ConsoleHumanInputFormApi()
+    handler = _unwrap(api.post)
+
+    with app.test_request_context(
+        "/console/api/form/human_input/token",
+        method="POST",
+        json={"inputs": {"content": "ok"}, "action": "approve"},
+    ):
+        with pytest.raises(NotFoundError):
+            handler(api, form_token="token")
+
+
 def test_post_form_success(app, monkeypatch: pytest.MonkeyPatch) -> None:
     submit_mock = Mock()
     form = SimpleNamespace(tenant_id="tenant-1", recipient_type=RecipientType.CONSOLE)

api/tests/unit_tests/controllers/console/workspace/test_endpoint.py

@@ -2,17 +2,14 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 
-from controllers.console import console_ns
 from controllers.console.workspace.endpoint import (
-    DeprecatedEndpointCreateApi,
-    DeprecatedEndpointDeleteApi,
-    DeprecatedEndpointUpdateApi,
-    EndpointCollectionApi,
+    EndpointCreateApi,
+    EndpointDeleteApi,
     EndpointDisableApi,
     EndpointEnableApi,
-    EndpointItemApi,
     EndpointListApi,
     EndpointListForSinglePluginApi,
+    EndpointUpdateApi,
 )
 from core.plugin.impl.exc import PluginPermissionDeniedError
 
@@ -38,9 +35,9 @@ def patch_current_account(user_and_tenant):
 
 
 @pytest.mark.usefixtures("patch_current_account")
-class TestEndpointCollectionApi:
+class TestEndpointCreateApi:
     def test_create_success(self, app):
-        api = EndpointCollectionApi()
+        api = EndpointCreateApi()
         method = unwrap(api.post)
 
         payload = {
@@ -58,7 +55,7 @@ class TestEndpointCollectionApi:
         assert result["success"] is True
 
     def test_create_permission_denied(self, app):
-        api = EndpointCollectionApi()
+        api = EndpointCreateApi()
         method = unwrap(api.post)
 
         payload = {
@@ -78,7 +75,7 @@ class TestEndpointCollectionApi:
                 method(api)
 
     def test_create_validation_error(self, app):
-        api = EndpointCollectionApi()
+        api = EndpointCreateApi()
         method = unwrap(api.post)
 
         payload = {
@@ -94,27 +91,6 @@ class TestEndpointCollectionApi:
                 method(api)
 
 
-@pytest.mark.usefixtures("patch_current_account")
-class TestDeprecatedEndpointCreateApi:
-    def test_create_success(self, app):
-        api = DeprecatedEndpointCreateApi()
-        method = unwrap(api.post)
-
-        payload = {
-            "plugin_unique_identifier": "plugin-1",
-            "name": "endpoint",
-            "settings": {"a": 1},
-        }
-
-        with (
-            app.test_request_context("/", json=payload),
-            patch("controllers.console.workspace.endpoint.EndpointService.create_endpoint", return_value=True),
-        ):
-            result = method(api)
-
-        assert result["success"] is True
-
-
 @pytest.mark.usefixtures("patch_current_account")
 class TestEndpointListApi:
     def test_list_success(self, app):
@@ -170,96 +146,9 @@ class TestEndpointListForSinglePluginApi:
 
 
 @pytest.mark.usefixtures("patch_current_account")
-class TestEndpointItemApi:
+class TestEndpointDeleteApi:
     def test_delete_success(self, app):
-        api = EndpointItemApi()
-        method = unwrap(api.delete)
-
-        with (
-            app.test_request_context("/", method="DELETE"),
-            patch(
-                "controllers.console.workspace.endpoint.EndpointService.delete_endpoint",
-                return_value=True,
-            ) as mock_delete,
-        ):
-            result = method(api, "e1")
-
-        assert result["success"] is True
-        mock_delete.assert_called_once_with(tenant_id="t1", user_id="u1", endpoint_id="e1")
-
-    def test_delete_service_failure(self, app):
-        api = EndpointItemApi()
-        method = unwrap(api.delete)
-
-        with (
-            app.test_request_context("/", method="DELETE"),
-            patch("controllers.console.workspace.endpoint.EndpointService.delete_endpoint", return_value=False),
-        ):
-            result = method(api, "e1")
-
-        assert result["success"] is False
-
-    def test_update_success(self, app):
-        api = EndpointItemApi()
-        method = unwrap(api.patch)
-
-        payload = {
-            "name": "new-name",
-            "settings": {"x": 1},
-        }
-
-        with (
-            app.test_request_context("/", method="PATCH", json=payload),
-            patch(
-                "controllers.console.workspace.endpoint.EndpointService.update_endpoint",
-                return_value=True,
-            ) as mock_update,
-        ):
-            result = method(api, "e1")
-
-        assert result["success"] is True
-        mock_update.assert_called_once_with(
-            tenant_id="t1",
-            user_id="u1",
-            endpoint_id="e1",
-            name="new-name",
-            settings={"x": 1},
-        )
-
-    def test_update_validation_error(self, app):
-        api = EndpointItemApi()
-        method = unwrap(api.patch)
-
-        payload = {"settings": {}}
-
-        with (
-            app.test_request_context("/", method="PATCH", json=payload),
-        ):
-            with pytest.raises(ValueError):
-                method(api, "e1")
-
-    def test_update_service_failure(self, app):
-        api = EndpointItemApi()
-        method = unwrap(api.patch)
-
-        payload = {
-            "name": "n",
-            "settings": {},
-        }
-
-        with (
-            app.test_request_context("/", method="PATCH", json=payload),
-            patch("controllers.console.workspace.endpoint.EndpointService.update_endpoint", return_value=False),
-        ):
-            result = method(api, "e1")
-
-        assert result["success"] is False
-
-
-@pytest.mark.usefixtures("patch_current_account")
-class TestDeprecatedEndpointDeleteApi:
-    def test_delete_success(self, app):
-        api = DeprecatedEndpointDeleteApi()
+        api = EndpointDeleteApi()
         method = unwrap(api.post)
 
         payload = {"endpoint_id": "e1"}
@@ -273,7 +162,7 @@ class TestDeprecatedEndpointDeleteApi:
         assert result["success"] is True
 
     def test_delete_invalid_payload(self, app):
-        api = DeprecatedEndpointDeleteApi()
+        api = EndpointDeleteApi()
         method = unwrap(api.post)
 
         with (
@@ -283,7 +172,7 @@ class TestDeprecatedEndpointDeleteApi:
                 method(api)
 
     def test_delete_service_failure(self, app):
-        api = DeprecatedEndpointDeleteApi()
+        api = EndpointDeleteApi()
         method = unwrap(api.post)
 
         payload = {"endpoint_id": "e1"}
@@ -298,9 +187,9 @@ class TestDeprecatedEndpointDeleteApi:
 
 
 @pytest.mark.usefixtures("patch_current_account")
-class TestDeprecatedEndpointUpdateApi:
+class TestEndpointUpdateApi:
     def test_update_success(self, app):
-        api = DeprecatedEndpointUpdateApi()
+        api = EndpointUpdateApi()
         method = unwrap(api.post)
 
         payload = {
@@ -318,7 +207,7 @@ class TestDeprecatedEndpointUpdateApi:
         assert result["success"] is True
 
     def test_update_validation_error(self, app):
-        api = DeprecatedEndpointUpdateApi()
+        api = EndpointUpdateApi()
         method = unwrap(api.post)
 
         payload = {"endpoint_id": "e1", "settings": {}}
@@ -330,7 +219,7 @@ class TestDeprecatedEndpointUpdateApi:
                 method(api)
 
     def test_update_service_failure(self, app):
-        api = DeprecatedEndpointUpdateApi()
+        api = EndpointUpdateApi()
         method = unwrap(api.post)
 
         payload = {
@@ -348,36 +237,6 @@ class TestDeprecatedEndpointUpdateApi:
         assert result["success"] is False
 
 
-class TestEndpointRouteMetadata:
-    def test_legacy_write_routes_are_marked_deprecated(self):
-        assert DeprecatedEndpointCreateApi.post.__apidoc__["deprecated"] is True
-        assert DeprecatedEndpointDeleteApi.post.__apidoc__["deprecated"] is True
-        assert DeprecatedEndpointUpdateApi.post.__apidoc__["deprecated"] is True
-        assert EndpointCollectionApi.post.__apidoc__.get("deprecated") is not True
-        assert EndpointItemApi.delete.__apidoc__.get("deprecated") is not True
-        assert EndpointItemApi.patch.__apidoc__.get("deprecated") is not True
-
-    def test_canonical_and_legacy_write_routes_are_registered(self):
-        route_map = {
-            resource.__name__: urls
-            for resource, urls, _route_doc, _kwargs in console_ns.resources
-            if resource.__name__
-            in {
-                "EndpointCollectionApi",
-                "EndpointItemApi",
-                "DeprecatedEndpointCreateApi",
-                "DeprecatedEndpointDeleteApi",
-                "DeprecatedEndpointUpdateApi",
-            }
-        }
-
-        assert route_map["EndpointCollectionApi"] == ("/workspaces/current/endpoints",)
-        assert route_map["EndpointItemApi"] == ("/workspaces/current/endpoints/<string:id>",)
-        assert route_map["DeprecatedEndpointCreateApi"] == ("/workspaces/current/endpoints/create",)
-        assert route_map["DeprecatedEndpointDeleteApi"] == ("/workspaces/current/endpoints/delete",)
-        assert route_map["DeprecatedEndpointUpdateApi"] == ("/workspaces/current/endpoints/update",)
-
-
 @pytest.mark.usefixtures("patch_current_account")
 class TestEndpointEnableApi:
     def test_enable_success(self, app):

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

@@ -0,0 +1,705 @@
+"""Dedicated tests for HITL behavior exposed through the Service API."""
+
+from __future__ import annotations
+
+import json
+import sys
+from collections.abc import Sequence
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from types import SimpleNamespace
+from unittest.mock import ANY, MagicMock, Mock
+
+import pytest
+
+import services.app_generate_service as ags_module
+from controllers.service_api.app.workflow_events import WorkflowEventsApi
+from core.app.app_config.entities import AppAdditionalFeatures, WorkflowUIBasedAppConfig
+from core.app.apps.common import workflow_response_converter
+from core.app.apps.common.workflow_response_converter import WorkflowResponseConverter
+from core.app.entities.app_invoke_entities import AdvancedChatAppGenerateEntity, InvokeFrom, WorkflowAppGenerateEntity
+from core.app.entities.queue_entities import QueueWorkflowPausedEvent
+from core.app.entities.task_entities import (
+    ChatbotAppPausedBlockingResponse,
+    HumanInputRequiredResponse,
+    WorkflowAppPausedBlockingResponse,
+    WorkflowPauseStreamResponse,
+)
+from core.app.layers.pause_state_persist_layer import WorkflowResumptionContext, _WorkflowGenerateEntityWrapper
+from core.workflow.system_variables import build_system_variables
+from graphon.entities import WorkflowStartReason
+from graphon.entities.pause_reason import HumanInputRequired, PauseReasonType
+from graphon.enums import WorkflowExecutionStatus, WorkflowNodeExecutionStatus
+from graphon.nodes.human_input.entities import FormInput, UserAction
+from graphon.nodes.human_input.enums import FormInputType
+from graphon.runtime import GraphRuntimeState, VariablePool
+from models.account import Account
+from models.enums import CreatorUserRole
+from models.model import AppMode
+from models.workflow import WorkflowRun
+from repositories.api_workflow_node_execution_repository import WorkflowNodeExecutionSnapshot
+from repositories.entities.workflow_pause import WorkflowPauseEntity
+from services.app_generate_service import AppGenerateService
+from services.workflow_event_snapshot_service import _build_snapshot_events
+from tests.unit_tests.controllers.service_api.conftest import _unwrap
+
+
+class _DummyRateLimit:
+    @staticmethod
+    def gen_request_key() -> str:
+        return "dummy-request-id"
+
+    def __init__(self, client_id: str, max_active_requests: int) -> None:
+        self.client_id = client_id
+        self.max_active_requests = max_active_requests
+
+    def enter(self, request_id: str | None = None) -> str:
+        return request_id or "dummy-request-id"
+
+    def exit(self, request_id: str) -> None:
+        return None
+
+    def generate(self, generator, request_id: str):
+        return generator
+
+
+def _mock_repo_for_run(monkeypatch: pytest.MonkeyPatch, workflow_run):
+    workflow_events_module = sys.modules["controllers.service_api.app.workflow_events"]
+    repo = SimpleNamespace(get_workflow_run_by_id_and_tenant_id=lambda **_kwargs: workflow_run)
+    monkeypatch.setattr(
+        workflow_events_module.DifyAPIRepositoryFactory,
+        "create_api_workflow_run_repository",
+        lambda *_args, **_kwargs: repo,
+    )
+    monkeypatch.setattr(workflow_events_module, "db", SimpleNamespace(engine=object()))
+    return workflow_events_module
+
+
+def _build_service_api_pause_converter() -> WorkflowResponseConverter:
+    application_generate_entity = SimpleNamespace(
+        inputs={},
+        files=[],
+        invoke_from=InvokeFrom.SERVICE_API,
+        app_config=SimpleNamespace(app_id="app-id", tenant_id="tenant-id"),
+    )
+    system_variables = build_system_variables(
+        user_id="user",
+        app_id="app-id",
+        workflow_id="workflow-id",
+        workflow_execution_id="run-id",
+    )
+    user = MagicMock(spec=Account)
+    user.id = "account-id"
+    user.name = "Tester"
+    user.email = "tester@example.com"
+    return WorkflowResponseConverter(
+        application_generate_entity=application_generate_entity,
+        user=user,
+        system_variables=system_variables,
+    )
+
+
+def _build_advanced_chat_paused_blocking_response() -> ChatbotAppPausedBlockingResponse:
+    data = ChatbotAppPausedBlockingResponse.Data(
+        id="msg-1",
+        mode="chat",
+        conversation_id="c1",
+        message_id="m1",
+        workflow_run_id="run-1",
+        answer="partial",
+        metadata={"usage": {"total_tokens": 1}},
+        created_at=1,
+        paused_nodes=["node-1"],
+        reasons=[
+            {
+                "type": PauseReasonType.HUMAN_INPUT_REQUIRED,
+                "form_id": "form-1",
+                "expiration_time": 100,
+            }
+        ],
+        status=WorkflowExecutionStatus.PAUSED,
+        elapsed_time=0.1,
+        total_tokens=0,
+        total_steps=0,
+    )
+    return ChatbotAppPausedBlockingResponse(task_id="t1", data=data)
+
+
+def _build_workflow_paused_blocking_response() -> WorkflowAppPausedBlockingResponse:
+    return WorkflowAppPausedBlockingResponse(
+        task_id="t1",
+        workflow_run_id="r1",
+        data=WorkflowAppPausedBlockingResponse.Data(
+            id="r1",
+            workflow_id="wf-1",
+            status=WorkflowExecutionStatus.PAUSED,
+            outputs={},
+            error=None,
+            elapsed_time=0.5,
+            total_tokens=0,
+            total_steps=2,
+            created_at=1,
+            finished_at=None,
+            paused_nodes=["node-1"],
+            reasons=[{"type": "human_input_required", "form_id": "form-1", "expiration_time": 100}],
+        ),
+    )
+
+
+@dataclass(frozen=True)
+class _FakePauseEntity(WorkflowPauseEntity):
+    pause_id: str
+    workflow_run_id: str
+    paused_at_value: datetime
+    pause_reasons: Sequence[HumanInputRequired]
+
+    @property
+    def id(self) -> str:
+        return self.pause_id
+
+    @property
+    def workflow_execution_id(self) -> str:
+        return self.workflow_run_id
+
+    def get_state(self) -> bytes:
+        raise AssertionError("state is not required for snapshot tests")
+
+    @property
+    def resumed_at(self) -> datetime | None:
+        return None
+
+    @property
+    def paused_at(self) -> datetime:
+        return self.paused_at_value
+
+    def get_pause_reasons(self) -> Sequence[HumanInputRequired]:
+        return self.pause_reasons
+
+
+def _build_workflow_run(status: WorkflowExecutionStatus) -> WorkflowRun:
+    return WorkflowRun(
+        id="run-1",
+        tenant_id="tenant-1",
+        app_id="app-1",
+        workflow_id="workflow-1",
+        type="workflow",
+        triggered_from="app-run",
+        version="v1",
+        graph=None,
+        inputs=json.dumps({"input": "value"}),
+        status=status,
+        outputs=json.dumps({}),
+        error=None,
+        elapsed_time=0.0,
+        total_tokens=0,
+        total_steps=0,
+        created_by_role=CreatorUserRole.END_USER,
+        created_by="user-1",
+        created_at=datetime(2024, 1, 1, tzinfo=UTC),
+    )
+
+
+def _build_snapshot(status: WorkflowNodeExecutionStatus) -> WorkflowNodeExecutionSnapshot:
+    created_at = datetime(2024, 1, 1, tzinfo=UTC)
+    finished_at = datetime(2024, 1, 1, 0, 0, 5, tzinfo=UTC)
+    return WorkflowNodeExecutionSnapshot(
+        execution_id="exec-1",
+        node_id="node-1",
+        node_type="human-input",
+        title="Human Input",
+        index=1,
+        status=status.value,
+        elapsed_time=0.5,
+        created_at=created_at,
+        finished_at=finished_at,
+        iteration_id=None,
+        loop_id=None,
+    )
+
+
+def _build_resumption_context(task_id: str) -> WorkflowResumptionContext:
+    app_config = WorkflowUIBasedAppConfig(
+        tenant_id="tenant-1",
+        app_id="app-1",
+        app_mode=AppMode.WORKFLOW,
+        workflow_id="workflow-1",
+    )
+    generate_entity = WorkflowAppGenerateEntity(
+        task_id=task_id,
+        app_config=app_config,
+        inputs={},
+        files=[],
+        user_id="user-1",
+        stream=True,
+        invoke_from=InvokeFrom.EXPLORE,
+        call_depth=0,
+        workflow_execution_id="run-1",
+    )
+    runtime_state = GraphRuntimeState(variable_pool=VariablePool(), start_at=0.0)
+    runtime_state.register_paused_node("node-1")
+    runtime_state.outputs = {"result": "value"}
+    wrapper = _WorkflowGenerateEntityWrapper(entity=generate_entity)
+    return WorkflowResumptionContext(
+        generate_entity=wrapper,
+        serialized_graph_runtime_state=runtime_state.dumps(),
+    )
+
+
+class TestHitlServiceApi:
+    # Service API event-stream continuation
+    def test_workflow_events_continue_on_pause_keeps_stream_open(self, app, monkeypatch: pytest.MonkeyPatch) -> None:
+        workflow_run = SimpleNamespace(
+            id="run-1",
+            app_id="app-1",
+            created_by_role=CreatorUserRole.END_USER,
+            created_by="end-user-1",
+            finished_at=None,
+        )
+        workflow_events_module = _mock_repo_for_run(monkeypatch, workflow_run=workflow_run)
+        msg_generator = Mock()
+        msg_generator.retrieve_events.return_value = ["raw-event"]
+        workflow_generator = Mock()
+        workflow_generator.convert_to_event_stream.return_value = iter(["data: streamed\n\n"])
+        monkeypatch.setattr(workflow_events_module, "MessageGenerator", lambda: msg_generator)
+        monkeypatch.setattr(workflow_events_module, "WorkflowAppGenerator", lambda: workflow_generator)
+
+        api = WorkflowEventsApi()
+        handler = _unwrap(api.get)
+        app_model = SimpleNamespace(id="app-1", tenant_id="tenant-1", mode=AppMode.WORKFLOW.value)
+        end_user = SimpleNamespace(id="end-user-1")
+
+        with app.test_request_context("/workflow/run-1/events?user=u1&continue_on_pause=true", method="GET"):
+            response = handler(api, app_model=app_model, end_user=end_user, task_id="run-1")
+
+        assert response.get_data(as_text=True) == "data: streamed\n\n"
+        msg_generator.retrieve_events.assert_called_once_with(
+            AppMode.WORKFLOW,
+            "run-1",
+            terminal_events=["workflow_finished"],
+        )
+        workflow_generator.convert_to_event_stream.assert_called_once_with(["raw-event"])
+
+    def test_workflow_events_snapshot_continue_on_pause_keeps_pause_open(
+        self, app, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        workflow_run = SimpleNamespace(
+            id="run-1",
+            app_id="app-1",
+            created_by_role=CreatorUserRole.END_USER,
+            created_by="end-user-1",
+            finished_at=None,
+        )
+        workflow_events_module = _mock_repo_for_run(monkeypatch, workflow_run=workflow_run)
+        msg_generator = Mock()
+        workflow_generator = Mock()
+        workflow_generator.convert_to_event_stream.return_value = iter(["data: snapshot\n\n"])
+        snapshot_builder = Mock(return_value=["snapshot-events"])
+        monkeypatch.setattr(workflow_events_module, "MessageGenerator", lambda: msg_generator)
+        monkeypatch.setattr(workflow_events_module, "WorkflowAppGenerator", lambda: workflow_generator)
+        monkeypatch.setattr(workflow_events_module, "build_workflow_event_stream", snapshot_builder)
+
+        api = WorkflowEventsApi()
+        handler = _unwrap(api.get)
+        app_model = SimpleNamespace(id="app-1", tenant_id="tenant-1", mode=AppMode.WORKFLOW.value)
+        end_user = SimpleNamespace(id="end-user-1")
+
+        with app.test_request_context(
+            "/workflow/run-1/events?user=u1&include_state_snapshot=true&continue_on_pause=true",
+            method="GET",
+        ):
+            response = handler(api, app_model=app_model, end_user=end_user, task_id="run-1")
+
+        assert response.get_data(as_text=True) == "data: snapshot\n\n"
+        msg_generator.retrieve_events.assert_not_called()
+        snapshot_builder.assert_called_once_with(
+            app_mode=AppMode.WORKFLOW,
+            workflow_run=workflow_run,
+            tenant_id="tenant-1",
+            app_id="app-1",
+            session_maker=ANY,
+            close_on_pause=False,
+        )
+        workflow_generator.convert_to_event_stream.assert_called_once_with(["snapshot-events"])
+
+    def test_advanced_chat_blocking_injects_pause_state_config(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(ags_module.dify_config, "BILLING_ENABLED", False)
+        monkeypatch.setattr(ags_module, "RateLimit", _DummyRateLimit)
+
+        workflow = MagicMock()
+        workflow.created_by = "owner-id"
+        monkeypatch.setattr(AppGenerateService, "_get_workflow", lambda *args, **kwargs: workflow)
+        monkeypatch.setattr(ags_module.session_factory, "get_session_maker", lambda: "session-maker")
+
+        generator_instance = MagicMock()
+        generator_instance.generate.return_value = {"result": "advanced-blocking"}
+        generator_instance.convert_to_event_stream.side_effect = lambda payload: payload
+        monkeypatch.setattr(ags_module, "AdvancedChatAppGenerator", lambda: generator_instance)
+
+        app_model = MagicMock()
+        app_model.mode = AppMode.ADVANCED_CHAT
+        app_model.id = "app-id"
+        app_model.tenant_id = "tenant-id"
+        app_model.max_active_requests = 0
+        app_model.is_agent = False
+
+        user = MagicMock()
+        user.id = "user-id"
+
+        result = AppGenerateService.generate(
+            app_model=app_model,
+            user=user,
+            args={"workflow_id": None, "query": "hi", "inputs": {}},
+            invoke_from=InvokeFrom.SERVICE_API,
+            streaming=False,
+        )
+
+        assert result == {"result": "advanced-blocking"}
+        call_kwargs = generator_instance.generate.call_args.kwargs
+        assert call_kwargs["streaming"] is False
+        assert call_kwargs["pause_state_config"] is not None
+        assert call_kwargs["pause_state_config"].session_factory == "session-maker"
+        assert call_kwargs["pause_state_config"].state_owner_user_id == "owner-id"
+
+    # Blocking payload contract
+    def test_advanced_chat_blocking_pause_payload_contract(self) -> None:
+        from core.app.apps.advanced_chat.generate_response_converter import AdvancedChatAppGenerateResponseConverter
+
+        response = AdvancedChatAppGenerateResponseConverter.convert_blocking_full_response(
+            _build_advanced_chat_paused_blocking_response()
+        )
+
+        assert response["event"] == "workflow_paused"
+        assert response["workflow_run_id"] == "run-1"
+        assert response["answer"] == "partial"
+        assert response["data"]["reasons"][0]["type"] == PauseReasonType.HUMAN_INPUT_REQUIRED
+        assert response["data"]["reasons"][0]["expiration_time"] == 100
+        assert "human_input_forms" not in response["data"]
+
+    def test_workflow_blocking_pause_payload_contract(self) -> None:
+        from core.app.apps.workflow.generate_response_converter import WorkflowAppGenerateResponseConverter
+
+        response = WorkflowAppGenerateResponseConverter.convert_blocking_full_response(
+            _build_workflow_paused_blocking_response()
+        )
+
+        assert response["workflow_run_id"] == "r1"
+        assert response["data"]["status"] == WorkflowExecutionStatus.PAUSED
+        assert response["data"]["paused_nodes"] == ["node-1"]
+        assert response["data"]["reasons"] == [
+            {"type": "human_input_required", "form_id": "form-1", "expiration_time": 100}
+        ]
+        assert "human_input_forms" not in response["data"]
+
+    def test_advanced_chat_blocking_pipeline_pause_payload_contract(self) -> None:
+        from core.app.app_config.entities import AppAdditionalFeatures
+        from core.app.apps.advanced_chat.generate_task_pipeline import AdvancedChatAppGenerateTaskPipeline
+        from models.enums import MessageStatus
+        from models.model import EndUser
+
+        app_config = WorkflowUIBasedAppConfig(
+            tenant_id="tenant",
+            app_id="app",
+            app_mode=AppMode.ADVANCED_CHAT,
+            additional_features=AppAdditionalFeatures(),
+            variables=[],
+            workflow_id="workflow-id",
+        )
+        application_generate_entity = AdvancedChatAppGenerateEntity.model_construct(
+            task_id="task",
+            app_config=app_config,
+            inputs={},
+            query="hello",
+            files=[],
+            user_id="user",
+            stream=False,
+            invoke_from=InvokeFrom.WEB_APP,
+            extras={},
+            trace_manager=None,
+            workflow_run_id="run-id",
+        )
+        pipeline = AdvancedChatAppGenerateTaskPipeline(
+            application_generate_entity=application_generate_entity,
+            workflow=SimpleNamespace(id="workflow-id", tenant_id="tenant", features_dict={}),
+            queue_manager=SimpleNamespace(invoke_from=InvokeFrom.WEB_APP, graph_runtime_state=None),
+            conversation=SimpleNamespace(id="conv-id", mode=AppMode.ADVANCED_CHAT),
+            message=SimpleNamespace(
+                id="message-id",
+                query="hello",
+                created_at=datetime.utcnow(),
+                status=MessageStatus.NORMAL,
+                answer="",
+            ),
+            user=EndUser(tenant_id="tenant", type="session", name="tester", session_id="session"),
+            stream=False,
+            dialogue_count=1,
+            draft_var_saver_factory=lambda **kwargs: None,
+        )
+        pipeline._task_state.answer = "partial answer"
+        pipeline._workflow_run_id = "run-id"
+
+        def _gen():
+            yield HumanInputRequiredResponse(
+                task_id="task",
+                workflow_run_id="run-id",
+                data=HumanInputRequiredResponse.Data(
+                    form_id="form-1",
+                    node_id="node-1",
+                    node_title="Approval",
+                    form_content="Need approval",
+                    inputs=[],
+                    actions=[UserAction(id="approve", title="Approve")],
+                    display_in_ui=True,
+                    form_token="token-1",
+                    resolved_default_values={},
+                    expiration_time=123,
+                ),
+            )
+            yield WorkflowPauseStreamResponse(
+                task_id="task",
+                workflow_run_id="run-id",
+                data=WorkflowPauseStreamResponse.Data(
+                    workflow_run_id="run-id",
+                    paused_nodes=["node-1"],
+                    outputs={},
+                    reasons=[
+                        {
+                            "type": PauseReasonType.HUMAN_INPUT_REQUIRED,
+                            "form_id": "form-1",
+                            "node_id": "node-1",
+                            "expiration_time": 123,
+                        },
+                    ],
+                    status="paused",
+                    created_at=1,
+                    elapsed_time=0.1,
+                    total_tokens=0,
+                    total_steps=0,
+                ),
+            )
+
+        response = pipeline._to_blocking_response(_gen())
+
+        assert isinstance(response, ChatbotAppPausedBlockingResponse)
+        assert response.data.answer == "partial answer"
+        assert response.data.workflow_run_id == "run-id"
+        assert response.data.reasons[0]["form_id"] == "form-1"
+        assert response.data.reasons[0]["expiration_time"] == 123
+
+    def test_workflow_blocking_pipeline_pause_payload_contract(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        from core.app.apps.workflow import generate_task_pipeline as workflow_pipeline_module
+        from core.app.apps.workflow.generate_task_pipeline import WorkflowAppGenerateTaskPipeline
+
+        app_config = WorkflowUIBasedAppConfig(
+            tenant_id="tenant",
+            app_id="app",
+            app_mode=AppMode.WORKFLOW,
+            additional_features=AppAdditionalFeatures(),
+            variables=[],
+            workflow_id="workflow-id",
+        )
+        application_generate_entity = WorkflowAppGenerateEntity.model_construct(
+            task_id="task",
+            app_config=app_config,
+            inputs={},
+            files=[],
+            user_id="user",
+            stream=False,
+            invoke_from=InvokeFrom.WEB_APP,
+            trace_manager=None,
+            workflow_execution_id="run-id",
+            extras={},
+            call_depth=0,
+        )
+        pipeline = WorkflowAppGenerateTaskPipeline(
+            application_generate_entity=application_generate_entity,
+            workflow=SimpleNamespace(id="workflow-id", tenant_id="tenant", features_dict={}),
+            queue_manager=SimpleNamespace(invoke_from=InvokeFrom.WEB_APP, graph_runtime_state=None),
+            user=SimpleNamespace(id="user", session_id="session"),
+            stream=False,
+            draft_var_saver_factory=lambda **kwargs: None,
+        )
+        monkeypatch.setattr(workflow_pipeline_module.time, "time", lambda: 1700000000)
+
+        def _gen():
+            yield HumanInputRequiredResponse(
+                task_id="task",
+                workflow_run_id="run",
+                data=HumanInputRequiredResponse.Data(
+                    form_id="form-1",
+                    node_id="node-1",
+                    node_title="Human Input",
+                    form_content="content",
+                    expiration_time=1,
+                ),
+            )
+            yield WorkflowPauseStreamResponse(
+                task_id="task",
+                workflow_run_id="run",
+                data=WorkflowPauseStreamResponse.Data(
+                    workflow_run_id="run",
+                    status=WorkflowExecutionStatus.PAUSED,
+                    outputs={},
+                    paused_nodes=["node-1"],
+                    reasons=[{"type": "human_input_required", "form_id": "form-1", "expiration_time": 1}],
+                    created_at=1,
+                    elapsed_time=0.1,
+                    total_tokens=0,
+                    total_steps=0,
+                ),
+            )
+
+        response = pipeline._to_blocking_response(_gen())
+
+        assert isinstance(response, WorkflowAppPausedBlockingResponse)
+        assert response.data.status == WorkflowExecutionStatus.PAUSED
+        assert response.data.paused_nodes == ["node-1"]
+        assert response.data.reasons == [{"type": "human_input_required", "form_id": "form-1", "expiration_time": 1}]
+
+    def test_service_api_pause_event_serializes_hitl_reason(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        converter = _build_service_api_pause_converter()
+        converter.workflow_start_to_stream_response(
+            task_id="task",
+            workflow_run_id="run-id",
+            workflow_id="workflow-id",
+            reason=WorkflowStartReason.INITIAL,
+        )
+
+        expiration_time = datetime(2024, 1, 1, tzinfo=UTC)
+
+        class _FakeSession:
+            def execute(self, _stmt):
+                return [("form-1", expiration_time, '{"display_in_ui": true}')]
+
+            def __enter__(self):
+                return self
+
+            def __exit__(self, exc_type, exc, tb):
+                return False
+
+        monkeypatch.setattr(workflow_response_converter, "Session", lambda **_: _FakeSession())
+        monkeypatch.setattr(workflow_response_converter, "db", SimpleNamespace(engine=object()))
+        monkeypatch.setattr(
+            workflow_response_converter,
+            "load_form_tokens_by_form_id",
+            lambda form_ids, session=None: {"form-1": "token"},
+        )
+
+        reason = HumanInputRequired(
+            form_id="form-1",
+            form_content="Rendered",
+            inputs=[
+                FormInput(type=FormInputType.TEXT_INPUT, output_variable_name="field", default=None),
+            ],
+            actions=[UserAction(id="approve", title="Approve")],
+            display_in_ui=True,
+            node_id="node-id",
+            node_title="Human Step",
+            form_token="token",
+        )
+        queue_event = QueueWorkflowPausedEvent(
+            reasons=[reason],
+            outputs={"answer": "value"},
+            paused_nodes=["node-id"],
+        )
+
+        runtime_state = SimpleNamespace(total_tokens=0, node_run_steps=0)
+        responses = converter.workflow_pause_to_stream_response(
+            event=queue_event,
+            task_id="task",
+            graph_runtime_state=runtime_state,
+        )
+
+        assert isinstance(responses[-1], WorkflowPauseStreamResponse)
+        pause_resp = responses[-1]
+        assert pause_resp.workflow_run_id == "run-id"
+        assert pause_resp.data.paused_nodes == ["node-id"]
+        assert pause_resp.data.outputs == {}
+        assert pause_resp.data.reasons[0]["type"] == "human_input_required"
+        assert pause_resp.data.reasons[0]["form_id"] == "form-1"
+        assert pause_resp.data.reasons[0]["form_token"] == "token"
+        assert pause_resp.data.reasons[0]["expiration_time"] == int(expiration_time.timestamp())
+
+        assert isinstance(responses[0], HumanInputRequiredResponse)
+        hi_resp = responses[0]
+        assert hi_resp.data.form_id == "form-1"
+        assert hi_resp.data.node_id == "node-id"
+        assert hi_resp.data.node_title == "Human Step"
+        assert hi_resp.data.inputs[0].output_variable_name == "field"
+        assert hi_resp.data.actions[0].id == "approve"
+        assert hi_resp.data.display_in_ui is True
+        assert hi_resp.data.form_token == "token"
+        assert hi_resp.data.expiration_time == int(expiration_time.timestamp())
+
+    # Snapshot payload contract
+    def test_snapshot_events_include_pause_payload_contract(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        workflow_run = _build_workflow_run(WorkflowExecutionStatus.PAUSED)
+        snapshot = _build_snapshot(WorkflowNodeExecutionStatus.PAUSED)
+        resumption_context = _build_resumption_context("task-ctx")
+        monkeypatch.setattr(
+            "services.workflow_event_snapshot_service.load_form_tokens_by_form_id",
+            lambda form_ids, session=None: {"form-1": "wtok"},
+        )
+
+        class _SessionContext:
+            def __init__(self, session):
+                self._session = session
+
+            def __enter__(self):
+                return self._session
+
+            def __exit__(self, exc_type, exc, tb):
+                return False
+
+        def session_maker() -> _SessionContext:
+            return _SessionContext(
+                SimpleNamespace(
+                    execute=lambda _stmt: [("form-1", datetime(2024, 1, 1, tzinfo=UTC), '{"display_in_ui": true}')],
+                )
+            )
+
+        pause_entity = _FakePauseEntity(
+            pause_id="pause-1",
+            workflow_run_id="run-1",
+            paused_at_value=datetime(2024, 1, 1, tzinfo=UTC),
+            pause_reasons=[
+                HumanInputRequired(
+                    form_id="form-1",
+                    form_content="content",
+                    node_id="node-1",
+                    node_title="Human Input",
+                    form_token="wtok",
+                )
+            ],
+        )
+
+        events = _build_snapshot_events(
+            workflow_run=workflow_run,
+            node_snapshots=[snapshot],
+            task_id="task-ctx",
+            message_context=None,
+            pause_entity=pause_entity,
+            resumption_context=resumption_context,
+            session_maker=session_maker,
+        )
+
+        assert [event["event"] for event in events] == [
+            "workflow_started",
+            "node_started",
+            "node_finished",
+            "human_input_required",
+            "workflow_paused",
+        ]
+        assert events[2]["data"]["status"] == WorkflowNodeExecutionStatus.PAUSED.value
+        assert events[3]["data"]["form_token"] == "wtok"
+        assert events[3]["data"]["expiration_time"] == int(datetime(2024, 1, 1, tzinfo=UTC).timestamp())
+        pause_data = events[-1]["data"]
+        assert pause_data["paused_nodes"] == ["node-1"]
+        assert pause_data["outputs"] == {"result": "value"}
+        assert pause_data["reasons"][0]["type"] == "human_input_required"
+        assert pause_data["reasons"][0]["form_token"] == "wtok"
+        assert pause_data["reasons"][0]["expiration_time"] == int(datetime(2024, 1, 1, tzinfo=UTC).timestamp())
+        assert pause_data["status"] == WorkflowExecutionStatus.PAUSED.value
+        assert pause_data["created_at"] == int(workflow_run.created_at.timestamp())
+        assert pause_data["elapsed_time"] == workflow_run.elapsed_time
+        assert pause_data["total_tokens"] == workflow_run.total_tokens
+        assert pause_data["total_steps"] == workflow_run.total_steps

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

@@ -0,0 +1,184 @@
+"""Unit tests for Service API human input form endpoints."""
+
+from __future__ import annotations
+
+import json
+import sys
+from datetime import UTC, datetime
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import pytest
+from werkzeug.exceptions import NotFound
+
+from controllers.service_api.app.human_input_form import WorkflowHumanInputFormApi
+from models.human_input import RecipientType
+from tests.unit_tests.controllers.service_api.conftest import _unwrap
+
+
+class TestWorkflowHumanInputFormApi:
+    def test_get_success(self, app, monkeypatch: pytest.MonkeyPatch) -> None:
+        definition = SimpleNamespace(
+            model_dump=lambda: {
+                "rendered_content": "Rendered form content",
+                "inputs": [{"output_variable_name": "name"}],
+                "default_values": {"name": "Alice", "age": 30, "meta": {"k": "v"}},
+                "user_actions": [{"id": "approve", "title": "Approve"}],
+            }
+        )
+        form = SimpleNamespace(
+            app_id="app-1",
+            tenant_id="tenant-1",
+            recipient_type=RecipientType.STANDALONE_WEB_APP,
+            expiration_time=datetime(2099, 1, 1, tzinfo=UTC),
+            get_definition=lambda: definition,
+        )
+        service_mock = Mock()
+        service_mock.get_form_by_token.return_value = form
+        workflow_module = sys.modules["controllers.service_api.app.human_input_form"]
+        monkeypatch.setattr(workflow_module, "HumanInputService", lambda _engine: service_mock)
+        monkeypatch.setattr(workflow_module, "db", SimpleNamespace(engine=object()))
+
+        api = WorkflowHumanInputFormApi()
+        handler = _unwrap(api.get)
+        app_model = SimpleNamespace(id="app-1", tenant_id="tenant-1")
+
+        with app.test_request_context("/form/human_input/token-1", method="GET"):
+            response = handler(api, app_model=app_model, form_token="token-1")
+
+        payload = json.loads(response.get_data(as_text=True))
+        assert payload == {
+            "form_content": "Rendered form content",
+            "inputs": [{"output_variable_name": "name"}],
+            "resolved_default_values": {"name": "Alice", "age": "30", "meta": '{"k": "v"}'},
+            "user_actions": [{"id": "approve", "title": "Approve"}],
+            "expiration_time": int(form.expiration_time.timestamp()),
+        }
+        service_mock.get_form_by_token.assert_called_once_with("token-1")
+        service_mock.ensure_form_active.assert_called_once_with(form)
+
+    def test_get_form_not_in_app(self, app, monkeypatch: pytest.MonkeyPatch) -> None:
+        form = SimpleNamespace(
+            app_id="another-app",
+            tenant_id="tenant-1",
+            expiration_time=datetime(2099, 1, 1, tzinfo=UTC),
+        )
+        service_mock = Mock()
+        service_mock.get_form_by_token.return_value = form
+        workflow_module = sys.modules["controllers.service_api.app.human_input_form"]
+        monkeypatch.setattr(workflow_module, "HumanInputService", lambda _engine: service_mock)
+        monkeypatch.setattr(workflow_module, "db", SimpleNamespace(engine=object()))
+
+        api = WorkflowHumanInputFormApi()
+        handler = _unwrap(api.get)
+        app_model = SimpleNamespace(id="app-1", tenant_id="tenant-1")
+
+        with app.test_request_context("/form/human_input/token-1", method="GET"):
+            with pytest.raises(NotFound):
+                handler(api, app_model=app_model, form_token="token-1")
+
+    @pytest.mark.parametrize(
+        "recipient_type",
+        [
+            RecipientType.CONSOLE,
+            RecipientType.BACKSTAGE,
+            RecipientType.EMAIL_MEMBER,
+            RecipientType.EMAIL_EXTERNAL,
+        ],
+    )
+    def test_get_rejects_non_service_api_recipient_types(
+        self, app, monkeypatch: pytest.MonkeyPatch, recipient_type: RecipientType
+    ) -> None:
+        form = SimpleNamespace(
+            app_id="app-1",
+            tenant_id="tenant-1",
+            recipient_type=recipient_type,
+            expiration_time=datetime(2099, 1, 1, tzinfo=UTC),
+        )
+        service_mock = Mock()
+        service_mock.get_form_by_token.return_value = form
+        workflow_module = sys.modules["controllers.service_api.app.human_input_form"]
+        monkeypatch.setattr(workflow_module, "HumanInputService", lambda _engine: service_mock)
+        monkeypatch.setattr(workflow_module, "db", SimpleNamespace(engine=object()))
+
+        api = WorkflowHumanInputFormApi()
+        handler = _unwrap(api.get)
+        app_model = SimpleNamespace(id="app-1", tenant_id="tenant-1")
+
+        with app.test_request_context("/form/human_input/token-1", method="GET"):
+            with pytest.raises(NotFound):
+                handler(api, app_model=app_model, form_token="token-1")
+
+        service_mock.ensure_form_active.assert_not_called()
+
+    def test_post_success(self, app, monkeypatch: pytest.MonkeyPatch) -> None:
+        form = SimpleNamespace(
+            app_id="app-1",
+            tenant_id="tenant-1",
+            recipient_type=RecipientType.STANDALONE_WEB_APP,
+        )
+        service_mock = Mock()
+        service_mock.get_form_by_token.return_value = form
+        workflow_module = sys.modules["controllers.service_api.app.human_input_form"]
+        monkeypatch.setattr(workflow_module, "HumanInputService", lambda _engine: service_mock)
+        monkeypatch.setattr(workflow_module, "db", SimpleNamespace(engine=object()))
+
+        api = WorkflowHumanInputFormApi()
+        handler = _unwrap(api.post)
+        app_model = SimpleNamespace(id="app-1", tenant_id="tenant-1")
+        end_user = SimpleNamespace(id="end-user-1")
+
+        with app.test_request_context(
+            "/form/human_input/token-1",
+            method="POST",
+            json={"inputs": {"name": "Alice"}, "action": "approve", "user": "external-1"},
+        ):
+            response, status = handler(api, app_model=app_model, end_user=end_user, form_token="token-1")
+
+        assert response == {}
+        assert status == 200
+        service_mock.submit_form_by_token.assert_called_once_with(
+            recipient_type=RecipientType.STANDALONE_WEB_APP,
+            form_token="token-1",
+            selected_action_id="approve",
+            form_data={"name": "Alice"},
+            submission_end_user_id="end-user-1",
+        )
+
+    @pytest.mark.parametrize(
+        "recipient_type",
+        [
+            RecipientType.CONSOLE,
+            RecipientType.BACKSTAGE,
+            RecipientType.EMAIL_MEMBER,
+            RecipientType.EMAIL_EXTERNAL,
+        ],
+    )
+    def test_post_rejects_non_service_api_recipient_types(
+        self, app, monkeypatch: pytest.MonkeyPatch, recipient_type: RecipientType
+    ) -> None:
+        form = SimpleNamespace(
+            app_id="app-1",
+            tenant_id="tenant-1",
+            recipient_type=recipient_type,
+        )
+        service_mock = Mock()
+        service_mock.get_form_by_token.return_value = form
+        workflow_module = sys.modules["controllers.service_api.app.human_input_form"]
+        monkeypatch.setattr(workflow_module, "HumanInputService", lambda _engine: service_mock)
+        monkeypatch.setattr(workflow_module, "db", SimpleNamespace(engine=object()))
+
+        api = WorkflowHumanInputFormApi()
+        handler = _unwrap(api.post)
+        app_model = SimpleNamespace(id="app-1", tenant_id="tenant-1")
+        end_user = SimpleNamespace(id="end-user-1")
+
+        with app.test_request_context(
+            "/form/human_input/token-1",
+            method="POST",
+            json={"inputs": {"name": "Alice"}, "action": "approve", "user": "external-1"},
+        ):
+            with pytest.raises(NotFound):
+                handler(api, app_model=app_model, end_user=end_user, form_token="token-1")
+
+        service_mock.submit_form_by_token.assert_not_called()

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

@@ -0,0 +1,166 @@
+"""Unit tests for Service API workflow event stream endpoints."""
+
+from __future__ import annotations
+
+import json
+import sys
+from datetime import UTC, datetime
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import pytest
+from werkzeug.exceptions import NotFound
+
+from controllers.service_api.app.error import NotWorkflowAppError
+from controllers.service_api.app.workflow_events import WorkflowEventsApi
+from models.enums import CreatorUserRole
+from models.model import AppMode
+from tests.unit_tests.controllers.service_api.conftest import _unwrap
+
+
+def _mock_repo_for_run(monkeypatch: pytest.MonkeyPatch, workflow_run):
+    workflow_events_module = sys.modules["controllers.service_api.app.workflow_events"]
+    repo = SimpleNamespace(get_workflow_run_by_id_and_tenant_id=lambda **_kwargs: workflow_run)
+    monkeypatch.setattr(
+        workflow_events_module.DifyAPIRepositoryFactory,
+        "create_api_workflow_run_repository",
+        lambda *_args, **_kwargs: repo,
+    )
+    monkeypatch.setattr(workflow_events_module, "db", SimpleNamespace(engine=object()))
+    return workflow_events_module
+
+
+class TestWorkflowEventsApi:
+    def test_wrong_app_mode(self, app) -> None:
+        api = WorkflowEventsApi()
+        handler = _unwrap(api.get)
+        app_model = SimpleNamespace(mode=AppMode.CHAT.value)
+        end_user = SimpleNamespace(id="end-user-1")
+
+        with app.test_request_context("/workflow/run-1/events?user=u1", method="GET"):
+            with pytest.raises(NotWorkflowAppError):
+                handler(api, app_model=app_model, end_user=end_user, task_id="run-1")
+
+    def test_workflow_run_not_found(self, app, monkeypatch: pytest.MonkeyPatch) -> None:
+        _mock_repo_for_run(monkeypatch, workflow_run=None)
+        api = WorkflowEventsApi()
+        handler = _unwrap(api.get)
+        app_model = SimpleNamespace(id="app-1", tenant_id="tenant-1", mode=AppMode.WORKFLOW.value)
+        end_user = SimpleNamespace(id="end-user-1")
+
+        with app.test_request_context("/workflow/run-1/events?user=u1", method="GET"):
+            with pytest.raises(NotFound):
+                handler(api, app_model=app_model, end_user=end_user, task_id="run-1")
+
+    def test_workflow_run_permission_denied(self, app, monkeypatch: pytest.MonkeyPatch) -> None:
+        workflow_run = SimpleNamespace(
+            id="run-1",
+            app_id="app-1",
+            created_by_role=CreatorUserRole.ACCOUNT,
+            created_by="another-user",
+            finished_at=None,
+        )
+        _mock_repo_for_run(monkeypatch, workflow_run=workflow_run)
+        api = WorkflowEventsApi()
+        handler = _unwrap(api.get)
+        app_model = SimpleNamespace(id="app-1", tenant_id="tenant-1", mode=AppMode.WORKFLOW.value)
+        end_user = SimpleNamespace(id="end-user-1")
+
+        with app.test_request_context("/workflow/run-1/events?user=u1", method="GET"):
+            with pytest.raises(NotFound):
+                handler(api, app_model=app_model, end_user=end_user, task_id="run-1")
+
+    def test_finished_run_returns_sse(self, app, monkeypatch: pytest.MonkeyPatch) -> None:
+        workflow_run = SimpleNamespace(
+            id="run-1",
+            app_id="app-1",
+            created_by_role=CreatorUserRole.END_USER,
+            created_by="end-user-1",
+            finished_at=datetime(2099, 1, 1, tzinfo=UTC),
+        )
+        workflow_events_module = _mock_repo_for_run(monkeypatch, workflow_run=workflow_run)
+        monkeypatch.setattr(
+            workflow_events_module.WorkflowResponseConverter,
+            "workflow_run_result_to_finish_response",
+            lambda **_kwargs: SimpleNamespace(
+                model_dump=lambda mode="json": {"task_id": "run-1", "status": "succeeded"},
+                event=SimpleNamespace(value="workflow_finished"),
+            ),
+        )
+
+        api = WorkflowEventsApi()
+        handler = _unwrap(api.get)
+        app_model = SimpleNamespace(id="app-1", tenant_id="tenant-1", mode=AppMode.WORKFLOW.value)
+        end_user = SimpleNamespace(id="end-user-1")
+
+        with app.test_request_context("/workflow/run-1/events?user=u1", method="GET"):
+            response = handler(api, app_model=app_model, end_user=end_user, task_id="run-1")
+
+        assert response.mimetype == "text/event-stream"
+        body = response.get_data(as_text=True).strip()
+        assert body.startswith("data: ")
+        payload = json.loads(body[len("data: ") :])
+        assert payload["task_id"] == "run-1"
+        assert payload["event"] == "workflow_finished"
+
+    def test_running_run_streams_events(self, app, monkeypatch: pytest.MonkeyPatch) -> None:
+        workflow_run = SimpleNamespace(
+            id="run-1",
+            app_id="app-1",
+            created_by_role=CreatorUserRole.END_USER,
+            created_by="end-user-1",
+            finished_at=None,
+        )
+        workflow_events_module = _mock_repo_for_run(monkeypatch, workflow_run=workflow_run)
+        msg_generator = Mock()
+        msg_generator.retrieve_events.return_value = ["raw-event"]
+        workflow_generator = Mock()
+        workflow_generator.convert_to_event_stream.return_value = iter(["data: streamed\n\n"])
+        monkeypatch.setattr(workflow_events_module, "MessageGenerator", lambda: msg_generator)
+        monkeypatch.setattr(workflow_events_module, "WorkflowAppGenerator", lambda: workflow_generator)
+
+        api = WorkflowEventsApi()
+        handler = _unwrap(api.get)
+        app_model = SimpleNamespace(id="app-1", tenant_id="tenant-1", mode=AppMode.WORKFLOW.value)
+        end_user = SimpleNamespace(id="end-user-1")
+
+        with app.test_request_context("/workflow/run-1/events?user=u1", method="GET"):
+            response = handler(api, app_model=app_model, end_user=end_user, task_id="run-1")
+
+        assert response.get_data(as_text=True) == "data: streamed\n\n"
+        msg_generator.retrieve_events.assert_called_once_with(
+            AppMode.WORKFLOW,
+            "run-1",
+            terminal_events=None,
+        )
+        workflow_generator.convert_to_event_stream.assert_called_once_with(["raw-event"])
+
+    def test_running_run_with_snapshot(self, app, monkeypatch: pytest.MonkeyPatch) -> None:
+        workflow_run = SimpleNamespace(
+            id="run-1",
+            app_id="app-1",
+            created_by_role=CreatorUserRole.END_USER,
+            created_by="end-user-1",
+            finished_at=None,
+        )
+        workflow_events_module = _mock_repo_for_run(monkeypatch, workflow_run=workflow_run)
+        msg_generator = Mock()
+        workflow_generator = Mock()
+        workflow_generator.convert_to_event_stream.return_value = iter(["data: snapshot\n\n"])
+        snapshot_builder = Mock(return_value=["snapshot-events"])
+        monkeypatch.setattr(workflow_events_module, "MessageGenerator", lambda: msg_generator)
+        monkeypatch.setattr(workflow_events_module, "WorkflowAppGenerator", lambda: workflow_generator)
+        monkeypatch.setattr(workflow_events_module, "build_workflow_event_stream", snapshot_builder)
+
+        api = WorkflowEventsApi()
+        handler = _unwrap(api.get)
+        app_model = SimpleNamespace(id="app-1", tenant_id="tenant-1", mode=AppMode.WORKFLOW.value)
+        end_user = SimpleNamespace(id="end-user-1")
+
+        with app.test_request_context("/workflow/run-1/events?user=u1&include_state_snapshot=true", method="GET"):
+            response = handler(api, app_model=app_model, end_user=end_user, task_id="run-1")
+
+        assert response.get_data(as_text=True) == "data: snapshot\n\n"
+        msg_generator.retrieve_events.assert_not_called()
+        snapshot_builder.assert_called_once()
+        workflow_generator.convert_to_event_stream.assert_called_once_with(["snapshot-events"])

api/tests/unit_tests/controllers/service_api/dataset/test_document.py

@@ -22,8 +22,6 @@ import pytest
 from werkzeug.exceptions import Forbidden, NotFound
 
 from controllers.service_api.dataset.document import (
-    DeprecatedDocumentAddByTextApi,
-    DeprecatedDocumentUpdateByTextApi,
     DocumentAddByFileApi,
     DocumentAddByTextApi,
     DocumentApi,
@@ -1007,7 +1005,7 @@ class TestDocumentAddByTextApi:
 
         # Act
         with app.test_request_context(
-            f"/datasets/{mock_dataset.id}/document/create-by-text",
+            f"/datasets/{mock_dataset.id}/document/create_by_text",
             method="POST",
             json={
                 "name": "Test Document",
@@ -1039,7 +1037,7 @@ class TestDocumentAddByTextApi:
 
         # Act & Assert
         with app.test_request_context(
-            f"/datasets/{mock_dataset.id}/document/create-by-text",
+            f"/datasets/{mock_dataset.id}/document/create_by_text",
             method="POST",
             json={"name": "Test Document", "text": "Content"},
             headers={"Authorization": "Bearer test_token"},
@@ -1068,7 +1066,7 @@ class TestDocumentAddByTextApi:
 
         # Act & Assert
         with app.test_request_context(
-            f"/datasets/{mock_dataset.id}/document/create-by-text",
+            f"/datasets/{mock_dataset.id}/document/create_by_text",
             method="POST",
             json={"name": "Test Document", "text": "Content"},
             headers={"Authorization": "Bearer test_token"},
@@ -1095,20 +1093,6 @@ class TestArchivedDocumentImmutableError:
         assert error.code == 403
 
 
-class TestDocumentTextRouteDeprecation:
-    """Test that legacy underscore text routes stay marked deprecated."""
-
-    def test_create_by_text_legacy_alias_is_deprecated(self):
-        """Ensure only the legacy create-by-text alias is marked deprecated."""
-        assert DeprecatedDocumentAddByTextApi.post.__apidoc__["deprecated"] is True
-        assert DocumentAddByTextApi.post.__apidoc__.get("deprecated") is not True
-
-    def test_update_by_text_legacy_alias_is_deprecated(self):
-        """Ensure only the legacy update-by-text alias is marked deprecated."""
-        assert DeprecatedDocumentUpdateByTextApi.post.__apidoc__["deprecated"] is True
-        assert DocumentUpdateByTextApi.post.__apidoc__.get("deprecated") is not True
-
-
 # =============================================================================
 # Endpoint tests for DocumentUpdateByTextApi, DocumentAddByFileApi,
 # DocumentUpdateByFileApi.
@@ -1178,7 +1162,7 @@ class TestDocumentUpdateByTextApiPost:
 
         doc_id = str(uuid.uuid4())
         with app.test_request_context(
-            f"/datasets/{mock_dataset.id}/documents/{doc_id}/update-by-text",
+            f"/datasets/{mock_dataset.id}/documents/{doc_id}/update_by_text",
             method="POST",
             json={"name": "Updated Doc", "text": "New content"},
             headers={"Authorization": "Bearer test_token"},
@@ -1211,7 +1195,7 @@ class TestDocumentUpdateByTextApiPost:
 
         doc_id = str(uuid.uuid4())
         with app.test_request_context(
-            f"/datasets/{mock_dataset.id}/documents/{doc_id}/update-by-text",
+            f"/datasets/{mock_dataset.id}/documents/{doc_id}/update_by_text",
             method="POST",
             json={"name": "Doc", "text": "Content"},
             headers={"Authorization": "Bearer test_token"},

api/tests/unit_tests/core/app/app_config/features/test_additional_feature_managers.py

@@ -77,38 +77,6 @@ class TestAdditionalFeatureManagers:
             SuggestedQuestionsAfterAnswerConfigManager.validate_and_set_defaults(
                 {"suggested_questions_after_answer": {"enabled": "yes"}}
             )
-        with pytest.raises(ValueError):
-            SuggestedQuestionsAfterAnswerConfigManager.validate_and_set_defaults(
-                {"suggested_questions_after_answer": {"enabled": True, "prompt": 123}}
-            )
-        with pytest.raises(ValueError, match="must be less than or equal to 1000 characters"):
-            SuggestedQuestionsAfterAnswerConfigManager.validate_and_set_defaults(
-                {"suggested_questions_after_answer": {"enabled": True, "prompt": "a" * 1001}}
-            )
-        with pytest.raises(ValueError):
-            SuggestedQuestionsAfterAnswerConfigManager.validate_and_set_defaults(
-                {"suggested_questions_after_answer": {"enabled": True, "model": "bad"}}
-            )
-        with pytest.raises(ValueError):
-            SuggestedQuestionsAfterAnswerConfigManager.validate_and_set_defaults(
-                {"suggested_questions_after_answer": {"enabled": True, "model": {"provider": "openai"}}}
-            )
-
-        validated_config, _ = SuggestedQuestionsAfterAnswerConfigManager.validate_and_set_defaults(
-            {
-                "suggested_questions_after_answer": {
-                    "enabled": True,
-                    "prompt": "custom prompt",
-                    "model": {
-                        "provider": "openai",
-                        "name": "gpt-4o-mini",
-                        "completion_params": {"max_tokens": 1024},
-                    },
-                }
-            }
-        )
-        assert validated_config["suggested_questions_after_answer"]["prompt"] == "custom prompt"
-        assert validated_config["suggested_questions_after_answer"]["model"]["name"] == "gpt-4o-mini"
 
         assert (
             SuggestedQuestionsAfterAnswerConfigManager.convert({"suggested_questions_after_answer": {"enabled": True}})

api/tests/unit_tests/core/app/apps/advanced_chat/test_generate_response_converter.py

@@ -1,8 +1,11 @@
 from collections.abc import Generator
 
+import pytest
+
 from core.app.apps.advanced_chat.generate_response_converter import AdvancedChatAppGenerateResponseConverter
 from core.app.entities.task_entities import (
     ChatbotAppBlockingResponse,
+    ChatbotAppPausedBlockingResponse,
     ChatbotAppStreamResponse,
     ErrorStreamResponse,
     MessageEndStreamResponse,
@@ -10,7 +13,8 @@ from core.app.entities.task_entities import (
     NodeStartStreamResponse,
     PingStreamResponse,
 )
-from graphon.enums import WorkflowNodeExecutionStatus
+from graphon.entities.pause_reason import PauseReasonType
+from graphon.enums import WorkflowExecutionStatus, WorkflowNodeExecutionStatus
 
 
 class TestAdvancedChatGenerateResponseConverter:
@@ -28,6 +32,37 @@ class TestAdvancedChatGenerateResponseConverter:
         response = AdvancedChatAppGenerateResponseConverter.convert_blocking_simple_response(blocking)
         assert "usage" not in response["metadata"]
 
+    def test_blocking_full_response_derives_pause_data_from_model_dump(self, monkeypatch: pytest.MonkeyPatch):
+        data = ChatbotAppPausedBlockingResponse.Data(
+            id="msg-1",
+            mode="chat",
+            conversation_id="c1",
+            message_id="m1",
+            workflow_run_id="run-1",
+            answer="partial",
+            metadata={"usage": {"total_tokens": 1}},
+            created_at=1,
+            paused_nodes=["node-1"],
+            reasons=[{"type": PauseReasonType.HUMAN_INPUT_REQUIRED, "form_id": "form-1"}],
+            status=WorkflowExecutionStatus.PAUSED,
+            elapsed_time=0.1,
+            total_tokens=0,
+            total_steps=0,
+        )
+        original_model_dump = type(data).model_dump
+
+        def _model_dump_with_future_field(self, *args, **kwargs):
+            payload = original_model_dump(self, *args, **kwargs)
+            payload["future_field"] = "future-value"
+            return payload
+
+        monkeypatch.setattr(type(data), "model_dump", _model_dump_with_future_field)
+        blocking = ChatbotAppPausedBlockingResponse(task_id="t1", data=data)
+
+        response = AdvancedChatAppGenerateResponseConverter.convert_blocking_full_response(blocking)
+
+        assert response["data"]["future_field"] == "future-value"
+
     def test_stream_simple_response_includes_node_events(self):
         node_start = NodeStartStreamResponse(
             task_id="t1",

api/tests/unit_tests/core/app/apps/advanced_chat/test_generate_task_pipeline_core.py

@@ -41,13 +41,17 @@ from core.app.entities.queue_entities import (
 from core.app.entities.task_entities import (
     AnnotationReply,
     AnnotationReplyAccount,
+    ChatbotAppPausedBlockingResponse,
+    HumanInputRequiredResponse,
     MessageAudioStreamResponse,
     MessageEndStreamResponse,
     PingStreamResponse,
 )
 from core.base.tts.app_generator_tts_publisher import AudioTrunk
 from core.workflow.system_variables import build_system_variables
+from graphon.entities.pause_reason import PauseReasonType
 from graphon.enums import BuiltinNodeTypes
+from graphon.nodes.human_input.entities import UserAction
 from graphon.runtime import GraphRuntimeState, VariablePool
 from libs.datetime_utils import naive_utc_now
 from models.enums import MessageStatus
@@ -123,6 +127,57 @@ class TestAdvancedChatGenerateTaskPipeline:
         assert response.data.answer == "done"
         assert response.data.metadata == {"k": "v"}
 
+    def test_to_blocking_response_falls_back_to_human_input_required_when_pause_event_missing(self):
+        pipeline = _make_pipeline()
+        pipeline._task_state.answer = "partial answer"
+        pipeline._workflow_run_id = "run-id"
+        pipeline._graph_runtime_state = GraphRuntimeState(
+            variable_pool=VariablePool(system_variables=build_system_variables(workflow_execution_id="run-id")),
+            start_at=0.0,
+            total_tokens=7,
+            node_run_steps=3,
+        )
+
+        def _gen():
+            yield HumanInputRequiredResponse(
+                task_id="task",
+                workflow_run_id="run-id",
+                data=HumanInputRequiredResponse.Data(
+                    form_id="form-1",
+                    node_id="node-1",
+                    node_title="Approval",
+                    form_content="Need approval",
+                    inputs=[],
+                    actions=[UserAction(id="approve", title="Approve")],
+                    display_in_ui=True,
+                    form_token="token-1",
+                    resolved_default_values={},
+                    expiration_time=123,
+                ),
+            )
+
+        response = pipeline._to_blocking_response(_gen())
+
+        assert isinstance(response, ChatbotAppPausedBlockingResponse)
+        assert response.data.workflow_run_id == "run-id"
+        assert response.data.status == "paused"
+        assert response.data.paused_nodes == ["node-1"]
+        assert response.data.reasons == [
+            {
+                "type": PauseReasonType.HUMAN_INPUT_REQUIRED,
+                "form_id": "form-1",
+                "node_id": "node-1",
+                "node_title": "Approval",
+                "form_content": "Need approval",
+                "inputs": [],
+                "actions": [{"id": "approve", "title": "Approve", "button_style": "default"}],
+                "display_in_ui": True,
+                "form_token": "token-1",
+                "resolved_default_values": {},
+                "expiration_time": 123,
+            }
+        ]
+
     def test_handle_text_chunk_event_updates_state(self):
         pipeline = _make_pipeline()
         pipeline._message_cycle_manager = SimpleNamespace(

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

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from collections.abc import Generator
+
+from core.app.apps.base_app_generate_response_converter import AppGenerateResponseConverter
+from core.app.entities.app_invoke_entities import InvokeFrom
+from core.app.entities.task_entities import (
+    AppStreamResponse,
+    PingStreamResponse,
+    WorkflowAppBlockingResponse,
+    WorkflowAppStreamResponse,
+)
+from graphon.enums import WorkflowExecutionStatus
+
+
+class _DummyConverter(AppGenerateResponseConverter[WorkflowAppBlockingResponse]):
+    blocking_full_calls: list[WorkflowAppBlockingResponse] = []
+    blocking_simple_calls: list[WorkflowAppBlockingResponse] = []
+    stream_full_calls: list[Generator[AppStreamResponse, None, None]] = []
+    stream_simple_calls: list[Generator[AppStreamResponse, None, None]] = []
+
+    @classmethod
+    def reset(cls) -> None:
+        cls.blocking_full_calls = []
+        cls.blocking_simple_calls = []
+        cls.stream_full_calls = []
+        cls.stream_simple_calls = []
+
+    @classmethod
+    def convert_blocking_full_response(cls, blocking_response: WorkflowAppBlockingResponse) -> dict[str, object]:
+        cls.blocking_full_calls.append(blocking_response)
+        return {"kind": "blocking-full", "task_id": blocking_response.task_id}
+
+    @classmethod
+    def convert_blocking_simple_response(cls, blocking_response: WorkflowAppBlockingResponse) -> dict[str, object]:
+        cls.blocking_simple_calls.append(blocking_response)
+        return {"kind": "blocking-simple", "task_id": blocking_response.task_id}
+
+    @classmethod
+    def convert_stream_full_response(
+        cls, stream_response: Generator[AppStreamResponse, None, None]
+    ) -> Generator[dict | str, None, None]:
+        cls.stream_full_calls.append(stream_response)
+        yield {"kind": "stream-full"}
+
+    @classmethod
+    def convert_stream_simple_response(
+        cls, stream_response: Generator[AppStreamResponse, None, None]
+    ) -> Generator[dict | str, None, None]:
+        cls.stream_simple_calls.append(stream_response)
+        yield {"kind": "stream-simple"}
+
+
+def _build_blocking_response() -> WorkflowAppBlockingResponse:
+    return WorkflowAppBlockingResponse(
+        task_id="task-1",
+        workflow_run_id="run-1",
+        data=WorkflowAppBlockingResponse.Data(
+            id="run-1",
+            workflow_id="workflow-1",
+            status=WorkflowExecutionStatus.SUCCEEDED,
+            outputs={"ok": True},
+            error=None,
+            elapsed_time=0.1,
+            total_tokens=0,
+            total_steps=1,
+            created_at=1,
+            finished_at=2,
+        ),
+    )
+
+
+def _build_stream_response() -> Generator[AppStreamResponse, None, None]:
+    yield WorkflowAppStreamResponse(
+        workflow_run_id="run-1",
+        stream_response=PingStreamResponse(task_id="task-1"),
+    )
+
+
+def test_convert_routes_blocking_response_by_invoke_from() -> None:
+    _DummyConverter.reset()
+    blocking_response = _build_blocking_response()
+
+    full_result = _DummyConverter.convert(blocking_response, InvokeFrom.SERVICE_API)
+    simple_result = _DummyConverter.convert(blocking_response, InvokeFrom.WEB_APP)
+
+    assert full_result == {"kind": "blocking-full", "task_id": "task-1"}
+    assert simple_result == {"kind": "blocking-simple", "task_id": "task-1"}
+    assert _DummyConverter.blocking_full_calls == [blocking_response]
+    assert _DummyConverter.blocking_simple_calls == [blocking_response]
+
+
+def test_convert_routes_stream_response_by_invoke_from() -> None:
+    _DummyConverter.reset()
+
+    full_result = list(_DummyConverter.convert(_build_stream_response(), InvokeFrom.SERVICE_API))
+    simple_result = list(_DummyConverter.convert(_build_stream_response(), InvokeFrom.WEB_APP))
+
+    assert full_result == [{"kind": "stream-full"}]
+    assert simple_result == [{"kind": "stream-simple"}]
+    assert len(_DummyConverter.stream_full_calls) == 1
+    assert len(_DummyConverter.stream_simple_calls) == 1

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

@@ -1,6 +1,7 @@
 from unittest.mock import Mock, patch
 
 from core.app.apps.message_generator import MessageGenerator
+from core.app.entities.task_entities import StreamEvent
 from models.model import AppMode
 
 
@@ -23,7 +24,21 @@ class TestMessageGenerator:
                 "core.app.apps.message_generator.stream_topic_events", return_value=iter([{"event": "ping"}])
             ) as mock_stream,
         ):
-            events = list(MessageGenerator.retrieve_events(AppMode.WORKFLOW, "run-1", idle_timeout=1, ping_interval=2))
+            events = list(
+                MessageGenerator.retrieve_events(
+                    AppMode.WORKFLOW,
+                    "run-1",
+                    idle_timeout=1,
+                    ping_interval=2,
+                    terminal_events=[StreamEvent.WORKFLOW_FINISHED.value],
+                )
+            )
 
         assert events == [{"event": "ping"}]
-        mock_stream.assert_called_once()
+        mock_stream.assert_called_once_with(
+            topic="topic",
+            idle_timeout=1,
+            ping_interval=2,
+            on_subscribe=None,
+            terminal_events=[StreamEvent.WORKFLOW_FINISHED.value],
+        )

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

@@ -106,3 +106,21 @@ def test_stream_topic_events_emits_ping_and_idle_timeout(monkeypatch):
     assert next(generator) == StreamEvent.PING.value
     # next receive yields None -> ping interval triggers
     assert next(generator) == StreamEvent.PING.value
+
+
+def test_stream_topic_events_can_continue_past_pause():
+    topic = FakeTopic()
+    topic.publish(json.dumps({"event": StreamEvent.WORKFLOW_PAUSED.value}).encode())
+    topic.publish(json.dumps({"event": StreamEvent.WORKFLOW_FINISHED.value}).encode())
+
+    generator = stream_topic_events(
+        topic=topic,
+        idle_timeout=1.0,
+        terminal_events=[StreamEvent.WORKFLOW_FINISHED.value],
+    )
+
+    assert next(generator) == StreamEvent.PING.value
+    assert next(generator)["event"] == StreamEvent.WORKFLOW_PAUSED.value
+    assert next(generator)["event"] == StreamEvent.WORKFLOW_FINISHED.value
+    with pytest.raises(StopIteration):
+        next(generator)

api/tests/unit_tests/core/app/apps/workflow/test_generate_task_pipeline_core.py

@@ -7,6 +7,7 @@ from unittest.mock import MagicMock
 import pytest
 
 from core.app.app_config.entities import AppAdditionalFeatures, WorkflowUIBasedAppConfig
+from core.app.apps.workflow import generate_task_pipeline as workflow_pipeline_module
 from core.app.apps.workflow.generate_task_pipeline import WorkflowAppGenerateTaskPipeline
 from core.app.entities.app_invoke_entities import InvokeFrom, WorkflowAppGenerateEntity
 from core.app.entities.queue_entities import (
@@ -36,11 +37,12 @@ from core.app.entities.queue_entities import (
 )
 from core.app.entities.task_entities import (
     ErrorStreamResponse,
+    HumanInputRequiredResponse,
     MessageAudioEndStreamResponse,
     MessageAudioStreamResponse,
     PingStreamResponse,
+    WorkflowAppPausedBlockingResponse,
     WorkflowFinishStreamResponse,
-    WorkflowPauseStreamResponse,
     WorkflowStartStreamResponse,
 )
 from core.base.tts.app_generator_tts_publisher import AudioTrunk
@@ -91,27 +93,51 @@ def _make_pipeline():
 
 
 class TestWorkflowGenerateTaskPipeline:
-    def test_to_blocking_response_handles_pause(self):
+    def test_to_blocking_response_falls_back_to_human_input_required_when_pause_event_missing(self, monkeypatch):
         pipeline = _make_pipeline()
+        pipeline._graph_runtime_state = GraphRuntimeState(
+            variable_pool=VariablePool(system_variables=build_system_variables(workflow_execution_id="run-id")),
+            start_at=0.0,
+            total_tokens=5,
+            node_run_steps=2,
+        )
+        monkeypatch.setattr(workflow_pipeline_module.time, "time", lambda: 1700000000)
 
         def _gen():
-            yield WorkflowPauseStreamResponse(
+            yield HumanInputRequiredResponse(
                 task_id="task",
-                workflow_run_id="run",
-                data=WorkflowPauseStreamResponse.Data(
-                    workflow_run_id="run",
-                    status=WorkflowExecutionStatus.PAUSED,
-                    outputs={},
-                    created_at=1,
-                    elapsed_time=0.1,
-                    total_tokens=0,
-                    total_steps=0,
+                workflow_run_id="run-id",
+                data=HumanInputRequiredResponse.Data(
+                    form_id="form-1",
+                    node_id="node-1",
+                    node_title="Human Input",
+                    form_content="content",
+                    expiration_time=1,
                 ),
             )
 
         response = pipeline._to_blocking_response(_gen())
 
+        assert isinstance(response, WorkflowAppPausedBlockingResponse)
+        assert response.workflow_run_id == "run-id"
         assert response.data.status == WorkflowExecutionStatus.PAUSED
+        assert response.data.created_at == 1700000000
+        assert response.data.paused_nodes == ["node-1"]
+        assert response.data.reasons == [
+            {
+                "type": "human_input_required",
+                "form_id": "form-1",
+                "node_id": "node-1",
+                "node_title": "Human Input",
+                "form_content": "content",
+                "inputs": [],
+                "actions": [],
+                "display_in_ui": False,
+                "form_token": None,
+                "resolved_default_values": {},
+                "expiration_time": 1,
+            }
+        ]
 
     def test_to_blocking_response_handles_finish(self):
         pipeline = _make_pipeline()

api/tests/unit_tests/core/llm_generator/test_llm_generator.py

@@ -6,12 +6,7 @@ import pytest
 from core.app.app_config.entities import ModelConfig
 from core.llm_generator.entities import RuleCodeGeneratePayload, RuleGeneratePayload, RuleStructuredOutputPayload
 from core.llm_generator.llm_generator import LLMGenerator
-from core.llm_generator.prompts import (
-    DEFAULT_SUGGESTED_QUESTIONS_MAX_TOKENS,
-    DEFAULT_SUGGESTED_QUESTIONS_TEMPERATURE,
-)
 from graphon.model_runtime.entities.llm_entities import LLMMode, LLMResult
-from graphon.model_runtime.entities.model_entities import ModelType
 from graphon.model_runtime.errors.invoke import InvokeAuthorizationError, InvokeError
 
 
@@ -101,10 +96,6 @@ class TestLLMGenerator:
         questions = LLMGenerator.generate_suggested_questions_after_answer("tenant_id", "histories")
         assert len(questions) == 2
         assert questions[0] == "Question 1?"
-        assert mock_model_instance.invoke_llm.call_args.kwargs["model_parameters"] == {
-            "max_tokens": DEFAULT_SUGGESTED_QUESTIONS_MAX_TOKENS,
-            "temperature": DEFAULT_SUGGESTED_QUESTIONS_TEMPERATURE,
-        }
 
     def test_generate_suggested_questions_after_answer_auth_error(self, mock_model_instance):
         with patch("core.llm_generator.llm_generator.ModelManager.for_tenant") as mock_manager:
@@ -122,97 +113,6 @@ class TestLLMGenerator:
         questions = LLMGenerator.generate_suggested_questions_after_answer("tenant_id", "histories")
         assert questions == []
 
-    @patch("core.llm_generator.llm_generator.ModelManager.for_tenant")
-    def test_generate_suggested_questions_after_answer_with_custom_model_and_prompt(self, mock_for_tenant):
-        custom_model_instance = MagicMock()
-        custom_response = MagicMock()
-        custom_response.message.get_text_content.return_value = '["Question 1?"]'
-        custom_model_instance.invoke_llm.return_value = custom_response
-
-        mock_for_tenant.return_value.get_model_instance.return_value = custom_model_instance
-
-        questions = LLMGenerator.generate_suggested_questions_after_answer(
-            "tenant_id",
-            "histories",
-            instruction_prompt="custom prompt",
-            model_config={
-                "provider": "openai",
-                "name": "gpt-4o",
-                "completion_params": {"temperature": 0.2},
-            },
-        )
-
-        assert questions == ["Question 1?"]
-        mock_for_tenant.return_value.get_model_instance.assert_called_once_with(
-            tenant_id="tenant_id",
-            model_type=ModelType.LLM,
-            provider="openai",
-            model="gpt-4o",
-        )
-
-        invoke_kwargs = custom_model_instance.invoke_llm.call_args.kwargs
-        assert invoke_kwargs["model_parameters"] == {"temperature": 0.2}
-        assert invoke_kwargs["stop"] == []
-        assert "custom prompt" in invoke_kwargs["prompt_messages"][0].content
-
-    @patch("core.llm_generator.llm_generator.ModelManager.for_tenant")
-    def test_generate_suggested_questions_after_answer_fallback_to_default_model(self, mock_for_tenant):
-        default_model_instance = MagicMock()
-        default_response = MagicMock()
-        default_response.message.get_text_content.return_value = '["Question 1?"]'
-        default_model_instance.invoke_llm.return_value = default_response
-
-        mock_for_tenant.return_value.get_model_instance.side_effect = ValueError("invalid configured model")
-        mock_for_tenant.return_value.get_default_model_instance.return_value = default_model_instance
-
-        questions = LLMGenerator.generate_suggested_questions_after_answer(
-            "tenant_id",
-            "histories",
-            model_config={
-                "provider": "openai",
-                "name": "not-found-model",
-                "completion_params": {"temperature": 0.2},
-            },
-        )
-
-        assert questions == ["Question 1?"]
-        mock_for_tenant.return_value.get_default_model_instance.assert_called_once_with(
-            tenant_id="tenant_id",
-            model_type=ModelType.LLM,
-        )
-        assert default_model_instance.invoke_llm.call_args.kwargs["model_parameters"] == {
-            "max_tokens": DEFAULT_SUGGESTED_QUESTIONS_MAX_TOKENS,
-            "temperature": DEFAULT_SUGGESTED_QUESTIONS_TEMPERATURE,
-        }
-        assert default_model_instance.invoke_llm.call_args.kwargs["stop"] == []
-
-    @patch("core.llm_generator.llm_generator.ModelManager.for_tenant")
-    def test_generate_suggested_questions_after_answer_drops_non_positive_max_tokens(self, mock_for_tenant):
-        custom_model_instance = MagicMock()
-        custom_response = MagicMock()
-        custom_response.message.get_text_content.return_value = '["Question 1?"]'
-        custom_model_instance.invoke_llm.return_value = custom_response
-        mock_for_tenant.return_value.get_model_instance.return_value = custom_model_instance
-
-        questions = LLMGenerator.generate_suggested_questions_after_answer(
-            "tenant_id",
-            "histories",
-            model_config={
-                "provider": "openai",
-                "name": "gpt-4o",
-                "completion_params": {
-                    "temperature": 0.2,
-                    "max_tokens": 0,
-                    "stop": ["END"],
-                },
-            },
-        )
-
-        assert questions == ["Question 1?"]
-        invoke_kwargs = custom_model_instance.invoke_llm.call_args.kwargs
-        assert invoke_kwargs["model_parameters"] == {"temperature": 0.2}
-        assert invoke_kwargs["stop"] == ["END"]
-
     def test_generate_rule_config_no_variable_success(self, mock_model_instance, model_config_entity):
         payload = RuleGeneratePayload(
             instruction="test instruction", model_config=model_config_entity, no_variable=True

api/tests/unit_tests/core/test_provider_manager.py

@@ -372,78 +372,6 @@ def test_get_configurations_binds_manager_runtime_to_provider_configuration(
     provider_configuration.bind_model_runtime.assert_called_once_with(manager._model_runtime)
 
 
-def test_get_configurations_reuses_cached_result_for_same_tenant(mocker: MockerFixture, mock_provider_entity):
-    manager = _build_provider_manager(mocker)
-    provider_configuration = Mock()
-    provider_factory = Mock()
-    provider_factory.get_providers.return_value = [mock_provider_entity]
-    custom_configuration = SimpleNamespace(provider=None, models=[])
-    system_configuration = SimpleNamespace(enabled=False, quota_configurations=[], current_quota_type=None)
-
-    with (
-        patch.object(manager, "_get_all_providers", return_value={"openai": []}) as mock_get_all_providers,
-        patch.object(manager, "_init_trial_provider_records", return_value={"openai": []}),
-        patch.object(manager, "_get_all_provider_models", return_value={"openai": []}),
-        patch.object(manager, "_get_all_preferred_model_providers", return_value={}),
-        patch.object(manager, "_get_all_provider_model_settings", return_value={}),
-        patch.object(manager, "_get_all_provider_load_balancing_configs", return_value={}),
-        patch.object(manager, "_get_all_provider_model_credentials", return_value={}),
-        patch.object(manager, "_to_custom_configuration", return_value=custom_configuration),
-        patch.object(manager, "_to_system_configuration", return_value=system_configuration),
-        patch.object(manager, "_to_model_settings", return_value=[]),
-        patch("core.provider_manager.ModelProviderFactory", return_value=provider_factory) as mock_factory_cls,
-        patch(
-            "core.provider_manager.ProviderConfiguration",
-            return_value=provider_configuration,
-        ) as mock_provider_configuration,
-    ):
-        first = manager.get_configurations("tenant-id")
-        second = manager.get_configurations("tenant-id")
-
-    assert first is second
-    mock_get_all_providers.assert_called_once_with("tenant-id")
-    mock_factory_cls.assert_called_once_with(model_runtime=manager._model_runtime)
-    mock_provider_configuration.assert_called_once()
-    provider_configuration.bind_model_runtime.assert_called_once_with(manager._model_runtime)
-
-
-def test_clear_configurations_cache_rebuilds_requested_tenant(mocker: MockerFixture, mock_provider_entity):
-    manager = _build_provider_manager(mocker)
-    provider_factory = Mock()
-    provider_factory.get_providers.return_value = [mock_provider_entity]
-    custom_configuration = SimpleNamespace(provider=None, models=[])
-    system_configuration = SimpleNamespace(enabled=False, quota_configurations=[], current_quota_type=None)
-    provider_configuration_first = Mock()
-    provider_configuration_second = Mock()
-
-    with (
-        patch.object(manager, "_get_all_providers", return_value={"openai": []}) as mock_get_all_providers,
-        patch.object(manager, "_init_trial_provider_records", return_value={"openai": []}),
-        patch.object(manager, "_get_all_provider_models", return_value={"openai": []}),
-        patch.object(manager, "_get_all_preferred_model_providers", return_value={}),
-        patch.object(manager, "_get_all_provider_model_settings", return_value={}),
-        patch.object(manager, "_get_all_provider_load_balancing_configs", return_value={}),
-        patch.object(manager, "_get_all_provider_model_credentials", return_value={}),
-        patch.object(manager, "_to_custom_configuration", return_value=custom_configuration),
-        patch.object(manager, "_to_system_configuration", return_value=system_configuration),
-        patch.object(manager, "_to_model_settings", return_value=[]),
-        patch("core.provider_manager.ModelProviderFactory", return_value=provider_factory),
-        patch(
-            "core.provider_manager.ProviderConfiguration",
-            side_effect=[provider_configuration_first, provider_configuration_second],
-        ) as mock_provider_configuration,
-    ):
-        first = manager.get_configurations("tenant-id")
-        manager.clear_configurations_cache("tenant-id")
-        second = manager.get_configurations("tenant-id")
-
-    assert first is not second
-    assert mock_get_all_providers.call_count == 2
-    assert mock_provider_configuration.call_count == 2
-    provider_configuration_first.bind_model_runtime.assert_called_once_with(manager._model_runtime)
-    provider_configuration_second.bind_model_runtime.assert_called_once_with(manager._model_runtime)
-
-
 def test_get_provider_model_bundle_returns_selected_model_type_instance(mocker: MockerFixture):
     manager = _build_provider_manager(mocker)
     provider_configuration = Mock()

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

@@ -1,5 +1,6 @@
 from types import SimpleNamespace
 
+from core.workflow.human_input_forms import _load_form_tokens_by_form_id
 from core.workflow.human_input_forms import load_form_tokens_by_form_id
 from models.human_input import RecipientType
 
@@ -53,3 +54,22 @@ def test_load_form_tokens_by_form_id_ignores_unsupported_recipients() -> None:
     )
 
     assert load_form_tokens_by_form_id(["form-1"], session=session) == {}
+
+
+def test_load_form_tokens_by_form_id_uses_shared_priority() -> None:
+    session = _FakeSession(
+        recipients=[
+            SimpleNamespace(
+                form_id="form-1",
+                recipient_type=RecipientType.STANDALONE_WEB_APP,
+                access_token="web-token",
+            ),
+            SimpleNamespace(
+                form_id="form-1",
+                recipient_type=RecipientType.CONSOLE,
+                access_token="console-token",
+            ),
+        ]
+    )
+
+    assert _load_form_tokens_by_form_id(session, ["form-1"]) == {"form-1": "console-token"}

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

@@ -0,0 +1,50 @@
+from core.workflow.human_input_policy import (
+    HumanInputSurface,
+    get_preferred_form_token,
+    is_recipient_type_allowed_for_surface,
+)
+from models.human_input import RecipientType
+
+
+def test_service_api_only_allows_public_webapp_forms() -> None:
+    assert is_recipient_type_allowed_for_surface(
+        RecipientType.STANDALONE_WEB_APP,
+        HumanInputSurface.SERVICE_API,
+    )
+    assert not is_recipient_type_allowed_for_surface(
+        RecipientType.CONSOLE,
+        HumanInputSurface.SERVICE_API,
+    )
+    assert not is_recipient_type_allowed_for_surface(
+        RecipientType.BACKSTAGE,
+        HumanInputSurface.SERVICE_API,
+    )
+    assert not is_recipient_type_allowed_for_surface(
+        RecipientType.EMAIL_MEMBER,
+        HumanInputSurface.SERVICE_API,
+    )
+
+
+def test_console_only_allows_internal_console_surfaces() -> None:
+    assert is_recipient_type_allowed_for_surface(
+        RecipientType.CONSOLE,
+        HumanInputSurface.CONSOLE,
+    )
+    assert is_recipient_type_allowed_for_surface(
+        RecipientType.BACKSTAGE,
+        HumanInputSurface.CONSOLE,
+    )
+    assert not is_recipient_type_allowed_for_surface(
+        RecipientType.STANDALONE_WEB_APP,
+        HumanInputSurface.CONSOLE,
+    )
+
+
+def test_preferred_form_token_uses_shared_priority_order() -> None:
+    recipients = [
+        (RecipientType.STANDALONE_WEB_APP, "web-token"),
+        (RecipientType.CONSOLE, "console-token"),
+        (RecipientType.BACKSTAGE, "backstage-token"),
+    ]
+
+    assert get_preferred_form_token(recipients) == "backstage-token"

api/tests/unit_tests/repositories/test_sqlalchemy_api_workflow_run_repository.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from types import SimpleNamespace
+
+from graphon.nodes.human_input.entities import FormDefinition, FormInput, UserAction
+from graphon.nodes.human_input.enums import FormInputType
+from models.human_input import RecipientType
+from repositories.sqlalchemy_api_workflow_run_repository import _build_human_input_required_reason
+
+
+def _build_form_model() -> SimpleNamespace:
+    expiration_time = datetime(2024, 1, 1, tzinfo=UTC)
+    definition = FormDefinition(
+        form_content="content",
+        inputs=[FormInput(type=FormInputType.TEXT_INPUT, output_variable_name="name")],
+        user_actions=[UserAction(id="approve", title="Approve")],
+        rendered_content="rendered",
+        expiration_time=expiration_time,
+        default_values={"name": "Alice"},
+        node_title="Ask Name",
+        display_in_ui=True,
+    )
+    return SimpleNamespace(
+        id="form-1",
+        node_id="node-1",
+        form_definition=definition.model_dump_json(),
+        expiration_time=expiration_time,
+    )
+
+
+def _build_reason_model() -> SimpleNamespace:
+    return SimpleNamespace(form_id="form-1", node_id="node-1")
+
+
+def test_build_human_input_required_reason_prefers_standalone_web_app_token() -> None:
+    reason = _build_human_input_required_reason(
+        _build_reason_model(),
+        _build_form_model(),
+        [
+            SimpleNamespace(recipient_type=RecipientType.BACKSTAGE, access_token="btok"),
+            SimpleNamespace(recipient_type=RecipientType.CONSOLE, access_token="ctok"),
+            SimpleNamespace(recipient_type=RecipientType.STANDALONE_WEB_APP, access_token="wtok"),
+        ],
+    )
+
+    assert reason.node_title == "Ask Name"
+    assert reason.resolved_default_values == {"name": "Alice"}
+    assert not hasattr(reason, "form_token")
+
+
+def test_build_human_input_required_reason_falls_back_to_console_token() -> None:
+    reason = _build_human_input_required_reason(
+        _build_reason_model(),
+        _build_form_model(),
+        [
+            SimpleNamespace(recipient_type=RecipientType.BACKSTAGE, access_token="btok"),
+            SimpleNamespace(recipient_type=RecipientType.CONSOLE, access_token="ctok"),
+        ],
+    )
+
+    assert reason.node_id == "node-1"
+    assert reason.actions[0].id == "approve"
+    assert not hasattr(reason, "form_token")

api/tests/unit_tests/services/test_app_generate_service.py

@@ -327,7 +327,8 @@ class TestGenerate:
             streaming=False,
         )
         assert result == {"result": "advanced-blocking"}
-        assert gen_spy.call_args.kwargs.get("streaming") is False
+        call_kwargs = gen_spy.call_args.kwargs
+        assert call_kwargs.get("streaming") is False
         retrieve_spy.assert_not_called()
 
     # -- ADVANCED_CHAT streaming --------------------------------------------

api/tests/unit_tests/services/test_message_service.py

@@ -3,7 +3,6 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 
-from graphon.model_runtime.entities.model_entities import ModelType
 from libs.infinite_scroll_pagination import InfiniteScrollPagination
 from models.enums import FeedbackFromSource, FeedbackRating
 from models.model import App, AppMode, EndUser, Message
@@ -932,130 +931,6 @@ class TestMessageServiceSuggestedQuestions:
         assert result == ["Q1?"]
         mock_llm_gen.generate_suggested_questions_after_answer.assert_called_once()
 
-    @patch("services.message_service.db")
-    @patch("services.message_service.ModelManager.for_tenant")
-    @patch("services.message_service.TokenBufferMemory")
-    @patch("services.message_service.LLMGenerator")
-    @patch("services.message_service.TraceQueueManager")
-    @patch.object(MessageService, "get_message")
-    @patch("services.message_service.ConversationService")
-    def test_get_suggested_questions_chat_app_uses_frontend_model_and_prompt(
-        self,
-        mock_conversation_service,
-        mock_get_message,
-        mock_trace_manager,
-        mock_llm_gen,
-        mock_memory,
-        mock_model_manager,
-        mock_db,
-        factory,
-    ):
-        """Test suggested question generation uses frontend configured model and prompt."""
-        from core.app.entities.app_invoke_entities import InvokeFrom
-
-        app = factory.create_app_mock(mode=AppMode.CHAT.value)
-        app.tenant_id = "tenant-123"
-        user = factory.create_end_user_mock()
-        message = factory.create_message_mock()
-        mock_get_message.return_value = message
-
-        conversation = MagicMock()
-        conversation.override_model_configs = None
-        mock_conversation_service.get_conversation.return_value = conversation
-
-        app_model_config = MagicMock()
-        app_model_config.suggested_questions_after_answer_dict = {
-            "enabled": True,
-            "prompt": "custom prompt",
-            "model": {
-                "provider": "openai",
-                "name": "gpt-4o-mini",
-                "completion_params": {"max_tokens": 2048, "temperature": 0.1},
-            },
-        }
-        mock_db.session.scalar.return_value = app_model_config
-
-        mock_memory.return_value.get_history_prompt_text.return_value = "histories"
-        mock_llm_gen.generate_suggested_questions_after_answer.return_value = ["Q1?"]
-
-        result = MessageService.get_suggested_questions_after_answer(
-            app_model=app,
-            user=user,
-            message_id="msg-123",
-            invoke_from=InvokeFrom.WEB_APP,
-        )
-
-        assert result == ["Q1?"]
-        mock_model_manager.return_value.get_default_model_instance.assert_called_once_with(
-            tenant_id="tenant-123",
-            model_type=ModelType.LLM,
-        )
-        mock_memory.assert_called_once_with(
-            conversation=conversation,
-            model_instance=mock_model_manager.return_value.get_default_model_instance.return_value,
-        )
-        mock_llm_gen.generate_suggested_questions_after_answer.assert_called_once_with(
-            tenant_id="tenant-123",
-            histories="histories",
-            instruction_prompt="custom prompt",
-            model_config={
-                "provider": "openai",
-                "name": "gpt-4o-mini",
-                "completion_params": {"max_tokens": 2048, "temperature": 0.1},
-            },
-        )
-
-    @patch("services.message_service.db")
-    @patch("services.message_service.ModelManager.for_tenant")
-    @patch("services.message_service.TokenBufferMemory")
-    @patch("services.message_service.LLMGenerator")
-    @patch("services.message_service.TraceQueueManager")
-    @patch.object(MessageService, "get_message")
-    @patch("services.message_service.ConversationService")
-    def test_get_suggested_questions_chat_app_invalid_frontend_model_fallback_to_default(
-        self,
-        mock_conversation_service,
-        mock_get_message,
-        mock_trace_manager,
-        mock_llm_gen,
-        mock_memory,
-        mock_model_manager,
-        mock_db,
-        factory,
-    ):
-        """Test invalid frontend configured model falls back to tenant default model."""
-        app = factory.create_app_mock(mode=AppMode.CHAT.value)
-        app.tenant_id = "tenant-123"
-        user = factory.create_end_user_mock()
-        message = factory.create_message_mock()
-        mock_get_message.return_value = message
-
-        conversation = MagicMock()
-        conversation.override_model_configs = None
-        mock_conversation_service.get_conversation.return_value = conversation
-
-        app_model_config = MagicMock()
-        app_model_config.suggested_questions_after_answer_dict = {
-            "enabled": True,
-            "model": {"provider": "openai", "name": "invalid-model"},
-        }
-        mock_db.session.scalar.return_value = app_model_config
-
-        mock_model_manager.return_value.get_model_instance.side_effect = ValueError("invalid model")
-        mock_memory.return_value.get_history_prompt_text.return_value = "histories"
-        mock_llm_gen.generate_suggested_questions_after_answer.return_value = ["Q1?"]
-
-        result = MessageService.get_suggested_questions_after_answer(
-            app_model=app, user=user, message_id="msg-123", invoke_from=MagicMock()
-        )
-
-        assert result == ["Q1?"]
-        mock_model_manager.return_value.get_default_model_instance.assert_called_once_with(
-            tenant_id="tenant-123",
-            model_type=ModelType.LLM,
-        )
-        mock_model_manager.return_value.get_model_instance.assert_not_called()
-
     # Test 30: get_suggested_questions_after_answer - Disabled Error
     @patch("services.message_service.WorkflowService")
     @patch("services.message_service.AdvancedChatAppConfigManager")

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

@@ -1,14 +1,20 @@
 import json
 import queue
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from datetime import UTC, datetime
+from itertools import cycle
 from threading import Event
+from types import SimpleNamespace
+from typing import Any, cast
+from unittest.mock import MagicMock
 
 import pytest
+from sqlalchemy.orm import Session, sessionmaker
 
 from core.app.app_config.entities import WorkflowUIBasedAppConfig
 from core.app.entities.app_invoke_entities import InvokeFrom, WorkflowAppGenerateEntity
+from core.app.entities.task_entities import StreamEvent
 from core.app.layers.pause_state_persist_layer import WorkflowResumptionContext, _WorkflowGenerateEntityWrapper
 from graphon.entities.pause_reason import HumanInputRequired
 from graphon.enums import WorkflowExecutionStatus, WorkflowNodeExecutionStatus
@@ -18,11 +24,14 @@ from models.model import AppMode
 from models.workflow import WorkflowRun
 from repositories.api_workflow_node_execution_repository import WorkflowNodeExecutionSnapshot
 from repositories.entities.workflow_pause import WorkflowPauseEntity
+from services import workflow_event_snapshot_service as service_module
 from services.workflow_event_snapshot_service import (
     BufferState,
     MessageContext,
     _build_snapshot_events,
+    _is_terminal_event,
     _resolve_task_id,
+    build_workflow_event_stream,
 )
 
 
@@ -125,50 +134,6 @@ def _build_resumption_context(task_id: str) -> WorkflowResumptionContext:
     )
 
 
-def test_build_snapshot_events_includes_pause_event() -> None:
-    workflow_run = _build_workflow_run(WorkflowExecutionStatus.PAUSED)
-    snapshot = _build_snapshot(WorkflowNodeExecutionStatus.PAUSED)
-    resumption_context = _build_resumption_context("task-ctx")
-    pause_entity = _FakePauseEntity(
-        pause_id="pause-1",
-        workflow_run_id="run-1",
-        paused_at_value=datetime(2024, 1, 1, tzinfo=UTC),
-        pause_reasons=[
-            HumanInputRequired(
-                form_id="form-1",
-                form_content="content",
-                node_id="node-1",
-                node_title="Human Input",
-            )
-        ],
-    )
-
-    events = _build_snapshot_events(
-        workflow_run=workflow_run,
-        node_snapshots=[snapshot],
-        task_id="task-ctx",
-        message_context=None,
-        pause_entity=pause_entity,
-        resumption_context=resumption_context,
-    )
-
-    assert [event["event"] for event in events] == [
-        "workflow_started",
-        "node_started",
-        "node_finished",
-        "workflow_paused",
-    ]
-    assert events[2]["data"]["status"] == WorkflowNodeExecutionStatus.PAUSED.value
-    pause_data = events[-1]["data"]
-    assert pause_data["paused_nodes"] == ["node-1"]
-    assert pause_data["outputs"] == {"result": "value"}
-    assert pause_data["status"] == WorkflowExecutionStatus.PAUSED.value
-    assert pause_data["created_at"] == int(workflow_run.created_at.timestamp())
-    assert pause_data["elapsed_time"] == workflow_run.elapsed_time
-    assert pause_data["total_tokens"] == workflow_run.total_tokens
-    assert pause_data["total_steps"] == workflow_run.total_steps
-
-
 def test_build_snapshot_events_applies_message_context() -> None:
     workflow_run = _build_workflow_run(WorkflowExecutionStatus.RUNNING)
     snapshot = _build_snapshot(WorkflowNodeExecutionStatus.SUCCEEDED)
@@ -222,3 +187,658 @@ def test_resolve_task_id_priority(context_task_id, buffered_task_id, expected) -
         buffer_state.task_id_ready.set()
     task_id = _resolve_task_id(resumption_context, buffer_state, "run-1", wait_timeout=0.0)
     assert task_id == expected
+
+
+def _build_workflow_run_additional(status: WorkflowExecutionStatus = WorkflowExecutionStatus.RUNNING) -> WorkflowRun:
+    return WorkflowRun(
+        id="run-1",
+        tenant_id="tenant-1",
+        app_id="app-1",
+        workflow_id="workflow-1",
+        type="workflow",
+        triggered_from="app-run",
+        version="v1",
+        graph=None,
+        inputs=json.dumps({"query": "hello"}),
+        status=status,
+        outputs=json.dumps({}),
+        error=None,
+        elapsed_time=1.2,
+        total_tokens=5,
+        total_steps=2,
+        created_by_role=CreatorUserRole.END_USER,
+        created_by="user-1",
+        created_at=datetime(2024, 1, 1, tzinfo=UTC),
+    )
+
+
+def _build_resumption_context_additional(task_id: str) -> WorkflowResumptionContext:
+    app_config = WorkflowUIBasedAppConfig(
+        tenant_id="tenant-1",
+        app_id="app-1",
+        app_mode=AppMode.WORKFLOW,
+        workflow_id="workflow-1",
+    )
+    generate_entity = WorkflowAppGenerateEntity(
+        task_id=task_id,
+        app_config=app_config,
+        inputs={},
+        files=[],
+        user_id="user-1",
+        stream=True,
+        invoke_from=InvokeFrom.EXPLORE,
+        call_depth=0,
+        workflow_execution_id="run-1",
+    )
+    runtime_state = GraphRuntimeState(variable_pool=VariablePool(), start_at=0.0)
+    runtime_state.outputs = {"answer": "ok"}
+    wrapper = _WorkflowGenerateEntityWrapper(entity=generate_entity)
+    return WorkflowResumptionContext(
+        generate_entity=wrapper,
+        serialized_graph_runtime_state=runtime_state.dumps(),
+    )
+
+
+class _SessionContext:
+    def __init__(self, session: Any) -> None:
+        self._session = session
+
+    def __enter__(self) -> Any:
+        return self._session
+
+    def __exit__(self, exc_type: Any, exc: Any, tb: Any) -> bool:
+        return False
+
+
+class _SessionMaker:
+    def __init__(self, session: Any) -> None:
+        self._session = session
+
+    def __call__(self) -> _SessionContext:
+        return _SessionContext(self._session)
+
+
+class _SubscriptionContext:
+    def __init__(self, subscription: Any) -> None:
+        self._subscription = subscription
+
+    def __enter__(self) -> Any:
+        return self._subscription
+
+    def __exit__(self, exc_type: Any, exc: Any, tb: Any) -> bool:
+        return False
+
+
+class _Topic:
+    def __init__(self, subscription: Any) -> None:
+        self._subscription = subscription
+
+    def subscribe(self) -> _SubscriptionContext:
+        return _SubscriptionContext(self._subscription)
+
+
+class _StaticSubscription:
+    def receive(self, timeout: int = 1) -> None:
+        return None
+
+
+@dataclass(frozen=True)
+class _PauseEntity(WorkflowPauseEntity):
+    state: bytes
+
+    @property
+    def id(self) -> str:
+        return "pause-1"
+
+    @property
+    def workflow_execution_id(self) -> str:
+        return "run-1"
+
+    @property
+    def resumed_at(self) -> datetime | None:
+        return None
+
+    @property
+    def paused_at(self) -> datetime:
+        return datetime(2024, 1, 1, tzinfo=UTC)
+
+    def get_state(self) -> bytes:
+        return self.state
+
+    def get_pause_reasons(self) -> list[Any]:
+        return []
+
+
+def test_get_message_context_should_return_none_when_no_message() -> None:
+    # Arrange
+    session = SimpleNamespace(scalar=MagicMock(return_value=None))
+    session_maker = _SessionMaker(session)
+
+    # Act
+    result = service_module._get_message_context(cast(sessionmaker[Session], session_maker), "run-1")
+
+    # Assert
+    assert result is None
+
+
+def test_get_message_context_should_default_created_at_to_zero_when_message_has_no_timestamp() -> None:
+    # Arrange
+    message = SimpleNamespace(
+        id="msg-1",
+        conversation_id="conv-1",
+        created_at=None,
+        answer="answer",
+    )
+    session = SimpleNamespace(scalar=MagicMock(return_value=message))
+    session_maker = _SessionMaker(session)
+
+    # Act
+    result = service_module._get_message_context(cast(sessionmaker[Session], session_maker), "run-1")
+
+    # Assert
+    assert result is not None
+    assert result.created_at == 0
+    assert result.message_id == "msg-1"
+    assert result.conversation_id == "conv-1"
+    assert result.answer == "answer"
+
+
+def test_load_resumption_context_should_return_none_when_pause_entity_missing() -> None:
+    # Arrange
+
+    # Act
+    result = service_module._load_resumption_context(None)
+
+    # Assert
+    assert result is None
+
+
+def test_load_resumption_context_should_return_none_when_pause_entity_state_is_invalid() -> None:
+    # Arrange
+    pause_entity = _PauseEntity(state=b"not-a-valid-state")
+
+    # Act
+    result = service_module._load_resumption_context(pause_entity)
+
+    # Assert
+    assert result is None
+
+
+def test_load_resumption_context_should_parse_valid_state_into_context() -> None:
+    # Arrange
+    context = _build_resumption_context_additional(task_id="task-ctx")
+    pause_entity = _PauseEntity(state=context.dumps().encode())
+
+    # Act
+    result = service_module._load_resumption_context(pause_entity)
+
+    # Assert
+    assert result is not None
+    assert result.get_generate_entity().task_id == "task-ctx"
+
+
+def test_resolve_task_id_should_return_workflow_run_id_when_buffer_state_is_missing() -> None:
+    # Arrange
+
+    # Act
+    result = service_module._resolve_task_id(
+        resumption_context=None,
+        buffer_state=None,
+        workflow_run_id="run-1",
+    )
+
+    # Assert
+    assert result == "run-1"
+
+
+@pytest.mark.parametrize(
+    ("payload", "expected"),
+    [
+        (b'{"event":"node_started"}', {"event": "node_started"}),
+        (b"invalid-json", None),
+        (b"[]", None),
+    ],
+)
+def test_parse_event_message_should_parse_only_json_object(
+    payload: bytes,
+    expected: dict[str, Any] | None,
+) -> None:
+    # Arrange
+
+    # Act
+    result = service_module._parse_event_message(payload)
+
+    # Assert
+    assert result == expected
+
+
+def test_is_terminal_event_should_recognize_finished_and_optional_paused_events() -> None:
+    # Arrange
+    finished_event = {"event": StreamEvent.WORKFLOW_FINISHED.value}
+    paused_event = {"event": StreamEvent.WORKFLOW_PAUSED.value}
+
+    # Act
+    is_finished = service_module._is_terminal_event(finished_event, close_on_pause=False)
+    paused_without_flag = service_module._is_terminal_event(paused_event, close_on_pause=False)
+    paused_with_flag = service_module._is_terminal_event(paused_event, close_on_pause=True)
+
+    # Assert
+    assert is_finished is True
+    assert paused_without_flag is False
+    assert paused_with_flag is True
+    assert service_module._is_terminal_event(StreamEvent.PING.value, close_on_pause=True) is False
+
+
+def test_apply_message_context_should_update_payload_when_context_exists() -> None:
+    # Arrange
+    payload: dict[str, Any] = {"event": "workflow_started"}
+    context = MessageContext(conversation_id="conv-1", message_id="msg-1", created_at=1700000000)
+
+    # Act
+    service_module._apply_message_context(payload, context)
+
+    # Assert
+    assert payload["conversation_id"] == "conv-1"
+    assert payload["message_id"] == "msg-1"
+    assert payload["created_at"] == 1700000000
+
+
+def test_start_buffering_should_capture_task_id_and_enqueue_event() -> None:
+    # Arrange
+    class Subscription:
+        def __init__(self) -> None:
+            self._calls = 0
+
+        def receive(self, timeout: int = 1) -> bytes | None:
+            self._calls += 1
+            if self._calls == 1:
+                return b'{"event":"node_started","task_id":"task-1"}'
+            return None
+
+    subscription = Subscription()
+
+    # Act
+    buffer_state = service_module._start_buffering(subscription)
+    ready = buffer_state.task_id_ready.wait(timeout=1)
+    event = buffer_state.queue.get(timeout=1)
+    buffer_state.stop_event.set()
+    finished = buffer_state.done_event.wait(timeout=1)
+
+    # Assert
+    assert ready is True
+    assert finished is True
+    assert buffer_state.task_id_hint == "task-1"
+    assert event["event"] == "node_started"
+
+
+def test_start_buffering_should_drop_old_event_when_queue_is_full(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # Arrange
+    class QueueWithSingleFull:
+        def __init__(self) -> None:
+            self._first_put = True
+            self.items: list[dict[str, Any]] = [{"event": "old"}]
+
+        def put_nowait(self, item: dict[str, Any]) -> None:
+            if self._first_put:
+                self._first_put = False
+                raise queue.Full
+            self.items.append(item)
+
+        def get_nowait(self) -> dict[str, Any]:
+            if not self.items:
+                raise queue.Empty
+            return self.items.pop(0)
+
+        def empty(self) -> bool:
+            return len(self.items) == 0
+
+    fake_queue = QueueWithSingleFull()
+    monkeypatch.setattr(service_module.queue, "Queue", lambda maxsize=2048: fake_queue)
+
+    class Subscription:
+        def __init__(self) -> None:
+            self._calls = 0
+
+        def receive(self, timeout: int = 1) -> bytes | None:
+            self._calls += 1
+            if self._calls == 1:
+                return b'{"event":"node_started","task_id":"task-2"}'
+            return None
+
+    subscription = Subscription()
+
+    # Act
+    buffer_state = service_module._start_buffering(subscription)
+    ready = buffer_state.task_id_ready.wait(timeout=1)
+    buffer_state.stop_event.set()
+    finished = buffer_state.done_event.wait(timeout=1)
+
+    # Assert
+    assert ready is True
+    assert finished is True
+    assert fake_queue.items[-1]["task_id"] == "task-2"
+
+
+def test_start_buffering_should_set_done_event_when_subscription_raises() -> None:
+    # Arrange
+    class Subscription:
+        def receive(self, timeout: int = 1) -> bytes | None:
+            raise RuntimeError("subscription failure")
+
+    subscription = Subscription()
+
+    # Act
+    buffer_state = service_module._start_buffering(subscription)
+    finished = buffer_state.done_event.wait(timeout=1)
+
+    # Assert
+    assert finished is True
+
+
+def test_build_workflow_event_stream_should_emit_ping_and_terminal_snapshot_event(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # Arrange
+    workflow_run = _build_workflow_run_additional(status=WorkflowExecutionStatus.RUNNING)
+    topic = _Topic(_StaticSubscription())
+    workflow_run_repo = SimpleNamespace(get_workflow_pause=MagicMock())
+    node_repo = SimpleNamespace(get_execution_snapshots_by_workflow_run=MagicMock(return_value=[]))
+    factory = SimpleNamespace(
+        create_api_workflow_run_repository=MagicMock(return_value=workflow_run_repo),
+        create_api_workflow_node_execution_repository=MagicMock(return_value=node_repo),
+    )
+    monkeypatch.setattr(service_module, "DifyAPIRepositoryFactory", factory)
+    monkeypatch.setattr(service_module.MessageGenerator, "get_response_topic", MagicMock(return_value=topic))
+    monkeypatch.setattr(
+        service_module,
+        "_get_message_context",
+        MagicMock(return_value=MessageContext("conv-1", "msg-1", 1700000000)),
+    )
+    monkeypatch.setattr(service_module, "_load_resumption_context", MagicMock(return_value=None))
+    buffer_state = BufferState(
+        queue=queue.Queue(),
+        stop_event=Event(),
+        done_event=Event(),
+        task_id_ready=Event(),
+        task_id_hint="task-1",
+    )
+    monkeypatch.setattr(service_module, "_start_buffering", MagicMock(return_value=buffer_state))
+    monkeypatch.setattr(service_module, "_resolve_task_id", MagicMock(return_value="task-1"))
+    monkeypatch.setattr(
+        service_module,
+        "_build_snapshot_events",
+        MagicMock(return_value=[{"event": StreamEvent.WORKFLOW_FINISHED.value, "task_id": "task-1"}]),
+    )
+
+    # Act
+    events = list(
+        build_workflow_event_stream(
+            app_mode=AppMode.ADVANCED_CHAT,
+            workflow_run=workflow_run,
+            tenant_id="tenant-1",
+            app_id="app-1",
+            session_maker=MagicMock(),
+        )
+    )
+
+    # Assert
+    assert events[0] == StreamEvent.PING.value
+    finished_event = cast(Mapping[str, Any], events[1])
+    assert finished_event["event"] == StreamEvent.WORKFLOW_FINISHED.value
+    assert buffer_state.stop_event.is_set() is True
+    node_repo.get_execution_snapshots_by_workflow_run.assert_called_once()
+    called_kwargs = node_repo.get_execution_snapshots_by_workflow_run.call_args.kwargs
+    assert called_kwargs["workflow_run_id"] == "run-1"
+
+
+def test_build_workflow_event_stream_should_emit_periodic_ping_and_stop_after_idle_timeout(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # Arrange
+    workflow_run = _build_workflow_run_additional(status=WorkflowExecutionStatus.RUNNING)
+    topic = _Topic(_StaticSubscription())
+    workflow_run_repo = SimpleNamespace(get_workflow_pause=MagicMock())
+    node_repo = SimpleNamespace(get_execution_snapshots_by_workflow_run=MagicMock(return_value=[]))
+    factory = SimpleNamespace(
+        create_api_workflow_run_repository=MagicMock(return_value=workflow_run_repo),
+        create_api_workflow_node_execution_repository=MagicMock(return_value=node_repo),
+    )
+    monkeypatch.setattr(service_module, "DifyAPIRepositoryFactory", factory)
+    monkeypatch.setattr(service_module.MessageGenerator, "get_response_topic", MagicMock(return_value=topic))
+    monkeypatch.setattr(service_module, "_load_resumption_context", MagicMock(return_value=None))
+    monkeypatch.setattr(service_module, "_build_snapshot_events", MagicMock(return_value=[]))
+    monkeypatch.setattr(service_module, "_resolve_task_id", MagicMock(return_value="task-1"))
+
+    class AlwaysEmptyQueue:
+        def empty(self) -> bool:
+            return False
+
+        def get(self, timeout: int = 1) -> None:
+            raise queue.Empty
+
+    buffer_state = BufferState(
+        queue=AlwaysEmptyQueue(),  # type: ignore[arg-type]
+        stop_event=Event(),
+        done_event=Event(),
+        task_id_ready=Event(),
+        task_id_hint="task-1",
+    )
+    monkeypatch.setattr(service_module, "_start_buffering", MagicMock(return_value=buffer_state))
+    time_values = cycle([0.0, 6.0, 21.0, 26.0])
+    monkeypatch.setattr(service_module.time, "time", lambda: next(time_values))
+
+    # Act
+    events = list(
+        build_workflow_event_stream(
+            app_mode=AppMode.WORKFLOW,
+            workflow_run=workflow_run,
+            tenant_id="tenant-1",
+            app_id="app-1",
+            session_maker=MagicMock(),
+            idle_timeout=20.0,
+            ping_interval=5.0,
+        )
+    )
+
+    # Assert
+    assert events == [StreamEvent.PING.value, StreamEvent.PING.value]
+    assert buffer_state.stop_event.is_set() is True
+
+
+def test_build_workflow_event_stream_should_exit_when_buffer_done_and_empty(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # Arrange
+    workflow_run = _build_workflow_run_additional(status=WorkflowExecutionStatus.RUNNING)
+    topic = _Topic(_StaticSubscription())
+    workflow_run_repo = SimpleNamespace(get_workflow_pause=MagicMock())
+    node_repo = SimpleNamespace(get_execution_snapshots_by_workflow_run=MagicMock(return_value=[]))
+    factory = SimpleNamespace(
+        create_api_workflow_run_repository=MagicMock(return_value=workflow_run_repo),
+        create_api_workflow_node_execution_repository=MagicMock(return_value=node_repo),
+    )
+    monkeypatch.setattr(service_module, "DifyAPIRepositoryFactory", factory)
+    monkeypatch.setattr(service_module.MessageGenerator, "get_response_topic", MagicMock(return_value=topic))
+    monkeypatch.setattr(service_module, "_load_resumption_context", MagicMock(return_value=None))
+    monkeypatch.setattr(service_module, "_build_snapshot_events", MagicMock(return_value=[]))
+    monkeypatch.setattr(service_module, "_resolve_task_id", MagicMock(return_value="task-1"))
+    buffer_state = BufferState(
+        queue=queue.Queue(),
+        stop_event=Event(),
+        done_event=Event(),
+        task_id_ready=Event(),
+        task_id_hint="task-1",
+    )
+    buffer_state.done_event.set()
+    monkeypatch.setattr(service_module, "_start_buffering", MagicMock(return_value=buffer_state))
+
+    # Act
+    events = list(
+        build_workflow_event_stream(
+            app_mode=AppMode.WORKFLOW,
+            workflow_run=workflow_run,
+            tenant_id="tenant-1",
+            app_id="app-1",
+            session_maker=MagicMock(),
+        )
+    )
+
+    # Assert
+    assert events == [StreamEvent.PING.value]
+    assert buffer_state.stop_event.is_set() is True
+
+
+def test_build_workflow_event_stream_should_continue_when_pause_loading_fails(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # Arrange
+    workflow_run = _build_workflow_run_additional(status=WorkflowExecutionStatus.PAUSED)
+    topic = _Topic(_StaticSubscription())
+    workflow_run_repo = SimpleNamespace(get_workflow_pause=MagicMock(side_effect=RuntimeError("boom")))
+    node_repo = SimpleNamespace(get_execution_snapshots_by_workflow_run=MagicMock(return_value=[]))
+    factory = SimpleNamespace(
+        create_api_workflow_run_repository=MagicMock(return_value=workflow_run_repo),
+        create_api_workflow_node_execution_repository=MagicMock(return_value=node_repo),
+    )
+    monkeypatch.setattr(service_module, "DifyAPIRepositoryFactory", factory)
+    monkeypatch.setattr(service_module.MessageGenerator, "get_response_topic", MagicMock(return_value=topic))
+    monkeypatch.setattr(service_module, "_load_resumption_context", MagicMock(return_value=None))
+    monkeypatch.setattr(service_module, "_resolve_task_id", MagicMock(return_value="task-1"))
+    snapshot_builder = MagicMock(return_value=[{"event": StreamEvent.WORKFLOW_FINISHED.value}])
+    monkeypatch.setattr(service_module, "_build_snapshot_events", snapshot_builder)
+    buffer_state = BufferState(
+        queue=queue.Queue(),
+        stop_event=Event(),
+        done_event=Event(),
+        task_id_ready=Event(),
+        task_id_hint="task-1",
+    )
+    monkeypatch.setattr(service_module, "_start_buffering", MagicMock(return_value=buffer_state))
+
+    # Act
+    events = list(
+        build_workflow_event_stream(
+            app_mode=AppMode.WORKFLOW,
+            workflow_run=workflow_run,
+            tenant_id="tenant-1",
+            app_id="app-1",
+            session_maker=MagicMock(),
+        )
+    )
+
+    # Assert
+    assert events[0] == StreamEvent.PING.value
+    assert snapshot_builder.call_args.kwargs["pause_entity"] is None
+
+
+def test_is_terminal_event_respects_close_on_pause_flag() -> None:
+    pause_event = {"event": "workflow_paused"}
+    finish_event = {"event": "workflow_finished"}
+
+    assert _is_terminal_event(pause_event, close_on_pause=True) is True
+    assert _is_terminal_event(pause_event, close_on_pause=False) is False
+    assert _is_terminal_event(finish_event, close_on_pause=False) is True
+
+
+def test_build_snapshot_events_preserves_public_form_token(monkeypatch: pytest.MonkeyPatch) -> None:
+    workflow_run = _build_workflow_run(WorkflowExecutionStatus.PAUSED)
+    snapshot = _build_snapshot(WorkflowNodeExecutionStatus.PAUSED)
+    resumption_context = _build_resumption_context("task-ctx")
+    monkeypatch.setattr(
+        service_module, "load_form_tokens_by_form_id", lambda form_ids, session=None: {"form-1": "wtok"}
+    )
+    session_maker = _SessionMaker(
+        SimpleNamespace(
+            execute=lambda _stmt: [("form-1", datetime(2024, 1, 1, tzinfo=UTC), '{"display_in_ui": true}')],
+        )
+    )
+    pause_entity = _FakePauseEntity(
+        pause_id="pause-1",
+        workflow_run_id="run-1",
+        paused_at_value=datetime(2024, 1, 1, tzinfo=UTC),
+        pause_reasons=[
+            HumanInputRequired(
+                form_id="form-1",
+                form_content="content",
+                node_id="node-1",
+                node_title="Human Input",
+                form_token="wtok",
+            )
+        ],
+    )
+
+    events = _build_snapshot_events(
+        workflow_run=workflow_run,
+        node_snapshots=[snapshot],
+        task_id="task-ctx",
+        message_context=None,
+        pause_entity=pause_entity,
+        resumption_context=resumption_context,
+        session_maker=cast(sessionmaker[Session], session_maker),
+    )
+
+    assert events[-2]["event"] == StreamEvent.HUMAN_INPUT_REQUIRED.value
+    assert events[-2]["data"]["form_token"] == "wtok"
+    assert events[-2]["data"]["expiration_time"] == int(datetime(2024, 1, 1, tzinfo=UTC).timestamp())
+    pause_data = events[-1]["data"]
+    assert pause_data["reasons"][0]["form_token"] == "wtok"
+    assert pause_data["reasons"][0]["expiration_time"] == int(datetime(2024, 1, 1, tzinfo=UTC).timestamp())
+
+
+def test_build_workflow_event_stream_loads_pause_tokens_without_flask_app_context(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    workflow_run = _build_workflow_run_additional(status=WorkflowExecutionStatus.PAUSED)
+    topic = _Topic(_StaticSubscription())
+    pause_entity = _FakePauseEntity(
+        pause_id="pause-1",
+        workflow_run_id="run-1",
+        paused_at_value=datetime(2024, 1, 1, tzinfo=UTC),
+        pause_reasons=[
+            HumanInputRequired(
+                form_id="form-1",
+                form_content="content",
+                node_id="node-1",
+                node_title="Human Input",
+            )
+        ],
+    )
+    workflow_run_repo = SimpleNamespace(get_workflow_pause=MagicMock(return_value=pause_entity))
+    node_repo = SimpleNamespace(get_execution_snapshots_by_workflow_run=MagicMock(return_value=[]))
+    factory = SimpleNamespace(
+        create_api_workflow_run_repository=MagicMock(return_value=workflow_run_repo),
+        create_api_workflow_node_execution_repository=MagicMock(return_value=node_repo),
+    )
+    monkeypatch.setattr(service_module, "DifyAPIRepositoryFactory", factory)
+    monkeypatch.setattr(service_module.MessageGenerator, "get_response_topic", MagicMock(return_value=topic))
+    monkeypatch.setattr(
+        service_module, "_load_resumption_context", MagicMock(return_value=_build_resumption_context("task-1"))
+    )
+    monkeypatch.setattr(
+        service_module, "load_form_tokens_by_form_id", lambda form_ids, session=None: {"form-1": "wtok"}
+    )
+
+    session = SimpleNamespace(
+        scalar=MagicMock(return_value=None),
+        execute=lambda _stmt: [("form-1", datetime(2024, 1, 1, tzinfo=UTC), '{"display_in_ui": true}')],
+    )
+    session_maker = _SessionMaker(session)
+
+    events = list(
+        build_workflow_event_stream(
+            app_mode=AppMode.WORKFLOW,
+            workflow_run=workflow_run,
+            tenant_id="tenant-1",
+            app_id="app-1",
+            session_maker=cast(sessionmaker[Session], session_maker),
+        )
+    )
+
+    pause_event = cast(Mapping[str, Any], events[-1])
+    assert pause_event["event"] == StreamEvent.WORKFLOW_PAUSED.value
+    assert pause_event["data"]["reasons"][0]["form_token"] == "wtok"
+    assert pause_event["data"]["reasons"][0]["expiration_time"] == int(
+        datetime(2024, 1, 1, tzinfo=UTC).timestamp()
+    )

api/tests/unit_tests/tasks/test_workflow_execute_task.py

@@ -7,11 +7,16 @@ from unittest.mock import MagicMock
 
 import pytest
 
-from core.app.entities.app_invoke_entities import AdvancedChatAppGenerateEntity, InvokeFrom
+from core.app.entities.app_invoke_entities import AdvancedChatAppGenerateEntity, InvokeFrom, WorkflowAppGenerateEntity
 from models.enums import CreatorUserRole
 from models.model import App, AppMode, Conversation
 from models.workflow import Workflow, WorkflowRun
-from tasks.app_generate.workflow_execute_task import _publish_streaming_response, _resume_app_execution
+from tasks.app_generate.workflow_execute_task import (
+    _publish_streaming_response,
+    _resume_advanced_chat,
+    _resume_app_execution,
+    _resume_workflow,
+)
 
 
 class _FakeSessionContext:
@@ -38,12 +43,28 @@ def _build_advanced_chat_generate_entity(conversation_id: str | None) -> Advance
     )
 
 
+def _build_workflow_generate_entity(stream: bool) -> WorkflowAppGenerateEntity:
+    return WorkflowAppGenerateEntity(
+        task_id="task-id",
+        inputs={},
+        files=[],
+        user_id="user-id",
+        stream=stream,
+        invoke_from=InvokeFrom.WEB_APP,
+        workflow_execution_id="workflow-run-id",
+    )
+
+
+def _single_event_generator(payload):
+    yield payload
+
+
 @pytest.fixture
-def mock_topic(mocker) -> MagicMock:
+def mock_topic(monkeypatch: pytest.MonkeyPatch) -> MagicMock:
     topic = MagicMock()
-    mocker.patch(
+    monkeypatch.setattr(
         "tasks.app_generate.workflow_execute_task.MessageBasedAppGenerator.get_response_topic",
-        return_value=topic,
+        lambda *_args, **_kwargs: topic,
     )
     return topic
 
@@ -67,31 +88,35 @@ def test_publish_streaming_response_coerces_string_uuid(mock_topic: MagicMock):
     mock_topic.publish.assert_called_once_with(json.dumps({"event": "bar"}).encode())
 
 
-def test_resume_app_execution_queries_message_by_conversation_and_workflow_run(mocker):
+def test_resume_app_execution_queries_message_by_conversation_and_workflow_run(monkeypatch: pytest.MonkeyPatch):
     workflow_run_id = "run-id"
     conversation_id = "conversation-id"
     message = MagicMock()
 
-    mocker.patch("tasks.app_generate.workflow_execute_task.db", SimpleNamespace(engine=object()))
+    monkeypatch.setattr("tasks.app_generate.workflow_execute_task.db", SimpleNamespace(engine=object()))
 
     pause_entity = MagicMock()
     pause_entity.get_state.return_value = b"state"
 
     workflow_run_repo = MagicMock()
     workflow_run_repo.get_workflow_pause.return_value = pause_entity
-    mocker.patch(
+    monkeypatch.setattr(
         "tasks.app_generate.workflow_execute_task.DifyAPIRepositoryFactory.create_api_workflow_run_repository",
-        return_value=workflow_run_repo,
+        lambda *_args, **_kwargs: workflow_run_repo,
     )
 
     generate_entity = _build_advanced_chat_generate_entity(conversation_id)
     resumption_context = MagicMock()
     resumption_context.serialized_graph_runtime_state = "{}"
     resumption_context.get_generate_entity.return_value = generate_entity
-    mocker.patch(
-        "tasks.app_generate.workflow_execute_task.WorkflowResumptionContext.loads", return_value=resumption_context
+    monkeypatch.setattr(
+        "tasks.app_generate.workflow_execute_task.WorkflowResumptionContext.loads",
+        lambda *_args, **_kwargs: resumption_context,
+    )
+    monkeypatch.setattr(
+        "tasks.app_generate.workflow_execute_task.GraphRuntimeState.from_snapshot",
+        lambda *_args, **_kwargs: MagicMock(),
     )
-    mocker.patch("tasks.app_generate.workflow_execute_task.GraphRuntimeState.from_snapshot", return_value=MagicMock())
 
     workflow_run = SimpleNamespace(
         workflow_id="wf-id",
@@ -120,10 +145,15 @@ def test_resume_app_execution_queries_message_by_conversation_and_workflow_run(m
     session.get.side_effect = _session_get
     session.scalar.return_value = message
 
-    mocker.patch("tasks.app_generate.workflow_execute_task.Session", return_value=_FakeSessionContext(session))
-    mocker.patch("tasks.app_generate.workflow_execute_task._resolve_user_for_run", return_value=MagicMock())
-    resume_advanced_chat = mocker.patch("tasks.app_generate.workflow_execute_task._resume_advanced_chat")
-    mocker.patch("tasks.app_generate.workflow_execute_task._resume_workflow")
+    monkeypatch.setattr(
+        "tasks.app_generate.workflow_execute_task.Session", lambda *_args, **_kwargs: _FakeSessionContext(session)
+    )
+    monkeypatch.setattr(
+        "tasks.app_generate.workflow_execute_task._resolve_user_for_run", lambda *_args, **_kwargs: MagicMock()
+    )
+    resume_advanced_chat = MagicMock()
+    monkeypatch.setattr("tasks.app_generate.workflow_execute_task._resume_advanced_chat", resume_advanced_chat)
+    monkeypatch.setattr("tasks.app_generate.workflow_execute_task._resume_workflow", MagicMock())
 
     _resume_app_execution({"workflow_run_id": workflow_run_id})
 
@@ -144,29 +174,35 @@ def test_resume_app_execution_queries_message_by_conversation_and_workflow_run(m
     assert resume_advanced_chat.call_args.kwargs["message"] is message
 
 
-def test_resume_app_execution_returns_early_when_advanced_chat_missing_conversation_id(mocker):
+def test_resume_app_execution_returns_early_when_advanced_chat_missing_conversation_id(
+    monkeypatch: pytest.MonkeyPatch,
+):
     workflow_run_id = "run-id"
 
-    mocker.patch("tasks.app_generate.workflow_execute_task.db", SimpleNamespace(engine=object()))
+    monkeypatch.setattr("tasks.app_generate.workflow_execute_task.db", SimpleNamespace(engine=object()))
 
     pause_entity = MagicMock()
     pause_entity.get_state.return_value = b"state"
 
     workflow_run_repo = MagicMock()
     workflow_run_repo.get_workflow_pause.return_value = pause_entity
-    mocker.patch(
+    monkeypatch.setattr(
         "tasks.app_generate.workflow_execute_task.DifyAPIRepositoryFactory.create_api_workflow_run_repository",
-        return_value=workflow_run_repo,
+        lambda *_args, **_kwargs: workflow_run_repo,
     )
 
     generate_entity = _build_advanced_chat_generate_entity(conversation_id=None)
     resumption_context = MagicMock()
     resumption_context.serialized_graph_runtime_state = "{}"
     resumption_context.get_generate_entity.return_value = generate_entity
-    mocker.patch(
-        "tasks.app_generate.workflow_execute_task.WorkflowResumptionContext.loads", return_value=resumption_context
+    monkeypatch.setattr(
+        "tasks.app_generate.workflow_execute_task.WorkflowResumptionContext.loads",
+        lambda *_args, **_kwargs: resumption_context,
+    )
+    monkeypatch.setattr(
+        "tasks.app_generate.workflow_execute_task.GraphRuntimeState.from_snapshot",
+        lambda *_args, **_kwargs: MagicMock(),
     )
-    mocker.patch("tasks.app_generate.workflow_execute_task.GraphRuntimeState.from_snapshot", return_value=MagicMock())
 
     workflow_run = SimpleNamespace(
         workflow_id="wf-id",
@@ -191,12 +227,107 @@ def test_resume_app_execution_returns_early_when_advanced_chat_missing_conversat
 
     session.get.side_effect = _session_get
 
-    mocker.patch("tasks.app_generate.workflow_execute_task.Session", return_value=_FakeSessionContext(session))
-    mocker.patch("tasks.app_generate.workflow_execute_task._resolve_user_for_run", return_value=MagicMock())
-    resume_advanced_chat = mocker.patch("tasks.app_generate.workflow_execute_task._resume_advanced_chat")
+    monkeypatch.setattr(
+        "tasks.app_generate.workflow_execute_task.Session", lambda *_args, **_kwargs: _FakeSessionContext(session)
+    )
+    monkeypatch.setattr(
+        "tasks.app_generate.workflow_execute_task._resolve_user_for_run", lambda *_args, **_kwargs: MagicMock()
+    )
+    resume_advanced_chat = MagicMock()
+    monkeypatch.setattr("tasks.app_generate.workflow_execute_task._resume_advanced_chat", resume_advanced_chat)
 
     _resume_app_execution({"workflow_run_id": workflow_run_id})
 
     session.scalar.assert_not_called()
     workflow_run_repo.resume_workflow_pause.assert_not_called()
     resume_advanced_chat.assert_not_called()
+
+
+def test_resume_advanced_chat_publishes_events_for_originally_blocking_runs(monkeypatch: pytest.MonkeyPatch):
+    generate_entity = _build_advanced_chat_generate_entity(conversation_id="conversation-id")
+    generate_entity.stream = False
+
+    generator_instance = MagicMock()
+    response_stream = _single_event_generator({"event": "message"})
+    generator_instance.resume.return_value = response_stream
+    monkeypatch.setattr(
+        "tasks.app_generate.workflow_execute_task.AdvancedChatAppGenerator",
+        lambda: generator_instance,
+    )
+
+    publish_streaming_response = MagicMock()
+    monkeypatch.setattr(
+        "tasks.app_generate.workflow_execute_task._publish_streaming_response", publish_streaming_response
+    )
+    monkeypatch.setattr(
+        "tasks.app_generate.workflow_execute_task.DifyCoreRepositoryFactory.create_workflow_execution_repository",
+        lambda **kwargs: MagicMock(),
+    )
+    monkeypatch.setattr(
+        "tasks.app_generate.workflow_execute_task.DifyCoreRepositoryFactory.create_workflow_node_execution_repository",
+        lambda **kwargs: MagicMock(),
+    )
+
+    _resume_advanced_chat(
+        app_model=SimpleNamespace(id="app-id"),
+        workflow=SimpleNamespace(created_by="workflow-owner"),
+        user=MagicMock(),
+        conversation=SimpleNamespace(id="conversation-id"),
+        message=MagicMock(),
+        generate_entity=generate_entity,
+        graph_runtime_state=MagicMock(),
+        session_factory=MagicMock(),
+        pause_state_config=MagicMock(),
+        workflow_run_id="workflow-run-id",
+        workflow_run=SimpleNamespace(triggered_from="app_run"),
+    )
+
+    resumed_entity = generator_instance.resume.call_args.kwargs["application_generate_entity"]
+    assert resumed_entity.stream is True
+    publish_streaming_response.assert_called_once_with(response_stream, "workflow-run-id", AppMode.ADVANCED_CHAT)
+
+
+def test_resume_workflow_publishes_events_for_originally_blocking_runs(monkeypatch: pytest.MonkeyPatch):
+    generate_entity = _build_workflow_generate_entity(stream=False)
+
+    generator_instance = MagicMock()
+    response_stream = _single_event_generator({"event": "workflow_finished"})
+    generator_instance.resume.return_value = response_stream
+    monkeypatch.setattr(
+        "tasks.app_generate.workflow_execute_task.WorkflowAppGenerator",
+        lambda: generator_instance,
+    )
+
+    publish_streaming_response = MagicMock()
+    monkeypatch.setattr(
+        "tasks.app_generate.workflow_execute_task._publish_streaming_response", publish_streaming_response
+    )
+    monkeypatch.setattr(
+        "tasks.app_generate.workflow_execute_task.DifyCoreRepositoryFactory.create_workflow_execution_repository",
+        lambda **kwargs: MagicMock(),
+    )
+    monkeypatch.setattr(
+        "tasks.app_generate.workflow_execute_task.DifyCoreRepositoryFactory.create_workflow_node_execution_repository",
+        lambda **kwargs: MagicMock(),
+    )
+    workflow_run_repo = MagicMock()
+    pause_entity = MagicMock()
+
+    _resume_workflow(
+        app_model=SimpleNamespace(id="app-id"),
+        workflow=SimpleNamespace(created_by="workflow-owner"),
+        user=MagicMock(),
+        generate_entity=generate_entity,
+        graph_runtime_state=MagicMock(),
+        session_factory=MagicMock(),
+        pause_state_config=MagicMock(),
+        workflow_run_id="workflow-run-id",
+        workflow_run=SimpleNamespace(triggered_from="app_run"),
+        workflow_run_repo=workflow_run_repo,
+        pause_entity=pause_entity,
+    )
+
+    resumed_entity = generator_instance.resume.call_args.kwargs["application_generate_entity"]
+    assert resumed_entity.stream is True
+    publish_streaming_response.assert_called_once_with(response_stream, "workflow-run-id", AppMode.WORKFLOW)
+    workflow_run_repo.delete_workflow_pause.assert_called_once_with(pause_entity)

api/uv.lock

@@ -469,14 +469,14 @@ wheels = [
 
 [[package]]
 name = "basedpyright"
-version = "1.39.3"
+version = "1.39.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "nodejs-wheel-binaries" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/04/19/5a5b9b9197973da732638957be3a65cf514d2f5a4964eeedbf33b6c65bbd/basedpyright-1.39.3.tar.gz", hash = "sha256:2f794e6b5f4260fb89f614ca6cd23c6f305373bb6b50c4ed7794ff2ae647fb14", size = 25503187, upload-time = "2026-04-20T22:14:47.424Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ac/f4/4a77cc1ffb3dab7391642cde30163961d8ee973e9e6b6740c7d15aa3d3ba/basedpyright-1.39.0.tar.gz", hash = "sha256:6666f51c378c7ac45877c4c1c7041ee0b5b83d755ebc82f898f47b6fafe0cc4f", size = 25357403, upload-time = "2026-04-01T12:27:41.92Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/54/5c/f950c1239ad26f3bb453e665428a2cf1893995de725a5eb0b64a2520b366/basedpyright-1.39.3-py3-none-any.whl", hash = "sha256:aba760dc83307727554f936d6b4381caa14482f30dbc2173167710e217c1f7ab", size = 12419181, upload-time = "2026-04-20T22:14:51.975Z" },
+    { url = "https://files.pythonhosted.org/packages/97/47/08145d1bcc3083ed20059bdecbde404bd767f91b91e2764ec01cffec9f4b/basedpyright-1.39.0-py3-none-any.whl", hash = "sha256:91b8ad50bc85ee4a985b928f9368c35c99eee5a56c44e99b2442fa12ecc3d670", size = 12353868, upload-time = "2026-04-01T12:27:38.495Z" },
 ]
 
 [[package]]
@@ -618,15 +618,15 @@ wheels = [
 
 [[package]]
 name = "boto3-stubs"
-version = "1.42.92"
+version = "1.42.88"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "botocore-stubs" },
     { name = "types-s3transfer" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/fa/b4/7f472d64a89f6aa6b8e8eeadc876667b7e4edfb526c6118efe2b2c98ba17/boto3_stubs-1.42.92.tar.gz", hash = "sha256:4bc934069c5e8c7b3cdd2442569dae14e8272fe207d445bd38aa578b8463638f", size = 102696, upload-time = "2026-04-20T19:55:19.858Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c2/c7/d4dfbb4757cd72fd350ba666902ec3ac19e04d6be639e96cdad4543d4726/boto3_stubs-1.42.88.tar.gz", hash = "sha256:85215fb4938a94d1cf83cd8632f46ae7728b5ec88187d83468f393bbe64236d6", size = 102495, upload-time = "2026-04-10T19:55:57.526Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6c/ce/2fe2c6456f8dc0b8bb8d80e05e154c7975ec058991bedf54f3aeed634b79/boto3_stubs-1.42.92-py3-none-any.whl", hash = "sha256:b3994e60f0133b2dd3d9a88ceaeef48fa6367d9a9429426e919575768a1ad9c6", size = 70666, upload-time = "2026-04-20T19:55:16.398Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/6f/3befd72080aedbb4ad26b353a6e364645668664930ce49668fd0bab8f2b5/boto3_stubs-1.42.88-py3-none-any.whl", hash = "sha256:9e74350715ca8ccd63fc250f8eca9fa3161b3d1704339554344d72e4e21c5ed1", size = 70603, upload-time = "2026-04-10T19:55:49.921Z" },
 ]
 
 [package.optional-dependencies]
@@ -1616,18 +1616,18 @@ requires-dist = [
 
 [package.metadata.requires-dev]
 dev = [
-    { name = "basedpyright", specifier = ">=1.39.3" },
-    { name = "boto3-stubs", specifier = ">=1.42.92" },
+    { name = "basedpyright", specifier = ">=1.39.0" },
+    { name = "boto3-stubs", specifier = ">=1.42.88" },
     { name = "celery-types", specifier = ">=0.23.0" },
     { name = "coverage", specifier = ">=7.13.4" },
     { name = "dotenv-linter", specifier = ">=0.7.0" },
-    { name = "faker", specifier = ">=40.15.0" },
-    { name = "hypothesis", specifier = ">=6.152.1" },
+    { name = "faker", specifier = ">=20.1.0" },
+    { name = "hypothesis", specifier = ">=6.151.12" },
     { name = "import-linter", specifier = ">=2.3" },
     { name = "lxml-stubs", specifier = ">=0.5.1" },
     { name = "mypy", specifier = ">=1.20.1" },
     { name = "pandas-stubs", specifier = ">=3.0.0" },
-    { name = "pyrefly", specifier = ">=0.62.0" },
+    { name = "pyrefly", specifier = ">=0.61.1" },
     { name = "pytest", specifier = ">=9.0.3" },
     { name = "pytest-benchmark", specifier = ">=5.2.3" },
     { name = "pytest-cov", specifier = ">=7.1.0" },
@@ -1635,8 +1635,8 @@ dev = [
     { name = "pytest-mock", specifier = ">=3.15.1" },
     { name = "pytest-timeout", specifier = ">=2.4.0" },
     { name = "pytest-xdist", specifier = ">=3.8.0" },
-    { name = "ruff", specifier = ">=0.15.11" },
-    { name = "scipy-stubs", specifier = ">=1.17.1.4" },
+    { name = "ruff", specifier = ">=0.15.10" },
+    { name = "scipy-stubs", specifier = ">=1.15.3.0" },
     { name = "testcontainers", specifier = ">=4.14.2" },
     { name = "types-aiofiles", specifier = ">=25.1.0" },
     { name = "types-beautifulsoup4", specifier = ">=4.12.0" },
@@ -2351,14 +2351,14 @@ wheels = [
 
 [[package]]
 name = "faker"
-version = "40.15.0"
+version = "40.13.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "tzdata", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/7f/13/6741787bd91c4109c7bed047d68273965cd52ce8a5f773c471b949334b6d/faker-40.15.0.tar.gz", hash = "sha256:20f3a6ec8c266b74d4c554e34118b21c3c2056c0b4a519d15c8decb3a4e6e795", size = 1967447, upload-time = "2026-04-17T20:05:27.555Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/89/95/4822ffe94723553789aef783104f4f18fc20d7c4c68e1bbd633e11d09758/faker-40.13.0.tar.gz", hash = "sha256:a0751c84c3abac17327d7bb4c98e8afe70ebf7821e01dd7d0b15cd8856415525", size = 1962043, upload-time = "2026-04-06T16:44:55.68Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a7/a7/a600f8f30d4505e89166de51dd121bd540ab8e560e8cf0901de00a81de8c/faker-40.15.0-py3-none-any.whl", hash = "sha256:71ab3c3370da9d2205ab74ffb0fd51273063ad562b3a3bb69d0026a20923e318", size = 2004447, upload-time = "2026-04-17T20:05:25.437Z" },
+    { url = "https://files.pythonhosted.org/packages/da/8a/708103325edff16a0b0e004de0d37db8ba216a32713948c64d71f6d4a4c2/faker-40.13.0-py3-none-any.whl", hash = "sha256:c1298fd0d819b3688fb5fd358c4ba8f56c7c8c740b411fd3dbd8e30bf2c05019", size = 1994597, upload-time = "2026-04-06T16:44:53.698Z" },
 ]
 
 [[package]]
@@ -3317,14 +3317,14 @@ wheels = [
 
 [[package]]
 name = "hypothesis"
-version = "6.152.1"
+version = "6.151.12"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "sortedcontainers" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/64/b1/c32bcddb9aab9e3abc700f1f56faf14e7655c64a16ca47701a57362276ea/hypothesis-6.152.1.tar.gz", hash = "sha256:4f4ed934eee295dd84ee97592477d23e8dc03e9f12ae0ee30a4e7c9ef3fca3b0", size = 465029, upload-time = "2026-04-14T22:29:24.062Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ce/ab/67ca321d1ab96fd3828b12142f1c258e2d4a668a025d06cd50ab3409787f/hypothesis-6.151.12.tar.gz", hash = "sha256:be485f503979af4c3dfa19e3fc2b967d0458e7f8c4e28128d7e215e0a55102e0", size = 463900, upload-time = "2026-04-08T19:40:06.205Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5d/83/860fb3075e00b0fc19a22a2301bc3c96f00437558c3911bdd0a3573a4a53/hypothesis-6.152.1-py3-none-any.whl", hash = "sha256:40a3619d9e0cb97b018857c7986f75cf5de2e5ec0fa8a0b172d00747758f749e", size = 530752, upload-time = "2026-04-14T22:29:20.893Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/5a/6cecf134b631050a1f8605096adbe812483b60790d951470989d39b56860/hypothesis-6.151.12-py3-none-any.whl", hash = "sha256:37d4f3a768365c30571b11dfd7a6857a12173d933010b2c4ab65619f1b5952c5", size = 529656, upload-time = "2026-04-08T19:40:03.126Z" },
 ]
 
 [[package]]
@@ -3687,28 +3687,28 @@ wheels = [
 
 [[package]]
 name = "lxml"
-version = "6.1.0"
+version = "6.0.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/28/30/9abc9e34c657c33834eaf6cd02124c61bdf5944d802aa48e69be8da3585d/lxml-6.1.0.tar.gz", hash = "sha256:bfd57d8008c4965709a919c3e9a98f76c2c7cb319086b3d26858250620023b13", size = 4197006, upload-time = "2026-04-18T04:32:51.613Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/88/262177de60548e5a2bfc46ad28232c9e9cbde697bd94132aeb80364675cb/lxml-6.0.2.tar.gz", hash = "sha256:cd79f3367bd74b317dda655dc8fcfa304d9eb6e4fb06b7168c5cf27f96e0cd62", size = 4073426, upload-time = "2025-09-22T04:04:59.287Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d2/d4/9326838b59dc36dfae42eec9656b97520f9997eee1de47b8316aaeed169c/lxml-6.1.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d2f17a16cd8751e8eb233a7e41aecdf8e511712e00088bf9be455f604cd0d28d", size = 8570663, upload-time = "2026-04-18T04:27:48.253Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/a4/053745ce1f8303ccbb788b86c0db3a91b973675cefc42566a188637b7c40/lxml-6.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f0cea5b1d3e6e77d71bd2b9972eb2446221a69dc52bb0b9c3c6f6e5700592d93", size = 4624024, upload-time = "2026-04-18T04:27:52.594Z" },
-    { url = "https://files.pythonhosted.org/packages/90/97/a517944b20f8fd0932ad2109482bee4e29fe721416387a363306667941f6/lxml-6.1.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fc46da94826188ed45cb53bd8e3fc076ae22675aea2087843d4735627f867c6d", size = 4930895, upload-time = "2026-04-18T04:32:56.29Z" },
-    { url = "https://files.pythonhosted.org/packages/94/7c/e08a970727d556caa040a44773c7b7e3ad0f0d73dedc863543e9a8b931f2/lxml-6.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9147d8e386ec3b82c3b15d88927f734f565b0aaadef7def562b853adca45784a", size = 5093820, upload-time = "2026-04-18T04:32:58.94Z" },
-    { url = "https://files.pythonhosted.org/packages/88/ee/2a5c2aa2c32016a226ca25d3e1056a8102ea6e1fe308bf50213586635400/lxml-6.1.0-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5715e0e28736a070f3f34a7ccc09e2fdcba0e3060abbcf61a1a5718ff6d6b105", size = 5005790, upload-time = "2026-04-18T04:33:01.272Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/38/a0db9be8f38ad6043ab9429487c128dd1d30f07956ef43040402f8da49e8/lxml-6.1.0-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4937460dc5df0cdd2f06a86c285c28afda06aefa3af949f9477d3e8df430c485", size = 5630827, upload-time = "2026-04-18T04:33:04.036Z" },
-    { url = "https://files.pythonhosted.org/packages/31/ba/3c13d3fc24b7cacf675f808a3a1baabf43a30d0cd24c98f94548e9aa58eb/lxml-6.1.0-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bc783ee3147e60a25aa0445ea82b3e8aabb83b240f2b95d32cb75587ff781814", size = 5240445, upload-time = "2026-04-18T04:33:06.87Z" },
-    { url = "https://files.pythonhosted.org/packages/55/ba/eeef4ccba09b2212fe239f46c1692a98db1878e0872ae320756488878a94/lxml-6.1.0-cp312-cp312-manylinux_2_28_i686.whl", hash = "sha256:40d9189f80075f2e1f88db21ef815a2b17b28adf8e50aaf5c789bfe737027f32", size = 5350121, upload-time = "2026-04-18T04:33:09.365Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/01/1da87c7b587c38d0cbe77a01aae3b9c1c49ed47d76918ef3db8fc151b1ca/lxml-6.1.0-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:05b9b8787e35bec69e68daf4952b2e6dfcfb0db7ecf1a06f8cdfbbac4eb71aad", size = 4694949, upload-time = "2026-04-18T04:33:11.628Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/88/7db0fe66d5aaf128443ee1623dec3db1576f3e4c17751ec0ef5866468590/lxml-6.1.0-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0f0f08beb0182e3e9a86fae124b3c47a7b41b7b69b225e1377db983802404e54", size = 5243901, upload-time = "2026-04-18T04:33:13.95Z" },
-    { url = "https://files.pythonhosted.org/packages/00/a8/1346726af7d1f6fca1f11223ba34001462b0a3660416986d37641708d57c/lxml-6.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73becf6d8c81d4c76b1014dbd3584cb26d904492dcf73ca85dc8bff08dcd6d2d", size = 5048054, upload-time = "2026-04-18T04:33:16.965Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/b7/85057012f035d1a0c87e02f8c723ca3c3e6e0728bcf4cb62080b21b1c1e3/lxml-6.1.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:1ae225f66e5938f4fa29d37e009a3bb3b13032ac57eb4eb42afa44f6e4054e69", size = 4777324, upload-time = "2026-04-18T04:33:19.832Z" },
-    { url = "https://files.pythonhosted.org/packages/75/6c/ad2f94a91073ef570f33718040e8e160d5fb93331cf1ab3ca1323f939e2d/lxml-6.1.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:690022c7fae793b0489aa68a658822cea83e0d5933781811cabbf5ea3bcfe73d", size = 5645702, upload-time = "2026-04-18T04:33:22.436Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/89/0bb6c0bd549c19004c60eea9dc554dd78fd647b72314ef25d460e0d208c6/lxml-6.1.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:63aeafc26aac0be8aff14af7871249e87ea1319be92090bfd632ec68e03b16a5", size = 5232901, upload-time = "2026-04-18T04:33:26.21Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/d9/d609a11fb567da9399f525193e2b49847b5a409cdebe737f06a8b7126bdc/lxml-6.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:264c605ab9c0e4aa1a679636f4582c4d3313700009fac3ec9c3412ed0d8f3e1d", size = 5261333, upload-time = "2026-04-18T04:33:28.984Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/3a/ac3f99ec8ac93089e7dd556f279e0d14c24de0a74a507e143a2e4b496e7c/lxml-6.1.0-cp312-cp312-win32.whl", hash = "sha256:56971379bc5ee8037c5a0f09fa88f66cdb7d37c3e38af3e45cf539f41131ac1f", size = 3596289, upload-time = "2026-04-18T04:27:42.819Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/a7/0a915557538593cb1bbeedcd40e13c7a261822c26fecbbdb71dad0c2f540/lxml-6.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:bba078de0031c219e5dd06cf3e6bf8fb8e6e64a77819b358f53bb132e3e03366", size = 3997059, upload-time = "2026-04-18T04:27:46.764Z" },
-    { url = "https://files.pythonhosted.org/packages/92/96/a5dc078cf0126fbfbc35611d77ecd5da80054b5893e28fb213a5613b9e1d/lxml-6.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:c3592631e652afa34999a088f98ba7dfc7d6aff0d535c410bea77a71743f3819", size = 3659552, upload-time = "2026-04-18T04:27:51.133Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/c8/8ff2bc6b920c84355146cd1ab7d181bc543b89241cfb1ebee824a7c81457/lxml-6.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a59f5448ba2ceccd06995c95ea59a7674a10de0810f2ce90c9006f3cbc044456", size = 8661887, upload-time = "2025-09-22T04:01:17.265Z" },
+    { url = "https://files.pythonhosted.org/packages/37/6f/9aae1008083bb501ef63284220ce81638332f9ccbfa53765b2b7502203cf/lxml-6.0.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e8113639f3296706fbac34a30813929e29247718e88173ad849f57ca59754924", size = 4667818, upload-time = "2025-09-22T04:01:19.688Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ca/31fb37f99f37f1536c133476674c10b577e409c0a624384147653e38baf2/lxml-6.0.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a8bef9b9825fa8bc816a6e641bb67219489229ebc648be422af695f6e7a4fa7f", size = 4950807, upload-time = "2025-09-22T04:01:21.487Z" },
+    { url = "https://files.pythonhosted.org/packages/da/87/f6cb9442e4bada8aab5ae7e1046264f62fdbeaa6e3f6211b93f4c0dd97f1/lxml-6.0.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:65ea18d710fd14e0186c2f973dc60bb52039a275f82d3c44a0e42b43440ea534", size = 5109179, upload-time = "2025-09-22T04:01:23.32Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/20/a7760713e65888db79bbae4f6146a6ae5c04e4a204a3c48896c408cd6ed2/lxml-6.0.2-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c371aa98126a0d4c739ca93ceffa0fd7a5d732e3ac66a46e74339acd4d334564", size = 5023044, upload-time = "2025-09-22T04:01:25.118Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/b0/7e64e0460fcb36471899f75831509098f3fd7cd02a3833ac517433cb4f8f/lxml-6.0.2-cp312-cp312-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:700efd30c0fa1a3581d80a748157397559396090a51d306ea59a70020223d16f", size = 5359685, upload-time = "2025-09-22T04:01:27.398Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/e1/e5df362e9ca4e2f48ed6411bd4b3a0ae737cc842e96877f5bf9428055ab4/lxml-6.0.2-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c33e66d44fe60e72397b487ee92e01da0d09ba2d66df8eae42d77b6d06e5eba0", size = 5654127, upload-time = "2025-09-22T04:01:29.629Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/d1/232b3309a02d60f11e71857778bfcd4acbdb86c07db8260caf7d008b08f8/lxml-6.0.2-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90a345bbeaf9d0587a3aaffb7006aa39ccb6ff0e96a57286c0cb2fd1520ea192", size = 5253958, upload-time = "2025-09-22T04:01:31.535Z" },
+    { url = "https://files.pythonhosted.org/packages/35/35/d955a070994725c4f7d80583a96cab9c107c57a125b20bb5f708fe941011/lxml-6.0.2-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:064fdadaf7a21af3ed1dcaa106b854077fbeada827c18f72aec9346847cd65d0", size = 4711541, upload-time = "2025-09-22T04:01:33.801Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/be/667d17363b38a78c4bd63cfd4b4632029fd68d2c2dc81f25ce9eb5224dd5/lxml-6.0.2-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fbc74f42c3525ac4ffa4b89cbdd00057b6196bcefe8bce794abd42d33a018092", size = 5267426, upload-time = "2025-09-22T04:01:35.639Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/47/62c70aa4a1c26569bc958c9ca86af2bb4e1f614e8c04fb2989833874f7ae/lxml-6.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6ddff43f702905a4e32bc24f3f2e2edfe0f8fde3277d481bffb709a4cced7a1f", size = 5064917, upload-time = "2025-09-22T04:01:37.448Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/55/6ceddaca353ebd0f1908ef712c597f8570cc9c58130dbb89903198e441fd/lxml-6.0.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:6da5185951d72e6f5352166e3da7b0dc27aa70bd1090b0eb3f7f7212b53f1bb8", size = 4788795, upload-time = "2025-09-22T04:01:39.165Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/e8/fd63e15da5e3fd4c2146f8bbb3c14e94ab850589beab88e547b2dbce22e1/lxml-6.0.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:57a86e1ebb4020a38d295c04fc79603c7899e0df71588043eb218722dabc087f", size = 5676759, upload-time = "2025-09-22T04:01:41.506Z" },
+    { url = "https://files.pythonhosted.org/packages/76/47/b3ec58dc5c374697f5ba37412cd2728f427d056315d124dd4b61da381877/lxml-6.0.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:2047d8234fe735ab77802ce5f2297e410ff40f5238aec569ad7c8e163d7b19a6", size = 5255666, upload-time = "2025-09-22T04:01:43.363Z" },
+    { url = "https://files.pythonhosted.org/packages/19/93/03ba725df4c3d72afd9596eef4a37a837ce8e4806010569bedfcd2cb68fd/lxml-6.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6f91fd2b2ea15a6800c8e24418c0775a1694eefc011392da73bc6cef2623b322", size = 5277989, upload-time = "2025-09-22T04:01:45.215Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/80/c06de80bfce881d0ad738576f243911fccf992687ae09fd80b734712b39c/lxml-6.0.2-cp312-cp312-win32.whl", hash = "sha256:3ae2ce7d6fedfb3414a2b6c5e20b249c4c607f72cb8d2bb7cc9c6ec7c6f4e849", size = 3611456, upload-time = "2025-09-22T04:01:48.243Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/d7/0cdfb6c3e30893463fb3d1e52bc5f5f99684a03c29a0b6b605cfae879cd5/lxml-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:72c87e5ee4e58a8354fb9c7c84cbf95a1c8236c127a5d1b7683f04bed8361e1f", size = 4011793, upload-time = "2025-09-22T04:01:50.042Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/7b/93c73c67db235931527301ed3785f849c78991e2e34f3fd9a6663ffda4c5/lxml-6.0.2-cp312-cp312-win_arm64.whl", hash = "sha256:61cb10eeb95570153e0c0e554f58df92ecf5109f75eacad4a95baa709e26c3d6", size = 3672836, upload-time = "2025-09-22T04:01:52.145Z" },
 ]
 
 [[package]]
@@ -5357,19 +5357,19 @@ wheels = [
 
 [[package]]
 name = "pyrefly"
-version = "0.62.0"
+version = "0.61.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/bb/ad/8874ed25781e7dd561c6d75fb4a7becf10a18d75b074f25b845cc334f781/pyrefly-0.62.0.tar.gz", hash = "sha256:da1fbe1075dc1e6c8e3134e9370b0a0e7a296061d782cca5bf83dbb8e4c10d7c", size = 5537672, upload-time = "2026-04-20T17:12:15.718Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/c8/52fce3f0e3718d9ff71d16af41cef925e58613741328004d3aa3fe585057/pyrefly-0.61.1.tar.gz", hash = "sha256:2a871320b7d2b28b8635064b620097d7091e84c49e4808d915ad31dad685d0f5", size = 5535788, upload-time = "2026-04-17T18:47:33.958Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1b/ea/09bd9da7d5df294db800312fb415be2fefbaa5594178e9e49f44fa071aea/pyrefly-0.62.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:9d78ec4f126dee1fa76215b193b964490ce10e62a32d2787a72c51623658b803", size = 13020414, upload-time = "2026-04-20T17:11:43.617Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/f0/f84afac4f220c4c8c801b779ee2ff28ad3f7731f4283c2e1b6ee9012e8c2/pyrefly-0.62.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:2a41a34902d20756264486f9e309f22633d100261bd960feea6e858a098d985d", size = 12515659, upload-time = "2026-04-20T17:11:46.59Z" },
-    { url = "https://files.pythonhosted.org/packages/40/0b/620c39cefa9ae1b25ee7a2da9d8d3c278b095649cb8435c5e01ea64f7c17/pyrefly-0.62.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4666c6b65aea662e5f77b64dc91c091b7ea5cede6aa66c0f4cbae26480403583", size = 36228332, upload-time = "2026-04-20T17:11:50.523Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/fb/47b8b76438c12761e509a3666cd5a99d4af7f21976ba8385feb475cbfe30/pyrefly-0.62.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1aefab798f47d37c13ded791192fee9b39a6d2b12e31f38ae06a1f80c4b26e22", size = 38995741, upload-time = "2026-04-20T17:11:54.702Z" },
-    { url = "https://files.pythonhosted.org/packages/55/d2/03bd17673f61147cd5609cd7d6a1455eeccc17a07a7e141ed9931b0c42c0/pyrefly-0.62.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8fa986b50d56740da1d7ae7c660a505143cb9d286fa98cc7e5f4a759cc6eaa5d", size = 37205321, upload-time = "2026-04-20T17:11:58.9Z" },
-    { url = "https://files.pythonhosted.org/packages/75/14/20ba7b7f2d182f9b7c1e24a3041dac9b5730ae28cfe1614a2c98706650f2/pyrefly-0.62.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:32e9b175805c82ffb967e4708f4910bace7e1a12736907380cc9afdbaabb0efb", size = 41786834, upload-time = "2026-04-20T17:12:03.221Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/c8/5a7ba88c4fa1b5090d877f70fa1b742b921b9e7d8d3f4b6b9b1ba1820850/pyrefly-0.62.0-py3-none-win32.whl", hash = "sha256:1cd98edc20cab5bac8016c9220ee66080e39bd22e7f0e9bb3e2c4e2be1555eed", size = 12010170, upload-time = "2026-04-20T17:12:06.791Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/78/d8f810de010ff2ed594c630c724fd817ef430963249e9eb396ce8f785e9d/pyrefly-0.62.0-py3-none-win_amd64.whl", hash = "sha256:6994f8ee7d6720325ee52207fbdaca98a799a1efe462bb5ba90c47160f7f3e6e", size = 12861816, upload-time = "2026-04-20T17:12:09.689Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/a9/ac824ef6a3f50b7c0ec5974471f8f2cb205cd1edd53a5abbcf7ba37feb5d/pyrefly-0.62.0-py3-none-win_arm64.whl", hash = "sha256:362a5d47a5ac5aaa5258091e878a1759ff8b687d8cf462af1c516144f7b0108a", size = 12352977, upload-time = "2026-04-20T17:12:12.736Z" },
+    { url = "https://files.pythonhosted.org/packages/61/38/e94ff401405a05fbf81c9bbfa993a34ffd03be84812b545063c8efb56b44/pyrefly-0.61.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:6e3ed857b99291fc4aa3b54ce22deb086c0174cf3a3775eccea7439efd16d925", size = 12969301, upload-time = "2026-04-17T18:47:06.036Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/be/53c7f9400696e46633c8cee8b6fd32ce7ab4a965ddf9ac4f4ea9e2034647/pyrefly-0.61.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:cf6335c1baf9470ca8113f7ea8bdbd0b96081c82a911157c576cdfc8a67a9a87", size = 12475413, upload-time = "2026-04-17T18:47:08.863Z" },
+    { url = "https://files.pythonhosted.org/packages/77/68/83cc3267620b14f81fa596a84efc7ebcf5c49f79b521499e85d1a4fca6d8/pyrefly-0.61.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:844b5baddc2a631f69648a4756c54c97d86e4b9c07e335b216668e24390b77b6", size = 36074785, upload-time = "2026-04-17T18:47:11.845Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/00/e8d437995b8dcea022f5310bc873f5de1dcc71da4876d5be917ee9a93fef/pyrefly-0.61.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eaa294f90622c5b3743af8e9de4263447f22bb0e8b60c80cf83292adb4f2d14b", size = 38802979, upload-time = "2026-04-17T18:47:16.058Z" },
+    { url = "https://files.pythonhosted.org/packages/16/3f/f1cbc58e8875608ae740d9575de95c8bc6d4dce202f82b4fe90005727618/pyrefly-0.61.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a8d8c3fe08b9593dce23ad4bc7c393891a379c2d580aa1f263182567721bd6f", size = 37029339, upload-time = "2026-04-17T18:47:19.601Z" },
+    { url = "https://files.pythonhosted.org/packages/18/8c/0ff67041c88c28f48b10ce15758831d1e4e60f11db5bfc09dcffd5edb6ba/pyrefly-0.61.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:305f2086f4d7d796244b337884d96cf0d32435420336a77840ca369cf6fa06fd", size = 41595667, upload-time = "2026-04-17T18:47:23.122Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/9e/62b8139b140931593a6b29334802ea6b86d033c0bfd9794950279732253b/pyrefly-0.61.1-py3-none-win32.whl", hash = "sha256:3271a019885a72c8dd064e928bb445af807771506842f5f2faaac17d8e6e73a5", size = 11963660, upload-time = "2026-04-17T18:47:25.86Z" },
+    { url = "https://files.pythonhosted.org/packages/38/6e/73280243d12bec28f55b6edd4e70c5cf11e3d7de2395ecb4eb36cca7dab4/pyrefly-0.61.1-py3-none-win_amd64.whl", hash = "sha256:3e3763d5d76f505c5b8897db1446bde8e138d50a67751f2aa76d6c6034254836", size = 12804056, upload-time = "2026-04-17T18:47:28.674Z" },
+    { url = "https://files.pythonhosted.org/packages/87/32/38ac5af84d96167412024abf5e2f49f15b777987a1942e7a442e8e5fef82/pyrefly-0.61.1-py3-none-win_arm64.whl", hash = "sha256:cef5631e2ab09702274ec2eaaafee28a114891cf85f2d31568b329727e3ff735", size = 12302467, upload-time = "2026-04-17T18:47:31.409Z" },
 ]
 
 [[package]]
@@ -5887,27 +5887,27 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.15.11"
+version = "0.15.10"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e4/8d/192f3d7103816158dfd5ea50d098ef2aec19194e6cbccd4b3485bdb2eb2d/ruff-0.15.11.tar.gz", hash = "sha256:f092b21708bf0e7437ce9ada249dfe688ff9a0954fc94abab05dcea7dcd29c33", size = 4637264, upload-time = "2026-04-16T18:46:26.58Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/d9/aa3f7d59a10ef6b14fe3431706f854dbf03c5976be614a9796d36326810c/ruff-0.15.10.tar.gz", hash = "sha256:d1f86e67ebfdef88e00faefa1552b5e510e1d35f3be7d423dc7e84e63788c94e", size = 4631728, upload-time = "2026-04-09T14:06:09.884Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/02/1e/6aca3427f751295ab011828e15e9bf452200ac74484f1db4be0197b8170b/ruff-0.15.11-py3-none-linux_armv6l.whl", hash = "sha256:e927cfff503135c558eb581a0c9792264aae9507904eb27809cdcff2f2c847b7", size = 10607943, upload-time = "2026-04-16T18:46:05.967Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/26/1341c262e74f36d4e84f3d6f4df0ac68cd53331a66bfc5080daa17c84c0b/ruff-0.15.11-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:7a1b5b2938d8f890b76084d4fa843604d787a912541eae85fd7e233398bbb73e", size = 10988592, upload-time = "2026-04-16T18:46:00.742Z" },
-    { url = "https://files.pythonhosted.org/packages/03/71/850b1d6ffa9564fbb6740429bad53df1094082fe515c8c1e74b6d8d05f18/ruff-0.15.11-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d4176f3d194afbdaee6e41b9ccb1a2c287dba8700047df474abfbe773825d1cb", size = 10338501, upload-time = "2026-04-16T18:46:03.723Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/11/cc1284d3e298c45a817a6aadb6c3e1d70b45c9b36d8d9cce3387b495a03a/ruff-0.15.11-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3b17c886fb88203ced3afe7f14e8d5ae96e9d2f4ccc0ee66aa19f2c2675a27e4", size = 10670693, upload-time = "2026-04-16T18:46:41.941Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/9e/f8288b034ab72b371513c13f9a41d9ba3effac54e24bfb467b007daee2ca/ruff-0.15.11-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:49fafa220220afe7758a487b048de4c8f9f767f37dfefad46b9dd06759d003eb", size = 10416177, upload-time = "2026-04-16T18:46:21.717Z" },
-    { url = "https://files.pythonhosted.org/packages/85/71/504d79abfd3d92532ba6bbe3d1c19fada03e494332a59e37c7c2dabae427/ruff-0.15.11-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f2ab8427e74a00d93b8bda1307b1e60970d40f304af38bccb218e056c220120d", size = 11221886, upload-time = "2026-04-16T18:46:15.086Z" },
-    { url = "https://files.pythonhosted.org/packages/43/5a/947e6ab7a5ad603d65b474be15a4cbc6d29832db5d762cd142e4e3a74164/ruff-0.15.11-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:195072c0c8e1fc8f940652073df082e37a5d9cb43b4ab1e4d0566ab8977a13b7", size = 12075183, upload-time = "2026-04-16T18:46:07.944Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/a1/0b7bb6268775fdd3a0818aee8efd8f5b4e231d24dd4d528ced2534023182/ruff-0.15.11-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a3a0996d486af3920dec930a2e7daed4847dfc12649b537a9335585ada163e9e", size = 11516575, upload-time = "2026-04-16T18:46:31.687Z" },
-    { url = "https://files.pythonhosted.org/packages/30/c3/bb5168fc4d233cc06e95f482770d0f3c87945a0cd9f614b90ea8dc2f2833/ruff-0.15.11-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bef2cb556d509259f1fe440bb9cd33c756222cf0a7afe90d15edf0866702431", size = 11306537, upload-time = "2026-04-16T18:46:36.988Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/92/4cfae6441f3967317946f3b788136eecf093729b94d6561f963ed810c82e/ruff-0.15.11-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:030d921a836d7d4a12cf6e8d984a88b66094ccb0e0f17ddd55067c331191bf19", size = 11296813, upload-time = "2026-04-16T18:46:24.182Z" },
-    { url = "https://files.pythonhosted.org/packages/43/26/972784c5dde8313acde8ac71ba8ac65475b85db4a2352a76c9934361f9bc/ruff-0.15.11-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:0e783b599b4577788dbbb66b9addcef87e9a8832f4ce0c19e34bf55543a2f890", size = 10633136, upload-time = "2026-04-16T18:46:39.802Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/53/3985a4f185020c2f367f2e08a103032e12564829742a1b417980ce1514a0/ruff-0.15.11-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:ae90592246625ba4a34349d68ec28d4400d75182b71baa196ddb9f82db025ef5", size = 10424701, upload-time = "2026-04-16T18:46:10.381Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/57/bf0dfb32241b56c83bb663a826133da4bf17f682ba8c096973065f6e6a68/ruff-0.15.11-py3-none-musllinux_1_2_i686.whl", hash = "sha256:1f111d62e3c983ed20e0ca2e800f8d77433a5b1161947df99a5c2a3fb60514f0", size = 10873887, upload-time = "2026-04-16T18:46:29.157Z" },
-    { url = "https://files.pythonhosted.org/packages/02/05/e48076b2a57dc33ee8c7a957296f97c744ca891a8ffb4ffb1aaa3b3f517d/ruff-0.15.11-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:06f483d6646f59eaffba9ae30956370d3a886625f511a3108994000480621d1c", size = 11404316, upload-time = "2026-04-16T18:46:19.462Z" },
-    { url = "https://files.pythonhosted.org/packages/88/27/0195d15fe7a897cbcba0904792c4b7c9fdd958456c3a17d2ea6093716a9a/ruff-0.15.11-py3-none-win32.whl", hash = "sha256:476a2aa56b7da0b73a3ee80b6b2f0e19cce544245479adde7baa65466664d5f3", size = 10655535, upload-time = "2026-04-16T18:46:12.47Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/5e/c927b325bd4c1d3620211a4b96f47864633199feed60fa936025ab27e090/ruff-0.15.11-py3-none-win_amd64.whl", hash = "sha256:8b6756d88d7e234fb0c98c91511aae3cd519d5e3ed271cae31b20f39cb2a12a3", size = 11779692, upload-time = "2026-04-16T18:46:17.268Z" },
-    { url = "https://files.pythonhosted.org/packages/63/b6/aeadee5443e49baa2facd51131159fd6301cc4ccfc1541e4df7b021c37dd/ruff-0.15.11-py3-none-win_arm64.whl", hash = "sha256:063fed18cc1bbe0ee7393957284a6fe8b588c6a406a285af3ee3f46da2391ee4", size = 11032614, upload-time = "2026-04-16T18:46:34.487Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/00/a1c2fdc9939b2c03691edbda290afcd297f1f389196172826b03d6b6a595/ruff-0.15.10-py3-none-linux_armv6l.whl", hash = "sha256:0744e31482f8f7d0d10a11fcbf897af272fefdfcb10f5af907b18c2813ff4d5f", size = 10563362, upload-time = "2026-04-09T14:06:21.189Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/15/006990029aea0bebe9d33c73c3e28c80c391ebdba408d1b08496f00d422d/ruff-0.15.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b1e7c16ea0ff5a53b7c2df52d947e685973049be1cdfe2b59a9c43601897b22e", size = 10951122, upload-time = "2026-04-09T14:06:02.236Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/c0/4ac978fe874d0618c7da647862afe697b281c2806f13ce904ad652fa87e4/ruff-0.15.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:93cc06a19e5155b4441dd72808fdf84290d84ad8a39ca3b0f994363ade4cebb1", size = 10314005, upload-time = "2026-04-09T14:06:00.026Z" },
+    { url = "https://files.pythonhosted.org/packages/da/73/c209138a5c98c0d321266372fc4e33ad43d506d7e5dd817dd89b60a8548f/ruff-0.15.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:83e1dd04312997c99ea6965df66a14fb4f03ba978564574ffc68b0d61fd3989e", size = 10643450, upload-time = "2026-04-09T14:05:42.137Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/76/0deec355d8ec10709653635b1f90856735302cb8e149acfdf6f82a5feb70/ruff-0.15.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8154d43684e4333360fedd11aaa40b1b08a4e37d8ffa9d95fee6fa5b37b6fab1", size = 10379597, upload-time = "2026-04-09T14:05:49.984Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/be/86bba8fc8798c081e28a4b3bb6d143ccad3fd5f6f024f02002b8f08a9fa3/ruff-0.15.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8ab88715f3a6deb6bde6c227f3a123410bec7b855c3ae331b4c006189e895cef", size = 11146645, upload-time = "2026-04-09T14:06:12.246Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/89/140025e65911b281c57be1d385ba1d932c2366ca88ae6663685aed8d4881/ruff-0.15.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a768ff5969b4f44c349d48edf4ab4f91eddb27fd9d77799598e130fb628aa158", size = 12030289, upload-time = "2026-04-09T14:06:04.776Z" },
+    { url = "https://files.pythonhosted.org/packages/88/de/ddacca9545a5e01332567db01d44bd8cf725f2db3b3d61a80550b48308ea/ruff-0.15.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0ee3ef42dab7078bda5ff6a1bcba8539e9857deb447132ad5566a038674540d0", size = 11496266, upload-time = "2026-04-09T14:05:55.485Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/bb/7ddb00a83760ff4a83c4e2fc231fd63937cc7317c10c82f583302e0f6586/ruff-0.15.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51cb8cc943e891ba99989dd92d61e29b1d231e14811db9be6440ecf25d5c1609", size = 11256418, upload-time = "2026-04-09T14:05:57.69Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/8d/55de0d35aacf6cd50b6ee91ee0f291672080021896543776f4170fc5c454/ruff-0.15.10-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:e59c9bdc056a320fb9ea1700a8d591718b8faf78af065484e801258d3a76bc3f", size = 11288416, upload-time = "2026-04-09T14:05:44.695Z" },
+    { url = "https://files.pythonhosted.org/packages/68/cf/9438b1a27426ec46a80e0a718093c7f958ef72f43eb3111862949ead3cc1/ruff-0.15.10-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:136c00ca2f47b0018b073f28cb5c1506642a830ea941a60354b0e8bc8076b151", size = 10621053, upload-time = "2026-04-09T14:05:52.782Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/50/e29be6e2c135e9cd4cb15fbade49d6a2717e009dff3766dd080fcb82e251/ruff-0.15.10-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:8b80a2f3c9c8a950d6237f2ca12b206bccff626139be9fa005f14feb881a1ae8", size = 10378302, upload-time = "2026-04-09T14:06:14.361Z" },
+    { url = "https://files.pythonhosted.org/packages/18/2f/e0b36a6f99c51bb89f3a30239bc7bf97e87a37ae80aa2d6542d6e5150364/ruff-0.15.10-py3-none-musllinux_1_2_i686.whl", hash = "sha256:e3e53c588164dc025b671c9df2462429d60357ea91af7e92e9d56c565a9f1b07", size = 10850074, upload-time = "2026-04-09T14:06:16.581Z" },
+    { url = "https://files.pythonhosted.org/packages/11/08/874da392558ce087a0f9b709dc6ec0d60cbc694c1c772dab8d5f31efe8cb/ruff-0.15.10-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:b0c52744cf9f143a393e284125d2576140b68264a93c6716464e129a3e9adb48", size = 11358051, upload-time = "2026-04-09T14:06:18.948Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/46/602938f030adfa043e67112b73821024dc79f3ab4df5474c25fa4c1d2d14/ruff-0.15.10-py3-none-win32.whl", hash = "sha256:d4272e87e801e9a27a2e8df7b21011c909d9ddd82f4f3281d269b6ba19789ca5", size = 10588964, upload-time = "2026-04-09T14:06:07.14Z" },
+    { url = "https://files.pythonhosted.org/packages/25/b6/261225b875d7a13b33a6d02508c39c28450b2041bb01d0f7f1a83d569512/ruff-0.15.10-py3-none-win_amd64.whl", hash = "sha256:28cb32d53203242d403d819fd6983152489b12e4a3ae44993543d6fe62ab42ed", size = 11745044, upload-time = "2026-04-09T14:05:39.473Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ed/dea90a65b7d9e69888890fb14c90d7f51bf0c1e82ad800aeb0160e4bacfd/ruff-0.15.10-py3-none-win_arm64.whl", hash = "sha256:601d1610a9e1f1c2165a4f561eeaa2e2ea1e97f3287c5aa258d3dab8b57c6188", size = 11035607, upload-time = "2026-04-09T14:05:47.593Z" },
 ]
 
 [[package]]
@@ -5946,14 +5946,14 @@ wheels = [
 
 [[package]]
 name = "scipy-stubs"
-version = "1.17.1.4"
+version = "1.17.1.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "optype", extra = ["numpy"] },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d1/75/d944a11fca64aa84fbb4bfcf613b758319c6103cb30a304a0e9727009d62/scipy_stubs-1.17.1.4.tar.gz", hash = "sha256:cae00c5207aa62ceb4bcadea202d9fbbf002e958f9e4de981720436b8d5c1802", size = 396980, upload-time = "2026-04-13T11:46:54.528Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a7/59/59c6cc3f9970154b9ed6b1aff42a0185cdd60cef54adc0404b9e77972221/scipy_stubs-1.17.1.3.tar.gz", hash = "sha256:5eb87a8d23d726706259b012ebe76a4a96a9ae9e141fc59bf55fc8eac2ed9e0f", size = 392185, upload-time = "2026-03-22T22:11:58.34Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/92/f8/334aa5a7a482ea89cb14d92f6a4d9ffa1e193e733144d4d14c7ffcb33583/scipy_stubs-1.17.1.4-py3-none-any.whl", hash = "sha256:e6e5c390fb864745bc3d5f591de81f5cb4f84403857d4f660acb5b6339956f5b", size = 604752, upload-time = "2026-04-13T11:46:53.135Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/d4/94304532c0a75a55526119043dd44a9bd1541a21e14483cbb54261c527d2/scipy_stubs-1.17.1.3-py3-none-any.whl", hash = "sha256:7b91d3f05aa47da06fbca14eb6c5bb4c28994e9245fd250cc847e375bab31297", size = 597933, upload-time = "2026-03-22T22:11:56.525Z" },
 ]
 
 [[package]]

docker/.env.example

@@ -273,7 +273,7 @@ SQLALCHEMY_POOL_TIMEOUT=30
 # Default is 100
 #
 # Reference: https://www.postgresql.org/docs/current/runtime-config-connection.html#GUC-MAX-CONNECTIONS
-POSTGRES_MAX_CONNECTIONS=200
+POSTGRES_MAX_CONNECTIONS=100
 
 # Sets the amount of shared memory used for postgres's shared buffers.
 # Default is 128MB

docker/docker-compose.yaml

@@ -70,7 +70,7 @@ x-shared-env: &shared-api-worker-env
   SQLALCHEMY_POOL_PRE_PING: ${SQLALCHEMY_POOL_PRE_PING:-false}
   SQLALCHEMY_POOL_USE_LIFO: ${SQLALCHEMY_POOL_USE_LIFO:-false}
   SQLALCHEMY_POOL_TIMEOUT: ${SQLALCHEMY_POOL_TIMEOUT:-30}
-  POSTGRES_MAX_CONNECTIONS: ${POSTGRES_MAX_CONNECTIONS:-200}
+  POSTGRES_MAX_CONNECTIONS: ${POSTGRES_MAX_CONNECTIONS:-100}
   POSTGRES_SHARED_BUFFERS: ${POSTGRES_SHARED_BUFFERS:-128MB}
   POSTGRES_WORK_MEM: ${POSTGRES_WORK_MEM:-4MB}
   POSTGRES_MAINTENANCE_WORK_MEM: ${POSTGRES_MAINTENANCE_WORK_MEM:-64MB}

docs/suggested-questions-configuration.md

@@ -0,0 +1,253 @@
+# Configurable Suggested Questions After Answer
+
+This document explains how to configure the "Suggested Questions After Answer" feature in Dify using environment variables.
+
+## Overview
+
+The suggested questions feature generates follow-up questions after each AI response to help users continue the conversation. By default, Dify generates 3 short questions (under 20 characters each), but you can customize this behavior to better fit your specific use case.
+
+## Environment Variables
+
+### `SUGGESTED_QUESTIONS_PROMPT`
+
+**Description**: Custom prompt template for generating suggested questions.
+
+**Default**:
+
+```
+Please help me predict the three most likely questions that human would ask, and keep each question under 20 characters.
+MAKE SURE your output is the SAME language as the Assistant's latest response.
+The output must be an array in JSON format following the specified schema:
+["question1","question2","question3"]
+```
+
+**Usage Examples**:
+
+1. **Technical/Developer Questions (Your Use Case)**:
+
+   ```bash
+   export SUGGESTED_QUESTIONS_PROMPT='Please help me predict the five most likely technical follow-up questions a developer would ask. Focus on implementation details, best practices, and architecture considerations. Keep each question between 40-60 characters. Output must be JSON array: ["question1","question2","question3","question4","question5"]'
+   ```
+
+1. **Customer Support**:
+
+   ```bash
+   export SUGGESTED_QUESTIONS_PROMPT='Generate 3 helpful follow-up questions that guide customers toward solving their own problems. Focus on troubleshooting steps and common issues. Keep questions under 30 characters. JSON format: ["q1","q2","q3"]'
+   ```
+
+1. **Educational Content**:
+
+   ```bash
+   export SUGGESTED_QUESTIONS_PROMPT='Create 4 thought-provoking questions that help students deeper understand the topic. Focus on concepts, relationships, and applications. Questions should be 25-40 characters. JSON: ["question1","question2","question3","question4"]'
+   ```
+
+1. **Multilingual Support**:
+
+   ```bash
+   export SUGGESTED_QUESTIONS_PROMPT='Generate exactly 3 follow-up questions in the same language as the conversation. Adapt question length appropriately for the language (Chinese: 10-15 chars, English: 20-30 chars, Arabic: 25-35 chars). Always output valid JSON array.'
+   ```
+
+**Important Notes**:
+
+- The prompt must request JSON array output format
+- Include language matching instructions for multilingual support
+- Specify clear character limits or question count requirements
+- Focus on your specific domain or use case
+
+### `SUGGESTED_QUESTIONS_MAX_TOKENS`
+
+**Description**: Maximum number of tokens for the LLM response.
+
+**Default**: `256`
+
+**Usage**:
+
+```bash
+export SUGGESTED_QUESTIONS_MAX_TOKENS=512  # For longer questions or more questions
+```
+
+**Recommended Values**:
+
+- `256`: Default, good for 3-4 short questions
+- `384`: Medium, good for 4-5 medium-length questions
+- `512`: High, good for 5+ longer questions or complex prompts
+- `1024`: Maximum, for very complex question generation
+
+### `SUGGESTED_QUESTIONS_TEMPERATURE`
+
+**Description**: Temperature parameter for LLM creativity.
+
+**Default**: `0.0`
+
+**Usage**:
+
+```bash
+export SUGGESTED_QUESTIONS_TEMPERATURE=0.3  # Balanced creativity
+```
+
+**Recommended Values**:
+
+- `0.0-0.2`: Very focused, predictable questions (good for technical support)
+- `0.3-0.5`: Balanced creativity and relevance (good for general use)
+- `0.6-0.8`: More creative, diverse questions (good for brainstorming)
+- `0.9-1.0`: Maximum creativity (good for educational exploration)
+
+## Configuration Examples
+
+### Example 1: Developer Documentation Chatbot
+
+```bash
+# .env file
+SUGGESTED_QUESTIONS_PROMPT='Generate exactly 5 technical follow-up questions that developers would ask after reading code documentation. Focus on implementation details, edge cases, performance considerations, and best practices. Each question should be 40-60 characters long. Output as JSON array: ["question1","question2","question3","question4","question5"]'
+SUGGESTED_QUESTIONS_MAX_TOKENS=512
+SUGGESTED_QUESTIONS_TEMPERATURE=0.3
+```
+
+### Example 2: Customer Service Bot
+
+```bash
+# .env file
+SUGGESTED_QUESTIONS_PROMPT='Create 3 actionable follow-up questions that help customers resolve their own issues. Focus on common problems, troubleshooting steps, and product features. Keep questions simple and under 25 characters. JSON: ["q1","q2","q3"]'
+SUGGESTED_QUESTIONS_MAX_TOKENS=256
+SUGGESTED_QUESTIONS_TEMPERATURE=0.1
+```
+
+### Example 3: Educational Tutor
+
+```bash
+# .env file
+SUGGESTED_QUESTIONS_PROMPT='Generate 4 thought-provoking questions that help students deepen their understanding of the topic. Focus on relationships between concepts, practical applications, and critical thinking. Questions should be 30-45 characters. Output: ["question1","question2","question3","question4"]'
+SUGGESTED_QUESTIONS_MAX_TOKENS=384
+SUGGESTED_QUESTIONS_TEMPERATURE=0.6
+```
+
+## Implementation Details
+
+### How It Works
+
+1. **Environment Variable Loading**: The system checks for environment variables at startup
+1. **Fallback to Defaults**: If no environment variables are set, original behavior is preserved
+1. **Prompt Template**: The custom prompt is used as-is, allowing full control over question generation
+1. **LLM Parameters**: Custom max_tokens and temperature are passed to the LLM API
+1. **JSON Parsing**: The system expects JSON array output and parses it accordingly
+
+### File Changes
+
+The implementation modifies these files:
+
+- `api/core/llm_generator/prompts.py`: Environment variable support
+- `api/core/llm_generator/llm_generator.py`: Custom LLM parameters
+- `api/.env.example`: Documentation of new variables
+
+### Backward Compatibility
+
+- ✅ **Zero Breaking Changes**: Works exactly as before if no environment variables are set
+- ✅ **Default Behavior Preserved**: Original prompt and parameters used as fallbacks
+- ✅ **No Database Changes**: Pure environment variable configuration
+- ✅ **No UI Changes Required**: Configuration happens at deployment level
+
+## Testing Your Configuration
+
+### Local Testing
+
+1. Set environment variables:
+
+   ```bash
+   export SUGGESTED_QUESTIONS_PROMPT='Your test prompt...'
+   export SUGGESTED_QUESTIONS_MAX_TOKENS=300
+   export SUGGESTED_QUESTIONS_TEMPERATURE=0.4
+   ```
+
+1. Start Dify API:
+
+   ```bash
+   cd api
+   python -m flask run --host 0.0.0.0 --port=5001 --debug
+   ```
+
+1. Test the feature in your chat application and verify the questions match your expectations.
+
+### Monitoring
+
+Monitor the following when testing:
+
+- **Question Quality**: Are questions relevant and helpful?
+- **Language Matching**: Do questions match the conversation language?
+- **JSON Format**: Is output properly formatted as JSON array?
+- **Length Constraints**: Do questions follow your length requirements?
+- **Response Time**: Are the custom parameters affecting performance?
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Invalid JSON Output**:
+
+   - **Problem**: LLM doesn't return valid JSON
+   - **Solution**: Make sure your prompt explicitly requests JSON array format
+
+1. **Questions Too Long/Short**:
+
+   - **Problem**: Questions don't follow length constraints
+   - **Solution**: Be more specific about character limits in your prompt
+
+1. **Too Few/Many Questions**:
+
+   - **Problem**: Wrong number of questions generated
+   - **Solution**: Clearly specify the exact number in your prompt
+
+1. **Language Mismatch**:
+
+   - **Problem**: Questions in wrong language
+   - **Solution**: Include explicit language matching instructions in prompt
+
+1. **Performance Issues**:
+
+   - **Problem**: Slow response times
+   - **Solution**: Reduce `SUGGESTED_QUESTIONS_MAX_TOKENS` or simplify prompt
+
+### Debug Logging
+
+To debug your configuration, you can temporarily add logging to see the actual prompt and parameters being used:
+
+```python
+import logging
+logger = logging.getLogger(__name__)
+
+# In llm_generator.py
+logger.info(f"Suggested questions prompt: {prompt}")
+logger.info(f"Max tokens: {SUGGESTED_QUESTIONS_MAX_TOKENS}")
+logger.info(f"Temperature: {SUGGESTED_QUESTIONS_TEMPERATURE}")
+```
+
+## Migration Guide
+
+### From Default Configuration
+
+If you're currently using the default configuration and want to customize:
+
+1. **Assess Your Needs**: Determine what aspects need customization (question count, length, domain focus)
+1. **Design Your Prompt**: Write a custom prompt that addresses your specific use case
+1. **Choose Parameters**: Select appropriate max_tokens and temperature values
+1. **Test Incrementally**: Start with small changes and test thoroughly
+1. **Deploy Gradually**: Roll out to production after successful testing
+
+### Best Practices
+
+1. **Start Simple**: Begin with minimal changes to the default prompt
+1. **Test Thoroughly**: Test with various conversation types and languages
+1. **Monitor Performance**: Watch for impact on response times and costs
+1. **Get User Feedback**: Collect feedback on question quality and relevance
+1. **Iterate**: Refine your configuration based on real-world usage
+
+## Future Enhancements
+
+This environment variable approach provides immediate customization while maintaining backward compatibility. Future enhancements could include:
+
+1. **App-Level Configuration**: Different apps with different suggested question settings
+1. **Dynamic Prompts**: Context-aware prompts based on conversation content
+1. **Multi-Model Support**: Different models for different types of questions
+1. **Analytics Dashboard**: Insights into question effectiveness and usage patterns
+1. **A/B Testing**: Built-in testing of different prompt configurations
+
+For now, the environment variable approach offers a simple, reliable way to customize the suggested questions feature for your specific needs.

e2e/features/apps/app-detail-navigation.feature

@@ -1,26 +0,0 @@
-@apps @authenticated @core
-Feature: App detail navigation
-
-  Scenario: Opening a workflow app navigates to the workflow editor
-    Given I am signed in as the default E2E admin
-    And a "workflow" app has been created via API
-    When I open the app from the app list
-    Then I should land on the workflow editor
-
-  Scenario: Opening a chatbot app navigates to the configuration page
-    Given I am signed in as the default E2E admin
-    And a "chat" app has been created via API
-    When I open the app from the app list
-    Then I should land on the app configuration page
-
-  Scenario: The develop tab is accessible from a workflow app
-    Given I am signed in as the default E2E admin
-    And a "workflow" app has been created via API
-    When I navigate to the app develop page
-    Then I should be on the app develop page
-
-  Scenario: The overview tab is accessible from a workflow app
-    Given I am signed in as the default E2E admin
-    And a "workflow" app has been created via API
-    When I navigate to the app overview page
-    Then I should be on the app overview page

e2e/features/apps/create-app.feature

@@ -1,4 +1,4 @@
-@apps @authenticated @core
+@apps @authenticated
 Feature: Create app
   Scenario: Create a new blank app and redirect to the editor
     Given I am signed in as the default E2E admin

e2e/features/apps/create-chatbot-app.feature

@@ -1,4 +1,4 @@
-@apps @authenticated @core @mode-matrix
+@apps @authenticated
 Feature: Create Chatbot app
   Scenario: Create a new Chatbot app and redirect to the configuration page
     Given I am signed in as the default E2E admin

e2e/features/apps/create-workflow-app.feature

@@ -1,4 +1,4 @@
-@apps @authenticated @core @mode-matrix
+@apps @authenticated
 Feature: Create Workflow app
   Scenario: Create a new Workflow app and redirect to the workflow editor
     Given I am signed in as the default E2E admin

e2e/features/apps/publish-app.feature

@@ -1,11 +0,0 @@
-@apps @authenticated @core
-Feature: Publish app
-
-  Scenario: Publish a workflow app for the first time
-    Given I am signed in as the default E2E admin
-    And a "workflow" app has been created via API
-    And a minimal workflow draft has been synced
-    When I open the app from the app list
-    And I open the publish panel
-    And I publish the app
-    Then the app should be marked as published

e2e/features/auth/sign-in.feature

@@ -1,8 +0,0 @@
-@auth @smoke @core @unauthenticated
-Feature: Sign in
-
-  Scenario: Sign in with valid credentials and reach the apps console
-    Given I am not signed in
-    When I open the sign-in page
-    And I sign in as the default E2E admin
-    Then I should be on the apps console

e2e/features/auth/sign-out.feature

@@ -1,4 +1,4 @@
-@auth @authenticated @core
+@auth @authenticated
 Feature: Sign out
   Scenario: Sign out from the apps console
     Given I am signed in as the default E2E admin

e2e/features/step-definitions/apps/app-detail-navigation.steps.ts

@@ -1,21 +0,0 @@
-import type { DifyWorld } from '../../support/world'
-import { Then, When } from '@cucumber/cucumber'
-import { expect } from '@playwright/test'
-
-When('I navigate to the app develop page', async function (this: DifyWorld) {
-  const appId = this.createdAppIds.at(-1)
-  await this.getPage().goto(`/app/${appId}/develop`)
-})
-
-When('I navigate to the app overview page', async function (this: DifyWorld) {
-  const appId = this.createdAppIds.at(-1)
-  await this.getPage().goto(`/app/${appId}/overview`)
-})
-
-Then('I should be on the app develop page', async function (this: DifyWorld) {
-  await expect(this.getPage()).toHaveURL(/\/app\/[^/]+\/develop(?:\?.*)?$/, { timeout: 30_000 })
-})
-
-Then('I should be on the app overview page', async function (this: DifyWorld) {
-  await expect(this.getPage()).toHaveURL(/\/app\/[^/]+\/overview(?:\?.*)?$/, { timeout: 30_000 })
-})

e2e/features/step-definitions/apps/publish-app.steps.ts

@@ -1,15 +0,0 @@
-import type { DifyWorld } from '../../support/world'
-import { Then, When } from '@cucumber/cucumber'
-import { expect } from '@playwright/test'
-
-When('I open the publish panel', async function (this: DifyWorld) {
-  await this.getPage().getByRole('button', { name: 'Publish' }).first().click()
-})
-
-When('I publish the app', async function (this: DifyWorld) {
-  await this.getPage().getByRole('button', { name: /Publish Update/ }).click()
-})
-
-Then('the app should be marked as published', async function (this: DifyWorld) {
-  await expect(this.getPage().getByRole('button', { name: 'Published' })).toBeVisible({ timeout: 30_000 })
-})

e2e/features/step-definitions/auth/sign-in.steps.ts

@@ -1,20 +0,0 @@
-import type { DifyWorld } from '../../support/world'
-import { Then, When } from '@cucumber/cucumber'
-import { expect } from '@playwright/test'
-import { adminCredentials } from '../../../fixtures/auth'
-
-When('I open the sign-in page', async function (this: DifyWorld) {
-  await this.getPage().goto('/signin')
-})
-
-When('I sign in as the default E2E admin', async function (this: DifyWorld) {
-  const page = this.getPage()
-
-  await page.getByLabel('Email address').fill(adminCredentials.email)
-  await page.getByLabel('Password').fill(adminCredentials.password)
-  await page.getByRole('button', { name: 'Sign in' }).click()
-})
-
-Then('I should be on the apps console', async function (this: DifyWorld) {
-  await expect(this.getPage()).toHaveURL(/\/apps(?:\?.*)?$/, { timeout: 30_000 })
-})

e2e/features/step-definitions/common/app.steps.ts

@@ -1,22 +0,0 @@
-import type { DifyWorld } from '../../support/world'
-import { Given, When } from '@cucumber/cucumber'
-import { expect } from '@playwright/test'
-import { createTestApp, syncMinimalWorkflowDraft } from '../../../support/api'
-
-Given('a {string} app has been created via API', async function (this: DifyWorld, mode: string) {
-  const app = await createTestApp(`E2E ${Date.now()}`, mode)
-  this.createdAppIds.push(app.id)
-  this.lastCreatedAppName = app.name
-})
-
-Given('a minimal workflow draft has been synced', async function (this: DifyWorld) {
-  const appId = this.createdAppIds.at(-1)!
-  await syncMinimalWorkflowDraft(appId)
-})
-
-When('I open the app from the app list', async function (this: DifyWorld) {
-  const page = this.getPage()
-  await page.goto('/apps')
-  await expect(page.getByRole('button', { name: 'Create from Blank' })).toBeVisible()
-  await page.getByText(this.lastCreatedAppName!).click()
-})

e2e/package.json

@@ -12,14 +12,13 @@
     "e2e:middleware:down": "tsx ./scripts/setup.ts middleware-down",
     "e2e:middleware:up": "tsx ./scripts/setup.ts middleware-up",
     "e2e:reset": "tsx ./scripts/setup.ts reset",
-    "type-check": "tsgo"
+    "type-check": "tsc"
   },
   "devDependencies": {
     "@cucumber/cucumber": "catalog:",
     "@dify/tsconfig": "workspace:*",
     "@playwright/test": "catalog:",
     "@types/node": "catalog:",
-    "@typescript/native-preview": "catalog:",
     "tsx": "catalog:",
     "typescript": "catalog:",
     "vite": "catalog:",

e2e/support/api.ts

@@ -43,34 +43,6 @@ export async function createTestApp(name: string, mode = 'workflow'): Promise<Ap
   }
 }
 
-export async function syncMinimalWorkflowDraft(appId: string): Promise<void> {
-  const ctx = await createApiContext()
-  try {
-    await ctx.post(`/console/api/apps/${appId}/workflows/draft`, {
-      data: {
-        graph: {
-          nodes: [
-            {
-              id: '1',
-              type: 'custom',
-              position: { x: 80, y: 282 },
-              data: { id: '1', type: 'start', title: 'Start', variables: [] },
-            },
-          ],
-          edges: [],
-          viewport: { x: 0, y: 0, zoom: 1 },
-        },
-        features: {},
-        environment_variables: [],
-        conversation_variables: [],
-      },
-    })
-  }
-  finally {
-    await ctx.dispose()
-  }
-}
-
 export async function deleteTestApp(id: string): Promise<void> {
   const ctx = await createApiContext()
   try {