@josephyan/qingflow-app-builder-mcp 1.1.19 → 1.1.21

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-app-builder-mcp@1.1.19
+npm install @josephyan/qingflow-app-builder-mcp@1.1.21
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-app-builder-mcp@1.1.19 qingflow-app-builder-mcp
+npx -y -p @josephyan/qingflow-app-builder-mcp@1.1.21 qingflow-app-builder-mcp
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-builder-mcp",
-  "version": "1.1.19",
+  "version": "1.1.21",
   "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 = "1.1.19"
+version = "1.1.21"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/builder_facade/service.py

@@ -9,6 +9,7 @@ import random
 import re
 import string
 import tempfile
+import time
 from typing import Any, NoReturn, cast
 from urllib.parse import quote_plus, unquote_plus
 from uuid import uuid4
@@ -8585,7 +8586,17 @@ class AiBuilderFacade:
         add_fields: list[FieldPatch],
         update_fields: list[FieldUpdatePatch],
         remove_fields: list[FieldRemovePatch],
+        inline_form_layout_sections: list[LayoutSectionPatch] | None = None,
     ) -> JSONObject:
+        apply_started_at = time.perf_counter()
+        schema_write_ms: int | None = None
+        inline_layout_ms: int | None = None
+        publish_ms: int | None = None
+        readback_ms: int | None = None
+        requested_inline_layout_sections = [
+            section.model_dump(mode="json", exclude_none=True)
+            for section in (inline_form_layout_sections or [])
+        ]
         normalized_args = {
             "app_key": app_key,
             "package_tag_id": package_tag_id,
@@ -8599,6 +8610,8 @@ class AiBuilderFacade:
             "update_fields": [patch.model_dump(mode="json") for patch in update_fields],
             "remove_fields": [patch.model_dump(mode="json") for patch in remove_fields],
         }
+        if requested_inline_layout_sections:
+            normalized_args["inline_form_layout_sections"] = requested_inline_layout_sections
         try:
             desired_auth = (
                 self._compile_visibility_to_member_auth(profile=profile, visibility=visibility)
@@ -8614,7 +8627,8 @@ class AiBuilderFacade:
                 suggested_next_call=None,
             )
         permission_outcomes: list[PermissionCheckOutcome] = []
-        requested_field_changes = bool(add_fields or update_fields or remove_fields)
+        requested_inline_layout = bool(requested_inline_layout_sections)
+        requested_field_changes = bool(add_fields or update_fields or remove_fields or requested_inline_layout)
         resolved: JSONObject
         if app_key:
             resolved = self.app_resolve(profile=profile, app_key=app_key)
@@ -8950,6 +8964,59 @@ class AiBuilderFacade:
                 suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
             )
 
