@qingflow-tech/qingflow-app-builder-mcp 1.0.44 → 1.1.1

package/src/qingflow_mcp/builder_facade/workflow_spec.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..backend_client import BackendClient, BackendRequestContext
+from ..json_types import JSONObject, JSONValue
+
+WORKFLOW_SPEC_SCHEMA_PATH = "/api/workflow/spec/schema"
+WORKFLOW_SPEC_GET_PATH = "/api/workflow/spec"
+WORKFLOW_SPEC_APPLY_PATH = "/api/workflow/spec:apply"
+DEFAULT_SCHEMA_VERSION = "vnext-2026-06"
+
+
+def fetch_schema(
+    backend: BackendClient,
+    context: BackendRequestContext,
+    *,
+    schema_version: str | None = None,
+) -> JSONValue:
+    params: JSONObject = {}
+    if schema_version:
+        params["schemaVersion"] = schema_version
+    return backend.request(
+        "GET",
+        context,
+        WORKFLOW_SPEC_SCHEMA_PATH,
+        params=params or None,
+    )
+
+
+def fetch_spec(
+    backend: BackendClient,
+    context: BackendRequestContext,
+    *,
+    app_key: str,
+    version_id: str | None = None,
+) -> JSONValue:
+    params: JSONObject = {"appKey": app_key}
+    if version_id:
+        params["versionId"] = version_id
+    return backend.request("GET", context, WORKFLOW_SPEC_GET_PATH, params=params)
+
+
+def post_apply(
+    backend: BackendClient,
+    context: BackendRequestContext,
+    *,
+    apply_body: JSONObject,
+) -> JSONValue:
+    return backend.request("POST", context, WORKFLOW_SPEC_APPLY_PATH, json_body=apply_body)
+
+
+def verify_apply_response(
+    *,
+    input_spec: JSONObject,
+    apply_result: JSONObject,
+) -> tuple[JSONObject, list[dict[str, Any]], bool]:
+    warnings: list[dict[str, Any]] = []
+    applied_spec = apply_result.get("appliedSpec")
+    diff_summary = apply_result.get("diffSummary")
+    semantic_lint = apply_result.get("semanticLint") if isinstance(apply_result.get("semanticLint"), list) else []
+
+    verification: JSONObject = {
+        "applied_spec_available": isinstance(applied_spec, dict),
+        "version_snapshot_confirmed": False,
+    }
+
+    lint_errors = [
+        item
+        for item in semantic_lint
+        if isinstance(item, dict) and str(item.get("severity") or item.get("level") or "").upper() == "ERROR"
+    ]
+    if lint_errors:
+        verification["semantic_lint_error_count"] = len(lint_errors)
+        for item in lint_errors:
+            warnings.append(
+                {
+                    "code": item.get("code") or "SEMANTIC_LINT_ERROR",
+                    "message": item.get("message") or "workflow spec semantic lint error",
+                    "path": item.get("path"),
+                }
+            )
+
+    diff_failed = False
+    input_ids: set[str] = set()
+    if isinstance(input_spec, dict):
+        input_ids = {
+            str(node.get("id"))
+            for node in (input_spec.get("nodes") or [])
+            if isinstance(node, dict) and node.get("id") is not None
+        }
+    if isinstance(diff_summary, dict) and input_ids:
+        removed = diff_summary.get("nodes", {}).get("removed") if isinstance(diff_summary.get("nodes"), dict) else None
+        if isinstance(removed, list):
+            unexpected = [node_id for node_id in removed if str(node_id) in input_ids]
+            if unexpected:
+                diff_failed = True
+                verification["unexpected_removed_node_ids"] = unexpected
+
+    if isinstance(applied_spec, dict) and isinstance(input_spec, dict):
+        applied_ids = {
+            str(node.get("id"))
+            for node in (applied_spec.get("nodes") or [])
+            if isinstance(node, dict) and node.get("id") is not None
+        }
+        missing_input_ids = sorted(node_id for node_id in input_ids if node_id not in applied_ids)
+        if missing_input_ids and not diff_failed:
+            verification["missing_input_node_ids"] = missing_input_ids
+
+    verified = not lint_errors and not diff_failed and verification.get("applied_spec_available") is True
+    return verification, warnings, verified

package/src/qingflow_mcp/cli/commands/builder.py

@@ -222,15 +222,25 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     views_apply_apply.add_argument("--remove-views-file")
     views_apply_apply.set_defaults(handler=_handle_views_apply, format_hint="builder_summary", force_json_output=True)
 
