@josephyan/qingflow-app-builder-mcp 1.1.24 → 1.1.26

package/src/qingflow_mcp/tools/task_context_tools.py

@@ -9,12 +9,12 @@ from mcp.server.fastmcp import FastMCP
 
 from ..backend_client import BackendRequestContext
 from ..config import DEFAULT_PROFILE
-from ..errors import QingflowApiError, backend_code_int, backend_code_value_int, is_auth_like_error, message_looks_like_invalid_token, raise_tool_error
+from ..errors import QingflowApiError, raise_tool_error
 from ..id_utils import ids_equal, normalize_positive_id_int, normalize_positive_id_text, stringify_backend_id
 from ..json_types import JSONObject
 from .approval_tools import ApprovalTools, _approval_page_amount, _approval_page_items, _approval_page_total
 from .base import ToolBase, tool_cn_name
-from .qingbi_report_tools import _qingbi_base_url, _should_retry_asos_data
+from .qingbi_report_tools import _qingbi_base_url
 from .record_tools import (
     FieldIndex,
     LAYOUT_ONLY_QUE_TYPES,
@@ -38,9 +38,6 @@ from .record_tools import (
 from .task_tools import TaskTools, _task_page_amount, _task_page_items, _task_page_total
 
 
-TASK_LOCATOR_MAX_SCAN_PAGES_PER_BOX = 3
-
-
 class TaskContextTools(ToolBase):
     """任务上下文工具（中文名：任务上下文与审批执行）。
 
@@ -88,37 +85,33 @@ class TaskContextTools(ToolBase):
                 page_size=page_size,
             )
 
-        @mcp.tool(
-            description=(
-                "Read one workflow task. Prefer task_id from task_list.data.items[].task_id; "
-                "task_id is not a row number, list index, record id, or workflow node id."
-            )
-        )
+        @mcp.tool()
         def task_get(
             profile: str = DEFAULT_PROFILE,
             task_id: str = "",
+            app_key: str = "",
+            record_id: str = "",
+            workflow_node_id: int = 0,
             include_candidates: bool = True,
             include_associated_reports: bool = True,
         ) -> dict[str, Any]:
             return self.task_get(
                 profile=profile,
                 task_id=task_id,
-                app_key="",
-                record_id="",
-                workflow_node_id=0,
+                app_key=app_key,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
                 include_candidates=include_candidates,
                 include_associated_reports=include_associated_reports,
             )
 
-        @mcp.tool(
-            description=(
-                self._high_risk_tool_description(operation="execute", target="workflow task action")
-                + " Pass task_id from task_list.data.items[].task_id. Do not pass a row number, list index, record id, or workflow node id as task_id."
-            )
-        )
+        @mcp.tool(description=self._high_risk_tool_description(operation="execute", target="workflow task action"))
         def task_action_execute(
             profile: str = DEFAULT_PROFILE,
             task_id: str = "",
+            app_key: str = "",
+            record_id: str = "",
+            workflow_node_id: int = 0,
             action: str = "",
             payload: dict[str, Any] | None = None,
             fields: dict[str, Any] | None = None,
@@ -126,20 +119,21 @@ class TaskContextTools(ToolBase):
             return self.task_action_execute(
                 profile=profile,
                 task_id=task_id,
+                app_key=app_key,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
                 action=action,
                 payload=payload or {},
                 fields=fields or {},
             )
 
-        @mcp.tool(
-            description=(
-                "Read a task-associated report. Pass task_id from task_list.data.items[].task_id; "
-                "task_id is not a row number, list index, record id, or workflow node id."
-            )
-        )
+        @mcp.tool()
         def task_associated_report_detail_get(
             profile: str = DEFAULT_PROFILE,
             task_id: str = "",
+            app_key: str = "",
+            record_id: str = "",
+            workflow_node_id: int = 0,
             report_id: int = 0,
             page: int = 1,
             page_size: int = 20,
@@ -147,30 +141,28 @@ class TaskContextTools(ToolBase):
             return self.task_associated_report_detail_get(
                 profile=profile,
                 task_id=task_id,
-                app_key="",
-                record_id="",
-                workflow_node_id=0,
+                app_key=app_key,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
                 report_id=report_id,
                 page=page,
                 page_size=page_size,
             )
 
-        @mcp.tool(
-            description=(
-                "Read workflow log for one task context. Pass task_id from task_list.data.items[].task_id; "
-                "task_id is not a row number, list index, record id, or workflow node id."
-            )
-        )
+        @mcp.tool()
         def task_workflow_log_get(
             profile: str = DEFAULT_PROFILE,
             task_id: str = "",
+            app_key: str = "",
+            record_id: str = "",
+            workflow_node_id: int = 0,
         ) -> dict[str, Any]:
             return self.task_workflow_log_get(
                 profile=profile,
                 task_id=task_id,
-                app_key="",
-                record_id="",
-                workflow_node_id=0,
+                app_key=app_key,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
             )
 
     @tool_cn_name("任务上下文列表")
@@ -279,7 +271,6 @@ class TaskContextTools(ToolBase):
             resolved_app_key = str(locator["app_key"])
             resolved_record_id = int(locator["record_id"])
             resolved_workflow_node_id = int(locator["workflow_node_id"])
-            resolved_task_box = str(locator.get("task_box") or "todo")
             self._require_app_record_and_node(resolved_app_key, resolved_record_id, resolved_workflow_node_id)
             data = self._build_task_context(
                 profile=profile,
@@ -287,12 +278,10 @@ class TaskContextTools(ToolBase):
                 app_key=resolved_app_key,
                 record_id=resolved_record_id,
                 workflow_node_id=resolved_workflow_node_id,
-                task_box=resolved_task_box,
                 include_candidates=include_candidates,
                 include_associated_reports=include_associated_reports,
                 current_uid=session_profile.uid,
             )
-            context_warnings = data.get("warnings") if isinstance(data.get("warnings"), list) else []
             data = self._compact_task_get_context(data)
             task_payload = data.get("task")
             if isinstance(task_payload, dict) and task_id_text is not None:
@@ -302,7 +291,7 @@ class TaskContextTools(ToolBase):
                 "ws_id": session_profile.selected_ws_id,
                 "ok": True,
                 "request_route": self._request_route_payload(context),
-                "warnings": context_warnings,
+                "warnings": [],
                 "output_profile": "normal",
                 "data": data,
             }
@@ -314,7 +303,9 @@ class TaskContextTools(ToolBase):
         self,
         *,
         profile: str,
-        task_id: Any,
+        app_key: str,
+        record_id: Any,
+        workflow_node_id: int,
         fields: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         """执行任务相关逻辑。"""
@@ -323,7 +314,9 @@ class TaskContextTools(ToolBase):
             raise_tool_error(QingflowApiError.config_error("fields is required and must be non-empty for task_save_only"))
         return self.task_action_execute(
             profile=profile,
-            task_id=task_id,
+            app_key=app_key,
+            record_id=record_id,
+            workflow_node_id=workflow_node_id,
             action="save_only",
             payload={},
             fields=field_updates,
@@ -331,34 +324,6 @@ class TaskContextTools(ToolBase):
 
     @tool_cn_name("执行任务动作")
     def task_action_execute(
-        self,
-        *,
-        profile: str,
-        task_id: Any,
-        action: str,
-        payload: dict[str, Any],
-        fields: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        """执行任务相关逻辑。"""
-        if task_id in (None, ""):
-            raise_tool_error(
-                QingflowApiError.config_error(
-                    "task_id is required for task_action_execute; get it from task_list.data.items[].task_id"
-                )
-            )
-
-        return self._task_action_execute_with_locator(
-            profile=profile,
-            task_id=task_id,
-            app_key="",
-            record_id="",
-            workflow_node_id=0,
-            action=action,
-            payload=payload,
-            fields=fields,
-        )
-
-    def _task_action_execute_with_locator(
         self,
         *,
         profile: str,
@@ -370,8 +335,10 @@ class TaskContextTools(ToolBase):
         payload: dict[str, Any],
         fields: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
+        """执行任务相关逻辑。"""
         if task_id in (None, ""):
             normalize_positive_id_int(record_id, field_name="record_id")
+
         normalized_action = (action or "").strip().lower()
         if normalized_action not in {"approve", "reject", "rollback", "transfer", "urge", "save_only"}:
             raise_tool_error(
@@ -401,63 +368,8 @@ class TaskContextTools(ToolBase):
             resolved_record_id = int(locator["record_id"])
             resolved_record_id_text = str(locator["record_id_text"] or "")
             resolved_workflow_node_id = int(locator["workflow_node_id"])
-            resolved_task_box = str(locator.get("task_box") or "todo")
             record_id_text = resolved_record_id_text
             self._require_app_record_and_node(resolved_app_key, resolved_record_id, resolved_workflow_node_id)
-            if normalized_action == "urge":
-                raw = self._execute_task_action(
-                    profile=profile,
-                    app_key=resolved_app_key,
-                    record_id=resolved_record_id,
-                    workflow_node_id=resolved_workflow_node_id,
-                    normalized_action=normalized_action,
-                    payload=body,
-                    prepared_fields=None,
-                )
-                verification, verification_warnings = self._verify_task_action_runtime(
-                    profile=profile,
-                    context=context,
-                    app_key=resolved_app_key,
-                    record_id=resolved_record_id,
-                    workflow_node_id=resolved_workflow_node_id,
-                    action=normalized_action,
-                    before_apply_status=None,
-                    runtime_baseline=None,
-                )
-                result = {
-                    "profile": raw.get("profile", profile),
-                    "ws_id": raw.get("ws_id", session_profile.selected_ws_id),
-                    "ok": bool(raw.get("ok", True)),
-                    "status": "success",
-                    "error_code": None,
-                    "action_executed": True,
-                    "safe_to_retry": False,
-                    "request_route": raw.get("request_route") or self._request_route_payload(context),
-                    "warnings": verification_warnings,
-                    "verification": verification,
-                    "output_profile": "normal",
-                    "data": {
-                        "action": normalized_action,
-                        "resource": {
-                            "app_key": resolved_app_key,
-                            "record_id": record_id_text,
-                            "workflow_node_id": resolved_workflow_node_id,
-                        },
-                        "selection": {"action": normalized_action},
-                        "result": raw.get("result"),
-                        "human_review": True,
-                        "field_update_applied": False,
-                    },
-                }
-                if task_id_text is not None:
-                    result["data"]["resource"]["task_id"] = task_id_text
-                return result
-            if resolved_task_box != "todo":
-                raise_tool_error(
-                    QingflowApiError.config_error(
-                        f"task_id={task_id_text or ''} resolved to task_box='{resolved_task_box}', but task_action_execute can only execute current todo tasks"
-                    )
-                )
             try:
                 task_context = self._build_task_context(
                     profile=profile,
@@ -465,13 +377,12 @@ class TaskContextTools(ToolBase):
                     app_key=resolved_app_key,
                     record_id=resolved_record_id,
                     workflow_node_id=resolved_workflow_node_id,
-                    task_box=resolved_task_box,
                     include_candidates=False,
                     include_associated_reports=False,
                     current_uid=session_profile.uid,
                 )
             except QingflowApiError as error:
-                if backend_code_int(error) == 46001:
+                if error.backend_code == 46001:
                     return self._task_action_visibility_unverified_response(
                         profile=profile,
                         session_profile=session_profile,
@@ -511,7 +422,7 @@ class TaskContextTools(ToolBase):
                     raise_tool_error(QingflowApiError.config_error(message))
                 raise_tool_error(
                     QingflowApiError.config_error(
-                        f"task action '{normalized_action}' is not currently available for task_id='{task_id_text}'"
+                        f"task action '{normalized_action}' is not currently available for app_key='{resolved_app_key}' record_id={record_id_text} workflow_node_id={resolved_workflow_node_id}"
                     )
                 )
             feedback_required_for = capabilities.get("action_constraints", {}).get("feedback_required_for") or []
@@ -559,7 +470,7 @@ class TaskContextTools(ToolBase):
                     prepared_fields=prepared_fields,
                 )
             except QingflowApiError as error:
-                if backend_code_int(error) == 46001:
+                if error.backend_code == 46001:
                     return self._task_action_visibility_unverified_response(
                         profile=profile,
                         session_profile=session_profile,
@@ -607,8 +518,6 @@ class TaskContextTools(ToolBase):
                 "ok": bool(raw.get("ok", True)) and status != "failed",
                 "status": status,
                 "error_code": error_code,
-                "action_executed": True,
-                "safe_to_retry": False,
                 "request_route": raw.get("request_route") or self._request_route_payload(context),
                 "warnings": warnings,
                 "verification": verification,
@@ -771,8 +680,6 @@ class TaskContextTools(ToolBase):
                 "http_status": error.http_status,
                 "backend_code": error.backend_code,
                 "category": error.category,
-                "request_id": error.request_id,
-                "message": error.message,
             }
 
         log_items: list[dict[str, Any]] = []
@@ -800,8 +707,6 @@ class TaskContextTools(ToolBase):
                 "http_status": error.http_status,
                 "backend_code": error.backend_code,
                 "category": error.category,
-                "request_id": error.request_id,
-                "message": error.message,
             }
 
         todo_items = self._safe_task_list_items(profile=profile, task_box="todo", app_key=app_key)
@@ -851,7 +756,7 @@ class TaskContextTools(ToolBase):
         runtime_consumed_after_action = bool(
             runtime_verified
             and isinstance(record_state_error, dict)
-            and backend_code_value_int(record_state_error.get("backend_code")) == 46001
+            and record_state_error.get("backend_code") == 46001
         )
         if runtime_consumed_after_action:
             verification["record_state_scope"] = "current_node_runtime"
@@ -866,28 +771,6 @@ class TaskContextTools(ToolBase):
                     ),
                 }
             )
-        permission_blocked_sources: list[str] = []
-        if (
-            isinstance(verification.get("record_state_error"), dict)
-            and _is_permission_context_error_payload(verification["record_state_error"])
-        ):
-            permission_blocked_sources.append("record_state")
-        if (
-            isinstance(verification.get("workflow_log_error"), dict)
-            and _is_permission_context_error_payload(verification["workflow_log_error"])
-        ):
-            permission_blocked_sources.append("workflow_log")
-        if permission_blocked_sources:
-            warnings.append(
-                {
-                    "code": "TASK_ACTION_VERIFICATION_PERMISSION_UNAVAILABLE",
-                    "message": (
-                        "task action executed, but some post-action verification reads are unavailable "
-                        "in this permission context; do not treat the verification read failure as action denial."
-                    ),
-                    "sources": permission_blocked_sources,
-                }
-            )
         verification["runtime_continuation_verified"] = runtime_verified
         if not runtime_verified:
             warnings.append(
@@ -1048,9 +931,7 @@ class TaskContextTools(ToolBase):
             baseline["workflow_log_visible"] = True
             baseline["workflow_log_count"] = len(log_items)
             baseline["workflow_log_digest"] = self._workflow_log_digest(log_items)
-        except QingflowApiError as exc:
-            if is_auth_like_error(exc):
-                raise
+        except QingflowApiError:
             pass
         todo_items = self._safe_task_list_items(profile=profile, task_box="todo", app_key=app_key)
         baseline["downstream_todo_nodes"] = sorted(
@@ -1177,9 +1058,7 @@ class TaskContextTools(ToolBase):
                 page=1,
                 page_size=50,
             )
-        except QingflowApiError as exc:
-            if not _is_task_optional_read_error(exc):
-                raise
+        except QingflowApiError:
             return []
         items = response.get("items") if isinstance(response, dict) else None
         if not isinstance(items, list):
@@ -1273,36 +1152,21 @@ class TaskContextTools(ToolBase):
         task_id_text = normalize_positive_id_text(task_id, field_name="task_id")
         searched_task_boxes = ("todo", "initiated", "cc", "done")
         incomplete_task_boxes: list[str] = []
-        inaccessible_task_boxes: list[dict[str, Any]] = []
-        truncated_task_boxes: list[dict[str, Any]] = []
         page_size = 100
         for task_box in searched_task_boxes:
             page = 1
             page_amount: int | None = None
             while True:
-                try:
-                    response = self._list_normalized_task_items(
-                        profile=profile,
-                        task_box=task_box,
-                        flow_status="all",
-                        app_key=None,
-                        workflow_node_id=None,
-                        query=None,
-                        page=page,
-                        page_size=page_size,
-                    )
-                except QingflowApiError as exc:
-                    if not _is_optional_task_box_locator_error(exc):
-                        raise
-                    inaccessible_task_boxes.append(
-                        {
-                            "task_box": task_box,
-                            "backend_code": exc.backend_code,
-                            "http_status": exc.http_status,
-                            "request_id": exc.request_id,
-                        }
-                    )
-                    break
+                response = self._list_normalized_task_items(
+                    profile=profile,
+                    task_box=task_box,
+                    flow_status="all",
+                    app_key=None,
+                    workflow_node_id=None,
+                    query=None,
+                    page=page,
+                    page_size=page_size,
+                )
                 items = response.get("items") if isinstance(response.get("items"), list) else []
                 for item in items:
                     if not isinstance(item, dict) or not ids_equal(item.get("task_id"), task_id_text):
@@ -1328,52 +1192,17 @@ class TaskContextTools(ToolBase):
                     break
                 if not items or len(items) < page_size:
                     break
-                if page >= TASK_LOCATOR_MAX_SCAN_PAGES_PER_BOX:
-                    truncated_task_boxes.append(
-                        {
-                            "task_box": task_box,
-                            "max_pages": TASK_LOCATOR_MAX_SCAN_PAGES_PER_BOX,
-                            "page_size": page_size,
-                            "reported_page_amount": page_amount,
-                        }
-                    )
-                    break
                 page += 1
         if incomplete_task_boxes:
             searched = ", ".join(incomplete_task_boxes)
             raise_tool_error(
                 QingflowApiError.config_error(
-                    f"task_id={task_id_text} resolved to an incomplete task locator in task_box={searched}; rerun task_list and pass the exact data.items[].task_id. Do not substitute a row number or rebuild the locator from app_key/record_id/workflow_node_id."
-                )
-            )
-        if inaccessible_task_boxes:
-            searched = ", ".join(str(item.get("task_box")) for item in inaccessible_task_boxes)
-            raise_tool_error(
-                QingflowApiError.config_error(
-                    f"task_id={task_id_text} was not found in visible task boxes; some task boxes were not searchable in the current permission context: {searched}. Rerun task_list and use data.items[].task_id; do not substitute a row number or rebuild the locator.",
-                    details={
-                        "task_id": task_id_text,
-                        "searched_task_boxes": list(searched_task_boxes),
-                        "inaccessible_task_boxes": inaccessible_task_boxes,
-                    },
-                )
-            )
-        if truncated_task_boxes:
-            raise_tool_error(
-                QingflowApiError.config_error(
-                    f"task_id={task_id_text} was not found in the first {TASK_LOCATOR_MAX_SCAN_PAGES_PER_BOX} pages of each visible task box. Rerun task_list with a query or the relevant page and pass the exact data.items[].task_id; do not guess task ids.",
-                    details={
-                        "task_id": task_id_text,
-                        "searched_task_boxes": list(searched_task_boxes),
-                        "truncated_task_boxes": truncated_task_boxes,
-                        "max_pages_per_task_box": TASK_LOCATOR_MAX_SCAN_PAGES_PER_BOX,
-                        "page_size": page_size,
-                    },
+                    f"task_id={task_id_text} resolved to an incomplete task locator in task_box={searched}; please refresh the task list and retry"
                 )
             )
         raise_tool_error(
             QingflowApiError.config_error(
-                f"task_id={task_id_text} was not found in the current visible task boxes (todo, initiated, cc, done). Rerun task_list and pass data.items[].task_id; do not use the displayed row number or guess app_key/record_id/workflow_node_id."
+                f"task_id={task_id_text} was not found in the current visible task boxes (todo, initiated, cc, done)"
             )
         )
 
@@ -1395,7 +1224,6 @@ class TaskContextTools(ToolBase):
             resolved_app_key = str(locator["app_key"])
             resolved_record_id = normalize_positive_id_int(locator["record_id"], field_name="record_id")
             resolved_workflow_node_id = int(locator["workflow_node_id"])
-            resolved_task_box = str(locator.get("task_box") or "todo")
             explicit_app_key = (app_key or "").strip()
             if explicit_app_key and explicit_app_key != resolved_app_key:
                 raise_tool_error(
@@ -1420,10 +1248,8 @@ class TaskContextTools(ToolBase):
         else:
             resolved_record_id = normalize_positive_id_int(record_id, field_name="record_id")
             resolved_workflow_node_id = int(workflow_node_id)
-            resolved_task_box = "todo"
         return {
             "task_id": task_id_text,
-            "task_box": resolved_task_box,
             "app_key": resolved_app_key,
             "record_id": resolved_record_id,
             "record_id_text": stringify_backend_id(resolved_record_id),
@@ -1481,7 +1307,6 @@ class TaskContextTools(ToolBase):
             resolved_record_id = int(locator["record_id"])
             record_id_text = str(locator["record_id_text"] or "")
             resolved_workflow_node_id = int(locator["workflow_node_id"])
-            resolved_task_box = str(locator.get("task_box") or "todo")
             self._require_app_record_and_node(resolved_app_key, resolved_record_id, resolved_workflow_node_id)
             task_context = self._build_task_context(
                 profile=profile,
@@ -1489,7 +1314,6 @@ class TaskContextTools(ToolBase):
                 app_key=resolved_app_key,
                 record_id=resolved_record_id,
                 workflow_node_id=resolved_workflow_node_id,
-                task_box=resolved_task_box,
                 include_candidates=False,
                 include_associated_reports=True,
                 current_uid=session_profile.uid,
@@ -1563,7 +1387,7 @@ class TaskContextTools(ToolBase):
 
             chart_key = str(report_item.get("chart_key") or "")
             source_type = report_item.get("source_type")
-            if source_type in {"qingbi", "bi_qingflow", "bi_dataset"}:
+            if source_type == "qingbi":
                 qingbi_context = BackendRequestContext(
                     base_url=_qingbi_base_url(context.base_url),
                     token=context.token,
@@ -1572,44 +1396,20 @@ class TaskContextTools(ToolBase):
                     qf_version=context.qf_version,
                     qf_version_source=context.qf_version_source,
                 )
-                chart_payload = {
-                    "asosChartId": report_id,
-                    "keyQueValues": association_query.get("keyQueValues") or [],
-                }
-                chart_params = {
-                    "qfUUID": uuid4().hex,
-                    "pageNum": page,
-                    "pageSize": page_size,
-                }
-                try:
-                    chart_result = self.backend.request(
-                        "POST",
-                        qingbi_context,
-                        f"/qingbi/charts/data/qflow/{chart_key}/detail",
-                        params=chart_params,
-                        json_body=chart_payload,
-                    )
-                except QingflowApiError as error:
-                    if not _should_retry_asos_data(error):
-                        raise
-                    try:
-                        chart_result = self.backend.request(
-                            "POST",
-                            qingbi_context,
-                            f"/qingbi/charts/data/qflow/{chart_key}/asos",
-                            params=chart_params,
-                            json_body=chart_payload,
-                        )
-                    except QingflowApiError as fallback_error:
-                        if not _should_retry_asos_data(fallback_error):
-                            raise
-                        chart_result = self.backend.request(
-                            "POST",
-                            qingbi_context,
-                            f"/qingbi/charts/data/{chart_key}",
-                            params=chart_params,
-                            json_body=chart_payload,
-                        )
+                chart_result = self.backend.request(
+                    "POST",
+                    qingbi_context,
+                    f"/qingbi/charts/data/{chart_key}",
+                    params={
+                        "qfUUID": uuid4().hex,
+                        "pageNum": page,
+                        "pageSize": page_size,
+                    },
+                    json_body={
+                        "asosChartId": report_id,
+                        "keyQueValues": association_query.get("keyQueValues") or [],
+                    },
+                )
                 request_route = {
                     "base_url": qingbi_context.base_url,
                     "qf_version": qingbi_context.qf_version,
@@ -1709,7 +1509,6 @@ class TaskContextTools(ToolBase):
             resolved_record_id = int(locator["record_id"])
             record_id_text = str(locator["record_id_text"] or "")
             resolved_workflow_node_id = int(locator["workflow_node_id"])
-            resolved_task_box = str(locator.get("task_box") or "todo")
             self._require_app_record_and_node(resolved_app_key, resolved_record_id, resolved_workflow_node_id)
             task_context = self._build_task_context(
                 profile=profile,
@@ -1717,16 +1516,12 @@ class TaskContextTools(ToolBase):
                 app_key=resolved_app_key,
                 record_id=resolved_record_id,
                 workflow_node_id=resolved_workflow_node_id,
-                task_box=resolved_task_box,
                 include_candidates=False,
                 include_associated_reports=False,
                 current_uid=session_profile.uid,
             )
             visibility = task_context.get("visibility") or {}
-            node = task_context.get("node") if isinstance(task_context.get("node"), dict) else {}
-            raw_node = node.get("raw") if isinstance(node.get("raw"), dict) else {}
-            audit_visibility_explicit = "auditRecordVisible" in raw_node
-            if audit_visibility_explicit and not visibility.get("audit_record_visible"):
+            if not visibility.get("audit_record_visible"):
                 raise_tool_error(
                     QingflowApiError.config_error(
                         f"workflow logs are not visible for app_key='{resolved_app_key}' record_id={record_id_text} workflow_node_id={resolved_workflow_node_id}"
@@ -1740,7 +1535,7 @@ class TaskContextTools(ToolBase):
                     "key": resolved_app_key,
                     "rowRecordId": resolved_record_id,
                     "nodeId": resolved_workflow_node_id,
-                    "role": _task_box_record_role(resolved_task_box),
+                    "role": 3,
                     "pageNum": 1,
                     "pageSize": 200,
                 },
@@ -1751,7 +1546,7 @@ class TaskContextTools(ToolBase):
                 "ws_id": session_profile.selected_ws_id,
                 "ok": True,
                 "request_route": self._request_route_payload(context),
-                "warnings": task_context.get("warnings") or [],
+                "warnings": [],
                 "output_profile": "normal",
                 "data": {
                     "selection": {
@@ -1760,9 +1555,7 @@ class TaskContextTools(ToolBase):
                         "workflow_node_id": resolved_workflow_node_id,
                     },
                     "visibility": {
-                        "audit_record_visible": (
-                            visibility.get("audit_record_visible") if audit_visibility_explicit else None
-                        ),
+                        "audit_record_visible": visibility.get("audit_record_visible"),
                         "qrobot_record_visible": visibility.get("qrobot_record_visible"),
                     },
                     "items": items,
@@ -1787,94 +1580,43 @@ class TaskContextTools(ToolBase):
         include_candidates: bool,
         include_associated_reports: bool,
         current_uid: int | None = None,
-        task_box: str = "todo",
     ) -> dict[str, Any]:
         """执行内部辅助逻辑。"""
-        context_warnings: list[JSONObject] = []
-        detail: dict[str, Any] | None = None
-        list_type = _task_box_record_list_type(task_box)
-        role = _task_box_record_role(task_box)
-        try:
-            audit_infos = self.backend.request(
-                "GET",
-                context,
-                f"/app/{app_key}/apply/{record_id}/auditInfo",
-                params={"type": list_type},
-            )
-            node_info = self._select_task_node(audit_infos, workflow_node_id, app_key=app_key, record_id=record_id)
-        except QingflowApiError as exc:
-            if not _is_optional_task_audit_info_error(exc):
-                raise
-            detail = self.backend.request(
-                "GET",
-                context,
-                f"/app/{app_key}/apply/{record_id}",
-                params={"role": role, "listType": list_type, "auditNodeId": workflow_node_id},
-            )
-            node_info = self._fallback_task_node_from_detail(
-                detail,
-                workflow_node_id=workflow_node_id,
-                source_error=exc,
-            )
-            context_warnings.append(
-                {
-                    "code": "TASK_AUDIT_INFO_UNAVAILABLE",
-                    "message": "Task context used the current task detail because auditInfo was unavailable in this permission context.",
-                    "backend_code": exc.backend_code,
-                    "request_id": exc.request_id,
-                    "http_status": exc.http_status,
-                }
-            )
-        if detail is None:
-            detail = self.backend.request(
-                "GET",
-                context,
-                f"/app/{app_key}/apply/{record_id}",
-                params={"role": role, "listType": list_type, "auditNodeId": workflow_node_id},
-            )
+        audit_infos = self.backend.request(
+            "GET",
+            context,
+            f"/app/{app_key}/apply/{record_id}/auditInfo",
+            params={"type": 1},
+        )
+        node_info = self._select_task_node(audit_infos, workflow_node_id, app_key=app_key, record_id=record_id)
+        detail = self.backend.request(
+            "GET",
+            context,
+            f"/app/{app_key}/apply/{record_id}",
+            params={"role": 3, "listType": 1, "auditNodeId": workflow_node_id},
+        )
         app_name = self._task_app_name(context=context, app_key=app_key, detail=detail, node_info=node_info)
         associated_report_visible = self._resolve_associated_report_visible(node_info, detail)
-        associated_reports = {"visible": associated_report_visible, "loaded": False, "count": 0, "items": [], "warnings": []}
+        associated_reports = {"visible": associated_report_visible, "loaded": False, "count": 0, "items": []}
         if include_associated_reports and associated_report_visible:
-            try:
-                asos_chart_list = self.backend.request(
-                    "GET",
-                    context,
-                    f"/app/{app_key}/asosChart",
-                    params={"role": role, "auditNodeId": workflow_node_id, "beingDraft": False},
-                )
-                associated_items = [
-                    self._normalize_associated_report(item)
-                    for item in (asos_chart_list.get("asosCharts") or [])
-                    if isinstance(item, dict)
-                ]
-                associated_reports = {
-                    "visible": True,
-                    "loaded": True,
-                    "count": len(associated_items),
-                    "items": associated_items,
-                    "warnings": [],
-                }
-            except QingflowApiError as exc:
-                if not _is_task_optional_read_error(exc):
-                    raise
-                associated_reports = {
-                    "visible": True,
-                    "loaded": False,
-                    "count": 0,
-                    "items": [],
-                    "warnings": [
-                        {
-                            "code": "TASK_ASSOCIATED_REPORTS_UNAVAILABLE",
-                            "message": "Associated reports are not readable in this permission context; task detail remains available.",
-                            "backend_code": exc.backend_code,
-                            "request_id": exc.request_id,
-                            "http_status": exc.http_status,
-                        }
-                    ],
-                }
+            asos_chart_list = self.backend.request(
+                "GET",
+                context,
+                f"/app/{app_key}/asosChart",
+                params={"role": 3, "auditNodeId": workflow_node_id, "beingDraft": False},
+            )
+            associated_items = [
+                self._normalize_associated_report(item)
+                for item in (asos_chart_list.get("asosCharts") or [])
+                if isinstance(item, dict)
+            ]
+            associated_reports = {
+                "visible": True,
+                "loaded": True,
+                "count": len(associated_items),
+                "items": associated_items,
+            }
         rollback_items: list[dict[str, Any]] = []
-        rollback_warnings: list[JSONObject] = []
         transfer_items: list[dict[str, Any]] = []
         transfer_warnings: list[JSONObject] = []
         transfer_pagination: JSONObject = {
@@ -1886,26 +1628,13 @@ class TaskContextTools(ToolBase):
             "truncated": False,
         }
         if include_candidates:
-            try:
-                rollback_result = self.backend.request(
-                    "GET",
-                    context,
-                    f"/app/{app_key}/apply/{record_id}/revertNode",
-                    params={"auditNodeId": workflow_node_id},
-                )
-                rollback_items = self._rollback_candidate_items(rollback_result)
-            except QingflowApiError as exc:
-                if not _is_task_optional_read_error(exc):
-                    raise
-                rollback_warnings.append(
-                    {
-                        "code": "TASK_ROLLBACK_CANDIDATES_UNAVAILABLE",
-                        "message": "Rollback candidates are not readable in this permission context; task detail remains available.",
-                        "backend_code": exc.backend_code,
-                        "request_id": exc.request_id,
-                        "http_status": exc.http_status,
-                    }
-                )
+            rollback_result = self.backend.request(
+                "GET",
+                context,
+                f"/app/{app_key}/apply/{record_id}/revertNode",
+                params={"auditNodeId": workflow_node_id},
+            )
+            rollback_items = self._rollback_candidate_items(rollback_result)
             transfer_items, transfer_warnings, transfer_pagination = self._transfer_candidate_items(
                 context,
                 app_key=app_key,
@@ -1928,7 +1657,6 @@ class TaskContextTools(ToolBase):
             context,
             app_key=app_key,
             workflow_node_id=workflow_node_id,
-            node_info=node_info,
         )
         capabilities = self._build_capabilities(
             node_info,
@@ -1975,9 +1703,7 @@ class TaskContextTools(ToolBase):
                 "transfer_members": transfer_items,
                 "loaded": include_candidates,
                 "transfer_pagination": transfer_pagination,
-                "rollback_warnings": rollback_warnings,
-                "transfer_warnings": transfer_warnings,
-                "warnings": [*rollback_warnings, *transfer_warnings],
+                "warnings": transfer_warnings,
             },
             "workflow_log_summary": {
                 "visible": visibility["audit_record_visible"],
@@ -1986,7 +1712,6 @@ class TaskContextTools(ToolBase):
                 "qrobot_log_visible": visibility["qrobot_record_visible"],
             },
             "update_schema": update_schema,
-            "warnings": context_warnings,
         }
 
     def _compact_task_get_context(self, data: dict[str, Any]) -> dict[str, Any]:
@@ -2056,14 +1781,12 @@ class TaskContextTools(ToolBase):
                     "loaded": bool(associated_reports.get("loaded")),
                     "count": len(associated_items),
                     "items": associated_items,
-                    "warnings": associated_reports.get("warnings") or [],
                 },
                 "rollback_candidates": {
                     "available": "rollback" in available_actions,
                     "loaded": bool(candidates.get("loaded")),
                     "count": len(rollback_items),
                     "items": rollback_items,
-                    "warnings": candidates.get("rollback_warnings") or [],
                 },
                 "transfer_candidates": {
                     "available": "transfer" in available_actions,
@@ -2071,7 +1794,7 @@ class TaskContextTools(ToolBase):
                     "count": len(transfer_items),
                     "items": transfer_items,
                     "pagination": transfer_pagination,
-                    "warnings": candidates.get("transfer_warnings") or [],
+                    "warnings": candidates.get("warnings") or [],
                 },
             },
         }
@@ -2106,8 +1829,6 @@ class TaskContextTools(ToolBase):
             metadata["blockers"] = blockers
         if warnings:
             metadata["warnings"] = warnings
-        if update_schema.get("editable_question_ids_source"):
-            metadata["editable_question_ids_source"] = update_schema.get("editable_question_ids_source")
         return metadata
 
     def _compact_initiator(self, payload: Any) -> dict[str, Any] | None:
@@ -2156,9 +1877,7 @@ class TaskContextTools(ToolBase):
     ) -> str | None:
         try:
             base_info = self.backend.request("GET", context, f"/app/{app_key}/baseInfo")
-        except QingflowApiError as exc:
-            if not _is_task_optional_read_error(exc):
-                raise
+        except QingflowApiError:
             return None
         if not isinstance(base_info, dict):
             return None
@@ -2176,9 +1895,7 @@ class TaskContextTools(ToolBase):
     ) -> str | None:
         try:
             visible_apps = self.backend.request("GET", context, "/tag/apps")
-        except QingflowApiError as exc:
-            if not _is_task_optional_read_error(exc):
-                raise
+        except QingflowApiError:
             return None
         return self._find_task_app_name_in_visible_apps(visible_apps, app_key=app_key)
 
@@ -2378,54 +2095,6 @@ class TaskContextTools(ToolBase):
             )
         )
 
-    def _fallback_task_node_from_detail(
-        self,
-        detail: dict[str, Any],
-        *,
-        workflow_node_id: int,
-        source_error: QingflowApiError,
-    ) -> dict[str, Any]:
-        """Build a conservative task node snapshot from the readable task detail."""
-        node_info: dict[str, Any] = {
-            "auditNodeId": workflow_node_id,
-            "nodeId": workflow_node_id,
-            "auditNodeName": (
-                detail.get("auditNodeName")
-                or detail.get("nodeName")
-                or detail.get("workflowNodeName")
-                or detail.get("currentNodeName")
-            ),
-            "_auditInfoUnavailable": True,
-            "_auditInfoError": {
-                "http_status": source_error.http_status,
-                "backend_code": source_error.backend_code,
-                "category": source_error.category,
-            },
-        }
-        for key in (
-            "canTransfer",
-            "canRevert",
-            "canUrge",
-            "rejectBtnStatus",
-            "canRevoke",
-            "beingEndWorkflow",
-            "beingCanApplyAgain",
-            "beingSubmitCheck",
-            "beingSubmitPreview",
-            "feedbackRequiredOperationType",
-            "queAuthSetting",
-            "auditRecordVisible",
-            "qrobotRecordBeingVisible",
-            "beingWorkflowNodeFutureListVisible",
-            "commentStatus",
-            "asosChartVisible",
-        ):
-            if key in detail:
-                node_info[key] = detail[key]
-        if "viewAsosChartVisible" in detail and "asosChartVisible" not in node_info:
-            node_info["asosChartVisible"] = detail.get("viewAsosChartVisible")
-        return node_info
-
     def _build_capabilities(
         self,
         node_info: dict[str, Any],
@@ -2490,18 +2159,35 @@ class TaskContextTools(ToolBase):
         try:
             app_schema = self._record_tools._get_form_schema(profile, context, app_key, force_refresh=False)
         except QingflowApiError as error:
-            if not _is_task_optional_read_error(error):
-                raise
-            return self._build_task_update_schema_from_runtime_answers(
-                profile=profile,
-                context=context,
-                app_key=app_key,
-                record_id=record_id,
-                workflow_node_id=workflow_node_id,
-                node_info=node_info,
-                current_answers=current_answers,
-                source_error=error,
-            )
+            public_schema: JSONObject = {
+                "schema_scope": "task_update_ready",
+                "writable_fields": [],
+                "payload_template": {},
+                "blockers": ["TASK_UPDATE_SCHEMA_UNAVAILABLE"],
+                "warnings": [
+                    {
+                        "code": "TASK_UPDATE_SCHEMA_UNAVAILABLE",
+                        "message": "task detail could not load the form schema for the current app, so node-scoped update schema is unavailable.",
+                    }
+                ],
+                "selection": {
+                    "app_key": app_key,
+                    "record_id": record_id_text,
+                    "workflow_node_id": workflow_node_id,
+                },
+                "transport_error": {
+                    "http_status": error.http_status,
+                    "backend_code": error.backend_code,
+                    "category": error.category,
+                },
+            }
+            return {
+                "public_schema": public_schema,
+                "index": None,
+                "editable_question_ids": [],
+                "effective_editable_question_ids": [],
+                "editable_question_ids_source": "schema_unavailable",
+            }
 
         question_relations = _collect_question_relations(app_schema)
         linked_field_ids = _collect_linked_required_field_ids(question_relations)
@@ -2574,7 +2260,6 @@ class TaskContextTools(ToolBase):
                 "record_id": record_id_text,
                 "workflow_node_id": workflow_node_id,
             },
-            "editable_question_ids_source": source,
         }
         return {
             "public_schema": public_schema,
@@ -2584,96 +2269,6 @@ class TaskContextTools(ToolBase):
             "editable_question_ids_source": source,
         }
 
-    def _build_task_update_schema_from_runtime_answers(
-        self,
-        *,
-        profile: str,
-        context: BackendRequestContext,
-        app_key: str,
-        record_id: int,
-        workflow_node_id: int,
-        node_info: dict[str, Any],
-        current_answers: Any,
-        source_error: QingflowApiError,
-    ) -> dict[str, Any]:
-        """Build node-scoped edit schema from the task detail when app schema is unavailable."""
-        record_id_text = stringify_backend_id(record_id)
-        editable_question_ids, schema_warnings, source = self._resolve_task_editable_question_ids(
-            context,
-            app_key=app_key,
-            workflow_node_id=workflow_node_id,
-            node_info=node_info,
-        )
-        schema_warnings.insert(
-            0,
-            {
-                "code": "TASK_UPDATE_SCHEMA_APP_SCHEMA_UNAVAILABLE",
-                "message": "task update schema used current task answers because the app applicant schema was unavailable in this permission context.",
-                "transport_error": {
-                    "http_status": source_error.http_status,
-                    "backend_code": source_error.backend_code,
-                    "category": source_error.category,
-                },
-            },
-        )
-        index = _build_answer_backed_field_index(
-            current_answers,
-            field_id_filter={str(que_id) for que_id in editable_question_ids if que_id > 0},
-        )
-        effective_editable_ids = set(editable_question_ids)
-        writable_fields: list[JSONObject] = []
-        for field in index.by_id.values():
-            if field.que_type in LAYOUT_ONLY_QUE_TYPES or field.que_id not in effective_editable_ids:
-                continue
-            editable_field = _clone_form_field(field, readonly=False)
-            write_hints = self._record_tools._schema_write_hints(editable_field)
-            if not bool(write_hints.get("writable")):
-                continue
-            writable_field = self._record_tools._ready_schema_field_payload(
-                profile,
-                context,
-                editable_field,
-                ws_id=context.ws_id,
-                required_override=False,
-                linkage_payloads_by_field_id={},
-            )
-            writable_field.setdefault("field_id", editable_field.que_id)
-            writable_fields.append(writable_field)
-
-        blockers: list[str] = []
-        if not writable_fields:
-            blockers.append("NO_TASK_EDITABLE_FIELDS")
-            schema_warnings.append(
-                {
-                    "code": "NO_TASK_EDITABLE_FIELDS",
-                    "message": "the current task node does not expose any writable fields in the current task detail.",
-                }
-            )
-        public_schema: JSONObject = {
-            "schema_scope": "task_update_ready",
-            "writable_fields": writable_fields,
-            "payload_template": {
-                item["title"]: self._record_tools._ready_schema_template_value(item)
-                for item in writable_fields
-                if isinstance(item, dict) and item.get("title")
-            },
-            "blockers": blockers,
-            "warnings": schema_warnings,
-            "selection": {
-                "app_key": app_key,
-                "record_id": record_id_text,
-                "workflow_node_id": workflow_node_id,
-            },
-            "editable_question_ids_source": f"{source}_runtime_answers",
-        }
-        return {
-            "public_schema": public_schema,
-            "index": index,
-            "editable_question_ids": sorted(editable_question_ids),
-            "effective_editable_question_ids": sorted(effective_editable_ids),
-            "editable_question_ids_source": f"{source}_runtime_answers",
-        }
-
     def _augment_task_editable_field_index(
         self,
         *,
@@ -2733,15 +2328,12 @@ class TaskContextTools(ToolBase):
             if question_ids:
                 return question_ids, warnings, "workflow_editable_que_ids"
         except QingflowApiError as error:
-            if not _is_task_optional_read_error(error):
+            if error.backend_code not in {40002, 40027, 404} and error.http_status != 404:
                 raise
             warnings.append(
                 {
                     "code": "TASK_EDITABLE_IDS_FALLBACK",
                     "message": "editable question ids endpoint is unavailable in the current route; task update schema fell back to queAuthSetting and may be conservative.",
-                    "backend_code": error.backend_code,
-                    "http_status": error.http_status,
-                    "request_id": error.request_id,
                 }
             )
         fallback_ids = self._editable_ids_from_que_auth_setting(node_info.get("queAuthSetting"))
@@ -2753,7 +2345,6 @@ class TaskContextTools(ToolBase):
         *,
         app_key: str,
         workflow_node_id: int,
-        node_info: dict[str, Any],
     ) -> tuple[bool, list[JSONObject], str]:
         """执行内部辅助逻辑。"""
         try:
@@ -2763,28 +2354,15 @@ class TaskContextTools(ToolBase):
                 f"/app/{app_key}/auditNode/{workflow_node_id}/editableQueIds",
             )
         except QingflowApiError as error:
-            if not _is_task_optional_read_error(error):
-                raise
-            fallback_ids = self._editable_ids_from_que_auth_setting(node_info.get("queAuthSetting"))
-            fallback_source = "que_auth_setting" if fallback_ids else "backend_editable_que_ids_unavailable"
             warning: JSONObject = {
-                "code": "TASK_SAVE_ONLY_EDITABLE_IDS_FALLBACK" if fallback_ids else "TASK_SAVE_ONLY_SIGNAL_UNAVAILABLE",
-                "message": (
-                    "save_only availability used current task queAuthSetting because backend editableQueIds was unavailable in this permission context."
-                    if fallback_ids
-                    else "save_only is hidden because backend editableQueIds is unavailable and current task detail does not expose editable fields."
-                ),
+                "code": "TASK_SAVE_ONLY_SIGNAL_UNAVAILABLE",
+                "message": "save_only is hidden because backend editableQueIds is unavailable for the current node; MCP no longer infers save_only from local schema reconstruction.",
             }
             if error.backend_code is not None:
                 warning["backend_code"] = error.backend_code
             if error.http_status is not None:
                 warning["http_status"] = error.http_status
-            if error.request_id is not None:
-                warning["request_id"] = error.request_id
-            if fallback_ids:
-                warning["field_ids"] = sorted(fallback_ids)
-                return True, [warning], fallback_source
-            return False, [warning], fallback_source
+            return False, [warning], "backend_editable_que_ids_unavailable"
         return bool(self._extract_question_ids(payload)), [], "workflow_editable_que_ids"
 
     def _extract_question_ids(self, payload: Any) -> set[int]:
@@ -3077,33 +2655,12 @@ class TaskContextTools(ToolBase):
         warnings: list[JSONObject] = []
 
         while page_num <= max_pages:
-            try:
-                result = self.backend.request(
-                    "GET",
-                    context,
-                    f"/app/{app_key}/apply/{record_id}/transfer/member",
-                    params={"pageNum": page_num, "pageSize": page_size, "auditNodeId": workflow_node_id},
-                )
-            except QingflowApiError as exc:
-                if not _is_task_optional_read_error(exc):
-                    raise
-                warnings.append(
-                    {
-                        "code": "TASK_TRANSFER_CANDIDATES_UNAVAILABLE",
-                        "message": "Transfer candidates are not readable in this permission context; task detail remains available.",
-                        "backend_code": exc.backend_code,
-                        "request_id": exc.request_id,
-                        "http_status": exc.http_status,
-                    }
-                )
-                return items, warnings, {
-                    "loaded": False,
-                    "page_size": page_size,
-                    "fetched_pages": fetched_pages,
-                    "reported_total": reported_total,
-                    "page_amount": page_amount,
-                    "truncated": False,
-                }
+            result = self.backend.request(
+                "GET",
+                context,
+                f"/app/{app_key}/apply/{record_id}/transfer/member",
+                params={"pageNum": page_num, "pageSize": page_size, "auditNodeId": workflow_node_id},
+            )
             fetched_pages += 1
             raw_items = _approval_page_items(result)
             fetched_raw_count += len(raw_items)
@@ -3268,9 +2825,7 @@ class TaskContextTools(ToolBase):
                 context,
                 f"/chart/{chart_key}/auth",
             )
-        except QingflowApiError as error:
-            if not _is_task_optional_read_error(error):
-                raise
+        except QingflowApiError:
             return False
         if not isinstance(auth, dict):
             return False
@@ -3447,62 +3002,3 @@ class TaskContextTools(ToolBase):
             "qf_version": context.qf_version,
             "qf_version_source": context.qf_version_source or ("context" if context.qf_version else "unknown"),
         }
-
-
-def _is_optional_task_audit_info_error(error: QingflowApiError) -> bool:
-    """Whether task auditInfo may be replaced by current task detail."""
-    if is_auth_like_error(error):
-        return False
-    return _is_task_permission_context_error(error) or error.http_status == 404
-
-
-def _task_box_record_list_type(task_box: str | None) -> int:
-    normalized = str(task_box or "todo").strip().lower()
-    if normalized == "initiated":
-        return 14
-    if normalized == "done":
-        return 2
-    if normalized == "cc":
-        return 12
-    return 1
-
-
-def _task_box_record_role(task_box: str | None) -> int:
-    normalized = str(task_box or "todo").strip().lower()
-    if normalized == "initiated":
-        return 2
-    return 3
-
-
-def _is_optional_task_box_locator_error(error: QingflowApiError) -> bool:
-    """Whether one task box may be skipped while resolving a task_id."""
-    if is_auth_like_error(error):
-        return False
-    return _is_task_permission_context_error(error) or error.http_status == 404
-
-
-def _is_task_optional_read_error(error: QingflowApiError) -> bool:
-    if is_auth_like_error(error):
-        return False
-    backend_code = _task_backend_code(error)
-    return backend_code in {40002, 40027, 404} or error.http_status == 404
-
-
-def _is_task_permission_context_error(error: QingflowApiError) -> bool:
-    if is_auth_like_error(error):
-        return False
-    return _task_backend_code(error) in {40002, 40027}
-
-
-def _is_permission_context_error_payload(payload: dict[str, Any]) -> bool:
-    if str(payload.get("category") or "").strip().lower() == "auth":
-        return False
-    if message_looks_like_invalid_token(payload.get("message")):
-        return False
-    if backend_code_value_int(payload.get("http_status")) == 401:
-        return False
-    return backend_code_value_int(payload.get("backend_code")) in {40002, 40027}
-
-
-def _task_backend_code(error: QingflowApiError) -> int | None:
-    return backend_code_int(error)