@josephyan/qingflow-app-builder-mcp 0.2.0-beta.49 → 0.2.0-beta.50

package/src/qingflow_mcp/builder_facade/service.py

@@ -12,6 +12,7 @@ from uuid import uuid4
 from ..backend_client import BackendRequestContext
 from ..errors import QingflowApiError
 from ..json_types import JSONObject
+from ..list_type_labels import RECORD_LIST_TYPE_LABELS, SYSTEM_VIEW_ID_TO_LIST_TYPE
 from ..solution.build_assembly_store import BuildAssemblyStore, default_artifacts, default_manifest
 from ..solution.compiler.chart_compiler import qingbi_workspace_visible_auth
 from ..solution.compiler.form_compiler import build_question, default_form_payload, default_member_auth
@@ -51,6 +52,7 @@ from .models import (
     PortalApplyRequest,
     PortalSectionPatch,
     PublicFieldType,
+    PublicRelationMode,
     PublicChartType,
     PublicViewType,
     SchemaPlanRequest,
@@ -1110,17 +1112,7 @@ class AiBuilderFacade:
         parsed = state["parsed"]
         response = AppFieldsReadResponse(
             app_key=app_key,
-            fields=[
-                {
-                    "field_id": field.get("field_id"),
-                    "que_id": field.get("que_id"),
-                    "name": field.get("name"),
-                    "type": field.get("type"),
-                    "required": bool(field.get("required")),
-                    "section_id": _find_field_section_id(parsed["layout"], str(field.get("name") or "")),
-                }
-                for field in parsed["fields"]
-            ],
+            fields=[_compact_public_field_read(field=field, layout=parsed["layout"]) for field in parsed["fields"]],
             field_count=len(parsed["fields"]),
         )
         return {
@@ -1198,10 +1190,26 @@ class AiBuilderFacade:
                 details={"app_key": app_key},
                 suggested_next_call={"tool_name": "app_read_summary", "arguments": {"profile": profile, "app_key": app_key}},
             )
+        summarized_views, config_read_errors = _summarize_views_with_config(self.views, profile=profile, views=views)
         response = AppViewsReadResponse(
             app_key=app_key,
-            views=_summarize_views(views),
+            views=summarized_views,
         )
+        warnings = []
+        if response.views:
+            warnings.append(
+                _warning(
+                    "VIEW_FILTERS_UNVERIFIED",
+                    "view summary does not verify saved filter behavior; use apply verification or explicit reads before relying on filters",
+                )
+            )
+        if config_read_errors:
+            warnings.append(
+                _warning(
+                    "VIEW_CONFIG_READ_PARTIAL",
+                    "some view configs could not be read back; field order and display order may be incomplete for those views",
+                )
+            )
         return {
             "status": "success",
             "error_code": None,
@@ -1210,12 +1218,16 @@ class AiBuilderFacade:
             "normalized_args": {"app_key": app_key},
             "missing_fields": [],
             "allowed_values": {},
-            "details": {},
+            "details": {"view_config_read_errors": config_read_errors} if config_read_errors else {},
             "request_id": None,
             "suggested_next_call": None,
             "noop": False,
-            "warnings": [_warning("VIEW_FILTERS_UNVERIFIED", "view summary does not verify saved filter behavior; use apply verification or explicit reads before relying on filters")] if response.views else [],
-            "verification": {"app_exists": True, "view_filters_verified": False},
+            "warnings": warnings,
+            "verification": {
+                "app_exists": True,
+                "view_filters_verified": False,
+                "view_display_readback_complete": not config_read_errors,
+            },
             "verified": True,
             **response.model_dump(mode="json"),
         }
@@ -2752,6 +2764,8 @@ class AiBuilderFacade:
                     matched_existing_view = name_matches[0]
                     existing_key = _extract_view_key(matched_existing_view)
             created_key: str | None = None
+            system_view_list_type = _resolve_system_view_list_type(view_key=existing_key, view_name=patch.name) if existing_key else None
+            operation_phase = "view_update" if existing_key else "view_create"
             try:
                 if existing_key:
                     payload = _build_view_update_payload(
@@ -2763,6 +2777,41 @@ class AiBuilderFacade:
                         view_filters=translated_filters,
                     )
                     self.views.view_update(profile=profile, viewgraph_key=existing_key, payload=payload)
+                    system_view_sync: dict[str, Any] | None = None
+                    if system_view_list_type is not None and patch.type.value == "table":
+                        operation_phase = "default_view_apply_config_sync"
+                        system_view_sync = self._sync_system_view_apply_config(
+                            profile=profile,
+                            app_key=app_key,
+                            list_type=system_view_list_type,
+                            schema=schema,
+                            visible_field_names=patch.columns,
+                        )
+                        if not bool(system_view_sync.get("verified")):
+                            failure_entry = {
+                                "name": patch.name,
+                                "view_key": existing_key,
+                                "type": patch.type.value,
+                                "status": "failed",
+                                "error_code": "SYSTEM_VIEW_ORDER_SYNC_FAILED",
+                                "message": "default view column order did not verify through app apply/baseInfo readback",
+                                "request_id": None,
+                                "backend_code": None,
+                                "http_status": None,
+                                "operation": "sync_default_view",
+                                "details": {
+                                    "app_key": app_key,
+                                    "view_name": patch.name,
+                                    "view_key": existing_key,
+                                    "view_type": patch.type.value,
+                                    "list_type": system_view_list_type,
+                                    "expected_visible_order": system_view_sync.get("expected_visible_order"),
+                                    "actual_visible_order": system_view_sync.get("actual_visible_order"),
+                                },
+                            }
+                            failed_views.append(failure_entry)
+                            view_results.append(failure_entry)
+                            continue
                     updated.append(patch.name)
                     view_results.append(
                         {
@@ -2771,6 +2820,7 @@ class AiBuilderFacade:
                             "type": patch.type.value,
                             "status": "updated",
                             "expected_filters": deepcopy(translated_filters),
+                            "system_view_sync": system_view_sync,
                         }
                     )
                 else:
@@ -2816,8 +2866,9 @@ class AiBuilderFacade:
                     )
             except (QingflowApiError, RuntimeError) as error:
                 api_error = _coerce_api_error(error)
-                should_retry_minimal = api_error.backend_code == 48104 or (
-                    patch.type.value == "table" and bool(patch.filters) and api_error.http_status is not None and api_error.http_status >= 500
+                should_retry_minimal = operation_phase != "default_view_apply_config_sync" and (
+                    api_error.backend_code == 48104
+                    or (patch.type.value == "table" and bool(patch.filters) and api_error.http_status is not None and api_error.http_status >= 500)
                 )
                 if should_retry_minimal:
                     try:
@@ -2893,7 +2944,7 @@ class AiBuilderFacade:
                     "request_id": api_error.request_id,
                     "backend_code": api_error.backend_code,
                     "http_status": None if api_error.http_status == 404 else api_error.http_status,
-                    "operation": "update" if existing_key or created_key else "create",
+                    "operation": "sync_default_view" if operation_phase == "default_view_apply_config_sync" else ("update" if existing_key or created_key else "create"),
                     "details": {
                         "app_key": app_key,
                         "view_name": patch.name,
@@ -2904,7 +2955,8 @@ class AiBuilderFacade:
                         "start_field": patch.start_field,
                         "end_field": patch.end_field,
                         "title_field": patch.title_field,
-                        "operation": "update" if existing_key or created_key else "create",
+                        "operation": "sync_default_view" if operation_phase == "default_view_apply_config_sync" else ("update" if existing_key or created_key else "create"),
+                        "list_type": system_view_list_type,
                         "transport_error": {
                             "http_status": api_error.http_status,
                             "backend_code": api_error.backend_code,
@@ -2966,6 +3018,9 @@ class AiBuilderFacade:
                     "status": status,
                     "present_in_readback": present_in_readback,
                 }
+                system_view_sync = item.get("system_view_sync")
+                if isinstance(system_view_sync, dict):
+                    verification_entry["system_view_sync"] = deepcopy(system_view_sync)
                 expected_filters = item.get("expected_filters") or []
                 if expected_filters:
                     if verified_views_unavailable or not present_in_readback:
@@ -3843,6 +3898,40 @@ class AiBuilderFacade:
             "schema_source": schema_source,
         }
 
+    def _sync_system_view_apply_config(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        list_type: int,
+        schema: dict[str, Any],
+        visible_field_names: list[str],
+    ) -> dict[str, Any]:
+        base_info_response = self.apps.app_get_apply_base_info(profile=profile, app_key=app_key, list_type=list_type)
+        base_info_result = base_info_response.get("result") if isinstance(base_info_response.get("result"), dict) else {}
+        current_que_base_infos = base_info_result.get("queBaseInfos") if isinstance(base_info_result.get("queBaseInfos"), list) else []
+        change_ques = _build_apply_config_change_ques(
+            current_que_base_infos=current_que_base_infos,
+            schema=schema,
+            visible_field_names=visible_field_names,
+        )
+        self.apps.app_update_apply_config(
+            profile=profile,
+            app_key=app_key,
+            payload={"type": list_type, "changeQues": change_ques},
+        )
+        readback_response = self.apps.app_get_apply_base_info(profile=profile, app_key=app_key, list_type=list_type)
+        readback_result = readback_response.get("result") if isinstance(readback_response.get("result"), dict) else {}
+        actual_visible_order = _extract_apply_visible_field_names(readback_result.get("queBaseInfos"))
+        expected_visible_order = [name for name in visible_field_names if name]
+        verified = actual_visible_order[: len(expected_visible_order)] == expected_visible_order
+        return {
+            "list_type": list_type,
+            "expected_visible_order": expected_visible_order,
+            "actual_visible_order": actual_visible_order,
+            "verified": verified,
+        }
+
     def _load_views_result(self, *, profile: str, app_key: str, tolerate_404: bool) -> tuple[Any, bool]:
         try:
             views = self.views.view_list_flat(profile=profile, app_key=app_key)
@@ -4402,6 +4491,23 @@ def _coerce_positive_int(value: Any) -> int | None:
     return None
 
 
+def _coerce_nonnegative_int(value: Any) -> int | None:
+    if isinstance(value, bool) or value is None:
+        return None
+    if isinstance(value, int):
+        return value if value >= 0 else None
+    if isinstance(value, float):
+        parsed = int(value)
+        return parsed if parsed >= 0 else None
+    if isinstance(value, str) and value.strip():
+        try:
+            parsed = int(value)
+        except ValueError:
+            return None
+        return parsed if parsed >= 0 else None
+    return None
+
+
 def _coerce_int_list(values: Any) -> list[int]:
     if not isinstance(values, list):
         return []
@@ -5035,6 +5141,143 @@ def _extract_view_key(view: dict[str, Any]) -> str:
     return str(view.get("viewgraphKey") or view.get("viewKey") or "").strip()
 
 
+def _resolve_system_view_list_type(*, view_key: str | None, view_name: str | None) -> int | None:
+    normalized_key = str(view_key or "").strip()
+    if normalized_key in SYSTEM_VIEW_ID_TO_LIST_TYPE:
+        return SYSTEM_VIEW_ID_TO_LIST_TYPE[normalized_key]
+    numeric_key = _coerce_positive_int(normalized_key)
+    if numeric_key is not None and numeric_key in RECORD_LIST_TYPE_LABELS:
+        return numeric_key
+    normalized_name = str(view_name or "").strip()
+    if not normalized_name:
+        return None
+    if normalized_name == "全部数据":
+        return 8
+    if normalized_name == "我发起的":
+        return 14
+    if normalized_name == "待办":
+        return 1
+    if normalized_name == "已办":
+        return 2
+    if normalized_name in {"抄送", "抄送我的"}:
+        return 12
+    return None
+
+
+def _build_apply_config_change_ques(
+    *,
+    current_que_base_infos: list[dict[str, Any]],
+    schema: dict[str, Any],
+    visible_field_names: list[str],
+) -> list[dict[str, Any]]:
+    parsed_schema = _parse_schema(schema)
+    fields_by_name = {
+        str(field.get("name") or ""): field
+        for field in parsed_schema.get("fields", [])
+        if isinstance(field, dict) and str(field.get("name") or "")
+    }
+    current_items: list[dict[str, Any]] = [item for item in current_que_base_infos if isinstance(item, dict)]
+    current_by_que_id = {
+        _coerce_positive_int(item.get("queId")): item
+        for item in current_items
+        if _coerce_positive_int(item.get("queId")) is not None
+    }
+    ordered_visible_que_ids: list[int] = []
+    for field_name in visible_field_names:
+        field = fields_by_name.get(str(field_name or "").strip())
+        que_id = _coerce_positive_int(field.get("que_id")) if isinstance(field, dict) else None
+        if que_id is not None and que_id not in ordered_visible_que_ids:
+            ordered_visible_que_ids.append(que_id)
+    selected_que_ids = set(ordered_visible_que_ids)
+    ordered_que_ids: list[int] = list(ordered_visible_que_ids)
+    for item in current_items:
+        que_id = _coerce_positive_int(item.get("queId"))
+        if que_id is not None and que_id not in selected_que_ids and que_id not in ordered_que_ids:
+            ordered_que_ids.append(que_id)
+    for field in parsed_schema.get("fields", []):
+        if not isinstance(field, dict):
+            continue
+        que_id = _coerce_positive_int(field.get("que_id"))
+        if que_id is not None and que_id not in ordered_que_ids:
+            ordered_que_ids.append(que_id)
+    return [
+        _normalize_apply_change_que(
+            current_by_que_id.get(que_id),
+            fallback_field=next(
+                (
+                    field
+                    for field in parsed_schema.get("fields", [])
+                    if isinstance(field, dict) and _coerce_positive_int(field.get("que_id")) == que_id
+                ),
+                None,
+            ),
+            visible=que_id in selected_que_ids,
+        )
+        for que_id in ordered_que_ids
+    ]
+
+
+def _normalize_apply_change_que(
+    item: dict[str, Any] | None,
+    *,
+    fallback_field: dict[str, Any] | None,
+    visible: bool,
+) -> dict[str, Any]:
+    que_id = _coerce_positive_int((item or {}).get("queId"))
+    if que_id is None and isinstance(fallback_field, dict):
+        que_id = _coerce_positive_int(fallback_field.get("que_id"))
+    payload: dict[str, Any] = {
+        "queId": que_id,
+        "beingVisible": visible,
+    }
+    width = _coerce_positive_int((item or {}).get("width"))
+    if width is not None:
+        payload["width"] = width
+    current_sub_ques = (item or {}).get("subQues")
+    if isinstance(current_sub_ques, list):
+        payload["subQues"] = [
+            _normalize_apply_sub_change_que(sub_item, visible=visible)
+            for sub_item in current_sub_ques
+            if isinstance(sub_item, dict)
+        ]
+    elif isinstance(fallback_field, dict) and isinstance(fallback_field.get("subfields"), list):
+        payload["subQues"] = [
+            {
+                "queId": _coerce_positive_int(subfield.get("que_id")),
+                "beingVisible": visible,
+            }
+            for subfield in fallback_field.get("subfields", [])
+            if isinstance(subfield, dict) and _coerce_positive_int(subfield.get("que_id")) is not None
+        ]
+    return payload
+
+
+def _normalize_apply_sub_change_que(item: dict[str, Any], *, visible: bool) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "queId": _coerce_positive_int(item.get("queId")),
+        "beingVisible": visible and bool(item.get("beingVisible", True)),
+    }
+    width = _coerce_positive_int(item.get("width"))
+    if width is not None:
+        payload["width"] = width
+    return payload
+
+
+def _extract_apply_visible_field_names(que_base_infos: Any) -> list[str]:
+    if not isinstance(que_base_infos, list):
+        return []
+    visible_names: list[str] = []
+    for item in que_base_infos:
+        if not isinstance(item, dict):
+            continue
+        if not bool(item.get("beingVisible", True)):
+            continue
+        name = str(item.get("queTitle") or "").strip()
+        if name:
+            visible_names.append(name)
+    return visible_names
+
+
 def _empty_schema_result(title: str) -> dict[str, Any]:
     return {
         "formTitle": title,
@@ -5090,6 +5333,33 @@ def _resolve_relation_target_field(
     return target_fields[match_index]
 
 
+def _relation_mode_from_optional_data_num(value: Any) -> str:
+    return PublicRelationMode.multiple.value if _relation_mode_to_optional_data_num(value) == 0 else PublicRelationMode.single.value
+
+
+def _relation_mode_to_optional_data_num(value: Any) -> int:
+    if isinstance(value, bool):
+        return 0 if value else 1
+    if isinstance(value, int):
+        return 0 if value == 0 else 1
+    if isinstance(value, str):
+        normalized = value.strip().lower()
+        if normalized in {
+            PublicRelationMode.multiple.value,
+            "multi",
+            "multi_select",
+            "multi-select",
+            "many",
+            "0",
+        }:
+            return 0
+    return 1
+
+
+def _normalize_relation_mode(value: Any) -> str:
+    return _relation_mode_from_optional_data_num(value)
+
+
 def _hydrate_relation_field_configs(
     facade: "AiBuilderFacade",
     *,
@@ -5104,6 +5374,11 @@ def _hydrate_relation_field_configs(
         target_app_key = str(field.get("target_app_key") or "").strip()
         if not target_app_key:
             continue
+        config = deepcopy(field.get("config") or {})
+        relation_mode = _normalize_relation_mode(field.get("relation_mode", config.get("optional_data_num")))
+        config["optional_data_num"] = _relation_mode_to_optional_data_num(relation_mode)
+        field["relation_mode"] = relation_mode
+        field["config"] = config
         display_selector = field.get("display_field") if isinstance(field.get("display_field"), dict) else None
         visible_selector_payloads = [item for item in cast(list[Any], field.get("visible_fields") or []) if isinstance(item, dict)]
         if display_selector is None and not visible_selector_payloads:
@@ -5132,7 +5407,6 @@ def _hydrate_relation_field_configs(
             for item in visible_fields
         ):
             visible_fields = [display_field, *visible_fields]
-        config = deepcopy(field.get("config") or {})
         config["target_field_label"] = display_field.get("name")
         config["target_field_type"] = display_field.get("type")
         config["target_field_que_id"] = display_field.get("que_id")
@@ -5217,6 +5491,7 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
     if field_type == FieldType.relation:
         reference = question.get("referenceConfig") if isinstance(question.get("referenceConfig"), dict) else {}
         field["target_app_key"] = reference.get("referAppKey")
+        field["relation_mode"] = _relation_mode_from_optional_data_num(reference.get("optionalDataNum"))
         refer_questions = reference.get("referQuestions") if isinstance(reference.get("referQuestions"), list) else []
         visible_fields: list[dict[str, Any]] = []
         display_field_que_id = _coerce_positive_int(reference.get("referQueId"))
@@ -5367,6 +5642,23 @@ def _resolve_layout_field_name(
     return None
 
 
+def _compact_public_field_read(*, field: dict[str, Any], layout: dict[str, Any]) -> dict[str, Any]:
+    payload = {
+        "field_id": field.get("field_id"),
+        "que_id": field.get("que_id"),
+        "name": field.get("name"),
+        "type": field.get("type"),
+        "required": bool(field.get("required")),
+        "section_id": _find_field_section_id(layout, str(field.get("name") or "")),
+    }
+    if field.get("type") == FieldType.relation.value:
+        payload["target_app_key"] = field.get("target_app_key")
+        payload["relation_mode"] = _normalize_relation_mode(field.get("relation_mode"))
+        payload["display_field"] = deepcopy(field.get("display_field"))
+        payload["visible_fields"] = deepcopy(field.get("visible_fields") or [])
+    return payload
+
+
 def _build_selector_map(fields: list[dict[str, Any]]) -> dict[str, int]:
     mapping: dict[str, int] = {}
     for index, field in enumerate(fields):
@@ -5415,6 +5707,7 @@ def _field_patch_to_internal(patch: FieldPatch) -> dict[str, Any]:
         "target_app_key": patch.target_app_key,
         "display_field": patch.display_field.model_dump(mode="json", exclude_none=True) if patch.display_field is not None else None,
         "visible_fields": [selector.model_dump(mode="json", exclude_none=True) for selector in patch.visible_fields],
+        "relation_mode": patch.relation_mode.value if patch.relation_mode is not None else None,
         "subfields": [_field_patch_to_internal(subfield) for subfield in patch.subfields],
         "que_id": None,
     }
@@ -5430,6 +5723,7 @@ def _field_matches_patch(field: dict[str, Any], patch: FieldPatch) -> bool:
         and (field.get("target_app_key") or None) == patch.target_app_key
         and _field_selector_payload_equal(field.get("display_field"), patch.display_field.model_dump(mode="json", exclude_none=True) if patch.display_field is not None else None)
         and _field_selector_list_equal(field.get("visible_fields"), [selector.model_dump(mode="json", exclude_none=True) for selector in patch.visible_fields])
+        and _normalize_relation_mode(field.get("relation_mode")) == _normalize_relation_mode(patch.relation_mode.value if patch.relation_mode is not None else None)
         and len(field.get("subfields") or []) == len(patch.subfields)
     )
 
@@ -5472,6 +5766,8 @@ def _apply_field_mutation(field: dict[str, Any], mutation: Any) -> None:
         field["display_field"] = payload["display_field"]
     if "visible_fields" in payload:
         field["visible_fields"] = list(payload["visible_fields"])
+    if "relation_mode" in payload:
+        field["relation_mode"] = payload["relation_mode"]
     if "subfields" in payload:
         field["subfields"] = [_field_patch_to_internal(item) for item in payload["subfields"]]
 
@@ -5956,6 +6252,7 @@ def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]
         reference["_targetEntityId"] = field.get("target_app_key")
         if field.get("target_field_que_id"):
             reference["referQueId"] = field.get("target_field_que_id")
+        reference["optionalDataNum"] = _relation_mode_to_optional_data_num(field.get("relation_mode"))
         question["referenceConfig"] = reference
     return question
 
@@ -6188,6 +6485,214 @@ def _summarize_views(result: Any) -> list[dict[str, Any]]:
     return items
 
 
+def _summarize_views_with_config(views_tool: ViewTools, *, profile: str, views: Any) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    base_items = _summarize_views(views)
+    if not base_items:
+        return [], []
+    config_read_errors: list[dict[str, Any]] = []
+    enriched_items: list[dict[str, Any]] = []
+    for item in base_items:
+        view_key = str(item.get("view_key") or "").strip()
+        if not view_key:
+            enriched_items.append(item)
+            continue
+        try:
+            config_response = views_tool.view_get_config(profile=profile, viewgraph_key=view_key)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            config_read_errors.append(
+                {
+                    "view_key": view_key,
+                    "name": item.get("name"),
+                    "request_id": api_error.request_id,
+                    "http_status": api_error.http_status,
+                    "backend_code": api_error.backend_code,
+                    "category": api_error.category,
+                }
+            )
+            enriched_items.append(item)
+            continue
+        config = config_response.get("result") if isinstance(config_response.get("result"), dict) else {}
+        enriched_items.append(_merge_view_summary_with_config(item, config=config))
+    return enriched_items, config_read_errors
+
+
+def _merge_view_summary_with_config(base: dict[str, Any], *, config: dict[str, Any]) -> dict[str, Any]:
+    summary = deepcopy(base)
+    if not isinstance(config, dict) or not config:
+        return summary
+    legacy_columns = [str(value) for value in (summary.get("columns") or []) if str(value or "").strip()]
+    question_entries = _extract_view_question_entries(config.get("viewgraphQuestions"))
+    question_entries_by_id = {
+        field_id: entry
+        for entry in question_entries
+        if (field_id := _coerce_nonnegative_int(entry.get("field_id"))) is not None
+    }
+    configured_column_ids = [
+        field_id
+        for field_id in (_coerce_nonnegative_int(value) for value in (config.get("viewgraphQueIds") or []))
+        if field_id is not None
+    ]
+    configured_columns = _resolve_view_column_names(
+        configured_column_ids,
+        question_entries_by_id=question_entries_by_id,
+        legacy_columns=legacy_columns,
+    )
+    config_enriched = False
+    display_entries = _sort_view_question_entries(
+        [entry for entry in question_entries if bool(entry.get("visible", True))],
+    )
+    display_column_ids = [
+        field_id
+        for field_id in (_coerce_nonnegative_int(entry.get("field_id")) for entry in display_entries)
+        if field_id is not None
+    ]
+    display_columns = [
+        str(entry.get("name") or "").strip()
+        for entry in display_entries
+        if str(entry.get("name") or "").strip()
+    ]
+    if not display_columns and configured_columns:
+        display_columns = configured_columns
+        display_column_ids = list(configured_column_ids)
+    if display_columns:
+        summary["columns"] = display_columns
+        summary["display_columns"] = display_columns
+        summary["display_column_ids"] = display_column_ids
+        config_enriched = True
+    elif configured_columns:
+        summary["columns"] = configured_columns
+        config_enriched = True
+    if configured_columns:
+        summary["configured_columns"] = configured_columns
+        summary["configured_column_ids"] = configured_column_ids
+        config_enriched = True
+    if question_entries:
+        summary["column_details"] = display_entries or _sort_view_question_entries(question_entries)
+        config_enriched = True
+    display_config = _extract_view_display_config(
+        config,
+        question_entries_by_id=question_entries_by_id,
+        fallback_group_by=str(summary.get("group_by") or "").strip() or None,
+    )
+    if display_config:
+        summary["display_config"] = display_config
+        if not summary.get("group_by") and display_config.get("group_by"):
+            summary["group_by"] = display_config.get("group_by")
+        config_enriched = True
+    if config_enriched:
+        summary["read_source"] = "view_config"
+    return summary
+
+
+def _extract_view_question_entries(questions: Any) -> list[dict[str, Any]]:
+    if not isinstance(questions, list):
+        return []
+    entries: list[dict[str, Any]] = []
+    for index, item in enumerate(questions, start=1):
+        if not isinstance(item, dict):
+            continue
+        field_id = _coerce_nonnegative_int(item.get("queId"))
+        name = str(item.get("queTitle") or "").strip() or None
+        visible_raw = item.get("beingListDisplay")
+        if visible_raw is None:
+            visible_raw = item.get("beingVisible")
+        visible = bool(visible_raw) if visible_raw is not None else True
+        display_order = _coerce_positive_int(item.get("displayOrdinal"))
+        entry: dict[str, Any] = {
+            "field_id": field_id,
+            "name": name,
+            "visible": visible,
+            "display_order": display_order if display_order is not None else index,
+        }
+        width = _coerce_positive_int(item.get("width"))
+        if width is not None:
+            entry["width"] = width
+        entries.append(entry)
+    return entries
+
+
+def _sort_view_question_entries(entries: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    return sorted(
+        entries,
+        key=lambda entry: (
+            _coerce_positive_int(entry.get("display_order")) if _coerce_positive_int(entry.get("display_order")) is not None else 10**9,
+            str(entry.get("name") or ""),
+        ),
+    )
+
+
+def _resolve_view_column_names(
+    field_ids: list[int],
+    *,
+    question_entries_by_id: dict[int, dict[str, Any]],
+    legacy_columns: list[str],
+) -> list[str]:
+    names: list[str] = []
+    for index, field_id in enumerate(field_ids):
+        entry = question_entries_by_id.get(field_id) or {}
+        name = str(entry.get("name") or "").strip()
+        if not name and index < len(legacy_columns):
+            name = str(legacy_columns[index] or "").strip()
+        if name:
+            names.append(name)
+    return names
+
+
+def _extract_view_display_config(
+    config: dict[str, Any],
+    *,
+    question_entries_by_id: dict[int, dict[str, Any]],
+    fallback_group_by: str | None,
+) -> dict[str, Any]:
+    if not isinstance(config, dict):
+        return {}
+    display_config: dict[str, Any] = {}
+    for source_key, public_key in (
+        ("defaultRowHigh", "row_height"),
+        ("sortType", "sort_type"),
+        ("beingPinNavigate", "pin_navigation"),
+        ("beingShowCover", "show_cover"),
+        ("beingShowTitleQue", "show_title_field"),
+    ):
+        if source_key in config:
+            display_config[public_key] = config.get(source_key)
+    title_field_id = _coerce_positive_int(config.get("titleQue"))
+    if title_field_id is not None:
+        display_config["title_field_id"] = title_field_id
+        title_field = str((question_entries_by_id.get(title_field_id) or {}).get("name") or "").strip()
+        if title_field:
+            display_config["title_field"] = title_field
+    group_field_id = _coerce_positive_int(config.get("groupQueId"))
+    if group_field_id is not None:
+        display_config["group_by_field_id"] = group_field_id
+        group_by = str((question_entries_by_id.get(group_field_id) or {}).get("name") or "").strip()
+        if group_by:
+            display_config["group_by"] = group_by
+    elif fallback_group_by:
+        display_config["group_by"] = fallback_group_by
+    raw_sorts = config.get("viewgraphSorts")
+    if isinstance(raw_sorts, list):
+        sorts: list[dict[str, Any]] = []
+        for item in raw_sorts:
+            if not isinstance(item, dict):
+                continue
+            sort_field_id = _coerce_positive_int(item.get("queId"))
+            if sort_field_id is None:
+                continue
+            sort_entry: dict[str, Any] = {
+                "field_id": sort_field_id,
+                "ascending": bool(item.get("beingSortAscend", True)),
+            }
+            sort_name = str((question_entries_by_id.get(sort_field_id) or {}).get("name") or "").strip()
+            if sort_name:
+                sort_entry["field"] = sort_name
+            sorts.append(sort_entry)
+        if sorts:
+            display_config["sorts"] = sorts
+    return display_config
+
+
 def _summarize_charts(result: Any) -> list[dict[str, Any]]:
     if not isinstance(result, list):
         return []