@josephyan/qingflow-cli 0.2.0-beta.61 → 0.2.0-beta.63

package/src/qingflow_mcp/tools/approval_tools.py

@@ -69,12 +69,24 @@ class ApprovalTools(ToolBase):
             return self.record_comment_mark_read(profile=profile, app_key=app_key, apply_id=record_id)
 
         @mcp.tool(description=self._high_risk_tool_description(operation="approve", target="workflow task"))
-        def task_approve(profile: str = DEFAULT_PROFILE, app_key: str = "", record_id: int = 0, payload: dict[str, Any] | None = None) -> dict[str, Any]:
-            return self.task_approve(profile=profile, app_key=app_key, record_id=record_id, payload=payload or {})
+        def task_approve(
+            profile: str = DEFAULT_PROFILE,
+            app_key: str = "",
+            record_id: int = 0,
+            payload: dict[str, Any] | None = None,
+            fields: dict[str, Any] | None = None,
+        ) -> dict[str, Any]:
+            return self.task_approve(profile=profile, app_key=app_key, record_id=record_id, payload=payload or {}, fields=fields or {})
 
         @mcp.tool(description=self._high_risk_tool_description(operation="reject", target="workflow task"))
-        def task_reject(profile: str = DEFAULT_PROFILE, app_key: str = "", record_id: int = 0, payload: dict[str, Any] | None = None) -> dict[str, Any]:
-            return self.task_reject(profile=profile, app_key=app_key, record_id=record_id, payload=payload or {})
+        def task_reject(
+            profile: str = DEFAULT_PROFILE,
+            app_key: str = "",
+            record_id: int = 0,
+            payload: dict[str, Any] | None = None,
+            fields: dict[str, Any] | None = None,
+        ) -> dict[str, Any]:
+            return self.task_reject(profile=profile, app_key=app_key, record_id=record_id, payload=payload or {}, fields=fields or {})
 
         @mcp.tool()
         def task_rollback_candidates(
@@ -86,12 +98,40 @@ class ApprovalTools(ToolBase):
             return self.task_rollback_candidates(profile=profile, app_key=app_key, record_id=record_id, workflow_node_id=workflow_node_id)
 
         @mcp.tool()
-        def task_rollback(profile: str = DEFAULT_PROFILE, app_key: str = "", record_id: int = 0, payload: dict[str, Any] | None = None) -> dict[str, Any]:
-            return self.task_rollback(profile=profile, app_key=app_key, record_id=record_id, payload=payload or {})
+        def task_rollback(
+            profile: str = DEFAULT_PROFILE,
+            app_key: str = "",
+            record_id: int = 0,
+            payload: dict[str, Any] | None = None,
+            fields: dict[str, Any] | None = None,
+        ) -> dict[str, Any]:
+            return self.task_rollback(profile=profile, app_key=app_key, record_id=record_id, payload=payload or {}, fields=fields or {})
 
         @mcp.tool()
-        def task_transfer(profile: str = DEFAULT_PROFILE, app_key: str = "", record_id: int = 0, payload: dict[str, Any] | None = None) -> dict[str, Any]:
-            return self.task_transfer(profile=profile, app_key=app_key, record_id=record_id, payload=payload or {})
+        def task_transfer(
+            profile: str = DEFAULT_PROFILE,
+            app_key: str = "",
+            record_id: int = 0,
+            payload: dict[str, Any] | None = None,
+            fields: dict[str, Any] | None = None,
+        ) -> dict[str, Any]:
+            return self.task_transfer(profile=profile, app_key=app_key, record_id=record_id, payload=payload or {}, fields=fields or {})
+
+        @mcp.tool(description=self._high_risk_tool_description(operation="save", target="workflow task fields without advancing the workflow"))
+        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_transfer_candidates(
@@ -156,7 +196,17 @@ class ApprovalTools(ToolBase):
             selection={"app_key": app_key, "record_id": record_id, "list_type": list_type, "keyword": keyword},
         )
 
-    def task_approve(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any]) -> dict[str, Any]:
+    def task_approve(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any], fields: dict[str, Any] | None = None) -> dict[str, Any]:
+        if fields:
+            return self._delegate_task_action(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                action="approve",
+                payload=payload,
+                fields=fields,
+                public_action="task_approve",
+            )
         raw = self.record_approve(profile=profile, app_key=app_key, apply_id=record_id, payload=payload)
         return self._public_action_response(
             raw,
@@ -166,7 +216,17 @@ class ApprovalTools(ToolBase):
             human_review=True,
         )
 
