@josephyan/qingflow-cli 0.2.0-beta.74 → 0.2.0-beta.75

package/src/qingflow_mcp/tools/task_context_tools.py

@@ -14,9 +14,11 @@ from .approval_tools import ApprovalTools, _approval_page_amount, _approval_page
 from .base import ToolBase
 from .qingbi_report_tools import _qingbi_base_url
 from .record_tools import (
+    FieldIndex,
     LAYOUT_ONLY_QUE_TYPES,
     SUBTABLE_QUE_TYPES,
     RecordTools,
+    _build_answer_backed_field_index,
     _build_applicant_hidden_linked_top_level_field_index,
     _build_applicant_top_level_field_index,
     _build_static_schema_linkage_payloads,
@@ -102,6 +104,22 @@ class TaskContextTools(ToolBase):
                 fields=fields or {},
             )
 
+        @mcp.tool()
+        def task_save_only(
+            profile: str = DEFAULT_PROFILE,
+            app_key: str = "",
+            record_id: int = 0,
+            workflow_node_id: int = 0,
+            fields: dict[str, Any] | None = None,
+        ) -> dict[str, Any]:
+            return self.task_save_only(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
+                fields=fields or {},
+            )
+
         @mcp.tool()
         def task_associated_report_detail_get(
             profile: str = DEFAULT_PROFILE,
@@ -228,6 +246,28 @@ class TaskContextTools(ToolBase):
 
         return self._run(profile, runner)
 
+    def task_save_only(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+        fields: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        field_updates = dict(fields or {})
+        if not field_updates:
+            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,
+            app_key=app_key,
+            record_id=record_id,
+            workflow_node_id=workflow_node_id,
+            action="save_only",
+            payload={},
+            fields=field_updates,
+        )
+
     def task_action_execute(
         self,
         *,
@@ -297,6 +337,15 @@ class TaskContextTools(ToolBase):
             capabilities = task_context.get("capabilities") or {}
             available_actions = capabilities.get("available_actions") or []
             if normalized_action not in available_actions:
+                if normalized_action == "save_only":
+                    capability_warnings = capabilities.get("warnings") or []
+                    message = (
+                        "task action 'save_only' is not currently available for the current node; "
+                        "MCP only exposes save_only when backend editableQueIds returns a non-empty result"
+                    )
+                    if capability_warnings:
+                        message += "; backend editableQueIds is unavailable or empty for this task context"
+                    raise_tool_error(QingflowApiError.config_error(message))
                 raise_tool_error(
                     QingflowApiError.config_error(
                         f"task action '{normalized_action}' is not currently available for app_key='{app_key}' record_id={record_id} workflow_node_id={workflow_node_id}"
@@ -426,10 +475,14 @@ class TaskContextTools(ToolBase):
         prepared_fields: dict[str, Any] | None,
     ) -> dict[str, Any]:
         merged_answers = None
+        normalized_answers = None
         if isinstance(prepared_fields, dict):
             candidate_answers = prepared_fields.get("merged_answers")
             if isinstance(candidate_answers, list):
                 merged_answers = candidate_answers
+            candidate_normalized = prepared_fields.get("normalized_answers")
+            if isinstance(candidate_normalized, list):
+                normalized_answers = candidate_normalized
         if normalized_action == "approve":
             action_payload = dict(payload)
             action_payload["nodeId"] = workflow_node_id
@@ -489,14 +542,14 @@ class TaskContextTools(ToolBase):
                 payload=action_payload,
             )
         if normalized_action == "save_only":
-            if merged_answers is None:
+            if normalized_answers is None:
                 raise_tool_error(QingflowApiError.config_error("fields is required for action 'save_only'"))
             return self._task_save_only(
                 profile=profile,
                 app_key=app_key,
                 record_id=record_id,
                 workflow_node_id=workflow_node_id,
-                merged_answers=merged_answers,
+                apply_answers=normalized_answers,
             )
         return self._task_tools.task_urge(
             profile=profile,
@@ -1223,9 +1276,16 @@ class TaskContextTools(ToolBase):
             current_answers=detail.get("answers") or [],
         )
         update_schema = update_schema_state["public_schema"]
+        save_only_available, capability_warnings, save_only_source = self._resolve_task_save_only_availability(
+            context,
+            app_key=app_key,
+            workflow_node_id=workflow_node_id,
+        )
         capabilities = self._build_capabilities(
             node_info,
-            allow_save_only=bool(update_schema.get("writable_fields")),
+            allow_save_only=save_only_available,
+            warnings=capability_warnings,
+            save_only_source=save_only_source,
         )
         visibility = self._build_visibility(node_info, detail)
         return {
@@ -1318,7 +1378,14 @@ class TaskContextTools(ToolBase):
             )
         )
 
-    def _build_capabilities(self, node_info: dict[str, Any], *, allow_save_only: bool) -> dict[str, Any]:
+    def _build_capabilities(
+        self,
+        node_info: dict[str, Any],
+        *,
+        allow_save_only: bool,
+        warnings: list[JSONObject] | None = None,
+        save_only_source: str = "workflow_editable_que_ids",
+    ) -> dict[str, Any]:
         available_actions = ["approve"]
         if self._coerce_bool(node_info.get("rejectBtnStatus")):
             available_actions.append("reject")
@@ -1347,6 +1414,8 @@ class TaskContextTools(ToolBase):
         return {
             "available_actions": available_actions,
             "visible_but_unimplemented_actions": visible_but_unimplemented_actions,
+            "save_only_source": save_only_source,
+            "warnings": list(warnings or []),
             "action_constraints": {
                 "feedback_required_for": feedback_required_for,
                 "submit_check_enabled": self._coerce_bool(node_info.get("beingSubmitCheck")),
@@ -1415,6 +1484,12 @@ class TaskContextTools(ToolBase):
             workflow_node_id=workflow_node_id,
             node_info=node_info,
         )
+        index, augmentation_warnings = self._augment_task_editable_field_index(
+            index=index,
+            current_answers=current_answers,
+            editable_question_ids=editable_question_ids,
+        )
+        schema_warnings.extend(augmentation_warnings)
         effective_editable_ids = set(editable_question_ids)
         for field in index.by_id.values():
             if field.que_type in SUBTABLE_QUE_TYPES and (_subtable_descendant_ids(field) & set(editable_question_ids)):
@@ -1474,6 +1549,44 @@ class TaskContextTools(ToolBase):
             "editable_question_ids_source": source,
         }
 
+    def _augment_task_editable_field_index(
+        self,
+        *,
+        index: FieldIndex,
+        current_answers: Any,
+        editable_question_ids: set[int],
+    ) -> tuple[FieldIndex, list[JSONObject]]:
+        if not editable_question_ids:
+            return index, []
+        missing_field_ids = {
+            str(que_id)
+            for que_id in editable_question_ids
+            if que_id > 0 and str(que_id) not in index.by_id
+        }
+        if not missing_field_ids:
+            return index, []
+        answer_backed_index = _build_answer_backed_field_index(
+            current_answers,
+            field_id_filter=missing_field_ids,
+        )
+        if not answer_backed_index.by_id:
+            return index, []
+        augmented_index = _merge_field_indexes(index, answer_backed_index)
+        return augmented_index, [
+            {
+                "code": "TASK_RUNTIME_EDITABLE_FIELDS_AUGMENTED",
+                "message": "task update schema added backend-editable fields from current task answers because applicant schema did not expose them.",
+                "fields": [
+                    {
+                        "field_id": field.que_id,
+                        "title": field.que_title,
+                        "que_type": field.que_type,
+                    }
+                    for field in answer_backed_index.by_id.values()
+                ],
+            }
+        ]
+
     def _resolve_task_editable_question_ids(
         self,
         context: BackendRequestContext,
@@ -1504,6 +1617,31 @@ class TaskContextTools(ToolBase):
         fallback_ids = self._editable_ids_from_que_auth_setting(node_info.get("queAuthSetting"))
         return fallback_ids, warnings, "que_auth_setting"
 
+    def _resolve_task_save_only_availability(
+        self,
+        context: BackendRequestContext,
+        *,
+        app_key: str,
+        workflow_node_id: int,
+    ) -> tuple[bool, list[JSONObject], str]:
+        try:
+            payload = self.backend.request(
+                "GET",
+                context,
+                f"/app/{app_key}/auditNode/{workflow_node_id}/editableQueIds",
+            )
+        except QingflowApiError as error:
+            warning: JSONObject = {
+                "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
+            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]:
         candidates: list[Any] = []
         if isinstance(payload, list):
@@ -1587,6 +1725,7 @@ class TaskContextTools(ToolBase):
                     },
                 )
             )
+        index = schema_state["index"]
         preflight = self._record_tools._build_record_write_preflight(
             profile=profile,
             context=context,
@@ -1601,8 +1740,8 @@ class TaskContextTools(ToolBase):
             view_key=None,
             view_name=None,
             existing_answers_override=current_answers,
+            field_index_override=index,
         )
-        index = schema_state["index"]
         effective_editable_ids = set(schema_state["effective_editable_question_ids"])
         scoped_field_errors = self._task_scope_field_errors(
             normalized_answers=preflight.get("normalized_answers") or [],
@@ -1692,14 +1831,14 @@ class TaskContextTools(ToolBase):
         app_key: str,
         record_id: int,
         workflow_node_id: int,
-        merged_answers: list[dict[str, Any]],
+        apply_answers: list[dict[str, Any]],
     ) -> dict[str, Any]:
         def runner(session_profile, context):
             result = self.backend.request(
                 "POST",
                 context,
                 f"/app/{app_key}/apply/{record_id}",
-                json_body={"role": 3, "auditNodeId": workflow_node_id, "answers": merged_answers},
+                json_body={"role": 3, "auditNodeId": workflow_node_id, "answers": apply_answers},
             )
             return {
                 "profile": profile,