@josephyan/qingflow-app-user-mcp 1.1.16 → 1.1.18

package/src/qingflow_mcp/builder_facade/service.py

@@ -90,6 +90,7 @@ from .models import (
     SchemaPlanRequest,
     VisibilityPatch,
     ViewAssociatedResourcesPatch,
+    ViewActionButtonPatch,
     ViewButtonBindingPatch,
     ViewPartialPatch,
     ViewUpsertPatch,
@@ -99,6 +100,9 @@ from .models import (
     ViewsPreset,
     FlowPreset,
     FlowNodePermissionsPatch,
+    public_view_action_button_payload,
+    public_view_partial_payload,
+    public_view_upsert_payload,
 )
 
 BUILDER_PORTAL_LIST_DETAIL_VERIFY_LIMIT = 50
@@ -8264,7 +8268,8 @@ class AiBuilderFacade:
             for field in current_fields
             if isinstance(field, dict) and str(field.get("name") or "")
         }
-        upsert_views = [view.model_dump(mode="json") for view in request.upsert_views]
+        upsert_views = [public_view_upsert_payload(view) for view in request.upsert_views]
+        patch_views = [public_view_partial_payload(patch) for patch in request.patch_views]
         if request.preset is not None:
             upsert_views = _build_views_preset(request.preset, list(field_names))
         blocking_issues: list[dict[str, Any]] = []
@@ -8326,6 +8331,7 @@ class AiBuilderFacade:
         normalized_args = {
             "app_key": request.app_key,
             "upsert_views": upsert_views,
+            "patch_views": patch_views,
             "remove_views": list(request.remove_views),
         }
         return {
@@ -8344,6 +8350,7 @@ class AiBuilderFacade:
             "request_id": None,
             "views_diff_preview": {
                 "upsert": [view.get("name") for view in upsert_views],
+                "patch": [view.get("view_key") or view.get("name") for view in patch_views],
                 "remove": list(request.remove_views),
             },
             "blocking_issues": blocking_issues,
@@ -9980,6 +9987,406 @@ class AiBuilderFacade:
         }
         return finalize(self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response))
 
+    def _extract_view_action_button_patch_intents(
+        self,
+        *,
+        existing_by_key: dict[str, dict[str, Any]],
+        existing_by_name: dict[str, list[dict[str, Any]]],
+        patch_views: list[ViewPartialPatch],
+    ) -> tuple[list[ViewPartialPatch], list[dict[str, Any]], list[dict[str, Any]], list[dict[str, Any]]]:
+        action_keys = {"action_buttons", "actionButtons"}
+        mode_keys = {"action_buttons_mode", "actionButtonsMode", "button_mode", "buttonMode"}
+        sanitized: list[ViewPartialPatch] = []
+        intents: list[dict[str, Any]] = []
+        issues: list[dict[str, Any]] = []
+        results: list[dict[str, Any]] = []
+        sentinel = object()
+        for index, patch in enumerate(patch_views):
+            raw_set = dict(patch.set or {})
+            action_buttons_raw: Any = sentinel
+            for key in action_keys:
+                if key in raw_set:
+                    action_buttons_raw = raw_set.pop(key)
+                    break
+            mode_raw: Any = sentinel
+            for key in mode_keys:
+                if key in raw_set:
+                    mode_raw = raw_set.pop(key)
+                    break
+            if action_buttons_raw is not sentinel:
+                requires_view_write = bool(raw_set or patch.unset)
+                if not isinstance(action_buttons_raw, list):
+                    issue = {
+                        "error_code": "INVALID_VIEW_ACTION_BUTTONS",
+                        "reason_path": f"patch_views[{index}].set.action_buttons",
+                        "message": "action_buttons must be a list",
+                    }
+                    issues.append(issue)
+                    results.append({"index": index, "status": "failed", **issue})
+                else:
+                    mode = str(mode_raw if mode_raw is not sentinel else "merge").strip().lower() or "merge"
+                    if mode not in {"merge", "replace"}:
+                        issue = {
+                            "error_code": "INVALID_VIEW_ACTION_BUTTONS_MODE",
+                            "reason_path": f"patch_views[{index}].set.action_buttons_mode",
+                            "message": "action_buttons_mode must be merge or replace",
+                        }
+                        issues.append(issue)
+                        results.append({"index": index, "status": "failed", **issue})
+                    else:
+                        try:
+                            action_buttons = [
+                                ViewActionButtonPatch.model_validate(item)
+                                for item in action_buttons_raw
+                            ]
+                        except Exception as error:
+                            issue = {
+                                "error_code": "INVALID_VIEW_ACTION_BUTTONS",
+                                "reason_path": f"patch_views[{index}].set.action_buttons",
+                                "message": str(error),
+                            }
+                            issues.append(issue)
+                            results.append({"index": index, "status": "failed", **issue})
+                        else:
+                            view_key = str(patch.view_key or "").strip()
+                            view_name = str(patch.name or "").strip()
+                            matched_view: dict[str, Any] | None = None
+                            if view_key:
+                                matched_view = existing_by_key.get(view_key)
+                                if matched_view is None:
+                                    issue = {
+                                        "error_code": "UNKNOWN_VIEW",
+                                        "reason_path": f"patch_views[{index}].view_key",
+                                        "view_key": view_key,
+                                        "message": "view_key does not exist on this app",
+                                    }
+                                    issues.append(issue)
+                                    results.append({"index": index, "status": "failed", **issue})
+                            else:
+                                matches = existing_by_name.get(view_name, [])
+                                if len(matches) != 1:
+                                    issue = {
+                                        "error_code": "AMBIGUOUS_VIEW" if matches else "UNKNOWN_VIEW",
+                                        "reason_path": f"patch_views[{index}].name",
+                                        "view_name": view_name,
+                                        "matches": [
+                                            {"name": _extract_view_name(view), "view_key": _extract_view_key(view), "type": _normalize_view_type_name(view.get("viewgraphType") or view.get("type"))}
+                                            for view in matches
+                                        ],
+                                        "message": "patch_views[].set.action_buttons must target a single existing view; use view_key when names are duplicated",
+                                    }
+                                    issues.append(issue)
+                                    results.append({"index": index, "status": "failed", **issue})
+                                else:
+                                    matched_view = matches[0]
+                                    view_key = _extract_view_key(matched_view)
+                            if matched_view is not None or view_key:
+                                view_name = _extract_view_name(matched_view or {}) or view_name or view_key
+                                intents.append(
+                                    {
+                                        "source": "patch_views",
+                                        "index": index,
+                                        "view_key": view_key,
+                                        "view_name": view_name,
+                                        "action_buttons": action_buttons,
+                                        "mode": mode,
+                                        "requires_view_write": requires_view_write,
+                                    }
+                                )
+                                results.append(
+                                    {
+                                        "index": index,
+                                        "status": "action_buttons_extracted",
+                                        "view_key": view_key,
+                                        "view_name": view_name,
+                                        "action_buttons_count": len(action_buttons),
+                                        "action_buttons_mode": mode,
+                                    }
+                                )
+            elif mode_raw is not sentinel:
+                issue = {
+                    "error_code": "ACTION_BUTTONS_MODE_WITHOUT_ACTION_BUTTONS",
+                    "reason_path": f"patch_views[{index}].set.action_buttons_mode",
+                    "message": "action_buttons_mode is only valid together with action_buttons",
+                }
+                issues.append(issue)
+                results.append({"index": index, "status": "failed", **issue})
+            if raw_set or patch.unset:
+                sanitized.append(
+                    ViewPartialPatch.model_validate(
+                        {
+                            "view_key": patch.view_key,
+                            "name": patch.name,
+                            "set": raw_set,
+                            "unset": list(patch.unset or []),
+                        }
+                    )
+                )
+        return sanitized, intents, issues, results
+
+    def _view_action_button_to_custom_button_payload(self, *, button: ViewActionButtonPatch, client_key: str | None) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "button_text": button.text,
+            "trigger_action": button.action.value,
+            "style_preset": button.style_preset or "primary_blue",
+        }
+        if button.button_id is not None:
+            payload["button_id"] = button.button_id
+        if client_key:
+            payload["client_key"] = client_key
+        if button.background_color:
+            payload["background_color"] = button.background_color
+        if button.text_color:
+            payload["text_color"] = button.text_color
+        if button.button_icon:
+            payload["button_icon"] = button.button_icon
+        if button.action == PublicButtonTriggerAction.link:
+            payload["trigger_link_url"] = button.url
+        elif button.action == PublicButtonTriggerAction.add_data:
+            add_data_config: dict[str, Any] = {
+                "related_app_key": button.target_app_key,
+                "related_app_name": button.target_app_name,
+                "field_mappings": deepcopy(button.field_mappings),
+                "default_values": deepcopy(button.default_values),
+            }
+            payload["trigger_add_data_config"] = _compact_dict(add_data_config)
+        elif button.action == PublicButtonTriggerAction.qrobot:
+            payload["external_qrobot_config"] = deepcopy(button.external_qrobot_config)
+        elif button.action == PublicButtonTriggerAction.wings:
+            payload["trigger_wings_config"] = deepcopy(button.trigger_wings_config)
+        return payload
+
+    def _view_action_button_binding_payload(self, *, button: ViewActionButtonPatch, button_ref: Any) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "button_ref": button_ref,
+            "placement": button.placement.value,
+            "primary": button.primary,
+            "button_limit": [
+                [rule.model_dump(mode="json") for rule in group]
+                for group in button.visible_when
+            ],
+            "button_formula_type": button.button_formula_type,
+            "print_tpls": deepcopy(button.print_tpls),
+        }
+        if button.button_formula:
+            payload["button_formula"] = button.button_formula
+        return payload
+
+    def _compile_view_action_buttons_request(
+        self,
+        *,
+        app_key: str,
+        intents: list[dict[str, Any]],
+    ) -> tuple[CustomButtonsApplyRequest | None, list[dict[str, Any]]]:
+        upsert_buttons: list[CustomButtonUpsertPatch] = []
+        view_configs: list[CustomButtonViewConfigPatch] = []
+        issues: list[dict[str, Any]] = []
+        seen_button_payloads: dict[str, dict[str, Any]] = {}
+        seen_button_refs: dict[str, Any] = {}
+        used_client_keys: set[str] = set()
+        for intent_index, intent in enumerate(intents):
+            view_key = str(intent.get("view_key") or "").strip()
+            mode = str(intent.get("mode") or "merge").strip().lower() or "merge"
+            action_buttons = [
+                item for item in (intent.get("action_buttons") or [])
+                if isinstance(item, ViewActionButtonPatch)
+            ]
+            bindings: list[dict[str, Any]] = []
+            for button_index, button in enumerate(action_buttons):
+                identity = f"id:{button.button_id}" if button.button_id is not None else f"text:{str(button.text or '').strip()}"
+                explicit_client_key = str(button.client_key or "").strip() or None
+                generated_client_key = explicit_client_key or f"view_action_{_slugify(str(button.text or ''), default='button')}"
+                client_key = generated_client_key
+                payload = self._view_action_button_to_custom_button_payload(
+                    button=button,
+                    client_key=None if button.button_id is not None else client_key,
+                )
+                compare_payload = deepcopy(payload)
+                compare_payload.pop("client_key", None)
+                existing_payload = seen_button_payloads.get(identity)
+                if existing_payload is not None:
+                    if existing_payload != compare_payload:
+                        issues.append(
+                            {
+                                "error_code": "DUPLICATE_ACTION_BUTTON_CONFLICT",
+                                "reason_path": f"{intent.get('source') or 'views'}[{intent.get('index', intent_index)}].action_buttons[{button_index}]",
+                                "button_text": button.text,
+                                "message": "the same app cannot declare two action_buttons with the same button text or id but different button body config in one app_views_apply call",
+                            }
+                        )
+                        continue
+                    button_ref = seen_button_refs[identity]
+                else:
+                    seen_button_payloads[identity] = compare_payload
+                    if button.button_id is not None:
+                        button_ref = button.button_id
+                    else:
+                        unique_client_key = client_key
+                        if unique_client_key in used_client_keys:
+                            unique_client_key = f"{unique_client_key}_{len(used_client_keys) + 1}"
+                            payload["client_key"] = unique_client_key
+                        used_client_keys.add(unique_client_key)
+                        button_ref = unique_client_key
+                        payload["client_key"] = unique_client_key
+                        try:
+                            upsert_buttons.append(CustomButtonUpsertPatch.model_validate(payload))
+                        except Exception as error:
+                            issues.append(
+                                {
+                                    "error_code": "INVALID_VIEW_ACTION_BUTTON",
+                                    "reason_path": f"{intent.get('source') or 'views'}[{intent.get('index', intent_index)}].action_buttons[{button_index}]",
+                                    "message": str(error),
+                                }
+                            )
+                            continue
+                    seen_button_refs[identity] = button_ref
+                bindings.append(self._view_action_button_binding_payload(button=button, button_ref=button_ref))
+            if mode == "replace" or bindings:
+                try:
+                    view_configs.append(CustomButtonViewConfigPatch.model_validate({"view_key": view_key, "mode": mode, "buttons": bindings}))
+                except Exception as error:
+                    issues.append(
+                        {
+                            "error_code": "INVALID_VIEW_ACTION_BUTTON_BINDING",
+                            "reason_path": f"{intent.get('source') or 'views'}[{intent.get('index', intent_index)}].action_buttons",
+                            "view_key": view_key,
+                            "message": str(error),
+                        }
+                    )
+        if issues:
+            return None, issues
+        if not upsert_buttons and not view_configs:
+            return None, []
+        try:
+            return CustomButtonsApplyRequest.model_validate(
+                {
+                    "app_key": app_key,
+                    "upsert_buttons": [item.model_dump(mode="json") for item in upsert_buttons],
+                    "view_configs": [item.model_dump(mode="json") for item in view_configs],
+                }
+            ), []
+        except Exception as error:
+            return None, [{"error_code": "INVALID_VIEW_ACTION_BUTTONS", "message": str(error)}]
+
+    def _view_action_buttons_retry_payload(self, *, profile: str, app_key: str, intents: list[dict[str, Any]]) -> dict[str, Any]:
+        return {
+            "tool_name": "app_views_apply",
+            "arguments": {
+                "profile": profile,
+                "app_key": app_key,
+                "publish": True,
+                "upsert_views": [],
+                "patch_views": [
+                    {
+                        "view_key": intent.get("view_key"),
+                        "set": {
+                            "action_buttons": [
+                                public_view_action_button_payload(button, compact=True)
+                                for button in (intent.get("action_buttons") or [])
+                                if isinstance(button, ViewActionButtonPatch)
+                            ],
+                            "action_buttons_mode": intent.get("mode") or "merge",
+                        },
+                    }
+                    for intent in intents
+                    if str(intent.get("view_key") or "").strip()
+                ],
+                "remove_views": [],
+            },
+        }
+
+    def _failed_view_action_button_intents(self, *, intents: list[dict[str, Any]], result: dict[str, Any]) -> list[dict[str, Any]]:
+        failed_view_keys: set[str] = set()
+        failed_button_texts: set[str] = set()
+        for item in result.get("failed") or []:
+            if not isinstance(item, dict):
+                continue
+            view_key = str(item.get("view_key") or item.get("viewgraph_key") or "").strip()
+            if view_key:
+                failed_view_keys.add(view_key)
+            button_text = str(item.get("button_text") or item.get("text") or "").strip()
+            if button_text:
+                failed_button_texts.add(button_text)
+        for item in result.get("view_configs") or []:
+            if not isinstance(item, dict):
+                continue
+            status = str(item.get("status") or "").strip()
+            if status and status not in {"success", "noop", "skipped"}:
+                view_key = str(item.get("view_key") or item.get("viewgraph_key") or "").strip()
+                if view_key:
+                    failed_view_keys.add(view_key)
+        if failed_view_keys:
+            return [
+                intent
+                for intent in intents
+                if str(intent.get("view_key") or "").strip() in failed_view_keys
+            ]
+        if failed_button_texts:
+            return [
+                intent
+                for intent in intents
+                if any(
+                    isinstance(button, ViewActionButtonPatch) and str(button.text or "").strip() in failed_button_texts
+                    for button in (intent.get("action_buttons") or [])
+                )
+            ]
+        if str(result.get("status") or "").strip() == "failed" or (result.get("write_succeeded") is False and bool(result.get("write_executed"))):
+            return list(intents)
+        return []
+
+    def _apply_view_action_buttons(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        intents: list[dict[str, Any]],
+    ) -> dict[str, Any]:
+        if not intents:
+            return {
+                "status": "success",
+                "verified": True,
+                "write_executed": False,
+                "write_succeeded": False,
+                "verification": {
+                    "action_buttons_verified": True,
+                    "view_button_bindings_verified": True,
+                },
+                "retry_payload": None,
+            }
+        request, issues = self._compile_view_action_buttons_request(app_key=app_key, intents=intents)
+        if issues:
+            return {
+                "status": "failed",
+                "error_code": "DUPLICATE_ACTION_BUTTON_CONFLICT" if any(item.get("error_code") == "DUPLICATE_ACTION_BUTTON_CONFLICT" for item in issues) else "VIEW_ACTION_BUTTONS_INVALID",
+                "recoverable": True,
+                "message": "view action_buttons could not be compiled; view writes may already have completed",
+                "details": {"blocking_issues": issues},
+                "verification": {
+                    "action_buttons_verified": False,
+                    "view_button_bindings_verified": False,
+                },
+                "verified": False,
+                "write_executed": False,
+                "write_succeeded": False,
+                "retry_payload": self._view_action_buttons_retry_payload(profile=profile, app_key=app_key, intents=intents),
+            }
+        if request is None:
+            return {
+                "status": "success",
+                "verified": True,
+                "write_executed": False,
+                "write_succeeded": False,
+                "verification": {
+                    "action_buttons_verified": True,
+                    "view_button_bindings_verified": True,
+                },
+                "retry_payload": None,
+            }
+        result = self.app_custom_buttons_apply(profile=profile, request=request)
+        retry_intents = [] if result.get("verified") else self._failed_view_action_button_intents(intents=intents, result=result)
+        result["retry_payload"] = self._view_action_buttons_retry_payload(profile=profile, app_key=app_key, intents=retry_intents) if retry_intents else None
+        return result
+
     def app_views_apply(
         self,
         *,
@@ -9993,11 +10400,27 @@ class AiBuilderFacade:
         patch_views = patch_views or []
         normalized_args = {
             "app_key": app_key,
-            "upsert_views": [patch.model_dump(mode="json") for patch in upsert_views],
-            "patch_views": [patch.model_dump(mode="json") for patch in patch_views],
+            "upsert_views": [public_view_upsert_payload(patch) for patch in upsert_views],
+            "patch_views": [public_view_partial_payload(patch) for patch in patch_views],
             "remove_views": list(remove_views),
             "publish": publish,
         }
+        has_action_button_intent = any(patch.action_buttons is not None for patch in upsert_views) or any(
+            any(key in (patch.set or {}) for key in ("action_buttons", "actionButtons"))
+            for patch in patch_views
+        )
+        if has_action_button_intent and not publish:
+            return _failed(
+                "VIEW_ACTION_BUTTONS_REQUIRE_PUBLISH",
+                "app_views_apply action_buttons require publish=true because the underlying custom button writer may publish after successful button writes",
+                normalized_args=normalized_args,
+                details={
+                    "app_key": app_key,
+                    "required_publish": True,
+                    "reason": "action_buttons are compiled through app_custom_buttons_apply",
+                },
+                suggested_next_call={"tool_name": "app_views_apply", "arguments": {"profile": profile, **{**normalized_args, "publish": True}}},
+            )
         if not upsert_views and not patch_views and not remove_views:
             response = {
                 "status": "success",
@@ -10104,6 +10527,28 @@ class AiBuilderFacade:
             if name and key:
                 existing_by_key[key] = view
                 existing_by_name.setdefault(name, []).append(view)
+        patch_action_button_intents: list[dict[str, Any]] = []
+        action_button_patch_results: list[dict[str, Any]] = []
+        if patch_views:
+            sanitized_patch_views, patch_action_button_intents, action_button_patch_issues, action_button_patch_results = self._extract_view_action_button_patch_intents(
+                existing_by_key=existing_by_key,
+                existing_by_name=existing_by_name,
+                patch_views=patch_views,
+            )
+            if action_button_patch_results:
+                normalized_args["action_button_patch_results"] = action_button_patch_results
+            if action_button_patch_issues:
+                return finalize(
+                    _failed(
+                        "VIEW_ACTION_BUTTON_PATCH_FAILED",
+                        "one or more patch_views action_buttons entries could not be resolved; no write was executed",
+                        normalized_args=normalized_args,
+                        details={"patch_results": action_button_patch_results, "blocking_issues": action_button_patch_issues},
+                        suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+                    )
+                )
+            patch_views = sanitized_patch_views
+            normalized_args["patch_views"] = [public_view_partial_payload(patch) for patch in patch_views]
         creating_view_names = [
             patch.name
             for patch in upsert_views
@@ -10155,7 +10600,7 @@ class AiBuilderFacade:
                     )
                 )
             upsert_views = [*upsert_views, *expanded_views]
-            normalized_args["upsert_views"] = [patch.model_dump(mode="json") for patch in upsert_views]
+            normalized_args["upsert_views"] = [public_view_upsert_payload(patch) for patch in upsert_views]
             normalized_args["patch_results"] = patch_results
         current_fields_by_name = {
             str(field.get("name") or ""): field
@@ -10250,6 +10695,22 @@ class AiBuilderFacade:
         removed_keys: set[str] = set()
         view_results: list[dict[str, Any]] = []
         failed_views: list[dict[str, Any]] = []
+        action_button_intents: list[dict[str, Any]] = list(patch_action_button_intents)
+
+        def record_action_button_intent(*, patch: ViewUpsertPatch, view_key: str | None, index: int) -> None:
+            if patch.action_buttons is None:
+                return
+            action_button_intents.append(
+                {
+                    "source": "upsert_views",
+                    "index": index,
+                    "view_key": str(view_key or "").strip(),
+                    "view_name": patch.name,
+                    "action_buttons": list(patch.action_buttons),
+                    "mode": patch.action_buttons_mode,
+                }
+            )
+
         for selector in remove_views:
             selector_text = str(selector or "").strip()
             if not selector_text:
@@ -10644,6 +11105,7 @@ class AiBuilderFacade:
                                 "apply_columns": deepcopy(apply_columns),
                             }
                         )
+                    record_action_button_intent(patch=patch, view_key=existing_key, index=ordinal - 1)
                 else:
                     template_key = _pick_view_template_key(existing_view_list, desired_type=patch.type.value)
                     should_copy_template = patch.type.value == "table" and template_key and not translated_filters
@@ -10698,6 +11160,7 @@ class AiBuilderFacade:
                                 "expected_associated_resources": deepcopy(expected_associated_resources_for_verify),
                             }
                         )
+                    record_action_button_intent(patch=patch, view_key=created_key, index=ordinal - 1)
             except (QingflowApiError, RuntimeError) as error:
                 api_error = _coerce_api_error(error)
                 should_retry_minimal = operation_phase != "default_view_apply_config_sync" and (
@@ -10790,6 +11253,7 @@ class AiBuilderFacade:
                                         "apply_columns": deepcopy(apply_columns),
                                     }
                                 )
+                                record_action_button_intent(patch=patch, view_key=existing_key, index=ordinal - 1)
                             else:
                                 created.append(patch.name)
                                 view_results.append(
@@ -10807,6 +11271,7 @@ class AiBuilderFacade:
                                         "apply_columns": deepcopy(apply_columns),
                                     }
                                 )
+                                record_action_button_intent(patch=patch, view_key=created_key, index=ordinal - 1)
                             continue
                         fallback_payload = _build_minimal_view_payload(
                             app_key=app_key,
@@ -10834,6 +11299,7 @@ class AiBuilderFacade:
                                 "expected_associated_resources": deepcopy(expected_associated_resources_for_verify),
                             }
                         )
+                        record_action_button_intent(patch=patch, view_key=created_key, index=ordinal - 1)
                         continue
                     except (QingflowApiError, RuntimeError) as fallback_error:
                         api_error = _coerce_api_error(fallback_error)
@@ -10881,6 +11347,56 @@ class AiBuilderFacade:
                 failed_views.append(failure_entry)
                 view_results.append(failure_entry)
                 continue
+        successful_action_view_keys = {
+            str(item.get("view_key") or "").strip()
+            for item in view_results
+            if str(item.get("status") or "") in {"created", "updated"} and str(item.get("view_key") or "").strip()
+        }
+        successful_action_view_names = {
+            str(item.get("name") or "").strip()
+            for item in view_results
+            if str(item.get("status") or "") in {"created", "updated"} and str(item.get("name") or "").strip()
+        }
+        skipped_action_button_intents = [
+            intent
+            for intent in action_button_intents
+            if bool(intent.get("requires_view_write"))
+            and str(intent.get("view_key") or "").strip() not in successful_action_view_keys
+            and str(intent.get("view_name") or "").strip() not in successful_action_view_names
+        ]
+        skipped_action_button_intent_ids = {id(intent) for intent in skipped_action_button_intents}
+        runnable_action_button_intents = [
+            intent for intent in action_button_intents if id(intent) not in skipped_action_button_intent_ids
+        ]
+        action_buttons_result = self._apply_view_action_buttons(
+            profile=profile,
+            app_key=app_key,
+            intents=runnable_action_button_intents,
+        )
+        if skipped_action_button_intents:
+            action_buttons_result.setdefault("skipped_due_to_view_write_failure", [])
+            if isinstance(action_buttons_result["skipped_due_to_view_write_failure"], list):
+                action_buttons_result["skipped_due_to_view_write_failure"].extend(
+                    {
+                        "source": intent.get("source"),
+                        "index": intent.get("index"),
+                        "view_key": intent.get("view_key"),
+                        "view_name": intent.get("view_name"),
+                        "action_buttons_count": len(intent.get("action_buttons") or []),
+                    }
+                    for intent in skipped_action_button_intents
+                )
+        action_button_write_executed = bool(action_buttons_result.get("write_executed"))
+        action_button_write_succeeded = bool(action_buttons_result.get("write_succeeded"))
+        action_buttons_verification = action_buttons_result.get("verification") if isinstance(action_buttons_result.get("verification"), dict) else {}
+        action_buttons_verified = (
+            bool(action_buttons_result.get("verified", True))
+            and bool(action_buttons_verification.get("custom_buttons_verified", action_buttons_verification.get("action_buttons_verified", True)))
+            and not skipped_action_button_intents
+        )
+        view_action_button_bindings_verified = bool(action_buttons_verification.get("view_button_bindings_verified", True)) and not skipped_action_button_intents
+        action_buttons_failed = bool(action_button_intents) and not (action_buttons_verified and view_action_button_bindings_verified)
+        action_buttons_retry_payload = action_buttons_result.get("retry_payload") if isinstance(action_buttons_result.get("retry_payload"), dict) else None
         needs_view_list_readback = bool(created or updated)
         verified_view_result: list[dict[str, Any]] | None = []
         verified_views_unavailable = False
@@ -11251,9 +11767,9 @@ class AiBuilderFacade:
         view_query_conditions_verified = verified and not query_condition_readback_pending and not query_condition_mismatches
         view_associated_resources_verified = verified and not associated_resource_readback_pending and not associated_resource_mismatches
         view_buttons_verified = verified and not button_readback_pending and not button_mismatches and not custom_button_readback_pending
-        noop = not created and not updated and not removed
+        noop = not created and not updated and not removed and not action_button_write_executed
         if failed_views:
-            successful_changes = bool(created or updated or removed)
+            successful_changes = bool(created or updated or removed or action_button_write_succeeded)
             first_failure = failed_views[0]
             response = {
                 "status": "partial_success" if successful_changes else "failed",
@@ -11269,6 +11785,7 @@ class AiBuilderFacade:
                     "query_condition_mismatches": query_condition_mismatches,
                     "associated_resource_mismatches": associated_resource_mismatches,
                     "button_mismatches": button_mismatches,
+                    **({"action_buttons_result": action_buttons_result} if action_button_intents else {}),
                     **(
                         {"custom_button_readback_pending": deepcopy(custom_button_readback_pending_entries)}
                         if custom_button_readback_pending_entries
@@ -11301,6 +11818,11 @@ class AiBuilderFacade:
                         if (button_readback_pending or button_mismatches)
                         else []
                     )
+                    + (
+                        [_warning("VIEW_ACTION_BUTTONS_UNVERIFIED", "view definitions may exist, but inline action button creation or binding is not fully verified")]
+                        if action_buttons_failed
+                        else []
+                    )
                     + (
                         [_warning("VIEW_CUSTOM_BUTTON_READBACK_PENDING", "system buttons verified, but draft custom button bindings are not fully visible through view readback yet")]
                         if custom_button_readback_pending
@@ -11313,6 +11835,8 @@ class AiBuilderFacade:
                     "view_query_conditions_verified": view_query_conditions_verified,
                     "view_associated_resources_verified": view_associated_resources_verified,
                     "view_buttons_verified": view_buttons_verified,
+                    "action_buttons_verified": action_buttons_verified,
+                    "view_button_bindings_verified": view_action_button_bindings_verified,
                     "views_read_unavailable": verified_views_unavailable,
                     "by_view": verification_by_view,
                     "custom_button_readback_pending": custom_button_readback_pending,
@@ -11321,10 +11845,10 @@ class AiBuilderFacade:
                 "app_key": app_key,
                 "app_name": app_name,
                 "views_diff": {"created": created, "updated": updated, "removed": removed, "failed": failed_views},
-                "verified": verified and view_filters_verified and view_query_conditions_verified and view_associated_resources_verified and view_buttons_verified,
-                "write_executed": bool(created or updated or removed),
-                "write_succeeded": bool(created or updated or removed),
-                "safe_to_retry": not bool(created or updated or removed),
+                "verified": verified and view_filters_verified and view_query_conditions_verified and view_associated_resources_verified and view_buttons_verified and action_buttons_verified and view_action_button_bindings_verified,
+                "write_executed": bool(created or updated or removed or action_button_write_executed),
+                "write_succeeded": bool(created or updated or removed or action_button_write_succeeded),
+                "safe_to_retry": not bool(created or updated or removed or action_button_write_executed),
             }
             return finalize(self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response))
         warnings: list[dict[str, Any]] = []
@@ -11336,6 +11860,8 @@ class AiBuilderFacade:
             warnings.append(_warning("VIEW_ASSOCIATED_RESOURCES_UNVERIFIED", "view definitions were applied, but associated resource visibility is not fully verified"))
         if button_readback_pending or button_mismatches:
             warnings.append(_warning("VIEW_BUTTONS_UNVERIFIED", "view definitions were applied, but saved button behavior is not fully verified"))
+        if action_buttons_failed:
+            warnings.append(_warning("VIEW_ACTION_BUTTONS_UNVERIFIED", "view definitions were applied, but inline action button creation or binding is not fully verified"))
         if custom_button_readback_pending:
             warnings.append(
                 _warning(
@@ -11350,14 +11876,25 @@ class AiBuilderFacade:
                     "view delete was sent, but deletion readback is not fully verified; do not blindly repeat delete",
                 )
             )
-        all_verified = verified and view_filters_verified and view_query_conditions_verified and view_associated_resources_verified and view_buttons_verified
+        all_verified = (
+            verified
+            and view_filters_verified
+            and view_query_conditions_verified
+            and view_associated_resources_verified
+            and view_buttons_verified
+            and action_buttons_verified
+            and view_action_button_bindings_verified
+        )
+        action_buttons_error_code = str(action_buttons_result.get("error_code") or "VIEW_ACTION_BUTTONS_APPLY_FAILED") if action_buttons_failed else None
         response = {
             "status": "success" if all_verified else "partial_success",
-            "error_code": None if all_verified else ("VIEW_BUTTON_READBACK_MISMATCH" if button_mismatches else "VIEW_ASSOCIATED_RESOURCE_READBACK_MISMATCH" if associated_resource_mismatches else "VIEW_QUERY_CONDITION_READBACK_MISMATCH" if query_condition_mismatches else "VIEW_FILTER_READBACK_MISMATCH" if filter_mismatches else "VIEWS_READBACK_PENDING"),
+            "error_code": None if all_verified else (action_buttons_error_code if action_buttons_failed else "VIEW_BUTTON_READBACK_MISMATCH" if button_mismatches else "VIEW_ASSOCIATED_RESOURCE_READBACK_MISMATCH" if associated_resource_mismatches else "VIEW_QUERY_CONDITION_READBACK_MISMATCH" if query_condition_mismatches else "VIEW_FILTER_READBACK_MISMATCH" if filter_mismatches else "VIEWS_READBACK_PENDING"),
             "recoverable": not all_verified,
             "message": (
                 "applied view patch"
                 if all_verified
+                else "applied view patch; inline action buttons did not fully verify"
+                if action_buttons_failed
                 else "applied view patch; buttons did not fully verify"
                 if button_mismatches
                 else "applied view patch; associated resources did not fully verify"
@@ -11376,6 +11913,7 @@ class AiBuilderFacade:
                 **({"query_condition_mismatches": query_condition_mismatches} if query_condition_mismatches else {}),
                 **({"associated_resource_mismatches": associated_resource_mismatches} if associated_resource_mismatches else {}),
                 **({"button_mismatches": button_mismatches} if button_mismatches else {}),
+                **({"action_buttons_result": action_buttons_result} if action_button_intents else {}),
                 **(
                     {"custom_button_readback_pending": deepcopy(custom_button_readback_pending_entries)}
                     if custom_button_readback_pending_entries
@@ -11383,7 +11921,7 @@ class AiBuilderFacade:
                 ),
             },
             "request_id": None,
-            "suggested_next_call": None if all_verified else {"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+            "suggested_next_call": None if all_verified else (action_buttons_retry_payload if action_buttons_failed and action_buttons_retry_payload else {"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}}),
             "noop": noop,
             "warnings": warnings,
             "verification": {
@@ -11392,6 +11930,8 @@ class AiBuilderFacade:
                 "view_query_conditions_verified": view_query_conditions_verified,
                 "view_associated_resources_verified": view_associated_resources_verified,
                 "view_buttons_verified": view_buttons_verified,
+                "action_buttons_verified": action_buttons_verified,
+                "view_button_bindings_verified": view_action_button_bindings_verified,
                 "views_read_unavailable": verified_views_unavailable,
                 "filter_readback_pending": filter_readback_pending,
                 "query_condition_readback_pending": query_condition_readback_pending,
@@ -11406,9 +11946,9 @@ class AiBuilderFacade:
             "app_name": app_name,
             "views_diff": {"created": created, "updated": updated, "removed": removed, "failed": []},
             "verified": all_verified,
-            "write_executed": bool(created or updated or removed),
-            "write_succeeded": bool(created or updated or removed),
-            "safe_to_retry": not bool(created or updated or removed),
+            "write_executed": bool(created or updated or removed or action_button_write_executed),
+            "write_succeeded": bool(created or updated or removed or action_button_write_succeeded),
+            "safe_to_retry": not bool(created or updated or removed or action_button_write_executed),
         }
         return finalize(self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response))
 
@@ -12478,6 +13018,7 @@ class AiBuilderFacade:
         draft_readback_error: JSONObject | None = None
         live_readback_error: JSONObject | None = None
         update_payload: dict[str, Any] = {}
+        inline_chart_results: list[dict[str, Any]] = []
         try:
             layout_diagnostics: dict[str, Any] = _empty_portal_layout_diagnostics()
             if creating:
@@ -12525,10 +13066,11 @@ class AiBuilderFacade:
                 base_payload=base_payload,
             )
             if sections_requested:
-                component_payload, layout_metadata = self._build_portal_components_from_sections(
+                component_payload, layout_metadata, inline_chart_results = self._build_portal_components_from_sections(
                     profile=profile,
                     sections=request.sections,
                     layout_preset=request.layout_preset,
+                    inline_chart_results=inline_chart_results,
                 )
                 layout_diagnostics = _portal_layout_diagnostics(request.sections, component_payload, layout_metadata=layout_metadata)
                 update_payload["components"] = component_payload
@@ -12556,11 +13098,12 @@ class AiBuilderFacade:
                 draft_result = {}
         except (QingflowApiError, RuntimeError, ValueError) as error:
             api_error = _coerce_api_error(error) if not isinstance(error, ValueError) else None
-            if write_executed:
+            inline_chart_write_executed = any(bool(item.get("write_executed")) for item in inline_chart_results)
+            if write_executed or inline_chart_write_executed:
                 transport_error = _transport_error_payload(api_error) if api_error is not None else None
                 warning = _warning(
                     "PORTAL_WRITE_INCOMPLETE_AFTER_PARTIAL_WRITE",
-                    "one or more portal write steps executed before a later write step failed",
+                    "one or more portal or inline-chart write steps executed before a later write step failed",
                 )
                 if transport_error is not None:
                     for key in ("backend_code", "http_status", "request_id"):
@@ -12581,6 +13124,7 @@ class AiBuilderFacade:
                             if api_error is not None
                             else {"message": str(error)}
                         ),
+                        **({"inline_chart_results": deepcopy(inline_chart_results)} if inline_chart_results else {}),
                     },
                     "request_id": api_error.request_id if api_error else None,
                     "backend_code": api_error.backend_code if api_error else None,
@@ -12596,6 +13140,7 @@ class AiBuilderFacade:
                         "published": False,
                         "publish_failed": False,
                         "write_incomplete": True,
+                        "inline_charts_verified": False if inline_chart_results else None,
                         "readback_unavailable": False,
                         "metadata_unverified": True,
                     },
@@ -12607,6 +13152,7 @@ class AiBuilderFacade:
                     "verified": False,
                     "write_executed": True,
                     "safe_to_retry": False,
+                    "inline_chart_results": deepcopy(inline_chart_results),
                 })
             return _failed(
                 "PORTAL_APPLY_FAILED",
@@ -12718,6 +13264,7 @@ class AiBuilderFacade:
                 "draft": draft_meta_mismatches,
                 "live": live_meta_mismatches,
             },
+            **({"inline_chart_results": deepcopy(inline_chart_results)} if inline_chart_results else {}),
             **({"publish_error": publish_error} if publish_error is not None else {}),
             **({"draft_readback_error": draft_readback_error} if draft_readback_error is not None else {}),
             **({"live_readback_error": live_readback_error} if live_readback_error is not None else {}),
@@ -12755,6 +13302,7 @@ class AiBuilderFacade:
             "noop": False,
             "warnings": warnings,
             "layout_diagnostics": layout_diagnostics,
+            "inline_chart_results": deepcopy(inline_chart_results),
             "verification": {
                 "draft_verified": draft_verified,
                 "draft_metadata_verified": draft_meta_verified,
@@ -12762,6 +13310,7 @@ class AiBuilderFacade:
                 "live_metadata_verified": live_meta_verified,
                 "published": published,
                 "publish_failed": publish_failed,
+                "inline_charts_verified": all(str(item.get("status") or "") in {"created", "updated"} and str(item.get("chart_id") or "").strip() for item in inline_chart_results),
                 "readback_unavailable": draft_readback_error is not None or live_readback_error is not None,
                 "metadata_unverified": draft_readback_error is not None or live_readback_error is not None,
             },
@@ -13515,9 +14064,11 @@ class AiBuilderFacade:
         profile: str,
         sections: list[PortalSectionPatch],
         layout_preset: str | None = None,
-    ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+        inline_chart_results: list[dict[str, Any]] | None = None,
+    ) -> tuple[list[dict[str, Any]], list[dict[str, Any]], list[dict[str, Any]]]:
         resolved_components: list[dict[str, Any]] = []
         layout_metadata: list[dict[str, Any]] = []
+        inline_chart_results = inline_chart_results if inline_chart_results is not None else []
         pc_x = 0
         pc_y = 0
         pc_row_height = 0
@@ -13544,11 +14095,53 @@ class AiBuilderFacade:
             dash_style = deepcopy(section.dash_style_config) if isinstance(section.dash_style_config, dict) else None
             component: dict[str, Any]
             if section.source_type == "chart":
-                resolved_chart = _resolve_chart_reference(
-                    charts=self.charts,
-                    profile=profile,
-                    ref=section.chart_ref,
-                )
+                if section.chart is not None:
+                    inline_chart_payload = section.chart.model_dump(mode="json", exclude={"app_key"})
+                    chart_request = ChartApplyRequest(
+                        app_key=section.chart.app_key,
+                        upsert_charts=[ChartUpsertPatch.model_validate(inline_chart_payload)],
+                        patch_charts=[],
+                        remove_chart_ids=[],
+                        reorder_chart_ids=[],
+                    )
+                    chart_apply = self.chart_apply(profile=profile, request=chart_request)
+                    chart_items = chart_apply.get("chart_results") if isinstance(chart_apply.get("chart_results"), list) else []
+                    successful_chart = next(
+                        (
+                            item
+                            for item in chart_items
+                            if isinstance(item, dict)
+                            and str(item.get("status") or "") in {"created", "updated"}
+                            and str(item.get("chart_id") or "").strip()
+                        ),
+                        None,
+                    )
+                    inline_chart_results.append({
+                        "title": section.title,
+                        "app_key": section.chart.app_key,
+                        "chart_name": section.chart.name,
+                        "chart_type": section.chart.chart_type.value,
+                        "status": str(successful_chart.get("status") or "") if isinstance(successful_chart, dict) else "failed",
+                        "chart_id": str(successful_chart.get("chart_id") or "") if isinstance(successful_chart, dict) else "",
+                        "chart_apply_status": chart_apply.get("status"),
+                        "write_executed": bool(chart_apply.get("write_executed")),
+                        **({"error_code": chart_apply.get("error_code")} if chart_apply.get("error_code") else {}),
+                        **({"message": chart_apply.get("message")} if chart_apply.get("message") else {}),
+                    })
+                    if not isinstance(successful_chart, dict):
+                        raise ValueError(f"inline chart '{section.chart.name}' could not be created or updated for portal section '{section.title}'")
+                    resolved_chart = {
+                        "chart_id": str(successful_chart.get("chart_id") or "").strip(),
+                        "chart_name": str(successful_chart.get("name") or section.chart.name).strip(),
+                        "app_key": section.chart.app_key,
+                        "chart_type": section.chart.chart_type.value,
+                    }
+                else:
+                    resolved_chart = _resolve_chart_reference(
+                        charts=self.charts,
+                        profile=profile,
+                        ref=section.chart_ref,
+                    )
                 chart_type = str(
                     resolved_chart.get("chart_type")
                     or _public_chart_type_from_backend(section.config.get("chartType") or section.config.get("chart_type"))
@@ -13608,7 +14201,7 @@ class AiBuilderFacade:
             if dash_style is not None:
                 component["dashStyleConfigBO"] = dash_style
             resolved_components.append(component)
-        return resolved_components, layout_metadata
+        return resolved_components, layout_metadata, inline_chart_results
 
     def _resolve_current_user_identity(self, *, profile: str) -> JSONObject:
         session_profile = self.apps.sessions.get_profile(profile)
@@ -17254,12 +17847,12 @@ def _portal_layout_diagnostics(
         if source_type == "chart" and role in {"metric", "metrics", "indicator", "kpi"} and not is_metric_chart:
             warnings.append(_warning(
                 "PORTAL_METRIC_SECTION_CHART_TYPE_MISMATCH",
-                "metric portal section must reference a target/indicator chart; create the missing metric chart before assembling the portal",
+                "metric portal section must reference a target/indicator chart; use inline_chart to create the missing metric chart while assembling the portal",
                 section_index=index,
                 title=title,
                 role=role,
                 chart_type=chart_type or None,
-                fix_hint="Use app_charts_apply with chart_type=target and metric='count(*)' or another metric expression, then reference that chart.",
+                fix_hint="Use section.inline_chart with chart_type=target or indicator and a metric expression, or change role away from metric.",
             ))
         if section is not None and section.position is not None and not bool(getattr(section.position, "mobile_provided", False)):
             warnings.append(_warning(
@@ -17319,7 +17912,7 @@ def _append_portal_standard_count_warnings(
             "standard portal metric area should contain 4-6 metric cards",
             actual_count=metric_count,
             expected_count="4-6",
-            fix_hint="Create missing target/indicator charts first, or keep 4 metric cards in one row with pc.cols=6, pc.rows=5.",
+            fix_hint="Use inline_chart for missing target/indicator metric cards, or keep 4 metric cards in one row with pc.cols=6, pc.rows=5.",
         ))
     if (bi_count or require_complete_standard) and not 2 <= bi_count <= 3:
         warnings.append(_warning(