-    def task_reject(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any]) -> dict[str, Any]:
+    def task_reject(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any], fields: dict[str, Any] | None = None) -> dict[str, Any]:
+        if fields:
+            return self._delegate_task_action(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                action="reject",
+                payload=payload,
+                fields=fields,
+                public_action="task_reject",
+            )
         raw = self.record_reject(profile=profile, app_key=app_key, apply_id=record_id, payload=payload)
         return self._public_action_response(
             raw,
@@ -186,7 +246,17 @@ class ApprovalTools(ToolBase):
             selection={"app_key": app_key, "record_id": record_id, "workflow_node_id": workflow_node_id},
         )
 
-    def task_rollback(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any]) -> dict[str, Any]:
+    def task_rollback(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any], fields: dict[str, Any] | None = None) -> dict[str, Any]:
+        if fields:
+            return self._delegate_task_action(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                action="rollback",
+                payload=payload,
+                fields=fields,
+                public_action="task_rollback",
+            )
         raw = self.record_rollback(profile=profile, app_key=app_key, apply_id=record_id, payload=payload)
         return self._public_action_response(
             raw,
@@ -196,7 +266,17 @@ class ApprovalTools(ToolBase):
             human_review=True,
         )
 
-    def task_transfer(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any]) -> dict[str, Any]:
+    def task_transfer(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any], fields: dict[str, Any] | None = None) -> dict[str, Any]:
+        if fields:
+            return self._delegate_task_action(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                action="transfer",
+                payload=payload,
+                fields=fields,
+                public_action="task_transfer",
+            )
         raw = self.record_transfer(profile=profile, app_key=app_key, apply_id=record_id, payload=payload)
         return self._public_action_response(
             raw,
@@ -206,6 +286,26 @@ class ApprovalTools(ToolBase):
             human_review=True,
         )
 
