@josephyan/qingflow-app-user-mcp 0.2.0-beta.992 → 0.2.0-beta.994

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-app-user-mcp@0.2.0-beta.992
+npm install @josephyan/qingflow-app-user-mcp@0.2.0-beta.994
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-app-user-mcp@0.2.0-beta.992 qingflow-app-user-mcp
+npx -y -p @josephyan/qingflow-app-user-mcp@0.2.0-beta.994 qingflow-app-user-mcp
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-user-mcp",
-  "version": "0.2.0-beta.992",
+  "version": "0.2.0-beta.994",
   "description": "Operational end-user MCP for Qingflow records, tasks, comments, and directory workflows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qingflow-mcp"
-version = "0.2.0b992"
+version = "0.2.0b994"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/__init__.py

@@ -5,7 +5,7 @@ from pathlib import Path
 
 __all__ = ["__version__"]
 
-_FALLBACK_VERSION = "0.2.0b992"
+_FALLBACK_VERSION = "0.2.0b994"
 
 
 def _resolve_local_pyproject_version() -> str | None:

package/src/qingflow_mcp/cli/formatters.py

@@ -173,20 +173,26 @@ def _format_record_list(result: dict[str, Any]) -> str:
 def _format_task_list(result: dict[str, Any]) -> str:
     data = result.get("data") if isinstance(result.get("data"), dict) else {}
     items = data.get("items") if isinstance(data.get("items"), list) else []
-    rows = []
+    lines = ["Tasks"]
     for item in items:
         if not isinstance(item, dict):
             continue
-        rows.append(
-            [
-                str(item.get("app_key") or ""),
-                str(item.get("record_id") or ""),
-                str(item.get("workflow_node_id") or ""),
-                str(item.get("workflow_node_name") or ""),
-            ]
+        lines.append(
+            "- "
+            + " / ".join(
+                [
+                    str(item.get("app_key") or "-"),
+                    str(item.get("record_id") or "-"),
+                    str(item.get("workflow_node_id") or "-"),
+                    str(item.get("workflow_node_name") or "-"),
+                ]
+            )
         )
-    output = _render_titled_table("Tasks", ["app_key", "record_id", "node_id", "node_name"], rows)
-    lines = output.rstrip("\n").split("\n")
+        summary_fields = item.get("summary_fields") if isinstance(item.get("summary_fields"), list) else []
+        for summary in summary_fields:
+            if not isinstance(summary, dict):
+                continue
+            lines.append(f"  {summary.get('title') or '-'}: {summary.get('answer') or '-'}")
     _append_warnings(lines, result.get("warnings"))
     return "\n".join(lines) + "\n"
 

package/src/qingflow_mcp/tools/auth_tools.py

@@ -269,6 +269,15 @@ class AuthTools(ToolBase):
         )
         if selected_ws_id is not None:
             session_profile = self.sessions.select_workspace(profile, ws_id=selected_ws_id, ws_name=selected_ws_name)
+        backend_session = self.sessions.get_backend_session(profile)
+        permission_level = (
+            self._workspace_permission_level(
+                session_profile=session_profile,
+                backend_session=backend_session,
+            )
+            if backend_session is not None
+            else None
+        )
 
         return {
             "profile": session_profile.profile,
@@ -282,6 +291,7 @@ class AuthTools(ToolBase):
             "selected_ws_name": session_profile.selected_ws_name,
             "suggested_ws_id": session_profile.selected_ws_id,
             "suggested_ws_name": session_profile.selected_ws_name,
+            "permission_level": permission_level,
             "persisted": session_profile.persisted,
             "request_route": self._request_route_payload(
                 BackendRequestContext(
@@ -781,6 +791,13 @@ class AuthTools(ToolBase):
         if ws_id is None:
             return default_payload, []
 
+        permission_level = self._workspace_permission_level(
+            session_profile=session_profile,
+            backend_session=backend_session,
+        )
+        payload = dict(default_payload)
+        payload["permission_level"] = permission_level
+
         context = BackendRequestContext(
             base_url=backend_session.base_url,
             token=backend_session.token,
@@ -788,12 +805,6 @@ class AuthTools(ToolBase):
             qf_version=backend_session.qf_version,
             qf_version_source=backend_session.qf_version_source,
         )
-        permission_level = self._resolve_permission_level(
-            self._workspace_auth(context, ws_id=ws_id)
-        )
-        payload = dict(default_payload)
-        payload["permission_level"] = permission_level
-
         member = self._lookup_current_member(
             context=context,
             uid=session_profile.uid,
@@ -815,6 +826,25 @@ class AuthTools(ToolBase):
         payload["roles"] = self._compact_roles(member)
         return payload, []
 
+    def _workspace_permission_level(
+        self,
+        *,
+        session_profile,  # type: ignore[no-untyped-def]
+        backend_session,  # type: ignore[no-untyped-def]
+    ) -> str | None:
+        """Resolve the selected workspace permission label without requiring member lookup."""
+        ws_id = session_profile.selected_ws_id
+        if ws_id is None:
+            return None
+        context = BackendRequestContext(
+            base_url=backend_session.base_url,
+            token=backend_session.token,
+            ws_id=ws_id,
+            qf_version=backend_session.qf_version,
+            qf_version_source=backend_session.qf_version_source,
+        )
+        return self._resolve_permission_level(self._workspace_auth(context, ws_id=ws_id))
+
     def _workspace_auth(self, context: BackendRequestContext, *, ws_id: int) -> int | None:
         """执行内部辅助逻辑。"""
         workspace = self._fetch_workspace_auth_from_detail(context, ws_id=ws_id)

package/src/qingflow_mcp/tools/task_context_tools.py

@@ -185,11 +185,7 @@ class TaskContextTools(ToolBase):
         )
         task_page = raw.get("page", {})
         warnings: list[dict[str, Any]] = []
-        items = [
-            self._normalize_task_item(item, task_box=task_box, flow_status=flow_status)
-            for item in _task_page_items(task_page)
-            if isinstance(item, dict)
-        ]
+        items = [self._normalize_task_item(item) for item in _task_page_items(task_page) if isinstance(item, dict)]
         returned_items = len(items)
         page_amount = _task_page_amount(task_page)
         reported_total = _task_page_total(task_page)
@@ -235,8 +231,6 @@ class TaskContextTools(ToolBase):
                     "reported_total": reported_total,
                 },
                 "selection": {
-                    "task_box": task_box,
-                    "flow_status": flow_status,
                     "app_key": app_key,
                     "workflow_node_id": workflow_node_id,
                     "query": query,
@@ -1050,11 +1044,7 @@ class TaskContextTools(ToolBase):
             )
             task_page = raw.get("page", {})
             raw_items = _task_page_items(task_page)
-            normalized_items = [
-                self._normalize_task_item(item, task_box=task_box, flow_status=flow_status)
-                for item in raw_items
-                if isinstance(item, dict)
-            ]
+            normalized_items = [self._normalize_task_item(item) for item in raw_items if isinstance(item, dict)]
             matched_items.extend(item for item in normalized_items if self._task_item_matches_query(item, query))
             if page_amount is None:
                 coerced_page_amount = _coerce_count(_task_page_amount(task_page))
@@ -1726,7 +1716,7 @@ class TaskContextTools(ToolBase):
             if value not in (None, "", [])
         }
 
-    def _normalize_task_item(self, raw: dict[str, Any], *, task_box: str, flow_status: str) -> dict[str, Any]:
+    def _normalize_task_item(self, raw: dict[str, Any]) -> dict[str, Any]:
         """执行内部辅助逻辑。"""
         app_key = raw.get("appKey") or raw.get("app_key")
         record_id = raw.get("rowRecordId") or raw.get("recordId") or raw.get("applyId")
@@ -1739,11 +1729,30 @@ class TaskContextTools(ToolBase):
             "workflow_node_id": workflow_node_id,
             "workflow_node_name": raw.get("nodeName") or raw.get("auditNodeName"),
             "apply_time": raw.get("applyTime") or raw.get("receiveTime"),
-            "task_box": task_box,
-            "flow_status": flow_status,
-            "actionable": task_box == "todo" and bool(record_id) and bool(workflow_node_id),
+            "summary_fields": self._normalize_task_summary_fields(raw.get("dataSnapshot")),
         }
 
+    def _normalize_task_summary_fields(self, raw: Any) -> list[dict[str, Any]]:
+        """执行内部辅助逻辑。"""
+        if not isinstance(raw, list):
+            return []
+        summary_fields: list[dict[str, Any]] = []
+        for item in raw:
+            if not isinstance(item, dict):
+                continue
+            summary_field: dict[str, Any] = {
+                "field_id": item.get("fieldId"),
+                "title": item.get("fieldTitle"),
+                "type": item.get("fieldType"),
+                "answer": item.get("fieldAnswer"),
+                "desensitized": self._coerce_bool(item.get("beingDesensitized")),
+            }
+            associated_field_type = item.get("associatedQueType")
+            if associated_field_type is not None:
+                summary_field["associated_field_type"] = associated_field_type
+            summary_fields.append(summary_field)
+        return summary_fields
+
     def _select_task_node(self, infos: Any, workflow_node_id: int, *, app_key: str, record_id: int) -> dict[str, Any]:
         """执行内部辅助逻辑。"""
         if not isinstance(infos, list) or not infos: