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

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.981
 ```
 
 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.981 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.981",
   "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.0b981"
 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.0b97"
+_FALLBACK_VERSION = "0.2.0b981"
 
 
 def _resolve_local_pyproject_version() -> str | None:

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

@@ -177,10 +177,10 @@ def _format_task_list(result: dict[str, Any]) -> str:
                 str(item.get("app_key") or ""),
                 str(item.get("record_id") or ""),
                 str(item.get("workflow_node_id") or ""),
-                str(item.get("title") or item.get("task_name") or ""),
+                str(item.get("workflow_node_name") or ""),
             ]
         )
-    output = _render_titled_table("Tasks", ["app_key", "record_id", "node_id", "title"], rows)
+    output = _render_titled_table("Tasks", ["app_key", "record_id", "node_id", "node_name"], rows)
     lines = output.rstrip("\n").split("\n")
     _append_warnings(lines, result.get("warnings"))
     return "\n".join(lines) + "\n"
@@ -189,34 +189,48 @@ 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 {}
+    initiator = task.get("initiator") if isinstance(task.get("initiator"), dict) else {}
+    initiator_label = initiator.get("displayName") or initiator.get("email") or "-"
     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: {initiator_label}",
+        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"
 
@@ -226,17 +240,22 @@ def _format_import_verify(result: dict[str, Any]) -> str:
         f"App Key: {result.get('app_key') or '-'}",
         f"File: {result.get('file_name') or result.get('file_path') or '-'}",
         f"Can Import: {result.get('can_import')}",
-        f"Apply Rows: {result.get('apply_rows')}",
         f"Verification ID: {result.get('verification_id') or '-'}",
     ]
-    issues = result.get("issues") if isinstance(result.get("issues"), list) else []
-    if issues:
-        lines.append("Issues:")
-        for issue in issues:
-            if isinstance(issue, dict):
-                lines.append(f"- {issue.get('code') or 'ISSUE'}: {issue.get('message') or issue}")
-            else:
-                lines.append(f"- {issue}")
+    issue_summary = result.get("issue_summary") if isinstance(result.get("issue_summary"), dict) else {}
+    if issue_summary:
+        lines.append(
+            "Issues: "
+            f"total={issue_summary.get('total', 0)}, "
+            f"errors={issue_summary.get('errors', 0)}, "
+            f"warnings={issue_summary.get('warnings', 0)}"
+        )
+        sample = issue_summary.get("sample") if isinstance(issue_summary.get("sample"), list) else []
+        if sample:
+            lines.append("Issue Samples:")
+            for item in sample:
+                if isinstance(item, dict):
+                    lines.append(f"- {item.get('code') or 'ISSUE'}: {item.get('message') or ''}".rstrip())
     _append_warnings(lines, result.get("warnings"))
     _append_verification(lines, result.get("verification"))
     return "\n".join(lines) + "\n"
@@ -247,8 +266,9 @@ def _format_import_status(result: dict[str, Any]) -> str:
         f"Status: {result.get('status') or '-'}",
         f"Import ID: {result.get('import_id') or '-'}",
         f"Process ID: {result.get('process_id_str') or '-'}",
-        f"Success Rows: {result.get('success_rows') or 0}",
-        f"Failed Rows: {result.get('failed_rows') or 0}",
+        f"Total Rows: {result.get('total') or 0}",
+        f"Finished Rows: {result.get('finished') or 0}",
+        f"Failed Rows: {result.get('failed') or 0}",
         f"Progress: {result.get('progress') or '-'}",
     ]
     _append_warnings(lines, result.get("warnings"))

package/src/qingflow_mcp/response_trim.py

@@ -293,34 +293,150 @@ def _trim_file_upload_local(payload: JSONObject) -> None:
 
 
 def _trim_import_schema(payload: JSONObject) -> None:
-    pass
+    columns: list[JSONObject] | None = None
+    if isinstance(payload.get("columns"), list):
+        columns = [item for item in payload.get("columns", []) if isinstance(item, dict)]
+    elif isinstance(payload.get("expected_columns"), list):
+        columns = [item for item in payload.get("expected_columns", []) if isinstance(item, dict)]
+    if columns is not None:
+        payload["columns"] = [_compact_import_column(item) for item in columns]
+    payload.pop("expected_columns", None)
+    payload.pop("schema_fingerprint", None)
+    payload.pop("import_capability", None)
+    payload.pop("request_route", None)
+    payload.pop("verification", None)
+
+    if _looks_like_import_verify(payload):
+        _trim_import_verify_payload(payload)
+        return
+    if "applied_repairs" in payload or "repaired_file_path" in payload:
+        _trim_import_repair_payload(payload)
+        return
+    if "template_url" in payload or "downloaded_to_path" in payload:
+        _trim_import_template_payload(payload)
+        return
+    if "import_id" in payload or "process_id_str" in payload:
+        _trim_import_status_payload(payload)
+        return
 
 
 def _trim_record_schema(payload: JSONObject) -> None:
     payload.pop("legacy_schema", None)
+    template_map = payload.get("payload_template")
+    if not isinstance(template_map, dict):
+        template_map = None
+
+    if "writable_fields" in payload:
+        writable_fields = payload.get("writable_fields")
+        payload.pop("writable_fields", None)
+        required_fields: list[JSONObject] = []
+        optional_fields: list[JSONObject] = []
+        if isinstance(writable_fields, list):
+            for item in writable_fields:
+                compact = _compact_schema_field(item, template_map=template_map)
+                if not compact:
+                    continue
+                if compact.get("required") is True:
+                    required_fields.append(compact)
+                else:
+                    optional_fields.append(compact)
+        payload["required_fields"] = required_fields
+        payload["optional_fields"] = optional_fields
+
+    for key in ("required_fields", "optional_fields", "runtime_linked_required_fields", "fields"):
+        if key in payload:
+            payload[key] = _compact_schema_fields(payload.get(key), template_map=template_map)
+
+    for key in ("suggested_dimensions", "suggested_metrics", "suggested_time_fields"):
+        if isinstance(payload.get(key), list):
+            payload[key] = [
+                _pick(item, ("field_id", "title")) for item in payload.get(key) if isinstance(item, dict)
+            ]
+
+    for key in ("workflow_node", "view_resolution", "field_count", "record_context_probe", "view_probe_summary", "ambiguous_fields"):
+        payload.pop(key, None)
 
 
 def _trim_record_write(payload: JSONObject) -> None:
     data = payload.get("data")
     if not isinstance(data, dict):
         return
+    data.pop("debug", None)
     data.pop("normalized_payload", None)
     data.pop("human_review", None)
     data.pop("action", None)
+    resource = _compact_record_resource(data.get("resource"))
+    if resource:
+        data["resource"] = resource
+    else:
+        data.pop("resource", None)
 
 
 def _trim_record_get(payload: JSONObject) -> None:
-    _keep_nested_keys(payload, ("data", "selection", "view"), allowed=("view_id", "name"))
-    _drop_nested_keys(payload, ("data", "selection"), keys=("columns", "workflow_node_id"))
+    data = payload.get("data")
+    if not isinstance(data, dict):
+        return
+    compact: dict[str, Any] = {}
+    app_key = data.get("app_key")
+    if app_key:
+        compact["app_key"] = app_key
+    record_id = data.get("record_id")
+    if record_id not in (None, ""):
+        compact["record_id"] = str(record_id)
+    record = data.get("record")
+    if isinstance(record, dict):
+        compact["record"] = record
+    payload["data"] = compact
 
 
 def _trim_record_list(payload: JSONObject) -> None:
-    _keep_nested_keys(payload, ("data", "selection", "view"), allowed=("view_id", "name"))
-    _drop_nested_keys(payload, ("data", "selection"), keys=("columns",))
+    data = payload.get("data")
+    if not isinstance(data, dict):
+        return
+    pagination = data.get("pagination") if isinstance(data.get("pagination"), dict) else {}
+    returned_items = pagination.get("returned_items")
+    result_amount = pagination.get("result_amount")
+    limit = pagination.get("limit")
+    truncated = False
+    if isinstance(result_amount, int) and isinstance(returned_items, int):
+        truncated = result_amount > returned_items
+    compact_pagination = {
+        "loaded": True,
+        "page_size": limit,
+        "fetched_pages": 1,
+        "reported_total": result_amount,
+        "truncated": truncated,
+    }
+    selection = data.get("selection") if isinstance(data.get("selection"), dict) else {}
+    view = selection.get("view") if isinstance(selection.get("view"), dict) else {}
+    compact: dict[str, Any] = {
+        "app_key": data.get("app_key"),
+        "items": data.get("items") if isinstance(data.get("items"), list) else [],
+        "pagination": compact_pagination,
+    }
+    if view:
+        compact["view"] = _pick(view, ("view_id", "name"))
+    payload["data"] = compact
 
 
 def _trim_record_analyze(payload: JSONObject) -> None:
-    _drop_deep_keys(payload, {"debug"})
+    summary: dict[str, Any] = {}
+    completeness = payload.get("completeness")
+    if isinstance(completeness, dict):
+        summary["completeness"] = completeness
+    presentation = payload.get("presentation")
+    if isinstance(presentation, dict):
+        summary["presentation"] = presentation
+    ranking = payload.get("ranking")
+    if isinstance(ranking, dict):
+        summary["ranking"] = ranking
+    error = payload.get("error")
+    if isinstance(error, dict):
+        summary["error"] = error
+    if summary:
+        payload["summary"] = summary
+    for key in ("query", "ranking", "ratios", "completeness", "presentation", "error", "debug"):
+        payload.pop(key, None)
 
 
 def _trim_code_block_schema(payload: JSONObject) -> None:
@@ -340,6 +456,211 @@ def _trim_task_get(payload: JSONObject) -> None:
     _drop_deep_keys(payload, {"request_route", "output_profile"})
 
 
+def _trim_task_context_detail(payload: JSONObject) -> None:
+    _drop_deep_keys(payload, {"request_route", "output_profile"})
+
+
+def _trim_record_delete(payload: JSONObject) -> None:
+    data = payload.get("data")
+    if not isinstance(data, dict):
+        return
+    resource = data.get("resource")
+    deleted_ids: list[str] = []
+    if isinstance(resource, dict):
+        raw_ids = resource.get("record_ids") or resource.get("apply_ids") or resource.get("applyIds")
+        if isinstance(raw_ids, list):
+            deleted_ids = [str(item) for item in raw_ids if item not in (None, "")]
+    data["deleted_ids"] = deleted_ids
+    data.setdefault("failed_ids", [])
+    for key in (
+        "resource",
+        "action",
+        "normalized_payload",
+        "human_review",
+        "verification",
+        "blockers",
+        "field_errors",
+        "confirmation_requests",
+        "resolved_fields",
+        "debug",
+    ):
+        data.pop(key, None)
+
+
+def _compact_record_resource(resource: Any) -> dict[str, Any] | None:
+    if not isinstance(resource, dict):
+        return None
+    compact: dict[str, Any] = {}
+    if resource.get("type") not in (None, ""):
+        compact["type"] = resource.get("type")
+    app_key = resource.get("app_key") or resource.get("appKey")
+    if app_key not in (None, ""):
+        compact["app_key"] = app_key
+    record_id = resource.get("record_id")
+    if record_id not in (None, ""):
+        compact["record_id"] = str(record_id)
+    apply_id = resource.get("apply_id") or resource.get("applyId")
+    if apply_id not in (None, "") and "record_id" not in compact:
+        compact["record_id"] = str(apply_id)
+    record_ids = resource.get("record_ids")
+    if isinstance(record_ids, list):
+        compact["record_ids"] = [str(item) for item in record_ids if item not in (None, "")]
+    apply_ids = resource.get("apply_ids") or resource.get("applyIds")
+    if isinstance(apply_ids, list) and "record_ids" not in compact:
+        compact["record_ids"] = [str(item) for item in apply_ids if item not in (None, "")]
+    return compact or None
+
+
+def _compact_schema_fields(items: Any, *, template_map: dict[str, Any] | None) -> list[JSONObject]:
+    if not isinstance(items, list):
+        return []
+    compacted: list[JSONObject] = []
+    for item in items:
+        compact = _compact_schema_field(item, template_map=template_map)
+        if compact:
+            compacted.append(compact)
+    return compacted
+
+
+def _compact_schema_field(item: Any, *, template_map: dict[str, Any] | None) -> JSONObject | None:
+    if not isinstance(item, dict):
+        return None
+    compact: dict[str, Any] = {}
+    field_id = item.get("field_id")
+    if field_id not in (None, ""):
+        compact["field_id"] = field_id
+    title = item.get("title")
+    if title not in (None, ""):
+        compact["title"] = title
+    kind = item.get("kind") or item.get("write_kind")
+    if kind not in (None, ""):
+        compact["kind"] = kind
+    if "required" in item:
+        compact["required"] = bool(item.get("required"))
+    if template_map is not None and isinstance(title, str) and title in template_map:
+        compact["template"] = template_map.get(title)
+    candidate_hint = item.get("candidate_hint")
+    if isinstance(candidate_hint, dict):
+        compact["candidate_hint"] = candidate_hint
+    options = item.get("options")
+    if isinstance(options, list) and options:
+        compact["options"] = options
+    target_app_key = item.get("target_app_key")
+    if isinstance(target_app_key, str) and target_app_key:
+        compact["target_app_key"] = target_app_key
+    searchable_fields = item.get("searchable_fields")
+    if isinstance(searchable_fields, list) and searchable_fields:
+        compact["searchable_fields"] = searchable_fields
+    row_fields = item.get("row_fields")
+    if isinstance(row_fields, list) and row_fields:
+        compact["row_fields"] = _compact_schema_fields(row_fields, template_map=None)
+    return compact or None
+
+
+def _compact_import_column(item: dict[str, Any]) -> dict[str, Any]:
+    compact: dict[str, Any] = {
+        "title": item.get("title"),
+        "kind": item.get("kind") or item.get("write_kind"),
+        "required": bool(item.get("required")),
+    }
+    options = item.get("options")
+    if isinstance(options, list) and options:
+        compact["options"] = options
+    if bool(item.get("accepts_natural_input")):
+        compact["accepts_natural_input"] = True
+    if bool(item.get("requires_upload")):
+        compact["requires_upload"] = True
+    target_app_key = item.get("target_app_key")
+    if isinstance(target_app_key, str) and target_app_key:
+        compact["target_app_key"] = target_app_key
+    target_app_name = item.get("target_app_name")
+    if isinstance(target_app_name, str) and target_app_name:
+        compact["target_app_name"] = target_app_name
+    searchable_fields = item.get("searchable_fields")
+    if isinstance(searchable_fields, list) and searchable_fields:
+        compact["searchable_fields"] = searchable_fields
+    return compact
+
+
+def _looks_like_import_verify(payload: JSONObject) -> bool:
+    return "verification_id" in payload and "can_import" in payload
+
+
+def _trim_import_verify_payload(payload: JSONObject) -> None:
+    issues = payload.get("issues") if isinstance(payload.get("issues"), list) else []
+    issue_summary = _summarize_import_issues(issues)
+    payload["issue_summary"] = issue_summary
+    file_name = payload.get("file_name")
+    if not file_name:
+        file_path = payload.get("file_path")
+        if isinstance(file_path, str) and file_path:
+            payload["file_name"] = file_path.split("/")[-1]
+    for key in ("issues", "apply_rows", "expected_columns", "schema_fingerprint", "import_capability", "file_path", "file_sha256", "verified_file_sha256", "file_format", "auto_normalized", "local_precheck_limited"):
+        payload.pop(key, None)
+
+
+def _trim_import_repair_payload(payload: JSONObject) -> None:
+    payload["verification_id"] = payload.get("new_verification_id") or payload.get("verification_id")
+    for key in ("new_verification_id", "source_file_path", "repaired_file_path", "post_repair_issues", "verification"):
+        payload.pop(key, None)
+
+
+def _trim_import_template_payload(payload: JSONObject) -> None:
+    for key in ("schema_fingerprint", "verification"):
+        payload.pop(key, None)
+
+
+def _trim_import_status_payload(payload: JSONObject) -> None:
+    total_rows = payload.get("total_rows")
+    success_rows = payload.get("success_rows")
+    failed_rows = payload.get("failed_rows")
+    payload["total"] = total_rows
+    payload["finished"] = success_rows
+    payload["failed"] = failed_rows
+    for key in (
+        "matched_by",
+        "source_file_name",
+        "total_rows",
+        "success_rows",
+        "failed_rows",
+        "error_file_urls",
+        "operate_time",
+        "operate_user",
+        "verification",
+    ):
+        payload.pop(key, None)
+
+
+def _summarize_import_issues(issues: list[Any]) -> dict[str, Any]:
+    total = 0
+    error_count = 0
+    warning_count = 0
+    sample: list[dict[str, Any]] = []
+    for item in issues:
+        if not isinstance(item, dict):
+            continue
+        total += 1
+        severity = str(item.get("severity") or "").lower()
+        if severity == "error":
+            error_count += 1
+        if severity == "warning":
+            warning_count += 1
+        if len(sample) < 3:
+            sample.append(
+                {
+                    "code": item.get("code"),
+                    "message": item.get("message"),
+                    "severity": item.get("severity"),
+                }
+            )
+    return {
+        "total": total,
+        "errors": error_count,
+        "warnings": warning_count,
+        "sample": sample,
+    }
+
+
 def _trim_directory(payload: JSONObject) -> None:
     pass
 
@@ -409,15 +730,15 @@ _register_policy((USER_DOMAIN,), ("record_list",), _trim_record_list)
 _register_policy((USER_DOMAIN,), ("record_analyze",), _trim_record_analyze)
 _register_policy((USER_DOMAIN,), ("record_code_block_run",), _trim_code_block_run)
 _register_policy((USER_DOMAIN,), ("task_list",), _trim_task_list)
+_register_policy((USER_DOMAIN,), ("task_get",), _trim_task_get)
 _register_policy(
     (USER_DOMAIN,),
     (
-        "task_get",
         "task_action_execute",
         "task_associated_report_detail_get",
         "task_workflow_log_get",
     ),
-    _trim_task_get,
+    _trim_task_context_detail,
 )
 _register_policy(
     (USER_DOMAIN,),
@@ -438,10 +759,10 @@ _register_policy(
     (
         "record_member_candidates",
         "record_department_candidates",
-        "record_delete",
     ),
     _trim_builder_list_like,
 )
+_register_policy((USER_DOMAIN,), ("record_delete",), _trim_record_delete)
 _register_policy(
     (BUILDER_DOMAIN,),
     (

package/src/qingflow_mcp/tools/record_tools.py

@@ -1025,6 +1025,7 @@ class RecordTools(ToolBase):
         else:
             required = bool(required_override) if required_override is not None else bool(field.required)
         payload: JSONObject = {
+            "field_id": field.que_id,
             "title": field.que_title,
             "kind": kind,
             "required": required,

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,16 +1333,229 @@ 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": self._compact_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 [],
+                },
+            },
+        }
+        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 _compact_initiator(self, payload: Any) -> dict[str, Any] | None:
+        if not isinstance(payload, dict):
+            return None
+        compact = {
+            "uid": payload.get("uid"),
+            "displayName": payload.get("displayName") or payload.get("name") or payload.get("nickName"),
+            "email": payload.get("email"),
+            "mobile": payload.get("mobile"),
+            "headImg": payload.get("headImg"),
+        }
+        return {key: value for key, value in compact.items() if value not in (None, "", [])} or None
+
+    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")
         workflow_node_id = raw.get("nodeId") or raw.get("auditNodeId")
-        apply_user = raw.get("applyUser")
-        if apply_user is None:
-            user_uid = raw.get("applyUserUid")
-            user_name = raw.get("applyUserName")
-            if user_uid is not None or user_name is not None:
-                apply_user = {"uid": user_uid, "name": user_name}
         return {
             "task_id": raw.get("id") or raw.get("taskId") or record_id,
             "app_key": app_key,
@@ -1333,8 +1563,6 @@ class TaskContextTools(ToolBase):
             "record_id": record_id,
             "workflow_node_id": workflow_node_id,
             "workflow_node_name": raw.get("nodeName") or raw.get("auditNodeName"),
-            "title": raw.get("title") or raw.get("applyTitle") or raw.get("name") or raw.get("formTitle"),
-            "apply_user": apply_user,
             "apply_time": raw.get("applyTime") or raw.get("receiveTime"),
             "task_box": task_box,
             "flow_status": flow_status,
@@ -1490,16 +1718,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 +2107,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: