@josephyan/qingflow-cli 0.2.0-beta.70 → 0.2.0-beta.72

package/src/qingflow_mcp/server_app_user.py

@@ -16,6 +16,7 @@ from .tools.directory_tools import DirectoryTools
 from .tools.feedback_tools import FeedbackTools
 from .tools.file_tools import FileTools
 from .tools.import_tools import ImportTools
+from .tools.resource_read_tools import ResourceReadTools
 from .tools.task_context_tools import TaskContextTools
 from .tools.workspace_tools import WorkspaceTools
 
@@ -95,6 +96,8 @@ Analysis answers must include concrete numbers. When applicable, include percent
 `record_update_schema_get -> record_update`
 `record_list / record_get -> record_delete`
 `record_code_block_schema_get -> record_code_block_run`
+`portal_list -> portal_get -> chart_get / view_get`
+`portal_get -> view_get -> record_list`
 
 - Use `columns` as `[{{field_id}}]`
 - Use `where` items as `{{field_id, op, value}}`
@@ -177,6 +180,7 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
     workspace = wrap_trimmed_methods(WorkspaceTools(sessions, backend), USER_SERVER_METHOD_MAP)
     file_tools = wrap_trimmed_methods(FileTools(sessions, backend), USER_SERVER_METHOD_MAP)
     imports = wrap_trimmed_methods(ImportTools(sessions, backend), USER_SERVER_METHOD_MAP)
+    resources = wrap_trimmed_methods(ResourceReadTools(sessions, backend), USER_SERVER_METHOD_MAP)
     feedback = FeedbackTools(backend, mcp_side="App User MCP")
     code_block_tools = wrap_trimmed_methods(CodeBlockTools(sessions, backend), USER_SERVER_METHOD_MAP)
     task_context_tools = wrap_trimmed_methods(TaskContextTools(sessions, backend), USER_SERVER_METHOD_MAP)
@@ -256,6 +260,22 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
     def app_get(profile: str = DEFAULT_PROFILE, app_key: str = "") -> dict:
         return apps.app_get(profile=profile, app_key=app_key)
 
+    @server.tool()
+    def portal_list(profile: str = DEFAULT_PROFILE) -> dict:
+        return resources.portal_list(profile=profile)
+
+    @server.tool()
+    def portal_get(profile: str = DEFAULT_PROFILE, dash_key: str = "") -> dict:
+        return resources.portal_get(profile=profile, dash_key=dash_key)
+
+    @server.tool()
+    def view_get(profile: str = DEFAULT_PROFILE, view_id: str = "") -> dict:
+        return resources.view_get(profile=profile, view_id=view_id)
+
+    @server.tool()
+    def chart_get(profile: str = DEFAULT_PROFILE, chart_id: str = "") -> dict:
+        return resources.chart_get(profile=profile, chart_id=chart_id)
+
     @server.tool()
     def file_get_upload_info(
         profile: str = DEFAULT_PROFILE,
@@ -320,7 +340,7 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
     ) -> dict:
         try:
             return trim_public_response(
-                "feedback_submit",
+                "user:feedback_submit",
                 feedback.feedback_submit(
                     category=category,
                     title=title,

package/src/qingflow_mcp/tools/ai_builder_tools.py

@@ -209,28 +209,28 @@ class AiBuilderTools(ToolBase):
             return self.app_custom_button_delete(profile=profile, app_key=app_key, button_id=button_id)
 
         @mcp.tool()
-        def app_read_summary(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
-            return self.app_read_summary(profile=profile, app_key=app_key)
+        def app_get(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
+            return self.app_get(profile=profile, app_key=app_key)
 
         @mcp.tool()
-        def app_read_fields(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
-            return self.app_read_fields(profile=profile, app_key=app_key)
+        def app_get_fields(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
+            return self.app_get_fields(profile=profile, app_key=app_key)
 
         @mcp.tool()
-        def app_read_layout_summary(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
-            return self.app_read_layout_summary(profile=profile, app_key=app_key)
+        def app_get_layout(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
+            return self.app_get_layout(profile=profile, app_key=app_key)
 
         @mcp.tool()
-        def app_read_views_summary(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
-            return self.app_read_views_summary(profile=profile, app_key=app_key)
+        def app_get_views(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
+            return self.app_get_views(profile=profile, app_key=app_key)
 
         @mcp.tool()
-        def app_read_flow_summary(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
-            return self.app_read_flow_summary(profile=profile, app_key=app_key)
+        def app_get_flow(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
+            return self.app_get_flow(profile=profile, app_key=app_key)
 
         @mcp.tool()
-        def app_read_charts_summary(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
-            return self.app_read_charts_summary(profile=profile, app_key=app_key)
+        def app_get_charts(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
+            return self.app_get_charts(profile=profile, app_key=app_key)
 
         @mcp.tool()
         def portal_list(profile: str = DEFAULT_PROFILE) -> JSONObject:
@@ -245,36 +245,15 @@ class AiBuilderTools(ToolBase):
             return self.portal_get(profile=profile, dash_key=dash_key, being_draft=being_draft)
 
         @mcp.tool()
-        def portal_read_summary(
-            profile: str = DEFAULT_PROFILE,
-            dash_key: str = "",
-            being_draft: bool = True,
-        ) -> JSONObject:
-            return self.portal_read_summary(profile=profile, dash_key=dash_key, being_draft=being_draft)
-
-        @mcp.tool()
-        def view_get(profile: str = DEFAULT_PROFILE, viewgraph_key: str = "") -> JSONObject:
-            return self.view_get(profile=profile, viewgraph_key=viewgraph_key)
+        def view_get(profile: str = DEFAULT_PROFILE, view_key: str = "") -> JSONObject:
+            return self.view_get(profile=profile, view_key=view_key)
 
         @mcp.tool()
         def chart_get(
             profile: str = DEFAULT_PROFILE,
             chart_id: str = "",
-            data_payload: JSONObject | None = None,
-            page_num: int | None = None,
-            page_size: int | None = None,
-            page_num_y: int | None = None,
-            page_size_y: int | None = None,
         ) -> JSONObject:
-            return self.chart_get(
-                profile=profile,
-                chart_id=chart_id,
-                data_payload=data_payload or {},
-                page_num=page_num,
-                page_size=page_size,
-                page_num_y=page_num_y,
-                page_size_y=page_size_y,
-            )
+            return self.chart_get(profile=profile, chart_id=chart_id)
 
         @mcp.tool()
         def app_schema_apply(
@@ -759,7 +738,16 @@ class AiBuilderTools(ToolBase):
             lambda: self._facade.app_read_summary(profile=profile, app_key=app_key),
             error_code="APP_READ_FAILED",
             normalized_args=normalized_args,
-            suggested_next_call={"tool_name": "app_read_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
+        )
+
+    def app_get(self, *, profile: str, app_key: str) -> JSONObject:
+        normalized_args = {"app_key": app_key}
+        return _safe_tool_call(
+            lambda: self._facade.app_get(profile=profile, app_key=app_key),
+            error_code="APP_GET_FAILED",
+            normalized_args=normalized_args,
+            suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
         )
 
     def app_read_fields(self, *, profile: str, app_key: str) -> JSONObject:
@@ -768,7 +756,16 @@ class AiBuilderTools(ToolBase):
             lambda: self._facade.app_read_fields(profile=profile, app_key=app_key),
             error_code="FIELDS_READ_FAILED",
             normalized_args=normalized_args,
-            suggested_next_call={"tool_name": "app_read_fields", "arguments": {"profile": profile, "app_key": app_key}},
+            suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
+        )
+
+    def app_get_fields(self, *, profile: str, app_key: str) -> JSONObject:
+        normalized_args = {"app_key": app_key}
+        return _safe_tool_call(
+            lambda: self._facade.app_get_fields(profile=profile, app_key=app_key),
+            error_code="APP_GET_FIELDS_FAILED",
+            normalized_args=normalized_args,
+            suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": app_key}},
         )
 
     def app_read_layout_summary(self, *, profile: str, app_key: str) -> JSONObject:
@@ -777,7 +774,16 @@ class AiBuilderTools(ToolBase):
             lambda: self._facade.app_read_layout_summary(profile=profile, app_key=app_key),
             error_code="LAYOUT_READ_FAILED",
             normalized_args=normalized_args,
-            suggested_next_call={"tool_name": "app_read_layout_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            suggested_next_call={"tool_name": "app_get_layout", "arguments": {"profile": profile, "app_key": app_key}},
+        )
+
+    def app_get_layout(self, *, profile: str, app_key: str) -> JSONObject:
+        normalized_args = {"app_key": app_key}
+        return _safe_tool_call(
+            lambda: self._facade.app_get_layout(profile=profile, app_key=app_key),
+            error_code="APP_GET_LAYOUT_FAILED",
+            normalized_args=normalized_args,
+            suggested_next_call={"tool_name": "app_get_layout", "arguments": {"profile": profile, "app_key": app_key}},
         )
 
     def app_read_views_summary(self, *, profile: str, app_key: str) -> JSONObject:
@@ -786,7 +792,16 @@ class AiBuilderTools(ToolBase):
             lambda: self._facade.app_read_views_summary(profile=profile, app_key=app_key),
             error_code="VIEWS_READ_FAILED",
             normalized_args=normalized_args,
-            suggested_next_call={"tool_name": "app_read_views_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            suggested_next_call={"tool_name": "app_get_views", "arguments": {"profile": profile, "app_key": app_key}},
+        )
+
+    def app_get_views(self, *, profile: str, app_key: str) -> JSONObject:
+        normalized_args = {"app_key": app_key}
+        return _safe_tool_call(
+            lambda: self._facade.app_get_views(profile=profile, app_key=app_key),
+            error_code="APP_GET_VIEWS_FAILED",
+            normalized_args=normalized_args,
+            suggested_next_call={"tool_name": "app_get_views", "arguments": {"profile": profile, "app_key": app_key}},
         )
 
     def app_read_flow_summary(self, *, profile: str, app_key: str) -> JSONObject:
@@ -795,7 +810,16 @@ class AiBuilderTools(ToolBase):
             lambda: self._facade.app_read_flow_summary(profile=profile, app_key=app_key),
             error_code="FLOW_READ_FAILED",
             normalized_args=normalized_args,
-            suggested_next_call={"tool_name": "app_read_flow_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            suggested_next_call={"tool_name": "app_get_flow", "arguments": {"profile": profile, "app_key": app_key}},
+        )
+
+    def app_get_flow(self, *, profile: str, app_key: str) -> JSONObject:
+        normalized_args = {"app_key": app_key}
+        return _safe_tool_call(
+            lambda: self._facade.app_get_flow(profile=profile, app_key=app_key),
+            error_code="APP_GET_FLOW_FAILED",
+            normalized_args=normalized_args,
+            suggested_next_call={"tool_name": "app_get_flow", "arguments": {"profile": profile, "app_key": app_key}},
         )
 
     def app_read_charts_summary(self, *, profile: str, app_key: str) -> JSONObject:
@@ -804,7 +828,16 @@ class AiBuilderTools(ToolBase):
             lambda: self._facade.app_read_charts_summary(profile=profile, app_key=app_key),
             error_code="CHARTS_READ_FAILED",
             normalized_args=normalized_args,
-            suggested_next_call={"tool_name": "app_read_charts_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            suggested_next_call={"tool_name": "app_get_charts", "arguments": {"profile": profile, "app_key": app_key}},
+        )
+
+    def app_get_charts(self, *, profile: str, app_key: str) -> JSONObject:
+        normalized_args = {"app_key": app_key}
+        return _safe_tool_call(
+            lambda: self._facade.app_get_charts(profile=profile, app_key=app_key),
+            error_code="APP_GET_CHARTS_FAILED",
+            normalized_args=normalized_args,
+            suggested_next_call={"tool_name": "app_get_charts", "arguments": {"profile": profile, "app_key": app_key}},
         )
 
     def portal_list(self, *, profile: str) -> JSONObject:
@@ -830,13 +863,14 @@ class AiBuilderTools(ToolBase):
             lambda: self._facade.portal_read_summary(profile=profile, dash_key=dash_key, being_draft=being_draft),
             error_code="PORTAL_READ_FAILED",
             normalized_args=normalized_args,
-            suggested_next_call={"tool_name": "portal_read_summary", "arguments": {"profile": profile, **normalized_args}},
+            suggested_next_call={"tool_name": "portal_get", "arguments": {"profile": profile, **normalized_args}},
         )
 
-    def view_get(self, *, profile: str, viewgraph_key: str) -> JSONObject:
-        normalized_args = {"viewgraph_key": viewgraph_key}
+    def view_get(self, *, profile: str, view_key: str = "", viewgraph_key: str = "") -> JSONObject:
+        resolved_view_key = str(view_key or viewgraph_key or "").strip()
+        normalized_args = {"view_key": resolved_view_key}
         return _safe_tool_call(
-            lambda: self._facade.view_get(profile=profile, viewgraph_key=viewgraph_key),
+            lambda: self._facade.view_get(profile=profile, view_key=resolved_view_key),
             error_code="VIEW_GET_FAILED",
             normalized_args=normalized_args,
             suggested_next_call={"tool_name": "view_get", "arguments": {"profile": profile, **normalized_args}},
@@ -847,30 +881,10 @@ class AiBuilderTools(ToolBase):
         *,
         profile: str,
         chart_id: str,
-        data_payload: JSONObject | None = None,
-        page_num: int | None = None,
-        page_size: int | None = None,
-        page_num_y: int | None = None,
-        page_size_y: int | None = None,
     ) -> JSONObject:
-        normalized_args = {
-            "chart_id": chart_id,
-            "data_payload": deepcopy(data_payload) if isinstance(data_payload, dict) else {},
-            "page_num": page_num,
-            "page_size": page_size,
-            "page_num_y": page_num_y,
-            "page_size_y": page_size_y,
-        }
+        normalized_args = {"chart_id": chart_id}
         return _safe_tool_call(
-            lambda: self._facade.chart_get(
-                profile=profile,
-                chart_id=chart_id,
-                data_payload=normalized_args["data_payload"],
-                page_num=page_num,
-                page_size=page_size,
-                page_num_y=page_num_y,
-                page_size_y=page_size_y,
-            ),
+            lambda: self._facade.chart_get(profile=profile, chart_id=chart_id),
             error_code="CHART_GET_FAILED",
             normalized_args=normalized_args,
             suggested_next_call={"tool_name": "chart_get", "arguments": {"profile": profile, "chart_id": chart_id}},
@@ -2517,7 +2531,7 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         "execution_notes": [
             "apply may return partial_success when some views land and others fail",
             "when duplicate view names exist, supply view_key to target the exact view",
-            "read back app_read_views_summary after any failed or partial view apply",
+            "read back app_get_views after any failed or partial view apply",
             "view existence verification and saved-filter verification are separate; treat filters as unverified until verification.view_filters_verified is true",
             "buttons omitted preserves existing button config; buttons=[] clears all buttons; buttons=[...] replaces the full button config",
         ],
@@ -2546,7 +2560,73 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "remove_views": [],
         },
     },
-    "app_read_charts_summary": {
+    "app_get": {
+        "allowed_keys": ["app_key"],
+        "aliases": {},
+        "allowed_values": {},
+        "execution_notes": [
+            "returns builder-side app configuration summary and editability",
+            "use this as the default builder discovery read before fields/layout/views/flow/charts detail reads",
+            "editability reflects builder permissions, not end-user data visibility",
+        ],
+        "minimal_example": {
+            "profile": "default",
+            "app_key": "APP_KEY",
+        },
+    },
+    "app_get_fields": {
+        "allowed_keys": ["app_key"],
+        "aliases": {},
+        "allowed_values": {},
+        "execution_notes": [
+            "returns compact current field configuration for one app",
+            "use this before app_schema_apply when you need exact field definitions",
+        ],
+        "minimal_example": {
+            "profile": "default",
+            "app_key": "APP_KEY",
+        },
+    },
+    "app_get_layout": {
+        "allowed_keys": ["app_key"],
+        "aliases": {},
+        "allowed_values": {},
+        "execution_notes": [
+            "returns compact current layout configuration for one app",
+            "use this before app_layout_apply when you need paragraph and row structure",
+        ],
+        "minimal_example": {
+            "profile": "default",
+            "app_key": "APP_KEY",
+        },
+    },
+    "app_get_views": {
+        "allowed_keys": ["app_key"],
+        "aliases": {},
+        "allowed_values": {},
+        "execution_notes": [
+            "returns compact current view inventory for one app",
+            "use this before app_views_apply when you need exact current view keys",
+        ],
+        "minimal_example": {
+            "profile": "default",
+            "app_key": "APP_KEY",
+        },
+    },
+    "app_get_flow": {
+        "allowed_keys": ["app_key"],
+        "aliases": {},
+        "allowed_values": {},
+        "execution_notes": [
+            "returns workflow configuration summary for one app",
+            "use this before app_flow_apply when you need the current node structure",
+        ],
+        "minimal_example": {
+            "profile": "default",
+            "app_key": "APP_KEY",
+        },
+    },
+    "app_get_charts": {
         "allowed_keys": ["app_key"],
         "aliases": {},
         "allowed_values": {},
@@ -2565,8 +2645,8 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         "aliases": {},
         "allowed_values": {},
         "execution_notes": [
-            "returns the current user's accessible portal list",
-            "use this as the portal discovery path before portal_get",
+            "returns builder-configurable portal list items only",
+            "use this as the builder portal discovery path before portal_get",
             "results are compact list items, not raw dash payloads",
         ],
         "minimal_example": {
@@ -2578,8 +2658,8 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         "aliases": {"beingDraft": "being_draft"},
         "allowed_values": {},
         "execution_notes": [
-            "returns portal-level detail plus a component inventory",
-            "chart and view components are returned as refs only; use chart_get or view_get for more detail",
+            "returns builder-side portal configuration detail plus a normalized component inventory",
+            "chart and view components are returned as refs only; use builder chart_get or builder view_get for configuration detail",
             "being_draft=true reads the current draft view; being_draft=false reads live",
         ],
         "minimal_example": {
@@ -2616,69 +2696,32 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "reorder_chart_ids": [],
         },
     },
-    "chart_apply": {
-        "allowed_keys": ["app_key", "upsert_charts", "remove_chart_ids", "reorder_chart_ids"],
-        "aliases": {
-            "legacy_tool_name": "app_charts_apply",
-        },
-        "allowed_values": {
-            "chart.chart_type": [member.value for member in PublicChartType],
-            "chart.filter.operator": [member.value for member in ViewFilterOperator],
-        },
-        "execution_notes": [
-            "legacy compatibility alias; prefer app_charts_apply in new builder flows",
-            "behavior matches app_charts_apply exactly",
-        ],
-        "minimal_example": {
-            "profile": "default",
-            "app_key": "APP_KEY",
-            "upsert_charts": [{"name": "数据总量", "chart_type": "target", "indicator_field_ids": []}],
-            "remove_chart_ids": [],
-            "reorder_chart_ids": [],
-        },
-    },
-    "portal_read_summary": {
-        "allowed_keys": ["dash_key", "being_draft"],
-        "aliases": {"beingDraft": "being_draft"},
-        "allowed_values": {},
-        "execution_notes": [
-            "returns a compact portal summary instead of the raw dash payload",
-            "being_draft=true reads the current draft view; being_draft=false reads live",
-            "use this before portal_apply when you need the current section inventory or target dash metadata",
-        ],
-        "minimal_example": {
-            "profile": "default",
-            "dash_key": "DASH_KEY",
-            "being_draft": True,
-        },
-    },
     "view_get": {
-        "allowed_keys": ["viewgraph_key"],
-        "aliases": {"viewKey": "viewgraph_key"},
+        "allowed_keys": ["view_key"],
+        "aliases": {},
         "allowed_values": {},
         "execution_notes": [
-            "returns one view's definition detail",
-            "does not return record data; use record_list with app_key + view_id for rows",
-            "use this after portal_get when a component references a view_ref.view_key",
+            "returns one builder-side view definition detail",
+            "does not return record data; use user-side view_get or record_list for runtime rows",
+            "use this after builder portal_get when a component references a view_ref.view_key",
         ],
         "minimal_example": {
             "profile": "default",
-            "viewgraph_key": "VIEW_KEY",
+            "view_key": "VIEW_KEY",
         },
     },
     "chart_get": {
-        "allowed_keys": ["chart_id", "data_payload", "page_num", "page_size", "page_num_y", "page_size_y"],
-        "aliases": {"payload": "data_payload"},
+        "allowed_keys": ["chart_id"],
+        "aliases": {},
         "allowed_values": {},
         "execution_notes": [
-            "returns chart base info, chart config, and chart data together",
+            "returns builder-side chart base info and chart config only",
             "chart_id is required; chart names are not accepted here",
-            "data_payload defaults to {} so chart_get queries concrete chart data by default",
+            "does not return chart data; use user-side chart_get for runtime data access",
         ],
         "minimal_example": {
             "profile": "default",
             "chart_id": "CHART_ID",
-            "data_payload": {},
         },
     },
     "portal_apply": {
@@ -2745,6 +2788,4 @@ _PRIVATE_BUILDER_TOOL_CONTRACTS = {
     "app_views_plan",
 }
 
-_BUILDER_TOOL_CONTRACT_ALIASES = {
-    "chart_apply": "app_charts_apply",
-}
+_BUILDER_TOOL_CONTRACT_ALIASES = {}

package/src/qingflow_mcp/tools/app_tools.py

@@ -179,9 +179,6 @@ class AppTools(ToolBase):
             accessible_views.extend(self._resolve_accessible_custom_views(context, app_key))
             import_capability, import_warnings = _derive_import_capability(base_info)
             warnings.extend(import_warnings)
-            editability, editability_warnings = _derive_editability(base_info)
-            warnings.extend(editability_warnings)
-
             return {
                 "profile": profile,
                 "ws_id": session_profile.selected_ws_id,
@@ -193,7 +190,6 @@ class AppTools(ToolBase):
                     "app_name": app_name,
                     "can_create": can_create,
                     "import_capability": import_capability,
-                    "editability": editability,
                     "accessible_views": accessible_views,
                 },
             }

package/src/qingflow_mcp/tools/qingbi_report_tools.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 from uuid import uuid4
 
 from mcp.server.fastmcp import FastMCP
@@ -18,6 +19,37 @@ def _qingbi_base_url(base_url: str) -> str:
     return normalized[:-4] if normalized.endswith("/api") else normalized
 
 
+def _should_retry_qflow_base(error: QingflowApiError) -> bool:
+    return int(getattr(error, "backend_code", 0) or 0) == 81007
+
+
+def _should_retry_asos_data(error: QingflowApiError) -> bool:
+    backend_code = int(getattr(error, "backend_code", 0) or 0)
+    http_status = getattr(error, "http_status", None)
+    return backend_code in {44011, 81007} or http_status == 404
+
+
+def _coerce_tool_error(error: RuntimeError | QingflowApiError) -> QingflowApiError | None:
+    if isinstance(error, QingflowApiError):
+        return error
+    if not isinstance(error, RuntimeError):
+        return None
+    try:
+        payload = json.loads(str(error))
+    except Exception:
+        return None
+    if not isinstance(payload, dict):
+        return None
+    return QingflowApiError(
+        category=str(payload.get("category") or "runtime"),
+        message=str(payload.get("message") or str(error)),
+        backend_code=payload.get("backend_code"),
+        request_id=payload.get("request_id"),
+        http_status=payload.get("http_status"),
+        details=payload.get("details") if isinstance(payload.get("details"), dict) else None,
+    )
+
+
 class QingbiReportTools(ToolBase):
     def register(self, mcp: FastMCP) -> None:
         @mcp.tool()
@@ -127,7 +159,13 @@ class QingbiReportTools(ToolBase):
 
     def qingbi_report_get_base(self, *, profile: str, chart_id: str) -> JSONObject:
         self._require_chart_id(chart_id)
-        return self._request(profile, "GET", f"/qingbi/charts/baseinfo/{chart_id}", chart_id=chart_id)
+        try:
+            return self._request(profile, "GET", f"/qingbi/charts/baseinfo/{chart_id}", chart_id=chart_id)
+        except (QingflowApiError, RuntimeError) as raw_error:
+            error = _coerce_tool_error(raw_error)
+            if error is None or not _should_retry_qflow_base(error):
+                raise
+        return self._request(profile, "GET", f"/qingbi/charts/qflow/baseinfo/{chart_id}", chart_id=chart_id)
 
     def qingbi_report_update_base(self, *, profile: str, chart_id: str, payload: JSONObject) -> JSONObject:
         self._require_chart_id(chart_id)
@@ -166,21 +204,34 @@ class QingbiReportTools(ToolBase):
             params["pageNumY"] = page_num_y
         if page_size_y is not None:
             params["pageSizeY"] = page_size_y
-        if payload:
+        try:
+            if payload:
+                return self._request(
+                    profile,
+                    "POST",
+                    f"/qingbi/charts/data/qflow/{chart_id}/detail",
+                    chart_id=chart_id,
+                    params=params,
+                    json_body=payload,
+                )
             return self._request(
                 profile,
-                "POST",
-                f"/qingbi/charts/data/qflow/{chart_id}/detail",
+                "GET",
+                f"/qingbi/charts/data/qflow/{chart_id}",
                 chart_id=chart_id,
                 params=params,
-                json_body=payload,
             )
+        except (QingflowApiError, RuntimeError) as raw_error:
+            error = _coerce_tool_error(raw_error)
+            if error is None or not _should_retry_asos_data(error):
+                raise
         return self._request(
             profile,
-            "GET",
-            f"/qingbi/charts/data/qflow/{chart_id}",
+            "POST",
+            f"/qingbi/charts/data/qflow/{chart_id}/asos",
             chart_id=chart_id,
             params=params,
+            json_body=payload or {},
         )
 
     def qingbi_report_delete(self, *, profile: str, chart_id: str) -> JSONObject: