@josephyan/qingflow-app-builder-mcp 0.2.0-beta.4 → 0.2.0-beta.41

package/src/qingflow_mcp/server_app_user.py

@@ -1,34 +1,153 @@
 from __future__ import annotations
 
+from datetime import date
+
 from mcp.server.fastmcp import FastMCP
 
 from .backend_client import BackendClient
 from .config import DEFAULT_PROFILE
 from .session_store import SessionStore
-from .tools.approval_tools import ApprovalTools
+from .tools.app_tools import AppTools
 from .tools.auth_tools import AuthTools
 from .tools.directory_tools import DirectoryTools
+from .tools.feedback_tools import FeedbackTools
 from .tools.file_tools import FileTools
+from .tools.import_tools import ImportTools
 from .tools.record_tools import RecordTools
-from .tools.task_tools import TaskTools
+from .tools.task_context_tools import TaskContextTools
 from .tools.workspace_tools import WorkspaceTools
 
 
 def build_user_server() -> FastMCP:
+    today = date.today()
+    current_year = today.year
     server = FastMCP(
         "Qingflow App User MCP",
-        instructions=(
-            "Use this server for Qingflow record queries, record writes, task center operations, "
-            "directory lookups, and approval actions. Avoid builder-side app or schema changes here."
-        ),
+        instructions=f"""Use this server for Qingflow operational workflows. Current date: `{today.isoformat()}`.
+
+## App Discovery
+
+If `app_key` is unknown, use `app_list` or `app_search` first.
+If the app is known but the data range is not, use `app_get` first and choose from `accessible_views`.
+If an accessible view has `analysis_supported=false`, do not use it for `record_list` or `record_analyze`. `boardView` and `ganttView` are special UI views, not list/analyze targets.
+
+## Shared Helper
+
+`feedback_submit` is always available as a cross-cutting helper.
+
+- Use it when the current MCP capability is unsupported, awkward, or still cannot satisfy the user's need after reasonable use.
+- It does not require Qingflow login or workspace selection.
+- Call it only after the user explicitly confirms submission.
+
+## Schema-First Rule
+
+Call `record_schema_get(schema_mode="applicant")` before `record_write`.
+Call `app_get` first when the data range is unclear, then use `record_schema_get(schema_mode="browse", view_id=...)` before `record_list`, `record_get`, or `record_analyze`.
+
+- All `field_id` values must come from the schema response.
+- Never guess field names or ids.
+
+## Schema Scope
+
+`record_schema_get(schema_mode="applicant")` returns the current user's applicant-node visible fields for write/create.
+`record_schema_get(schema_mode="browse", view_id=...)` returns browse-schema fields for the selected accessible view.
+
+- Hidden fields are omitted.
+- Missing fields mean the field is not visible in the current permission scope.
+- Read `fields` and `suggested_*` from the top level of the schema response.
+
+## Analytics Path
+
+`app_get -> record_schema_get(schema_mode="browse", view_id=...) -> record_analyze`
+
+Prefer `view_id` entries from `accessible_views` where `analysis_supported=true`.
+
+Use this DSL shape:
+
+- `dimensions`: `{{field_id, alias, bucket}}`
+- `metrics`: `{{op, field_id, alias}}`
+- `filters`: `{{field_id, op, value}}`
+- `sort`: `{{by, order}}`
+
+Important key rules:
+
+- Use `op`
+- Do **not** use `type`
+- Do **not** use `agg`
+- Do **not** use `aggregation`
+- Do **not** use `operator`
+
+Analysis answers must include concrete numbers. When applicable, include percentages based on the returned totals.
+
+## Record CRUD Path
+
+`app_get -> record_schema_get(schema_mode="browse", view_id=...) -> record_list / record_get`
+`record_schema_get(schema_mode="applicant") -> record_write`
+
+- Use `columns` as `[{{field_id}}]`
+- Use `where` items as `{{field_id, op, value}}`
+- Use `order_by` items as `{{field_id, direction}}`
+- Legacy forms such as bare integer `field_id`, `fieldId`, `operator`, `values`, or `order` may still parse, but they are compatibility-only and not the canonical DSL
+
+`record_write` uses SQL-like JSON clauses:
+
+- `insert` -> `values`
+- `update` -> `record_id + set`
+- `delete` -> `record_id` or `record_ids`
+
+- Read relation targets from `record_schema_get.target_app_key` / `target_app_name` before preparing relation writes.
+- If a member or department field id is known but candidate ids are not, use `record_member_candidates` or `record_department_candidates` before `record_write`.
+- For default-all member or department fields, prefer those field candidate tools instead of starting with `directory_*`.
+
+## Import Path
+
+`record_import_template_get -> record_import_verify -> (optional authorized record_import_repair_local) -> record_import_start -> record_import_status_get`
+
+- Import must go through `verify -> start`; do not start directly from a raw file path.
+- `record_import_start` requires an explicit `being_enter_auditing` choice. Do not assume a default.
+- Do not modify user-uploaded files unless the user explicitly authorizes repair.
+- If repair is authorized, keep the original file and repair a copy, then run `record_import_verify` again before `record_import_start`.
+
+## Task Workflow Path
+
+`task_list -> task_get -> task_action_execute`
+
+- Use `task_associated_report_detail_get` for associated view or report details.
+- Use `task_workflow_log_get` for full workflow log history.
+- Task actions operate on `app_key + record_id + workflow_node_id`, not `task_id`.
+
+## Time Handling
+
+Normalize relative dates before building DSL.
+
+- If the user says `3月` without a year, use the current year: `{current_year}`
+- Convert month-only phrases into explicit legal date ranges
+- Never send impossible dates such as `2026-02-29`
+
+## Environment
+
+Default to `prod` unless the user explicitly specifies `test`.
+
+## Constraints
+
+Avoid builder-side app or schema changes here.
+
+## Feedback Path
+
+If the current MCP capability is unsupported, the workflow is awkward, or the user's need still cannot be satisfied after reasonable use, offer to submit product feedback.
+
+- First summarize what is still not working
+- Ask the user whether to submit feedback
+- Call `feedback_submit` only after explicit user confirmation""",
     )
     sessions = SessionStore()
     backend = BackendClient()
     auth = AuthTools(sessions, backend)
+    apps = AppTools(sessions, backend)
     workspace = WorkspaceTools(sessions, backend)
     files = FileTools(sessions, backend)
-    approvals = ApprovalTools(sessions, backend)
-    tasks = TaskTools(sessions, backend)
+    imports = ImportTools(sessions, backend)
+    feedback = FeedbackTools(backend, mcp_side="App User MCP")
 
     @server.tool()
     def auth_login(
@@ -92,6 +211,18 @@ def build_user_server() -> FastMCP:
     def workspace_select(profile: str = DEFAULT_PROFILE, ws_id: int = 0) -> dict:
         return workspace.workspace_select(profile=profile, ws_id=ws_id)
 
+    @server.tool()
+    def app_list(profile: str = DEFAULT_PROFILE) -> dict:
+        return apps.app_list(profile=profile)
+
+    @server.tool()
+    def app_search(profile: str = DEFAULT_PROFILE, keyword: str = "", page_num: int = 1, page_size: int = 50) -> dict:
+        return apps.app_search(profile=profile, keyword=keyword, page_num=page_num, page_size=page_size)
+
+    @server.tool()
+    def app_get(profile: str = DEFAULT_PROFILE, app_key: str = "") -> dict:
+        return apps.app_get(profile=profile, app_key=app_key)
+
     @server.tool()
     def file_get_upload_info(
         profile: str = DEFAULT_PROFILE,
@@ -138,188 +269,13 @@ def build_user_server() -> FastMCP:
             file_related_url=file_related_url,
         )
 
+    imports.register(server)
+
+    feedback.register(server)
     RecordTools(sessions, backend).register(server)
+    TaskContextTools(sessions, backend).register(server)
     DirectoryTools(sessions, backend).register(server)
 
-    @server.tool()
-    def record_comment_add(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        payload: dict | None = None,
-    ) -> dict:
-        return approvals.record_comment_add(profile=profile, app_key=app_key, apply_id=apply_id, payload=payload or {})
-
-    @server.tool()
-    def record_comment_list(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        page_size: int = 20,
-        list_type: int | None = None,
-        page_num: int | None = 1,
-    ) -> dict:
-        return approvals.record_comment_list(
-            profile=profile,
-            app_key=app_key,
-            apply_id=apply_id,
-            page_size=page_size,
-            list_type=list_type,
-            page_num=page_num,
-        )
-
-    @server.tool()
-    def record_comment_mention_candidates(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        page_size: int = 20,
-        page_num: int = 1,
-        list_type: int | None = None,
-        keyword: str | None = None,
-    ) -> dict:
-        return approvals.record_comment_mention_candidates(
-            profile=profile,
-            app_key=app_key,
-            apply_id=apply_id,
-            page_size=page_size,
-            page_num=page_num,
-            list_type=list_type,
-            keyword=keyword,
-        )
-
-    @server.tool()
-    def record_comment_mark_read(profile: str = DEFAULT_PROFILE, app_key: str = "", apply_id: int = 0) -> dict:
-        return approvals.record_comment_mark_read(profile=profile, app_key=app_key, apply_id=apply_id)
-
-    @server.tool()
-    def record_comment_stats(profile: str = DEFAULT_PROFILE, app_key: str = "", apply_id: int = 0) -> dict:
-        return approvals.record_comment_stats(profile=profile, app_key=app_key, apply_id=apply_id)
-
-    @server.tool()
-    def task_list(
-        profile: str = DEFAULT_PROFILE,
-        type: int = 1,
-        process_status: int = 1,
-        app_key: str | None = None,
-        node_id: int | None = None,
-        search_key: str | None = None,
-        page_num: int = 1,
-        page_size: int = 20,
-        create_time_asc: bool | None = None,
-    ) -> dict:
-        return tasks.task_list(
-            profile=profile,
-            type=type,
-            process_status=process_status,
-            app_key=app_key,
-            node_id=node_id,
-            search_key=search_key,
-            page_num=page_num,
-            page_size=page_size,
-            create_time_asc=create_time_asc,
-        )
-
-    @server.tool()
-    def task_list_grouped(
-        profile: str = DEFAULT_PROFILE,
-        type: int = 1,
-        process_status: int = 1,
-        app_key: str | None = None,
-        node_id: int | None = None,
-        search_key: str | None = None,
-        page_num: int = 1,
-        page_size: int = 20,
-    ) -> dict:
-        return tasks.task_list_grouped(
-            profile=profile,
-            type=type,
-            process_status=process_status,
-            app_key=app_key,
-            node_id=node_id,
-            search_key=search_key,
-            page_num=page_num,
-            page_size=page_size,
-        )
-
-    @server.tool()
-    def task_statistics(profile: str = DEFAULT_PROFILE, app_key: str | None = None) -> dict:
-        return tasks.task_statistics(profile=profile, app_key=app_key)
-
-    @server.tool()
-    def task_urge(profile: str = DEFAULT_PROFILE, app_key: str = "", row_record_id: int = 0) -> dict:
-        return tasks.task_urge(profile=profile, app_key=app_key, row_record_id=row_record_id)
-
-    @server.tool(description=approvals._high_risk_tool_description(operation="approve", target="workflow task"))
-    def task_approve(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        payload: dict | None = None,
-    ) -> dict:
-        return approvals.record_approve(profile=profile, app_key=app_key, apply_id=apply_id, payload=payload or {})
-
-    @server.tool(description=approvals._high_risk_tool_description(operation="reject", target="workflow task"))
-    def task_reject(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        payload: dict | None = None,
-    ) -> dict:
-        return approvals.record_reject(profile=profile, app_key=app_key, apply_id=apply_id, payload=payload or {})
-
-    @server.tool()
-    def task_rollback_candidates(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        audit_node_id: int = 0,
-    ) -> dict:
-        return approvals.record_rollback_candidates(
-            profile=profile,
-            app_key=app_key,
-            apply_id=apply_id,
-            audit_node_id=audit_node_id,
-        )
-
-    @server.tool()
-    def task_rollback(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        payload: dict | None = None,
-    ) -> dict:
-        return approvals.record_rollback(profile=profile, app_key=app_key, apply_id=apply_id, payload=payload or {})
-
-    @server.tool()
-    def task_transfer_candidates(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        page_size: int = 20,
-        page_num: int = 1,
-        audit_node_id: int = 0,
-        keyword: str | None = None,
-    ) -> dict:
-        return approvals.record_transfer_candidates(
-            profile=profile,
-            app_key=app_key,
-            apply_id=apply_id,
-            page_size=page_size,
-            page_num=page_num,
-            audit_node_id=audit_node_id,
-            keyword=keyword,
-        )
-
-    @server.tool()
-    def task_transfer(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        payload: dict | None = None,
-    ) -> dict:
-        return approvals.record_transfer(profile=profile, app_key=app_key, apply_id=apply_id, payload=payload or {})
-
     return server
 
 

package/src/qingflow_mcp/solution/compiler/form_compiler.py

@@ -249,7 +249,7 @@ def build_question(field: dict[str, Any], temp_id: int) -> tuple[dict[str, Any],
             sub_question, next_temp_id = build_question(subfield, next_temp_id)
             sub_questions.append(sub_question)
         question["subQuestions"] = sub_questions
-        question["innerQuestions"] = deepcopy(sub_questions)
+        question["innerQuestions"] = [deepcopy(sub_questions)]
         question["queDefaultValues"] = {"queId": temp_id, "queTitle": field["label"], "queType": que_type, "values": [], "tableValues": []}
     return question, next_temp_id
 
@@ -257,13 +257,16 @@ def build_question(field: dict[str, Any], temp_id: int) -> tuple[dict[str, Any],
 def build_reference_config(field: dict[str, Any], temp_id: int) -> dict[str, Any]:
     config = field.get("config") or {}
     display_field_id = field.get("target_field_id") or "title"
+    display_field_que_id = field.get("target_field_que_id") or config.get("target_field_que_id") or 0
     display_field_label = config.get("target_field_label") or "__TARGET_FIELD_LABEL__"
     refer_field_ids = list(config.get("refer_field_ids") or [display_field_id])
+    refer_field_que_ids = list(config.get("refer_field_que_ids") or [])
     refer_field_labels = config.get("refer_field_labels") or [display_field_label]
     refer_field_types = config.get("refer_field_types")
     refer_questions = []
     for ordinal, field_id in enumerate(refer_field_ids, start=1):
         label = refer_field_labels[ordinal - 1] if ordinal - 1 < len(refer_field_labels) else field_id
+        que_id = refer_field_que_ids[ordinal - 1] if ordinal - 1 < len(refer_field_que_ids) else 0
         raw_type = _reference_field_type_value(
             refer_field_types,
             field_id=field_id,
@@ -272,7 +275,7 @@ def build_reference_config(field: dict[str, Any], temp_id: int) -> dict[str, Any
         )
         refer_questions.append(
             {
-                "queId": 0,
+                "queId": que_id,
                 "queTitle": label,
                 "queType": _normalize_reference_que_type(raw_type) or "2",
                 "queAuth": 1,
@@ -282,15 +285,22 @@ def build_reference_config(field: dict[str, Any], temp_id: int) -> dict[str, Any
             }
         )
     auth_field_ids = list(config.get("auth_field_ids") or refer_field_ids)
+    auth_field_que_ids = list(config.get("auth_field_que_ids") or [])
+    auth_ques = deepcopy(config.get("refer_auth_ques") or [])
+    if not auth_ques:
+        auth_ques = []
+        for ordinal, field_id in enumerate(auth_field_ids, start=1):
+            que_id = auth_field_que_ids[ordinal - 1] if ordinal - 1 < len(auth_field_que_ids) else 0
+            auth_ques.append({"queId": que_id, "queAuth": 1, "_field_id": field_id})
     return {
         "referAppKey": "__TARGET_APP_KEY__",
-        "referQueId": 0,
+        "referQueId": display_field_que_id,
         "customButtonText": config.get("custom_button_text") or "选择数据",
         "beingTableSource": False,
         "referQuestions": refer_questions,
         "referMatchRules": deepcopy(config.get("refer_match_rules") or []),
         "referFillRules": deepcopy(config.get("refer_fill_rules") or []),
-        "referAuthQues": deepcopy(config.get("refer_auth_ques") or [{"queId": 0, "queAuth": 1, "_field_id": field_id} for field_id in auth_field_ids]),
+        "referAuthQues": auth_ques,
         "canAddData": bool(config.get("can_add_data", False)),
         "dataAdditionButtonText": config.get("data_addition_button_text") or "新增数据",
         "canViewProcessLog": bool(config.get("can_view_process_log", True)),

package/src/qingflow_mcp/solution/compiler/workflow_compiler.py

@@ -36,6 +36,11 @@ def compile_workflow(entity: EntitySpec) -> dict[str, Any] | None:
     actions: list[dict[str, Any]] = []
     seen_node_ids: set[str] = set()
     created_extra_branch_lanes: set[str] = set()
+    start_node_ids = {
+        node.node_id
+        for node in workflow.nodes
+        if node.node_type == WorkflowNodeType.start
+    }
     for node in workflow.nodes:
         if node.node_type == WorkflowNodeType.start:
             seen_node_ids.add(node.node_id)
@@ -58,6 +63,26 @@ def compile_workflow(entity: EntitySpec) -> dict[str, Any] | None:
                 }
             )
             created_extra_branch_lanes.add(branch_lane_ref)
+        lane_only = bool((node.config or {}).get("__lane_only__")) and node.node_type == WorkflowNodeType.condition and branch_lane_ref
+        if lane_only:
+            lane_payload = {key: value for key, value in node.config.items() if key != "__lane_only__"}
+            actions.append(
+                {
+                    "action": "update_node",
+                    "node_id": branch_lane_ref,
+                    "node_name": node.name,
+                    "node_type": node.node_type.value,
+                    "payload": {
+                        "editVersionNo": 1,
+                        "auditNodeName": node.name,
+                        "type": WORKFLOW_TYPE_MAP[node.node_type]["type"],
+                        "dealType": WORKFLOW_TYPE_MAP[node.node_type]["dealType"],
+                        **lane_payload,
+                    },
+                }
+            )
+            seen_node_ids.add(node.node_id)
+            continue
         actions.append(
             {
                 "action": "add_node",
@@ -69,7 +94,7 @@ def compile_workflow(entity: EntitySpec) -> dict[str, Any] | None:
                     "auditNodeName": node.name,
                     "type": WORKFLOW_TYPE_MAP[node.node_type]["type"],
                     "dealType": WORKFLOW_TYPE_MAP[node.node_type]["dealType"],
-                    "prevNodeRef": _prev_node_ref(node, branch_lane_ref),
+                    "prevNodeRef": _prev_node_ref(node, branch_lane_ref, start_node_ids),
                     "auditUserInfos": _build_audit_user_infos(node)
                     if node.node_type in {WorkflowNodeType.audit, WorkflowNodeType.fill, WorkflowNodeType.copy}
                     else None,
@@ -100,17 +125,31 @@ def _build_audit_user_infos(node) -> dict[str, Any]:
     role_refs = assignees.get("role_refs") or []
     if role_refs:
         audit_user_infos["role_refs"] = [role_ref for role_ref in role_refs if role_ref]
+    role_entries = assignees.get("role_entries") or []
+    if role_entries:
+        audit_user_infos["role"] = [
+            {
+                "roleId": int(entry.get("roleId") or entry.get("role_id")),
+                "roleName": entry.get("roleName") or entry.get("role_name") or str(entry.get("roleId") or entry.get("role_id")),
+                "roleIcon": entry.get("roleIcon") or entry.get("role_icon") or "ex-user-outlined",
+                "beingFrontendConfig": True,
+            }
+            for entry in role_entries
+            if isinstance(entry, dict) and isinstance(entry.get("roleId") or entry.get("role_id"), int) and int(entry.get("roleId") or entry.get("role_id")) > 0
+        ]
     include_sub_departs = assignees.get("include_sub_departs")
     if include_sub_departs is not None:
         audit_user_infos["includeSubDeparts"] = bool(include_sub_departs)
     return audit_user_infos
 
 
-def _prev_node_ref(node, branch_lane_ref: str | None) -> str:
+def _prev_node_ref(node, branch_lane_ref: str | None, start_node_ids: set[str]) -> str:
     if branch_lane_ref:
         if node.parent_node_id and node.parent_node_id != node.branch_parent_id:
             return node.parent_node_id
         return branch_lane_ref
+    if node.parent_node_id in start_node_ids:
+        return "__applicant__"
     return node.parent_node_id or "__applicant__"
 
 

package/src/qingflow_mcp/solution/executor.py

@@ -415,13 +415,13 @@ class SolutionExecutor:
         current_nodes = _coerce_workflow_nodes(existing_nodes)
         existing_nodes_by_name = {
             node.get("auditNodeName"): int(node_id)
-            for node_id, node in existing_nodes.items()
+            for node_id, node in current_nodes.items()
             if isinstance(node, dict) and node.get("auditNodeName")
         }
         applicant_node_id = next(
             (
                 int(node_id)
-                for node_id, node in existing_nodes.items()
+                for node_id, node in current_nodes.items()
                 if isinstance(node, dict) and node.get("type") == 0 and node.get("dealType") == 3
             ),
             None,
@@ -429,11 +429,24 @@ class SolutionExecutor:
         if applicant_node_id is not None:
             node_artifacts.setdefault("__applicant__", applicant_node_id)
 
-        current_global_settings = self.workflow_tools.workflow_get_global_settings(profile=profile, app_key=app_key).get("result") or {}
-        global_settings = deepcopy(current_global_settings if isinstance(current_global_settings, dict) else {})
-        global_settings.update(entity.workflow_plan["global_settings"])
-        global_settings["editVersionNo"] = workflow_edit_version_no or global_settings.get("editVersionNo") or 1
-        self.workflow_tools.workflow_update_global_settings(profile=profile, app_key=app_key, payload=global_settings)
+        desired_global_settings = deepcopy(entity.workflow_plan["global_settings"])
+        explicit_global_settings = _has_explicit_workflow_global_settings(desired_global_settings)
+        current_global_settings: dict[str, Any] = {}
+        if explicit_global_settings:
+            current_global_settings = self.workflow_tools.workflow_get_global_settings(profile=profile, app_key=app_key).get("result") or {}
+        else:
+            try:
+                current_global_settings = self.workflow_tools.workflow_get_global_settings(profile=profile, app_key=app_key).get("result") or {}
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = QingflowApiError(**_coerce_nested_error_payload(error))
+                if api_error.http_status != 404:
+                    raise
+                current_global_settings = {}
+        if explicit_global_settings:
+            global_settings = deepcopy(current_global_settings if isinstance(current_global_settings, dict) else {})
+            global_settings.update(desired_global_settings)
+            global_settings["editVersionNo"] = workflow_edit_version_no or global_settings.get("editVersionNo") or 1
+            self.workflow_tools.workflow_update_global_settings(profile=profile, app_key=app_key, payload=global_settings)
         for action in entity.workflow_plan["actions"]:
             if action["action"] == "create_sub_branch" and node_artifacts.get(action["node_id"]) is not None:
                 continue
@@ -462,6 +475,16 @@ class SolutionExecutor:
                 payload["editVersionNo"] = int(workflow_edit_version_no)
             if action["action"] == "create_sub_branch":
                 result = self.workflow_tools.workflow_create_sub_branch(profile=profile, app_key=app_key, payload=payload)
+            elif action["action"] == "update_node":
+                target_node_id = node_artifacts.get(action["node_id"])
+                if target_node_id is None:
+                    raise RuntimeError(f"workflow lane '{action['node_id']}' could not be resolved before update")
+                result = self.workflow_tools.workflow_update_node(
+                    profile=profile,
+                    app_key=app_key,
+                    audit_node_id=target_node_id,
+                    payload=payload,
+                )
             else:
                 result = self.workflow_tools.workflow_add_node(profile=profile, app_key=app_key, payload=payload)
             expected_type = 1 if action.get("node_type") == "branch" else None
@@ -2046,6 +2069,20 @@ def _find_created_sub_branch_lane_id(
     return candidates[0] if candidates else None
 
 
+def _has_explicit_workflow_global_settings(global_settings: dict[str, Any] | None) -> bool:
+    if not isinstance(global_settings, dict):
+        return False
+    for key, value in global_settings.items():
+        if key == "editVersionNo":
+            continue
+        if value is None:
+            continue
+        if isinstance(value, (list, dict)) and not value:
+            continue
+        return True
+    return False
+
+
 def _is_navigation_plugin_unavailable(error: QingflowApiError) -> bool:
     try:
         backend_code = int(error.backend_code)