@josephyan/qingflow-app-user-mcp 0.2.0-beta.97 → 0.2.0-beta.98

package/README.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-user-mcp",
-  "version": "0.2.0-beta.97",
+  "version": "0.2.0-beta.98",
   "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.0b97"
+version = "0.2.0b98"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/builder_facade/service.py

@@ -445,6 +445,7 @@ class AiBuilderFacade:
         base = base_result.get("result") if isinstance(base_result.get("result"), dict) else {}
         summary = detail_result.get("summary") if isinstance(detail_result, dict) and isinstance(detail_result.get("summary"), dict) else {}
         source = detail if detail else base
+        layout_tag_items = _select_package_layout_tag_items(detail=detail, base=base)
         warnings: list[JSONObject] = []
         if detail_read_error is not None:
             warnings.append(
@@ -455,7 +456,7 @@ class AiBuilderFacade:
                     "http_status": detail_read_error.http_status,
                 }
             )
-        public_items = _public_package_items_from_tag_items(source.get("tagItems") or base.get("tagItems"))
+        public_items = _public_package_items_from_tag_items(layout_tag_items)
         item_count = summary.get("itemCount")
         if not isinstance(item_count, int) or item_count < 0 or (item_count == 0 and public_items):
             item_count = len(public_items)
@@ -886,9 +887,7 @@ class AiBuilderFacade:
             if isinstance(current_base_result, dict) and isinstance(current_base_result.get("result"), dict)
             else {}
         )