+        inline_form_layout_target: dict[str, Any] | None = None
+        inline_form_layout_auto_added_fields: list[str] = []
+        inline_form_layout_changed = False
+        if requested_inline_layout:
+            inline_layout_started_at = time.perf_counter()
+            resolved_inline_sections, missing_selectors = _resolve_layout_sections_to_names(
+                requested_inline_layout_sections,
+                current_fields,
+            )
+            normalized_args["inline_form_layout_sections"] = resolved_inline_sections
+            if missing_selectors:
+                return _failed(
+                    "UNKNOWN_LAYOUT_FIELD",
+                    "inline form layout references unknown field selectors",
+                    normalized_args=normalized_args,
+                    details={"unknown_selectors": missing_selectors},
+                    missing_fields=[str(item) for item in missing_selectors],
+                    suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
+                )
+            fields_by_name = {field["name"]: field for field in current_fields}
+            seen_layout_fields: list[str] = []
+            for section in resolved_inline_sections:
+                for row in section.get("rows", []):
+                    for field_name in row:
+                        if field_name not in fields_by_name:
+                            return _failed(
+                                "UNKNOWN_LAYOUT_FIELD",
+                                f"inline form layout references unknown field '{field_name}'",
+                                normalized_args=normalized_args,
+                                details={"field_name": field_name},
+                                suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
+                            )
+                        if field_name in seen_layout_fields:
+                            return _failed(
+                                "DUPLICATE_LAYOUT_FIELD",
+                                f"inline form layout references field '{field_name}' more than once",
+                                normalized_args=normalized_args,
+                                details={"field_name": field_name},
+                                suggested_next_call={"tool_name": "app_schema_apply", "arguments": {"profile": profile, **normalized_args}},
+                            )
+                        seen_layout_fields.append(field_name)
+            merged_inline_layout = _merge_layout(
+                current_layout=layout,
+                requested_sections=resolved_inline_sections,
+                all_field_names=[field["name"] for field in current_fields],
+            )
+            inline_form_layout_auto_added_fields = list(merged_inline_layout.get("auto_added_fields") or [])
+            inline_form_layout_target = cast(dict[str, Any], merged_inline_layout["layout"])
+            inline_form_layout_changed = not _layouts_equal(layout, inline_form_layout_target)
+            if inline_form_layout_changed:
+                layout = inline_form_layout_target
+            inline_layout_ms = _duration_ms(inline_layout_started_at)
+
         schema_write_requested = bool(
             added
             or updated
@@ -8957,6 +9024,7 @@ class AiBuilderFacade:
             or normalized_code_block_fields
             or data_display_selection.has_any
             or bool(resolved.get("created"))
+            or inline_form_layout_changed
         )
         if schema_write_requested:
             try:
@@ -9006,7 +9074,8 @@ class AiBuilderFacade:
             else []
         )
 
-        if not added and not updated and not removed and not normalized_code_block_fields and not data_display_selection.has_any and not bool(resolved.get("created")):
+        if not schema_write_requested:
+            readback_started_at = time.perf_counter()
             try:
                 base_info = self.apps.app_get_base(profile=profile, app_key=target.app_key, include_raw=True).get("result") or {}
             except (QingflowApiError, RuntimeError) as error:
@@ -9042,6 +9111,7 @@ class AiBuilderFacade:
             expected_app_icon = str(visual_result.get("app_icon") or "").strip() or None
             app_icon_verified = True if expected_app_icon is None else actual_app_icon == expected_app_icon
             app_base_verified = actual_app_name == effective_app_name and app_icon_verified
+            readback_ms = _duration_ms(readback_started_at)
             verified = app_base_verified and relation_target_metadata_verified
             response = {
                 "status": "success" if verified else "partial_success",
@@ -9079,11 +9149,34 @@ class AiBuilderFacade:
                 "package_attached": package_attached,
             }
             response["details"]["relation_field_count"] = relation_field_count
+            if requested_inline_layout:
+                response["inline_form_layout"] = {
+                    "requested": True,
+                    "section_count": len(requested_inline_layout_sections),
+                    "app_key": target.app_key,
+                    "applied": True,
+                    "applied_in_schema": True,
+                    "layout_status": "success",
+                    "message": "layout already matched requested state",
+                    "auto_added_fields": inline_form_layout_auto_added_fields,
+                }
+                response["verification"]["inline_form_layout_verified"] = True
             if normalized_code_block_fields:
                 response["normalized_code_block_output_assignment"] = True
                 response["normalized_code_block_fields"] = normalized_code_block_fields
             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))
