@josephyan/qingflow-app-user-mcp 0.2.0-beta.87 → 0.2.0-beta.89

package/README.md

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

package/package.json

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

package/src/qingflow_mcp/builder_facade/service.py

@@ -4789,12 +4789,22 @@ class AiBuilderFacade:
             response = _apply_permission_outcomes(response, relation_permission_outcome)
             return finalize(self._append_publish_result(profile=profile, app_key=target.app_key, publish=publish, response=response))
 
-        payload = _build_form_payload_from_fields(
-            title=effective_app_name,
-            current_schema=schema_result,
-            fields=current_fields,
-            layout=layout,
-            question_relations=compiled_question_relations,
+        payload = (
+            _build_form_payload_from_fields(
+                title=effective_app_name,
+                current_schema=schema_result,
+                fields=current_fields,
+                layout=layout,
+                question_relations=compiled_question_relations,
+            )
+            if bool(resolved.get("created"))
+            else _build_form_payload_for_edit_fields(
+                title=effective_app_name,
+                current_schema=schema_result,
+                fields=current_fields,
+                layout=layout,
+                question_relations=compiled_question_relations,
+            )
         )
         payload["editVersionNo"] = self._resolve_form_edit_version(
             profile=profile,
@@ -4897,12 +4907,22 @@ class AiBuilderFacade:
                     },
                     suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
                 )
-            rebound_payload = _build_form_payload_from_fields(
-                title=effective_app_name,
-                current_schema=rebound_schema,
-                fields=rebound_fields,
-                layout=rebound_layout,
-                question_relations=compiled_question_relations,
+            rebound_payload = (
+                _build_form_payload_from_fields(
+                    title=effective_app_name,
+                    current_schema=rebound_schema,
+                    fields=rebound_fields,
+                    layout=rebound_layout,
+                    question_relations=compiled_question_relations,
+                )
+                if bool(resolved.get("created"))
+                else _build_form_payload_for_edit_fields(
+                    title=effective_app_name,
+                    current_schema=rebound_schema,
+                    fields=rebound_fields,
+                    layout=rebound_layout,
+                    question_relations=compiled_question_relations,
+                )
             )
             rebound_payload["editVersionNo"] = self._resolve_form_edit_version(
                 profile=profile,
@@ -9844,8 +9864,8 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
         "subfields": [],
         "que_id": que_id,
         "que_type": que_type,
-        "default_type": _coerce_positive_int(question.get("queDefaultType")) or 1,
-        "default_value": question.get("queDefaultValue"),
+        "default_type": _coerce_positive_int(question.get("queDefaultType")) if "queDefaultType" in question else None,
+        "default_value": question.get("queDefaultValue") if "queDefaultValue" in question else None,
     }
     if field_type in {FieldType.single_select.value, FieldType.multi_select.value, FieldType.boolean.value}:
         options = question.get("options")
@@ -9960,6 +9980,7 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
                 continue
             subfields.append(_parse_field(sub_question))
         field["subfields"] = subfields
+    field["_question_template"] = deepcopy(question)
     return field
 
 
@@ -10846,53 +10867,82 @@ def _apply_field_mutation(field: dict[str, Any], mutation: Any) -> None:
         payload.get("type") == FieldType.relation.value
         or any(key in payload for key in ("target_app_key", "display_field", "visible_fields", "relation_mode"))
     )
+    question_overlay_keys = set(cast(list[str], field.get("_question_overlay_keys") or []))
+    question_rebuild_required = bool(field.get("_question_rebuild_required"))
     if "name" in payload:
         field["name"] = payload["name"]
+        question_overlay_keys.add("name")
     if "type" in payload:
         field["type"] = payload["type"]
+        question_rebuild_required = True
     if "required" in payload:
         field["required"] = payload["required"]
+        question_overlay_keys.add("required")
     if "description" in payload:
         field["description"] = payload["description"]
+        question_overlay_keys.add("description")
     if "options" in payload:
         field["options"] = list(payload["options"])
+        question_rebuild_required = True
     if "target_app_key" in payload:
         field["target_app_key"] = payload["target_app_key"]
+        question_rebuild_required = True
     if "display_field" in payload:
         field["display_field"] = payload["display_field"]
+        question_rebuild_required = True
     if "visible_fields" in payload:
         field["visible_fields"] = list(payload["visible_fields"])
+        question_rebuild_required = True
     if "relation_mode" in payload:
         field["relation_mode"] = payload["relation_mode"]
+        question_rebuild_required = True
     if "department_scope" in payload:
         field["department_scope"] = payload["department_scope"]
+        question_rebuild_required = True
     if "remote_lookup_config" in payload:
         field["remote_lookup_config"] = payload["remote_lookup_config"]
         field["config"] = deepcopy(payload["remote_lookup_config"])
         field["_explicit_remote_lookup_config"] = True
+        question_rebuild_required = True
     if "q_linker_binding" in payload:
         field["q_linker_binding"] = payload["q_linker_binding"]
         if "remote_lookup_config" not in payload:
             field["_explicit_remote_lookup_config"] = False
+        question_rebuild_required = True
     if "code_block_config" in payload:
         field["code_block_config"] = payload["code_block_config"]
         field["config"] = deepcopy(payload["code_block_config"])
+        question_rebuild_required = True
     if "code_block_binding" in payload:
         field["code_block_binding"] = payload["code_block_binding"]
         field["_explicit_code_block_binding"] = True
+        question_rebuild_required = True
     if "auto_trigger" in payload:
         field["auto_trigger"] = payload["auto_trigger"]
+        question_rebuild_required = True
     if "custom_button_text_enabled" in payload:
         field["custom_button_text_enabled"] = payload["custom_button_text_enabled"]
+        question_rebuild_required = True
     if "custom_button_text" in payload:
         field["custom_button_text"] = payload["custom_button_text"]
+        question_rebuild_required = True
     if "subfields" in payload:
         field["subfields"] = [_field_patch_to_internal(item) for item in payload["subfields"]]
+        question_rebuild_required = True
     if relation_config_explicit:
         field["_relation_config_explicit"] = True
+        question_rebuild_required = True
     elif payload.get("type") and payload.get("type") != FieldType.relation.value:
         field.pop("_relation_config_explicit", None)
         field.pop("_reference_config_template", None)
+    if question_overlay_keys:
+        field["_question_overlay_keys"] = sorted(question_overlay_keys)
+    else:
+        field.pop("_question_overlay_keys", None)
+    if question_rebuild_required:
+        field["_question_rebuild_required"] = True
+    else:
+        field.pop("_question_rebuild_required", None)
 
 
 def _resolve_field_selector_with_uniqueness(
@@ -12690,8 +12740,44 @@ def _verify_package_attachment(packages: PackageTools, *, profile: str, tag_id:
     return last_result
 
 
+def _field_question_overlay_keys(field: dict[str, Any]) -> set[str]:
+    raw_value = field.get("_question_overlay_keys")
+    if isinstance(raw_value, set):
+        return {str(item) for item in raw_value if isinstance(item, str) and item}
+    if isinstance(raw_value, list):
+        return {str(item) for item in raw_value if isinstance(item, str) and item}
+    return set()
+
+
+def _field_needs_question_rebuild(field: dict[str, Any]) -> bool:
+    return not isinstance(field.get("_question_template"), dict) or bool(field.get("_question_rebuild_required"))
+
+
+def _materialize_preserved_question(field: dict[str, Any]) -> dict[str, Any] | None:
+    template = deepcopy(field.get("_question_template"))
+    if not isinstance(template, dict):
+        return None
+    overlay_keys = _field_question_overlay_keys(field)
+    if "name" in overlay_keys:
+        template["queTitle"] = str(field.get("name") or "")
+    if "required" in overlay_keys:
+        template["required"] = bool(field.get("required", False))
+    if "description" in overlay_keys:
+        description = field.get("description")
+        template["queHint"] = "" if description is None else str(description)
+    return template
+
+
+def _materialize_edit_question(field: dict[str, Any], *, temp_id: int) -> tuple[dict[str, Any], bool]:
+    if not _field_needs_question_rebuild(field):
+        preserved = _materialize_preserved_question(field)
+        if preserved is not None:
+            return preserved, True
+    return _field_to_question(field, temp_id=temp_id), False
+
+
 def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]:
-    question, _next_temp_id = build_question(
+    built_question, _next_temp_id = build_question(
         {
             "label": field["name"],
             "type": field["type"],
@@ -12716,11 +12802,23 @@ def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]
         },
         temp_id,
     )
+    relation_question_template = (
+        deepcopy(field.get("_question_template"))
+        if field.get("type") == FieldType.relation.value and isinstance(field.get("_question_template"), dict)
+        else None
+    )
+    question = relation_question_template if relation_question_template is not None else built_question
     if _coerce_nonnegative_int(field.get("que_id")) is not None:
         question["queId"] = field["que_id"]
+        question.pop("queTempId", None)
     else:
+        question["queId"] = 0
         question["queTempId"] = temp_id
         field["que_temp_id"] = temp_id
+    question["queType"] = built_question.get("queType", question.get("queType"))
+    question["queTitle"] = built_question.get("queTitle", field["name"])
+    question["required"] = built_question.get("required", bool(field.get("required", False)))
+    question["queHint"] = built_question.get("queHint", field.get("description") or "")
     if field.get("default_type") is not None:
         question["queDefaultType"] = _coerce_positive_int(field.get("default_type")) or 1
     if "default_value" in field:
@@ -12733,15 +12831,28 @@ def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]
         )
         if preserved_reference is not None:
             preserved_reference["referAppKey"] = field.get("target_app_key")
