@josephyan/qingflow-app-builder-mcp 0.2.0-beta.98 → 0.2.0-beta.981

package/README.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-builder-mcp",
-  "version": "0.2.0-beta.98",
+  "version": "0.2.0-beta.981",
   "description": "Builder MCP for Qingflow app/package/system design and staged solution workflows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qingflow-mcp"
-version = "0.2.0b98"
+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/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"
@@ -193,11 +193,13 @@ def _format_task_get(result: dict[str, Any]) -> str:
     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"App: {task.get('app_name') or '-'}",
-        f"Initiator: {task.get('initiator') 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)}",
@@ -238,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"
@@ -259,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:
@@ -344,6 +460,207 @@ 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
 
@@ -442,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

@@ -1371,7 +1371,7 @@ class TaskContextTools(ToolBase):
                 "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"),
+                "initiator": self._compact_initiator(record.get("apply_user")),
                 "actionable": task.get("actionable"),
             },
             "record_summary": {
@@ -1416,12 +1416,6 @@ class TaskContextTools(ToolBase):
                 },
             },
         }
-        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]:
@@ -1449,6 +1443,18 @@ class TaskContextTools(ToolBase):
             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"):
@@ -1550,12 +1556,6 @@ class TaskContextTools(ToolBase):
         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,
@@ -1563,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,