-        detail_tag_items = detail_raw.get("tagItems") if isinstance(detail_raw.get("tagItems"), list) else None
-        base_tag_items = base_raw.get("tagItems") if isinstance(base_raw.get("tagItems"), list) else None
-        raw_tag_items = detail_tag_items if detail_tag_items else base_tag_items
+        raw_tag_items = _select_package_layout_tag_items(detail=detail_raw, base=base_raw)
         if not isinstance(raw_tag_items, list):
             return _failed(
                 "PACKAGE_LAYOUT_UNREADABLE",
@@ -12485,6 +12484,26 @@ def _public_package_items_from_tag_items(tag_items: Any) -> list[JSONObject]:
     return public_items
 
 
+def _select_package_layout_tag_items(*, detail: Any, base: Any) -> list[Any] | None:
+    base_tag_items = base.get("tagItems") if isinstance(base, dict) and isinstance(base.get("tagItems"), list) else None
+    detail_tag_items = detail.get("tagItems") if isinstance(detail, dict) and isinstance(detail.get("tagItems"), list) else None
+    if _package_tag_items_include_groups(base_tag_items):
+        return deepcopy(base_tag_items)
+    if _package_tag_items_include_groups(detail_tag_items):
+        return deepcopy(detail_tag_items)
+    if detail_tag_items is not None:
+        return deepcopy(detail_tag_items)
+    if base_tag_items is not None:
+        return deepcopy(base_tag_items)
+    return None
+
+
+def _package_tag_items_include_groups(tag_items: Any) -> bool:
+    if not isinstance(tag_items, list):
+        return False
+    return any(isinstance(item, dict) and _coerce_positive_int(item.get("itemType")) == 3 for item in tag_items)
+
+
 def _flatten_package_resource_identities(items: Any, *, public: bool) -> set[tuple[str, str]]:
     flattened: set[tuple[str, str]] = set()
 

package/src/qingflow_mcp/cli/formatters.py

@@ -189,34 +189,46 @@ def _format_task_list(result: dict[str, Any]) -> str:
 def _format_task_get(result: dict[str, Any]) -> str:
     data = result.get("data") if isinstance(result.get("data"), dict) else {}
     task = data.get("task") if isinstance(data.get("task"), dict) else {}
-    record = data.get("record") if isinstance(data.get("record"), dict) else {}
-    capabilities = data.get("capabilities") if isinstance(data.get("capabilities"), dict) else {}
-    update_schema = data.get("update_schema") if isinstance(data.get("update_schema"), dict) else {}
-    writable_fields = update_schema.get("writable_fields") if isinstance(update_schema.get("writable_fields"), list) else []
+    record_summary = data.get("record_summary") if isinstance(data.get("record_summary"), dict) else {}
+    editable_fields = data.get("editable_fields") if isinstance(data.get("editable_fields"), list) else []
+    available_actions = data.get("available_actions") if isinstance(data.get("available_actions"), list) else []
+    extras = data.get("extras") if isinstance(data.get("extras"), dict) else {}
     lines = [
         f"Task: {task.get('app_key') or '-'} / {task.get('record_id') or '-'} / {task.get('workflow_node_id') or '-'}",
         f"Node: {task.get('workflow_node_name') or '-'}",
-        f"Apply Status: {record.get('apply_status')}",
-        f"Available Actions: {', '.join(str(item) for item in (capabilities.get('available_actions') or [])) or '-'}",
-        f"Editable Fields: {len(writable_fields)}",
+        f"App: {task.get('app_name') or '-'}",
+        f"Initiator: {task.get('initiator') or '-'}",
+        f"Apply Status: {record_summary.get('apply_status')}",
+        f"Available Actions: {', '.join(str(item) for item in available_actions) or '-'}",
+        f"Editable Fields: {len(editable_fields)}",
     ]
-    if writable_fields:
-        for item in writable_fields[:10]:
+    core_fields = record_summary.get("core_fields") if isinstance(record_summary.get("core_fields"), dict) else {}
+    if core_fields:
+        lines.append("Core Fields:")
+        for key, value in list(core_fields.items())[:12]:
+            lines.append(f"- {key}: {value}")
+    if editable_fields:
+        lines.append("Editable Fields:")
+        for item in editable_fields[:10]:
             if isinstance(item, dict):
                 lines.append(f"- {item.get('title') or '-'} ({item.get('kind') or 'field'})")
-    blockers = update_schema.get("blockers") if isinstance(update_schema.get("blockers"), list) else []
-    if blockers:
-        lines.append("Update Schema Blockers:")
-        for item in blockers:
-            lines.append(f"- {item}")
-    schema_warnings = update_schema.get("warnings") if isinstance(update_schema.get("warnings"), list) else []
-    if schema_warnings:
-        lines.append("Update Schema Warnings:")
-        for item in schema_warnings:
+    associated_reports = extras.get("associated_reports") if isinstance(extras.get("associated_reports"), dict) else {}
+    rollback_candidates = extras.get("rollback_candidates") if isinstance(extras.get("rollback_candidates"), dict) else {}
+    transfer_candidates = extras.get("transfer_candidates") if isinstance(extras.get("transfer_candidates"), dict) else {}
+    lines.append(
+        "Extras: "
+        f"reports={associated_reports.get('count', 0)}, "
+        f"rollback={rollback_candidates.get('count', 0)}, "
+        f"transfer={transfer_candidates.get('count', 0)}"
+    )
+    transfer_items = transfer_candidates.get("items") if isinstance(transfer_candidates.get("items"), list) else []
+    if transfer_items:
+        lines.append("Transfer Candidates:")
+        for item in transfer_items:
             if isinstance(item, dict):
-                lines.append(f"- {item.get('code') or 'WARNING'}: {item.get('message') or ''}".rstrip())
-            else:
-                lines.append(f"- {item}")
+                display = item.get("name") or item.get("uid") or item
+                suffix = f" <{item.get('email')}>" if item.get("email") else ""
+                lines.append(f"- {display}{suffix} (uid={item.get('uid') or '-'})")
     _append_warnings(lines, result.get("warnings"))
     return "\n".join(lines) + "\n"
 

package/src/qingflow_mcp/tools/task_context_tools.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import re
 from typing import Any
 from uuid import uuid4
 
@@ -218,6 +219,7 @@ class TaskContextTools(ToolBase):
                 include_associated_reports=include_associated_reports,
                 current_uid=session_profile.uid,
             )
+            data = self._compact_task_get_context(data)
             return {
                 "profile": profile,
                 "ws_id": session_profile.selected_ws_id,
@@ -1213,8 +1215,9 @@ class TaskContextTools(ToolBase):
             f"/app/{app_key}/apply/{record_id}",
             params={"role": 3, "listType": 1, "auditNodeId": workflow_node_id},
         )
+        app_name = self._task_app_name(detail, node_info)
         associated_report_visible = self._resolve_associated_report_visible(node_info, detail)