-            preserved_reference["_targetEntityId"] = field.get("target_app_key")
             question["referenceConfig"] = preserved_reference
         else:
-            reference = question.get("referenceConfig") if isinstance(question.get("referenceConfig"), dict) else {}
+            reference = deepcopy(question.get("referenceConfig")) if isinstance(question.get("referenceConfig"), dict) else {}
+            built_reference = (
+                deepcopy(built_question.get("referenceConfig"))
+                if isinstance(built_question.get("referenceConfig"), dict)
+                else {}
+            )
+            for key in (
+                "referQueId",
+                "referQuestions",
+                "referAuthQues",
+                "optionalDataNum",
+                "fieldNameShow",
+                "_targetFieldId",
+            ):
+                if key in built_reference:
+                    reference[key] = deepcopy(built_reference[key])
             reference["referAppKey"] = field.get("target_app_key")
             reference["_targetEntityId"] = field.get("target_app_key")
             if field.get("target_field_que_id") is not None:
                 reference["referQueId"] = field.get("target_field_que_id")
-            reference["optionalDataNum"] = _relation_mode_to_optional_data_num(field.get("relation_mode"))
             question["referenceConfig"] = reference
     if field.get("type") == FieldType.department.value:
         scope_type, scope_payload = _serialize_department_scope_for_question(field.get("department_scope"))
@@ -12887,6 +12998,96 @@ def _build_form_payload_from_fields(
     return payload
 
 
+def _build_form_payload_for_edit_fields(
+    *,
+    title: str,
+    current_schema: dict[str, Any],
+    fields: list[dict[str, Any]],
+    layout: dict[str, Any],
+    question_relations: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    _, section_templates = _extract_question_templates(current_schema)
+    fields_by_name = {
+        str(field.get("name") or ""): field
+        for field in fields
+        if isinstance(field, dict) and str(field.get("name") or "").strip()
+    }
+    form_rows: list[list[dict[str, Any]]] = []
+    temp_id = -10000
+
+    for row in layout.get("root_rows", []) or []:
+        questions: list[dict[str, Any]] = []
+        row_preserved = True
+        for name in row:
+            field = fields_by_name.get(str(name))
+            if field is None:
+                continue
+            question, preserved = _materialize_edit_question(field, temp_id=temp_id)
+            questions.append(question)
+            row_preserved = row_preserved and preserved
+            temp_id -= 100
+        if not questions:
+            continue
+        if not row_preserved:
+            _apply_row_widths(questions)
+        form_rows.append(questions)
+
+    for section in layout.get("sections", []) or []:
+        inner_rows: list[list[dict[str, Any]]] = []
+        for row in section.get("rows", []) or []:
+            questions: list[dict[str, Any]] = []
+            row_preserved = True
+            for name in row:
+                field = fields_by_name.get(str(name))
+                if field is None:
+                    continue
+                question, preserved = _materialize_edit_question(field, temp_id=temp_id)
+                questions.append(question)
+                row_preserved = row_preserved and preserved
+                temp_id -= 100
+            if not questions:
+                continue
+            if not row_preserved:
+                _apply_row_widths(questions)
+            inner_rows.append(questions)
+        if not inner_rows:
+            continue
+        template = _select_section_template(section_templates, section)
+        wrapper = deepcopy(template) if isinstance(template, dict) else {
+            "queId": 0,
+            "queTempId": -(20000 + sum(ord(ch) for ch in str(section.get("section_id") or section.get("title") or "section"))),
+            "queType": 24,
+            "queWidth": 100,
+            "scanType": 1,
+            "status": 1,
+            "required": False,
+            "queHint": "",
+            "linkedQuestions": {},
+            "logicalShow": True,
+            "queDefaultValue": None,
+            "queDefaultType": 1,
+            "subQueWidth": 2,
+            "beingHide": False,
+            "beingDesensitized": False,
+        }
+        if section.get("title") is not None:
+            wrapper["queTitle"] = section.get("title") or wrapper.get("queTitle") or "未命名分组"
+        parsed_section_id = _coerce_positive_int(section.get("section_id"))
+        if parsed_section_id is not None:
+            wrapper["sectionId"] = parsed_section_id
+        elif template is None and section.get("section_id") is not None:
+            wrapper["sectionId"] = section.get("section_id")
+        wrapper["innerQuestions"] = inner_rows
+        form_rows.append([wrapper])
+
+    payload = deepcopy(current_schema)
+    payload["formTitle"] = title
+    payload["formQues"] = form_rows
+    payload["questionRelations"] = deepcopy(question_relations if question_relations is not None else (current_schema.get("questionRelations") or []))
+    payload["editVersionNo"] = int(current_schema.get("editVersionNo") or 1)
+    return payload
+
+
 def _apply_row_widths(row: list[dict[str, Any]]) -> None:
     if not row:
         return