+            publish_started_at = time.perf_counter()
+            response = self._append_publish_result(profile=profile, app_key=target.app_key, publish=publish, response=response)
+            publish_ms = _duration_ms(publish_started_at)
+            _merge_duration_breakdown(
+                response,
+                schema_write_ms=0,
+                inline_layout_ms=inline_layout_ms,
+                publish_ms=publish_ms,
+                readback_ms=readback_ms,
+                total_ms=_duration_ms(apply_started_at),
+            )
+            return finalize(response)
 
         payload = (
             _build_form_payload_from_fields(
@@ -9109,7 +9202,9 @@ class AiBuilderFacade:
             current_schema=schema_result,
         )
         try:
+            schema_write_started_at = time.perf_counter()
             self.apps.app_update_form_schema(profile=profile, app_key=target.app_key, payload=payload)
+            schema_write_ms = _duration_ms(schema_write_started_at)
         except (QingflowApiError, RuntimeError) as error:
             api_error = _coerce_api_error(error)
             if backend_code_int(api_error) == 49614:
@@ -9271,7 +9366,9 @@ class AiBuilderFacade:
                 current_schema=rebound_schema,
             )
             try:
+                schema_write_started_at = time.perf_counter()
                 self.apps.app_update_form_schema(profile=profile, app_key=target.app_key, payload=rebound_payload)
+                schema_write_ms = (schema_write_ms or 0) + _duration_ms(schema_write_started_at)
             except (QingflowApiError, RuntimeError) as error:
                 api_error = _coerce_api_error(error)
                 return _failed_from_api_error(
@@ -9334,6 +9431,22 @@ class AiBuilderFacade:
             "package_attached": None,
         }
         response["details"]["relation_field_count"] = relation_field_count
+        if requested_inline_layout:
+            response["inline_form_layout"] = {
+                "requested": True,
+                "section_count": len(requested_inline_layout_sections),
+                "app_key": target.app_key,
+                "applied": True,
+                "applied_in_schema": True,
+                "layout_status": "success",
+                "message": (
+                    "applied inline form layout inside schema write"
+                    if inline_form_layout_changed
+                    else "layout already matched requested state"
+                ),
+                "auto_added_fields": inline_form_layout_auto_added_fields,
+            }
+            response["verification"]["inline_form_layout_verified"] = False
         if normalized_code_block_fields:
             response["normalized_code_block_output_assignment"] = True
             response["normalized_code_block_fields"] = normalized_code_block_fields
@@ -9342,11 +9455,14 @@ class AiBuilderFacade:
             if schema_readback_delayed_error is not None:
                 response["details"]["schema_readback_delayed_error"] = schema_readback_delayed_error
         response = _apply_permission_outcomes(response, relation_permission_outcome)
+        publish_started_at = time.perf_counter()
         response = self._append_publish_result(profile=profile, app_key=target.app_key, publish=publish, response=response)
+        publish_ms = _duration_ms(publish_started_at)
         verification_ok = False
         tag_ids_after: list[int] = []
         package_attached: bool | None = None
         verification_error: QingflowApiError | None = None
+        readback_started_at = time.perf_counter()
         try:
             verified = self.app_read(profile=profile, app_key=target.app_key, include_raw=False)
             verified_field_names = {field["name"] for field in verified["schema"]["fields"]}
@@ -9380,6 +9496,14 @@ class AiBuilderFacade:
             response["verification"].update(data_display_verification)
             if data_display_verification.get("data_display_config_verified") is False:
                 verification_ok = False
+            if requested_inline_layout and inline_form_layout_target is not None:
+                verified_layout = verified.get("layout") if isinstance(verified.get("layout"), dict) else {}
+                inline_layout_verified = _layouts_equal(verified_layout, inline_form_layout_target) or _layouts_semantically_equal(
+                    verified_layout,
+                    inline_form_layout_target,
+                )
+                response["verification"]["inline_form_layout_verified"] = inline_layout_verified
+                verification_ok = verification_ok and inline_layout_verified
             if relation_degraded_expectations:
                 relation_verified_fields = cast(list[dict[str, Any]], verified["schema"]["fields"])
                 try:
@@ -9412,6 +9536,7 @@ class AiBuilderFacade:
             tag_ids_after = []
             package_attached = None if package_tag_id is None else False
             app_base_verified = False
+        readback_ms = _duration_ms(readback_started_at)
         response["verification"]["fields_verified"] = verification_ok
         response["verification"]["package_attached"] = package_attached
         response["verification"]["app_visuals_verified"] = app_base_verified
@@ -9460,6 +9585,14 @@ class AiBuilderFacade:
                 "message": verification_error.message,
                 **_transport_error_payload(verification_error),
             }
+        _merge_duration_breakdown(
+            response,
+            schema_write_ms=schema_write_ms,
+            inline_layout_ms=inline_layout_ms,
+            publish_ms=publish_ms,
+            readback_ms=readback_ms,
+            total_ms=_duration_ms(apply_started_at),
+        )
         return finalize(response)
 
     def app_layout_apply(
@@ -21636,6 +21769,21 @@ def _layouts_semantically_equal(left: dict[str, Any], right: dict[str, Any]) ->
     return _layout_field_sequence(left) == _layout_field_sequence(right)
 
 
+def _duration_ms(started_at: float) -> int:
+    return max(0, int((time.perf_counter() - started_at) * 1000))
+
+
+def _merge_duration_breakdown(response: JSONObject, **items: int | None) -> None:
+    breakdown = response.get("duration_breakdown_ms")
+    if not isinstance(breakdown, dict):
+        breakdown = {}
+        response["duration_breakdown_ms"] = breakdown
+    for key, value in items.items():
+        if value is None:
+            continue
+        breakdown[key] = int(value)
+
+
 def _find_field_section_id(layout: dict[str, Any], field_name: str) -> str | None:
     for section in layout.get("sections", []) or []:
         for row in section.get("rows", []) or []:

package/src/qingflow_mcp/tools/ai_builder_tools.py

@@ -107,6 +107,26 @@ def _payload_bool(payload: JSONObject, *keys: str, default: bool = True) -> bool
     return bool(value)
 
 
+def _elapsed_ms(started_at: float) -> int:
+    return max(0, int((time.perf_counter() - started_at) * 1000))
+
+
+def _merge_duration_breakdown(payload: JSONObject, **items: int | None) -> None:
+    breakdown = payload.get("duration_breakdown_ms")
+    if not isinstance(breakdown, dict):
+        breakdown = {}
+        payload["duration_breakdown_ms"] = breakdown
+    for key, value in items.items():
+        if value is None:
+            continue
+        breakdown[key] = int(value)
+
+
+def _inline_form_layout_was_handled(payload: JSONObject) -> bool:
+    inline_layout = payload.get("inline_form_layout")
+    return isinstance(inline_layout, dict) and bool(inline_layout.get("requested"))
+
+
 PUBLIC_STABLE_FLOW_NODE_TYPES = ["start", "approve", "fill", "copy", "webhook", "end"]
 BUILDER_APPLY_SCHEMA_VERSION = "builder.apply.v1"
 BUILDER_APPLY_TOOL_NAMES = {
@@ -2359,6 +2379,7 @@ class AiBuilderTools(ToolBase):
                 continue
 
             initial_add_fields, deferred_add_fields = _split_multi_app_initial_add_fields(item, is_new_app=not bool(app_key))
+            inline_layout_sections = list(item.get("_inline_form_layout_sections") or [])
             item["_deferred_add_fields"] = deferred_add_fields
             shell = self._app_schema_apply_once(
                 profile=profile,
@@ -2374,6 +2395,7 @@ class AiBuilderTools(ToolBase):
                 add_fields=initial_add_fields,
                 update_fields=[],
                 remove_fields=[],
+                inline_form_layout_sections=inline_layout_sections if not deferred_add_fields else None,
             )
             public_shell = _publicize_package_fields(shell)
             resolved_key = str(public_shell.get("app_key") or "").strip()
@@ -2471,7 +2493,7 @@ class AiBuilderTools(ToolBase):
             if bool(existing.get("created")) and not deferred_add_fields and not update_fields and not remove_fields:
                 shell_result = existing.get("shell_result") if isinstance(existing.get("shell_result"), dict) else {}
                 layout_sections = list(compiled_item.get("_inline_form_layout_sections") or [])
-                if layout_sections:
+                if layout_sections and not _inline_form_layout_was_handled(shell_result):
                     shell_result = self._apply_inline_form_layout_after_schema(
                         profile=profile,
                         schema_result=shell_result,
@@ -2522,10 +2544,11 @@ class AiBuilderTools(ToolBase):
                 add_fields=deferred_add_fields,
                 update_fields=update_fields,
                 remove_fields=remove_fields,
+                inline_form_layout_sections=list(compiled_item.get("_inline_form_layout_sections") or []),
             )
             public_result = _publicize_package_fields(field_result)
             layout_sections = list(compiled_item.get("_inline_form_layout_sections") or [])
-            if layout_sections:
+            if layout_sections and not _inline_form_layout_was_handled(public_result):
                 public_result = self._apply_inline_form_layout_after_schema(
                     profile=profile,
                     schema_result=public_result,
@@ -2632,6 +2655,7 @@ class AiBuilderTools(ToolBase):
         inline_form_layout_sections: list[JSONObject] | None = None,
     ) -> JSONObject:
         """执行内部辅助逻辑。"""
+        started_at = time.perf_counter()
         effective_app_name = app_name or app_title
         system_field_failure = _reserved_system_field_name_failure(
             tool_name="app_schema_apply",
@@ -2686,6 +2710,10 @@ class AiBuilderTools(ToolBase):
             parsed_add = [FieldPatch.model_validate(item) for item in plan_args.get("add_fields") or []]
             parsed_update = [FieldUpdatePatch.model_validate(item) for item in plan_args.get("update_fields") or []]
             parsed_remove = [FieldRemovePatch.model_validate(item) for item in plan_args.get("remove_fields") or []]
+            parsed_inline_layout = [
+                LayoutSectionPatch.model_validate(item)
+                for item in (inline_form_layout_sections or [])
+            ]
         except ValidationError as exc:
             return _validation_failure(
                 str(exc),
@@ -2721,6 +2749,16 @@ class AiBuilderTools(ToolBase):
             "add_fields": [patch.model_dump(mode="json") for patch in parsed_add],
             "update_fields": [patch.model_dump(mode="json") for patch in parsed_update],
             "remove_fields": [patch.model_dump(mode="json") for patch in parsed_remove],
+            **(
+                {
+                    "inline_form_layout_sections": [
+                        section.model_dump(mode="json", exclude_none=True)
+                        for section in parsed_inline_layout
+                    ]
+                }
+                if parsed_inline_layout
+                else {}
+            ),
         }
         result = _safe_tool_call(
             lambda: self._facade.app_schema_apply(
@@ -2736,13 +2774,15 @@ class AiBuilderTools(ToolBase):
                 add_fields=parsed_add,
                 update_fields=parsed_update,
                 remove_fields=parsed_remove,
+                inline_form_layout_sections=parsed_inline_layout,
             ),
             error_code="SCHEMA_APPLY_FAILED",
             normalized_args=normalized_args,
             suggested_next_call={"tool_name": "app_schema_apply", "arguments": {"profile": profile, **normalized_args}},
         )
         public_result = _publicize_package_fields(result)
-        if inline_form_layout_sections:
+        if inline_form_layout_sections and not _inline_form_layout_was_handled(public_result):
+            layout_started_at = time.perf_counter()
             public_result = self._apply_inline_form_layout_after_schema(
                 profile=profile,
                 schema_result=public_result,
@@ -2750,6 +2790,11 @@ class AiBuilderTools(ToolBase):
                 publish=publish,
                 sections=inline_form_layout_sections,
             )
+            _merge_duration_breakdown(
+                public_result,
+                inline_layout_ms=_elapsed_ms(layout_started_at),
+            )
+        _merge_duration_breakdown(public_result, total_ms=_elapsed_ms(started_at))
         return public_result
 
     def _apply_inline_form_layout_after_schema(