-        associated_reports = {"visible": associated_report_visible, "count": 0, "items": []}
+        associated_reports = {"visible": associated_report_visible, "loaded": False, "count": 0, "items": []}
         if include_associated_reports and associated_report_visible:
             asos_chart_list = self.backend.request(
                 "GET",
@@ -1229,11 +1232,21 @@ class TaskContextTools(ToolBase):
             ]
             associated_reports = {
                 "visible": True,
+                "loaded": True,
                 "count": len(associated_items),
                 "items": associated_items,
             }
         rollback_items: list[dict[str, Any]] = []
         transfer_items: list[dict[str, Any]] = []
+        transfer_warnings: list[JSONObject] = []
+        transfer_pagination: JSONObject = {
+            "loaded": False,
+            "page_size": 100,
+            "fetched_pages": 0,
+            "reported_total": None,
+            "page_amount": None,
+            "truncated": False,
+        }
         if include_candidates:
             rollback_result = self.backend.request(
                 "GET",
@@ -1242,13 +1255,13 @@ class TaskContextTools(ToolBase):
                 params={"auditNodeId": workflow_node_id},
             )
             rollback_items = self._rollback_candidate_items(rollback_result)
-            transfer_result = self.backend.request(
-                "GET",
+            transfer_items, transfer_warnings, transfer_pagination = self._transfer_candidate_items(
                 context,
-                f"/app/{app_key}/apply/{record_id}/transfer/member",
-                params={"pageNum": 1, "pageSize": 20, "auditNodeId": workflow_node_id},
+                app_key=app_key,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
+                current_uid=current_uid,
             )
-            transfer_items = self._filter_transfer_members(_approval_page_items(transfer_result), current_uid=current_uid)
 
         update_schema_state = self._build_task_update_schema(
             profile=profile,
@@ -1275,6 +1288,7 @@ class TaskContextTools(ToolBase):
         return {
             "task": {
                 "app_key": app_key,
+                "app_name": app_name,
                 "record_id": record_id,
                 "workflow_node_id": workflow_node_id,
                 "workflow_node_name": node_info.get("auditNodeName") or node_info.get("nodeName"),
@@ -1306,6 +1320,9 @@ class TaskContextTools(ToolBase):
             "candidates": {
                 "rollback_nodes": rollback_items,
                 "transfer_members": transfer_items,
+                "loaded": include_candidates,
+                "transfer_pagination": transfer_pagination,
+                "warnings": transfer_warnings,
             },
             "workflow_log_summary": {
                 "visible": visibility["audit_record_visible"],
@@ -1316,6 +1333,219 @@ class TaskContextTools(ToolBase):
             "update_schema": update_schema,
         }
 
+    def _compact_task_get_context(self, data: dict[str, Any]) -> dict[str, Any]:
+        task = data.get("task") if isinstance(data.get("task"), dict) else {}
+        record = data.get("record") if isinstance(data.get("record"), dict) else {}
+        capabilities = data.get("capabilities") if isinstance(data.get("capabilities"), dict) else {}
+        update_schema = data.get("update_schema") if isinstance(data.get("update_schema"), dict) else {}
+        associated_reports = data.get("associated_reports") if isinstance(data.get("associated_reports"), dict) else {}
+        candidates = data.get("candidates") if isinstance(data.get("candidates"), dict) else {}
+        workflow_log = data.get("workflow_log_summary") if isinstance(data.get("workflow_log_summary"), dict) else {}
+
+        available_actions = [
+            str(item)
+            for item in (capabilities.get("available_actions") or [])
+            if str(item).strip()
+        ]
+        writable_fields = update_schema.get("writable_fields") if isinstance(update_schema.get("writable_fields"), list) else []
+        rollback_items = [
+            self._compact_rollback_candidate(item)
+            for item in (candidates.get("rollback_nodes") or [])
+            if isinstance(item, dict)
+        ]
+        transfer_items = [
+            self._compact_transfer_member(item)
+            for item in (candidates.get("transfer_members") or [])
+            if isinstance(item, dict)
+        ]
+        associated_items = [
+            self._compact_associated_report(item)
+            for item in (associated_reports.get("items") or [])
+            if isinstance(item, dict)
+        ]
+        transfer_pagination = candidates.get("transfer_pagination") if isinstance(candidates.get("transfer_pagination"), dict) else {}
+        compact: dict[str, Any] = {
+            "task": {
+                "app_key": task.get("app_key"),
+                "app_name": task.get("app_name"),
+                "record_id": task.get("record_id"),
+                "workflow_node_id": task.get("workflow_node_id"),
+                "workflow_node_name": task.get("workflow_node_name"),
+                "initiator": record.get("apply_user"),
+                "actionable": task.get("actionable"),
+            },
+            "record_summary": {
+                "apply_status": record.get("apply_status"),
+                "apply_num": record.get("apply_num"),
+                "custom_apply_num": record.get("custom_apply_num"),
+                "apply_time": record.get("apply_time"),
+                "last_update_time": record.get("last_update_time"),
+                "core_fields": self._task_record_core_fields(record.get("answers") or []),
+            },
+            "available_actions": available_actions,
+            "editable_fields": [
+                self._compact_task_editable_field(item, update_schema)
+                for item in writable_fields
+                if isinstance(item, dict)
+            ],
+            "extras": {
+                "workflow_log": {
+                    "available": bool(workflow_log.get("available")),
+                    "qrobot_log_visible": bool(workflow_log.get("qrobot_log_visible")),
+                    "history_count": workflow_log.get("history_count"),
+                },
+                "associated_reports": {
+                    "available": bool(associated_reports.get("visible")),
+                    "loaded": bool(associated_reports.get("loaded")),
+                    "count": len(associated_items),
+                    "items": associated_items,
+                },
+                "rollback_candidates": {
+                    "available": "rollback" in available_actions,
+                    "loaded": bool(candidates.get("loaded")),
+                    "count": len(rollback_items),
+                    "items": rollback_items,
+                },
+                "transfer_candidates": {
+                    "available": "transfer" in available_actions,
+                    "loaded": bool(transfer_pagination.get("loaded")),
+                    "count": len(transfer_items),
+                    "items": transfer_items,
+                    "pagination": transfer_pagination,
+                    "warnings": candidates.get("warnings") or [],
+                },
+            },
+        }
+        action_metadata = self._compact_task_action_metadata(capabilities)
+        if action_metadata:
+            compact["action_metadata"] = action_metadata
+        editable_metadata = self._compact_task_editable_metadata(update_schema)
+        if editable_metadata:
+            compact["editable_metadata"] = editable_metadata
+        return compact
+
+    def _compact_task_action_metadata(self, capabilities: dict[str, Any]) -> dict[str, Any]:
+        constraints = capabilities.get("action_constraints") if isinstance(capabilities.get("action_constraints"), dict) else {}
+        metadata: dict[str, Any] = {}
+        feedback_required_for = constraints.get("feedback_required_for") if isinstance(constraints.get("feedback_required_for"), list) else []
+        if feedback_required_for:
+            metadata["feedback_required_for"] = feedback_required_for
+        visible_but_unimplemented = capabilities.get("visible_but_unimplemented_actions")
+        if visible_but_unimplemented:
+            metadata["visible_but_unimplemented_actions"] = visible_but_unimplemented
+        if capabilities.get("save_only_source"):
+            metadata["save_only_source"] = capabilities.get("save_only_source")
+        if capabilities.get("warnings"):
+            metadata["warnings"] = capabilities.get("warnings")
+        return metadata
+
+    def _compact_task_editable_metadata(self, update_schema: dict[str, Any]) -> dict[str, Any]:
+        metadata: dict[str, Any] = {}
+        blockers = update_schema.get("blockers") if isinstance(update_schema.get("blockers"), list) else []
+        warnings = update_schema.get("warnings") if isinstance(update_schema.get("warnings"), list) else []
+        if blockers:
+            metadata["blockers"] = blockers
+        if warnings:
+            metadata["warnings"] = warnings
+        return metadata
+
+    def _task_app_name(self, detail: dict[str, Any], node_info: dict[str, Any]) -> Any:
+        for source in (detail, node_info):
+            for key in ("formTitle", "appName", "worksheetName", "appTitle"):
+                value = source.get(key)
+                if value not in (None, ""):
+                    return value
+        return None
+
+    def _task_record_core_fields(self, answers: Any, *, limit: int = 12) -> dict[str, Any]:
+        if not isinstance(answers, list):
+            return {}
+        core_fields: dict[str, Any] = {}
+        for answer in answers:
+            if not isinstance(answer, dict):
+                continue
+            title = answer.get("queTitle") or answer.get("title") or answer.get("fieldName")
+            if not title:
+                que_id = answer.get("queId")
+                title = f"field_{que_id}" if que_id not in (None, "") else None
+            if not title:
+                continue
+            table_values = answer.get("tableValues") if isinstance(answer.get("tableValues"), list) else []
+            if table_values:
+                value: Any = f"子表格 {len(table_values)} 行"
+            else:
+                values = self._extract_answer_values(answer)
+                if not values:
+                    continue
+                value = values[0] if len(values) == 1 else values
+            if value in (None, "", []):
+                continue
+            core_fields[str(title)] = self._compact_task_value(value)
+            if len(core_fields) >= limit:
+                break
+        return core_fields
+
+    def _compact_task_value(self, value: Any) -> Any:
+        if isinstance(value, list):
+            return [self._compact_task_value(item) for item in value[:8]]
+        text = re.sub(r"<[^>]+>", " ", str(value))
+        text = re.sub(r"\s+", " ", text).strip()
+        if len(text) <= 160:
+            return text
+        return text[:157].rstrip() + "..."
+
+    def _compact_task_editable_field(self, field: dict[str, Any], update_schema: dict[str, Any]) -> dict[str, Any]:
+        payload_template = update_schema.get("payload_template") if isinstance(update_schema.get("payload_template"), dict) else {}
+        title = field.get("title")
+        compact: dict[str, Any] = {}
+        for key in ("field_id", "title", "kind", "required", "candidate_hint"):
+            if key in field:
+                compact[key] = field.get(key)
+        if title in payload_template:
+            compact["template"] = payload_template.get(title)
+        return compact
+
+    def _compact_associated_report(self, item: dict[str, Any]) -> dict[str, Any]:
+        return {
+            key: value
+            for key, value in {
+                "report_id": item.get("report_id"),
+                "chart_key": item.get("chart_key"),
+                "chart_name": item.get("chart_name"),
+                "graph_type": item.get("graph_type"),
+                "source_type": item.get("source_type"),
+                "target_app_key": item.get("target_app_key"),
+                "target_app_name": item.get("target_app_name"),
+            }.items()
+            if value not in (None, "", [])
+        }
+
+    def _compact_rollback_candidate(self, item: dict[str, Any]) -> dict[str, Any]:
+        return {
+            key: value
+            for key, value in {
+                "workflow_node_id": item.get("auditNodeId") or item.get("nodeId"),
+                "workflow_node_name": item.get("auditNodeName") or item.get("nodeName"),
+            }.items()
+            if value not in (None, "", [])
+        }
+
+    def _compact_transfer_member(self, item: dict[str, Any]) -> dict[str, Any]:
+        uid = item.get("uid")
+        if uid is None:
+            uid = item.get("userId") or item.get("memberId") or item.get("id")
+        return {
+            key: value
+            for key, value in {
+                "uid": uid,
+                "name": item.get("name") or item.get("userName") or item.get("memberName") or item.get("realName"),
+                "email": item.get("email") or item.get("mail"),
+                "department_id": item.get("departmentId") or item.get("deptId"),
+                "department_name": item.get("departmentName") or item.get("deptName"),
+            }.items()
+            if value not in (None, "", [])
+        }
+
     def _normalize_task_item(self, raw: dict[str, Any], *, task_box: str, flow_status: str) -> 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")
@@ -1490,16 +1720,16 @@ class TaskContextTools(ToolBase):
             write_hints = self._record_tools._schema_write_hints(editable_field)
             if not bool(write_hints.get("writable")):
                 continue
-            writable_fields.append(
-                self._record_tools._ready_schema_field_payload(
-                    profile,
-                    context,
-                    editable_field,
-                    ws_id=context.ws_id,
-                    required_override=False,
-                    linkage_payloads_by_field_id=linkage_payloads_by_field_id,
-                )
+            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=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")
@@ -1879,11 +2109,85 @@ class TaskContextTools(ToolBase):
         for item in items:
             if not isinstance(item, dict):
                 continue
-            if current_uid is not None and item.get("uid") == current_uid:
+            uid = _coerce_count(item.get("uid") or item.get("userId") or item.get("memberId") or item.get("id"))
+            if current_uid is not None and uid == current_uid:
                 continue
             filtered.append(item)
         return filtered
 
+    def _transfer_candidate_items(
+        self,
+        context: BackendRequestContext,
+        *,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+        current_uid: int | None,
+    ) -> tuple[list[dict[str, Any]], list[JSONObject], JSONObject]:
+        page_size = 100
+        max_pages = 100
+        page_num = 1
+        fetched_pages = 0
+        fetched_raw_count = 0
+        page_amount: int | None = None
+        reported_total: int | None = None
+        items: list[dict[str, Any]] = []
+        seen_member_keys: set[str] = set()
+        warnings: list[JSONObject] = []
+
+        while page_num <= max_pages:
+            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)
+            if page_amount is None:
+                page_amount = _coerce_count(_approval_page_amount(result))
+            if reported_total is None:
+                reported_total = _coerce_count(_approval_page_total(result))
+            for item in self._filter_transfer_members(raw_items, current_uid=current_uid):
+                member_key = self._transfer_member_dedupe_key(item)
+                if member_key in seen_member_keys:
+                    continue
+                seen_member_keys.add(member_key)
+                items.append(item)
+            if not raw_items:
+                break
+            if page_amount is not None and page_num >= page_amount:
+                break
+            if reported_total is not None and fetched_raw_count >= reported_total:
+                break
+            page_num += 1
+        truncated = page_num > max_pages
+        if truncated:
+            warnings.append(
+                {
+                    "code": "TRANSFER_CANDIDATES_TRUNCATED",
+                    "message": "transfer candidates reached the MCP safety page cap; returned candidates may be incomplete.",
+                    "max_pages": max_pages,
+                    "page_size": page_size,
+                }
+            )
+        pagination: JSONObject = {
+            "loaded": True,
+            "page_size": page_size,
+            "fetched_pages": fetched_pages,
+            "reported_total": reported_total,
+            "page_amount": page_amount,
+            "truncated": truncated,
+        }
+        return items, warnings, pagination
+
+    def _transfer_member_dedupe_key(self, item: dict[str, Any]) -> str:
+        uid = item.get("uid") or item.get("userId") or item.get("memberId") or item.get("id")
+        if uid not in (None, ""):
+            return f"uid:{uid}"
+        return json.dumps(item, ensure_ascii=False, sort_keys=True, default=str)
+
     def _find_associated_report(self, task_context: dict[str, Any], report_id: int) -> dict[str, Any] | None:
         associated_reports = ((task_context.get("associated_reports") or {}).get("items") or [])
         for item in associated_reports:

package/src/qingflow_mcp/__init__.py

@@ -1,37 +0,0 @@
-from __future__ import annotations
-
-from importlib.metadata import PackageNotFoundError, packages_distributions, version as _dist_version
-from pathlib import Path
-
-__all__ = ["__version__"]
-
-_FALLBACK_VERSION = "0.2.0b97"
-
-
-def _resolve_local_pyproject_version() -> str | None:
-    module_path = Path(__file__).resolve()
-    for parent in module_path.parents:
-        candidate = parent / "pyproject.toml"
-        if not candidate.is_file():
-            continue
-        for line in candidate.read_text(encoding="utf-8").splitlines():
-            stripped = line.strip()
-            if stripped.startswith("version = "):
-                return stripped.split("=", 1)[1].strip().strip('"')
-        break
-    return None
-
-
-def _resolve_runtime_version() -> str:
-    local_version = _resolve_local_pyproject_version()
-    if local_version:
-        return local_version
-    for dist_name in packages_distributions().get("qingflow_mcp", []):
-        try:
-            return _dist_version(dist_name)
-        except PackageNotFoundError:
-            continue
-    return _FALLBACK_VERSION
-
-
-__version__ = _resolve_runtime_version()

package/src/qingflow_mcp/__main__.py

@@ -1,5 +0,0 @@
-"""Entry point for running qingflow_mcp as a module."""
-from qingflow_mcp.server import main
-
-if __name__ == "__main__":
-    main()