+    def task_save_only(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+        fields: dict[str, Any],
+    ) -> dict[str, Any]:
+        return self._delegate_task_action(
+            profile=profile,
+            app_key=app_key,
+            record_id=record_id,
+            action="save_only",
+            payload={},
+            fields=fields,
+            public_action="task_save_only",
+            workflow_node_id=workflow_node_id,
+        )
+
     def task_transfer_candidates(
         self,
         *,
@@ -749,6 +849,41 @@ class ApprovalTools(ToolBase):
         if payload.get("handSignImageUrl"):
             raise_tool_error(QingflowApiError.not_supported("NOT_SUPPORTED_IN_V1: handSignImageUrl is not supported"))
 
+    def _delegate_task_action(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        action: str,
+        payload: dict[str, Any],
+        fields: dict[str, Any],
+        public_action: str,
+        workflow_node_id: int | None = None,
+    ) -> dict[str, Any]:
+        from .task_context_tools import TaskContextTools
+
+        node_id = workflow_node_id
+        if node_id is None:
+            node_payload = dict(payload or {})
+            node_id = self._extract_node_id(node_payload)
+        delegated = TaskContextTools(self.sessions, self.backend).task_action_execute(
+            profile=profile,
+            app_key=app_key,
+            record_id=record_id,
+            workflow_node_id=node_id,
+            action=action,
+            payload=payload or {},
+            fields=fields or {},
+        )
+        response = dict(delegated)
+        data = response.get("data")
+        if isinstance(data, dict):
+            payload_data = dict(data)
+            payload_data["action"] = public_action
+            response["data"] = payload_data
+        return response
+
     def _public_page_response(
         self,
         raw: dict[str, Any],

package/src/qingflow_mcp/tools/custom_button_tools.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+from copy import deepcopy
+
+from ..config import DEFAULT_PROFILE
+from ..errors import QingflowApiError, raise_tool_error
+from ..json_types import JSONObject
+from .base import ToolBase
+
+
+class CustomButtonTools(ToolBase):
+    def custom_button_list(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        being_draft: bool = True,
+        include_raw: bool = False,
+    ) -> JSONObject:
+        self._require_app_key(app_key)
+
+        def runner(session_profile, context):
+            result = self.backend.request(
+                "GET",
+                context,
+                f"/app/{app_key}/customButton",
+                params={"beingDraft": being_draft},
+            )
+            items = []
+            raw_items = result.get("result") if isinstance(result, dict) and isinstance(result.get("result"), list) else []
+            for item in raw_items:
+                if not isinstance(item, dict):
+                    continue
+                items.append(self._compact_button_base_info(item))
+            response = {
+                "profile": profile,
+                "ws_id": session_profile.selected_ws_id,
+                "app_key": app_key,
+                "being_draft": being_draft,
+                "items": result if include_raw else items,
+                "count": len(items),
+                "compact": not include_raw,
+            }
+            if include_raw:
+                response["summary"] = items
+            return response
+
+        return self._run(profile, runner)
+
+    def custom_button_get(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        button_id: int,
+        being_draft: bool = True,
+        include_raw: bool = False,
+    ) -> JSONObject:
+        self._require_app_key(app_key)
+        self._require_button_id(button_id)
+
+        def runner(session_profile, context):
+            params = {"beingDraft": being_draft}
+            result = self.backend.request("GET", context, f"/app/{app_key}/customButton/{button_id}", params=params)
+            response = {
+                "profile": profile,
+                "ws_id": session_profile.selected_ws_id,
+                "app_key": app_key,
+                "button_id": button_id,
+                "being_draft": being_draft,
+                "result": result if include_raw else self._compact_button_detail(result if isinstance(result, dict) else {}),
+                "compact": not include_raw,
+            }
+            if include_raw:
+                response["summary"] = self._compact_button_detail(result if isinstance(result, dict) else {})
+            return response
+
+        return self._run(profile, runner)
+
+    def custom_button_create(self, *, profile: str, app_key: str, payload: JSONObject) -> JSONObject:
+        self._require_app_key(app_key)
+        body = self._require_dict(payload)
+
+        def runner(session_profile, context):
+            result = self.backend.request("POST", context, f"/app/{app_key}/customButton", json_body=deepcopy(body))
+            return {"profile": profile, "ws_id": session_profile.selected_ws_id, "app_key": app_key, "result": result}
+
+        return self._run(profile, runner)
+
+    def custom_button_update(self, *, profile: str, app_key: str, button_id: int, payload: JSONObject) -> JSONObject:
+        self._require_app_key(app_key)
+        self._require_button_id(button_id)
+        body = self._require_dict(payload)
+
+        def runner(session_profile, context):
+            result = self.backend.request(
+                "POST",
+                context,
+                f"/app/{app_key}/customButton/{button_id}",
+                json_body=deepcopy(body),
+            )
+            return self._attach_human_review_notice(
+                {
+                    "profile": profile,
+                    "ws_id": session_profile.selected_ws_id,
+                    "app_key": app_key,
+                    "button_id": button_id,
+                    "result": result,
+                },
+                operation="update",
+                target="custom button configuration",
+            )
+
+        return self._run(profile, runner)
+
+    def custom_button_delete(self, *, profile: str, app_key: str, button_id: int) -> JSONObject:
+        self._require_app_key(app_key)
+        self._require_button_id(button_id)
+
+        def runner(session_profile, context):
+            result = self.backend.request("DELETE", context, f"/app/{app_key}/customButton/{button_id}")
+            return self._attach_human_review_notice(
+                {
+                    "profile": profile,
+                    "ws_id": session_profile.selected_ws_id,
+                    "app_key": app_key,
+                    "button_id": button_id,
+                    "result": result,
+                },
+                operation="delete",
+                target="custom button configuration",
+            )
+
+        return self._run(profile, runner)
+
+    def _require_app_key(self, app_key: str) -> None:
+        if not str(app_key or "").strip():
+            raise_tool_error(QingflowApiError.config_error("app_key is required"))
+
+    def _require_button_id(self, button_id: int) -> None:
+        if not isinstance(button_id, int) or isinstance(button_id, bool) or button_id <= 0:
+            raise_tool_error(QingflowApiError.config_error("button_id must be a positive integer"))
+
+    def _compact_button_base_info(self, item: dict[str, object]) -> JSONObject:
+        creator = item.get("creatorUserInfo") if isinstance(item.get("creatorUserInfo"), dict) else {}
+        return {
+            "button_id": item.get("buttonId"),
+            "button_text": item.get("buttonText"),
+            "button_icon": item.get("buttonIcon"),
+            "background_color": item.get("backgroundColor"),
+            "text_color": item.get("textColor"),
+            "creator_user_info": {
+                "uid": creator.get("uid"),
+                "name": creator.get("name"),
+                "email": creator.get("email"),
+            }
+            if creator
+            else None,
+            "used_in_chart_count": item.get("userInChartCount"),
+            "being_effective_external_qrobot": item.get("beingEffectiveExternalQRobot"),
+        }
+
+    def _compact_button_detail(self, item: dict[str, object]) -> JSONObject:
+        return {
+            "button_id": item.get("buttonId"),
+            "button_text": item.get("buttonText"),
+            "button_icon": item.get("buttonIcon"),
+            "background_color": item.get("backgroundColor"),
+            "text_color": item.get("textColor"),
+            "trigger_action": item.get("triggerAction"),
+            "trigger_link_url": item.get("triggerLinkUrl"),
+            "trigger_add_data_config": deepcopy(item.get("triggerAddDataConfig")) if isinstance(item.get("triggerAddDataConfig"), dict) else None,
+            "external_qrobot_config": deepcopy(item.get("customButtonExternalQRobotRelationVO"))
+            if isinstance(item.get("customButtonExternalQRobotRelationVO"), dict)
+            else None,
+            "trigger_wings_config": deepcopy(item.get("triggerWingsConfig")) if isinstance(item.get("triggerWingsConfig"), dict) else None,
+        }