@josephyan/qingflow-app-user-mcp 0.2.0-beta.25 → 0.2.0-beta.26

package/README.md

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

package/package.json

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

package/src/qingflow_mcp/__init__.py

@@ -2,4 +2,4 @@ from __future__ import annotations
 
 __all__ = ["__version__"]
 
-__version__ = "0.2.0b25"
+__version__ = "0.2.0b26"

package/src/qingflow_mcp/tools/directory_tools.py

@@ -303,15 +303,57 @@ class DirectoryTools(ToolBase):
         page_num: int,
         page_size: int,
     ) -> dict[str, Any]:
-        if not keyword:
-            raise_tool_error(QingflowApiError.config_error("keyword is required"))
+        if page_num <= 0:
+            raise_tool_error(QingflowApiError.config_error("page_num must be positive"))
+        if page_size <= 0:
+            raise_tool_error(QingflowApiError.config_error("page_size must be positive"))
+        normalized_keyword = keyword.strip()
+
+        if not normalized_keyword:
+            def runner(session_profile, context):
+                fetch_limit = max((page_num + 1) * page_size + 1, page_size + 1)
+                items, truncated, deepest_depth = self._walk_department_tree(
+                    context,
+                    parent_dept_id=None,
+                    max_depth=20,
+                    max_items=fetch_limit,
+                )
+                start = (page_num - 1) * page_size
+                page_items = items[start : start + page_size]
+                reported_total = None if truncated else len(items)
+                page_amount = None if truncated else ((len(items) + page_size - 1) // page_size if items else 0)
+                if truncated and page_items:
+                    page_amount = max(page_num + 1, (start + len(page_items) + page_size - 1) // page_size)
+                return {
+                    "profile": profile,
+                    "ws_id": session_profile.selected_ws_id,
+                    "request_route": self._request_route_payload(context),
+                    "items": page_items,
+                    "pagination": {
+                        "page": page_num,
+                        "page_size": page_size,
+                        "returned_items": len(page_items),
+                        "reported_total": reported_total,
+                        "page_amount": page_amount,
+                        "depth_scanned": deepest_depth + 1 if page_items else 0,
+                    },
+                }
+
+            raw = self._run(profile, runner)
+            items = [item for item in raw.get("items", []) if isinstance(item, dict)]
+            return self._public_directory_response(
+                raw,
+                items=items,
+                pagination=raw.get("pagination", {}),
+                selection={"keyword": None},
+            )
 
         def runner(session_profile, context):
             result = self.backend.request(
                 "GET",
                 context,
                 "/contact/deptByPage",
-                params={"keyword": keyword, "pageNum": page_num, "pageSize": page_size},
+                params={"keyword": normalized_keyword, "pageNum": page_num, "pageSize": page_size},
             )
             return {
                 "profile": profile,
@@ -332,7 +374,7 @@ class DirectoryTools(ToolBase):
                 "reported_total": _coerce_int(_payload_value(raw.get("page"), "total")),
                 "page_amount": _coerce_int(_payload_value(raw.get("page"), "pageAmount")),
             },
-            selection={"keyword": keyword},
+            selection={"keyword": normalized_keyword},
         )
 
     def directory_list_all_departments(

package/src/qingflow_mcp/tools/record_tools.py

@@ -1686,6 +1686,9 @@ class RecordTools(ToolBase):
         support_matrix = _summarize_write_support(resolved_fields)
         invalid_fields: list[JSONObject] = []
         normalized_answers: list[JSONObject] = []
+        validation_warnings = [
+            "record_write performs static preflight from form metadata before apply; runtime visibility and dynamic linkage can still reject writes."
+        ]
         try:
             normalized_answers = self._resolve_answers(
                 profile,
@@ -1706,6 +1709,16 @@ class RecordTools(ToolBase):
                     "received_value": error.details.get("received_value") if error.details else None,
                 }
             )
+        validation_answers = normalized_answers
+        if operation == "update" and apply_id is not None and not invalid_fields:
+            try:
+                existing_answers = self._load_record_answers_for_preflight(context, app_key=app_key, apply_id=apply_id)
+            except QingflowApiError:
+                validation_warnings.append(
+                    "update preflight could not load the current record; required-field completeness was not revalidated."
+                )
+            else:
+                validation_answers = self._merge_record_answers(existing_answers, normalized_answers)
         readonly_or_system_fields = [
             {
                 "que_id": entry.get("que_id"),
@@ -1721,8 +1734,9 @@ class RecordTools(ToolBase):
         ]
         provided_field_ids = {
             str(answer.get("queId"))
-            for answer in normalized_answers
+            for answer in validation_answers
             if isinstance(answer.get("queId"), int) and int(answer["queId"]) > 0
+            and _answer_has_meaningful_content(answer)
         }
         missing_required_fields = []
         for field in index.by_id.values():
@@ -1738,9 +1752,6 @@ class RecordTools(ToolBase):
             )
         question_relations = _collect_question_relations(schema)
         option_links = _collect_option_links(resolved_fields)
-        validation_warnings = [
-            "record_write performs static preflight from form metadata before apply; runtime visibility and dynamic linkage can still reject writes."
-        ]
         if question_relations:
             validation_warnings.append(
                 "form contains questionRelations; linked visibility and runtime required rules may differ at submit time."
@@ -1795,6 +1806,39 @@ class RecordTools(ToolBase):
             "recommended_next_actions": actions,
         }
 
+    def _load_record_answers_for_preflight(
+        self,
+        context,  # type: ignore[no-untyped-def]
+        *,
+        app_key: str,
+        apply_id: int,
+    ) -> list[JSONObject]:
+        record = self.backend.request(
+            "GET",
+            context,
+            f"/app/{app_key}/apply/{apply_id}",
+            params={"role": 1, "listType": DEFAULT_RECORD_LIST_TYPE},
+        )
+        answers = record.get("answers") if isinstance(record, dict) else None
+        return [item for item in answers if isinstance(item, dict)] if isinstance(answers, list) else []
+
+    def _merge_record_answers(
+        self,
+        existing_answers: list[JSONObject],
+        patch_answers: list[JSONObject],
+    ) -> list[JSONObject]:
+        merged_by_id: dict[int, JSONObject] = {}
+        order: list[int] = []
+        for source in (existing_answers, patch_answers):
+            for item in source:
+                que_id = _coerce_count(item.get("queId")) if isinstance(item, dict) else None
+                if que_id is None or que_id <= 0:
+                    continue
+                if que_id not in merged_by_id:
+                    order.append(que_id)
+                merged_by_id[que_id] = item
+        return [merged_by_id[que_id] for que_id in order]
+
     def record_query(
         self,
         *,
@@ -3946,6 +3990,26 @@ def _normalize_audit_nodes(payload: JSONValue) -> list[JSONObject]:
     return []
 
 
+def _answer_has_meaningful_content(answer: JSONObject) -> bool:
+    table_values = answer.get("tableValues")
+    if isinstance(table_values, list) and table_values:
+        for row in table_values:
+            if isinstance(row, list) and any(_answer_has_meaningful_content(item) for item in row if isinstance(item, dict)):
+                return True
+        return False
+    values = answer.get("values")
+    if not isinstance(values, list) or not values:
+        return False
+    for item in values:
+        if isinstance(item, dict):
+            if any(value not in (None, "", [], {}) for value in item.values()):
+                return True
+            continue
+        if item not in (None, "", [], {}):
+            return True
+    return False
+
+
 def _extract_applicant_node(payload: JSONValue) -> WorkflowNodeRef | None:
     for item in _normalize_audit_nodes(payload):
         node_type = _coerce_count(item.get("type"))