-    flow_apply = builder_subparsers.add_parser("flow", help="流程")
-    flow_apply_subparsers = flow_apply.add_subparsers(dest="builder_flow_command", required=True)
-    flow_apply_apply = flow_apply_subparsers.add_parser("apply", help="执行流程变更")
-    flow_apply_apply.add_argument("--app-key", required=True)
-    flow_apply_apply.add_argument("--mode", choices=["replace"], default="replace")
-    flow_apply_apply.add_argument("--publish", action=argparse.BooleanOptionalAction, default=True)
-    flow_apply_apply.add_argument("--nodes-file", required=True)
-    flow_apply_apply.add_argument("--transitions-file", required=True)
-    flow_apply_apply.set_defaults(handler=_handle_flow_apply, format_hint="builder_summary", force_json_output=True)
+    flow_parser = builder_subparsers.add_parser("flow", help="流程（WorkflowSpec）")
+    flow_subparsers = flow_parser.add_subparsers(dest="builder_flow_command", required=True)
+
+    flow_schema = flow_subparsers.add_parser("schema", help="读取 WorkflowSpec JSON Schema")
+    flow_schema.add_argument("--schema-version", default="")
+    flow_schema.set_defaults(handler=_handle_flow_schema, format_hint="builder_summary")
+
+    flow_get = flow_subparsers.add_parser("get", help="读取 WorkflowSpec")
+    flow_get.add_argument("--app-key", required=True)
+    flow_get.add_argument("--version-id", default="")
+    flow_get.set_defaults(handler=_handle_flow_get, format_hint="builder_summary")
+
+    flow_apply = flow_subparsers.add_parser("apply", help="应用 WorkflowSpec")
+    flow_apply.add_argument("--app-key", required=True)
+    flow_apply.add_argument("--spec-file", required=True)
+    flow_apply.add_argument("--publish", action=argparse.BooleanOptionalAction, default=True)
+    flow_apply.add_argument("--idempotency-key", default="")
+    flow_apply.add_argument("--schema-version", default="")
+    flow_apply.set_defaults(handler=_handle_flow_apply, format_hint="builder_summary", force_json_output=True)
 
     charts_apply = builder_subparsers.add_parser("charts", help="报表")
     charts_apply_subparsers = charts_apply.add_subparsers(dest="builder_charts_command", required=True)
@@ -720,14 +730,36 @@ def _handle_views_apply(args: argparse.Namespace, context: CliContext) -> dict:
     )
 
 
+def _handle_flow_schema(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.builder.app_flow_get_schema(
+        profile=args.profile,
+        schema_version=args.schema_version or None,
+    )
+
+
+def _handle_flow_get(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.builder.app_get_flow(
+        profile=args.profile,
+        app_key=args.app_key,
+        version_id=args.version_id or None,
+    )
+
+
 def _handle_flow_apply(args: argparse.Namespace, context: CliContext) -> dict:
+    spec_payload = load_object_arg(args.spec_file, option_name="--spec-file")
+    if not isinstance(spec_payload, dict):
+        raise_config_error("flow apply --spec-file must contain a JSON object.")
+    if "spec" in spec_payload and isinstance(spec_payload.get("spec"), dict):
+        spec = spec_payload["spec"]
+    else:
+        spec = spec_payload
     return context.builder.app_flow_apply(
         profile=args.profile,
         app_key=args.app_key,
-        mode=args.mode,
         publish=bool(args.publish),
-        nodes=require_list_arg(args.nodes_file, option_name="--nodes-file"),
-        transitions=require_list_arg(args.transitions_file, option_name="--transitions-file"),
+        spec=spec,
+        idempotency_key=args.idempotency_key or None,
+        schema_version=args.schema_version or None,
     )
 
 

package/src/qingflow_mcp/public_surface.py

@@ -158,6 +158,8 @@ BUILDER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(BUILDER_DOMAIN, "chart_get", ("chart_get",), ("builder", "chart", "get"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_schema_apply", ("app_schema_apply",), ("builder", "schema", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_layout_apply", ("app_layout_apply",), ("builder", "layout", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
+    PublicToolSpec(BUILDER_DOMAIN, "app_flow_get_schema", ("app_flow_get_schema",), ("builder", "flow", "schema"), has_contract=True, cli_show_effective_context=True),
+    PublicToolSpec(BUILDER_DOMAIN, "app_flow_get", ("app_flow_get",), ("builder", "flow", "get"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_flow_apply", ("app_flow_apply",), ("builder", "flow", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_views_apply", ("app_views_apply",), ("builder", "views", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_charts_apply", ("app_charts_apply",), ("builder", "charts", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),

package/src/qingflow_mcp/server_app_builder.py

@@ -37,7 +37,7 @@ def build_builder_server() -> FastMCP:
             "Use solution_install when the user explicitly wants to install a packaged solution/template by solution_key, optionally copying bundled demo data. "
             "Use package_list to find visible app packages by keyword and package_get to read package detail before editing; if creating or updating an app package may be appropriate, use package_apply with explicit user intent; otherwise use app_resolve to locate app resources, "
             "Use workspace_icon_catalog_get before creating app packages, apps, or portals when supported icon/color candidates are needed; new workspace resources require explicit non-template icon + color, and the CLI validates choices without inferring business defaults. "
-            "app_get as the default app map read, then app_get_fields/app_repair_code_blocks/app_get_layout/app_get_views/app_get_flow/app_get_charts/portal_list/portal_get/view_get/chart_get for focused configuration reads, "
+            "app_get as the default app map read, then app_get_fields/app_repair_code_blocks/app_get_layout/app_get_views/app_get_flow/app_flow_get/app_flow_get_schema/app_get_charts/portal_list/portal_get/view_get/chart_get for focused configuration reads, "
             "member_search/role_search/role_create when workflow assignees must come from the directory or role catalog, preferring roles over explicit members unless the user explicitly names members, "
             "then app_schema_apply/app_layout_apply/app_flow_apply/app_views_apply/app_custom_buttons_apply/app_associated_resources_apply/app_charts_apply/portal_apply/portal_delete to execute normalized patches; these apply/delete tools perform planning, normalization, and dependency checks internally where applicable. Schema/layout/views noop requests skip publish, app_custom_buttons_apply and app_associated_resources_apply publish after at least one write succeeds and expose no draft-only parameter, charts are immediate-live without publish and resolve targets by chart_id first then exact unique chart name, portal updates use replace semantics only when sections are supplied and edit-mode base-info-only updates may omit sections, portal delete separates DELETE execution from readback verification, portal pc layout is a 24-column grid and mobile is a 6-column grid so omit position or use layout_preset when unsure, publish=false only guarantees draft/base-info updates for tools that still expose that parameter, and flow should use publish=false whenever you only want draft/precheck behavior. "
             "Builder apply/write outputs include schema_version, operation, summary, and resources[]; use resources[].id/key/name/ids/parent as the stable UI and agent display entry, and keep legacy fields such as field_diff/views_diff/chart_results only for compatibility or troubleshooting. "
@@ -52,7 +52,7 @@ def build_builder_server() -> FastMCP:
             "For associated reports/views, use app_associated_resources_apply for both the app-level associated_resources pool and per-view display config; associated_item_id is the app-level form_asos_chart.id, and view_configs/remove/reorder may also pass an existing resource's chart_id/chart_key/view_key because the tool resolves those to the internal id. Before creating an associated resource, read app_get.associated_resources and reuse an existing matching target_app_key + view_key/chart_key through patch_resources; client_key only works inside one apply call and is not persisted. Do not ask agents to pass backend raw sourceType: views infer the internal Qingflow view source, reports default to BI app reports, and dataset reports use report_source=dataset. "
             "For code_block fields with output bindings, always use qf_output assignment rather than const/let qf_output, and use app_repair_code_blocks when an existing form hangs because output-bound fields stay loading. "
             "Use package_apply to manage package metadata, visibility, grouping, and ordering, and app_publish_verify for explicit final publish verification. "
-            "For workflow edits, keep the public builder surface on stable linear flows only: start/approve/fill/copy/webhook/end. Branch and condition nodes are intentionally disabled because the backend workflow route is not front-end stable for those node types. Declare node assignees and editable fields explicitly. "
+            "For workflow edits, use app_flow_get_schema and app_flow_get (GET-first), author a complete WorkflowSpecDTO in spec, then app_flow_apply; CLI equivalent is qingflow builder flow schema|get|apply --spec-file. Do not use general-server legacy workflow config reads (auditNodes list/detail, global settings, qsource config reads); they are removed. "
             "If builder writes are blocked by the current user's own edit lock, use app_release_edit_lock_if_mine with the lock owner details from the failed result. "
             "Do not handcraft internal solution payloads or rely on build_id/stage/repair. "
             "If the current MCP capability is unsupported, the workflow is awkward, or the user's need still cannot be satisfied after reasonable use, first summarize the gap, ask whether to submit feedback, and call feedback_submit only after explicit user confirmation."
@@ -485,22 +485,30 @@ def build_builder_server() -> FastMCP:
     ) -> dict:
         return ai_builder.app_layout_apply(profile=profile, app_key=app_key, mode=mode, publish=publish, sections=sections or [])
 
+    @server.tool()
+    def app_flow_get(profile: str = DEFAULT_PROFILE, app_key: str = "", version_id: str = "") -> dict:
+        return ai_builder.app_get_flow(profile=profile, app_key=app_key, version_id=version_id or None)
+
+    @server.tool()
+    def app_flow_get_schema(profile: str = DEFAULT_PROFILE, schema_version: str = "") -> dict:
+        return ai_builder.app_flow_get_schema(profile=profile, schema_version=schema_version or None)
+
     @server.tool()
     def app_flow_apply(
         profile: str = DEFAULT_PROFILE,
         app_key: str = "",
-        mode: str = "replace",
         publish: bool = True,
-        nodes: list[dict] | None = None,
-        transitions: list[dict] | None = None,
+        spec: dict | None = None,
+        idempotency_key: str = "",
+        schema_version: str = "",
     ) -> dict:
         return ai_builder.app_flow_apply(
             profile=profile,
             app_key=app_key,
-            mode=mode,
             publish=publish,
-            nodes=nodes or [],
-            transitions=transitions or [],
+            spec=spec or {},
+            idempotency_key=idempotency_key or None,
+            schema_version=schema_version or None,
         )
 
     @server.tool()

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

@@ -10,8 +10,6 @@ from .navigation_compiler import compile_navigation
 from .package_compiler import compile_package
 from .portal_compiler import compile_portal
 from .view_compiler import compile_views
-from .workflow_compiler import compile_workflow
-
 
 @dataclass(slots=True)
 class ExecutionStep:
@@ -101,7 +99,7 @@ def compile_solution(spec: SolutionSpec) -> CompiledSolution:
 
 def compile_entity(entity: EntitySpec, *, include_package: bool) -> CompiledEntity:
     app_create_payload, form_base_payload, form_relation_payload, field_specs, field_labels = compile_entity_form(entity, include_package=include_package)
-    workflow_plan = compile_workflow(entity)
+    workflow_plan = None
     view_plans = compile_views(entity)
     chart_plans = compile_charts(entity)
     return CompiledEntity(

package/src/qingflow_mcp/solution/executor.py

@@ -14,7 +14,6 @@ from ..tools.qingbi_report_tools import QingbiReportTools
 from ..tools.record_tools import RecordTools
 from ..tools.role_tools import RoleTools
 from ..tools.view_tools import ViewTools
-from ..tools.workflow_tools import WorkflowTools
 from ..tools.workspace_tools import WorkspaceTools
 from .compiler import CompiledEntity, CompiledRole, CompiledSolution
 from .compiler.form_compiler import QUESTION_TYPE_MAP
@@ -36,7 +35,6 @@ class SolutionExecutor:
         role_tools: RoleTools,
         app_tools: AppTools,
         record_tools: RecordTools,
-        workflow_tools: WorkflowTools,
         view_tools: ViewTools,
         chart_tools: QingbiReportTools,
         portal_tools: PortalTools,
@@ -47,7 +45,6 @@ class SolutionExecutor:
         self.role_tools = role_tools
         self.app_tools = app_tools
         self.record_tools = record_tools
-        self.workflow_tools = workflow_tools
         self.view_tools = view_tools
         self.chart_tools = chart_tools
         self.portal_tools = portal_tools
@@ -456,123 +453,10 @@ class SolutionExecutor:
     def _build_workflow(self, profile: str, entity: CompiledEntity, store: RunArtifactStore) -> None:
         if entity.workflow_plan is None:
             return
-        app_key = self._get_app_key(store, entity.entity_id)
-        workflow_edit_version_no = self._ensure_edit_version(
-            profile,
-            entity.entity_id,
-            store,
-            app_key=app_key,
-            force_new=True,
-        )
-        node_artifacts = store.get_artifact("apps", entity.entity_id, {}).get("workflow_nodes", {})
-        existing_nodes = self.workflow_tools.workflow_list_nodes(profile=profile, app_key=app_key).get("result") or {}
-        current_nodes = _coerce_workflow_nodes(existing_nodes)
-        existing_nodes_by_name = {
-            node.get("auditNodeName"): int(node_id)
-            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 current_nodes.items()
-                if isinstance(node, dict) and node.get("type") == 0 and node.get("dealType") == 3
-            ),
-            None,
+        raise RuntimeError(
+            "Legacy auditNode workflow execution was removed. "
+            "Pass {app_key, spec} to solution_build_flow or use qingflow builder flow apply."
         )
-        if applicant_node_id is not None:
-            node_artifacts.setdefault("__applicant__", applicant_node_id)
-
-        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
-            if action["action"] == "add_node":
-                if action.get("node_type") == "branch":
-                    existing_branch_id = node_artifacts.get(action["node_id"])
-                    if existing_branch_id is not None and not _workflow_node_is_branch(current_nodes, existing_branch_id):
-                        existing_branch_id = None
-                    if existing_branch_id is not None:
-                        for branch_index, lane_id in enumerate(_find_branch_lane_ids(current_nodes, existing_branch_id), start=1):
-                            node_artifacts[_branch_lane_ref(action["node_id"], branch_index)] = lane_id
-                        apps_artifact = store.get_artifact("apps", entity.entity_id, {})
-                        apps_artifact["workflow_nodes"] = node_artifacts
-                        store.set_artifact("apps", entity.entity_id, apps_artifact)
-                        continue
-                existing_node_id = node_artifacts.get(action["node_id"]) or existing_nodes_by_name.get(action.get("node_name"))
-                if existing_node_id is not None:
-                    node_artifacts[action["node_id"]] = existing_node_id
-                    apps_artifact = store.get_artifact("apps", entity.entity_id, {})
-                    apps_artifact["workflow_nodes"] = node_artifacts
-                    store.set_artifact("apps", entity.entity_id, apps_artifact)
-                    continue
-            before_node_ids = set(current_nodes)
-            payload = self._resolve_workflow_payload(action["payload"], node_artifacts)
-            if workflow_edit_version_no is not None:
-                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
-            audit_node_id = _extract_workflow_node_id(result.get("result"), expected_type=expected_type)
-            if action.get("node_type") == "branch" or action["action"] == "create_sub_branch":
-                current_nodes = _coerce_workflow_nodes(
-                    self.workflow_tools.workflow_list_nodes(profile=profile, app_key=app_key).get("result") or {}
-                )
-            if audit_node_id is not None:
-                node_artifacts[action["node_id"]] = audit_node_id
-            if action.get("node_type") == "branch":
-                branch_node_id = node_artifacts.get(action["node_id"]) or _find_created_branch_node_id(
-                    current_nodes,
-                    before_node_ids=before_node_ids,
-                    prev_id=payload.get("prevId"),
-                )
-                if branch_node_id is not None:
-                    node_artifacts[action["node_id"]] = branch_node_id
-                for branch_index, lane_id in enumerate(_find_branch_lane_ids(current_nodes, branch_node_id), start=1):
-                    node_artifacts[_branch_lane_ref(action["node_id"], branch_index)] = lane_id
-            if action["action"] == "create_sub_branch" and node_artifacts.get(action["node_id"]) is None:
-                created_lane_id = audit_node_id or _find_created_sub_branch_lane_id(
-                    current_nodes,
-                    before_node_ids=before_node_ids,
-                    branch_node_id=payload.get("auditNodeId"),
-                )
-                if created_lane_id is not None:
-                    node_artifacts[action["node_id"]] = created_lane_id
-                apps_artifact = store.get_artifact("apps", entity.entity_id, {})
-                apps_artifact["workflow_nodes"] = node_artifacts
-                store.set_artifact("apps", entity.entity_id, apps_artifact)
-        apps_artifact = store.get_artifact("apps", entity.entity_id, {})
-        apps_artifact["workflow_nodes"] = node_artifacts
-        store.set_artifact("apps", entity.entity_id, apps_artifact)
 
     def _build_views(self, profile: str, entity: CompiledEntity, store: RunArtifactStore) -> None:
         app_key = self._get_app_key(store, entity.entity_id)
@@ -2157,20 +2041,6 @@ 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:
     if is_auth_like_error(error):
         return False