@josephyan/qingflow-app-builder-mcp 0.2.0-beta.4 → 0.2.0-beta.41

package/src/qingflow_mcp/config.py

@@ -12,6 +12,8 @@ DEFAULT_USER_AGENT = "qingflow-mcp/1.0"
 DEFAULT_RECORD_LIST_TYPE = 8
 ATTACHMENT_QUESTION_TYPE = 13
 DEFAULT_BASE_URL = "https://qingflow.com/api"
+DEFAULT_FEEDBACK_APP_KEY = "e0d017kju002"
+DEFAULT_FEEDBACK_QSOURCE_TOKEN = "mcp-feedback-7755d14748fc"
 
 
 def get_mcp_home() -> Path:
@@ -136,6 +138,43 @@ def get_default_qf_version() -> str | None:
     return normalized or None
 
 
+def get_feedback_qsource_token() -> str | None:
+    """获取反馈 q-source 被动入口 token"""
+    value = get_config_value(
+        "feedback.qsource_token",
+        env_var="QINGFLOW_MCP_FEEDBACK_QSOURCE_TOKEN",
+        default=DEFAULT_FEEDBACK_QSOURCE_TOKEN,
+    )
+    if value is None:
+        return None
+    normalized = str(value).strip()
+    return normalized or None
+
+
+def get_feedback_base_url() -> str | None:
+    """获取反馈 q-source 使用的 base URL"""
+    value = get_config_value(
+        "feedback.base_url",
+        env_var="QINGFLOW_MCP_FEEDBACK_BASE_URL",
+        default=None,
+    )
+    if value is None:
+        return get_default_base_url()
+    normalized = normalize_base_url(value)
+    return normalized or get_default_base_url()
+
+
+def get_feedback_app_key() -> str:
+    """获取内部反馈表 app_key"""
+    value = get_config_value(
+        "feedback.app_key",
+        env_var="QINGFLOW_MCP_FEEDBACK_APP_KEY",
+        default=DEFAULT_FEEDBACK_APP_KEY,
+    )
+    normalized = str(value or "").strip()
+    return normalized or DEFAULT_FEEDBACK_APP_KEY
+
+
 def get_timeout_seconds() -> float:
     """获取 HTTP 超时秒数"""
     value = get_config_value(

package/src/qingflow_mcp/import_store.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+
+from .config import get_mcp_home
+
+
+def _utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _parse_utc(value: Any) -> datetime | None:
+    if not isinstance(value, str) or not value.strip():
+        return None
+    normalized = value.strip().replace("Z", "+00:00")
+    try:
+        parsed = datetime.fromisoformat(normalized)
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=timezone.utc)
+    return parsed.astimezone(timezone.utc)
+
+
+def _json_safe_key(value: str) -> str:
+    keep = []
+    for char in value:
+        if char.isalnum() or char in {"-", "_"}:
+            keep.append(char)
+        else:
+            keep.append("_")
+    result = "".join(keep).strip("_")
+    return result or "entry"
+
+
+def _store_dir(env_var: str, default_name: str) -> Path:
+    custom = os.getenv(env_var)
+    if custom:
+        return Path(custom).expanduser()
+    return get_mcp_home() / default_name
+
+
+@dataclass(slots=True)
+class _JsonEntryStore:
+    base_dir: Path
+    ttl: timedelta
+
+    def __post_init__(self) -> None:
+        self.base_dir.mkdir(parents=True, exist_ok=True)
+        self.prune()
+
+    def put(self, entry_id: str, payload: dict[str, Any]) -> None:
+        data = dict(payload)
+        data["id"] = entry_id
+        data["updated_at"] = _utc_now().isoformat()
+        self._path(entry_id).write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    def get(self, entry_id: str) -> dict[str, Any] | None:
+        path = self._path(entry_id)
+        if not path.exists():
+            return None
+        try:
+            payload = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            path.unlink(missing_ok=True)
+            return None
+        created_at = _parse_utc(payload.get("created_at")) or _parse_utc(payload.get("updated_at"))
+        if created_at is None or _utc_now() - created_at > self.ttl:
+            path.unlink(missing_ok=True)
+            return None
+        return payload
+
+    def prune(self) -> None:
+        for path in self.base_dir.glob("*.json"):
+            try:
+                payload = json.loads(path.read_text(encoding="utf-8"))
+            except (OSError, json.JSONDecodeError):
+                path.unlink(missing_ok=True)
+                continue
+            created_at = _parse_utc(payload.get("created_at")) or _parse_utc(payload.get("updated_at"))
+            if created_at is None or _utc_now() - created_at > self.ttl:
+                path.unlink(missing_ok=True)
+
+    def list(self) -> list[dict[str, Any]]:
+        entries: list[dict[str, Any]] = []
+        self.prune()
+        for path in self.base_dir.glob("*.json"):
+            try:
+                payload = json.loads(path.read_text(encoding="utf-8"))
+            except (OSError, json.JSONDecodeError):
+                continue
+            created_at = _parse_utc(payload.get("created_at")) or _parse_utc(payload.get("updated_at"))
+            if created_at is None:
+                continue
+            entries.append(payload)
+        entries.sort(key=lambda item: item.get("created_at") or item.get("updated_at") or "", reverse=True)
+        return entries
+
+    def _path(self, entry_id: str) -> Path:
+        return self.base_dir / f"{_json_safe_key(entry_id)}.json"
+
+
+class ImportVerificationStore(_JsonEntryStore):
+    def __init__(self, base_dir: Path | None = None, *, ttl_seconds: int = 3600) -> None:
+        super().__init__(
+            base_dir=base_dir or _store_dir("QINGFLOW_MCP_IMPORT_VERIFY_HOME", "import-verifications"),
+            ttl=timedelta(seconds=ttl_seconds),
+        )
+
+
+class ImportJobStore(_JsonEntryStore):
+    def __init__(self, base_dir: Path | None = None, *, ttl_seconds: int = 24 * 3600) -> None:
+        super().__init__(
+            base_dir=base_dir or _store_dir("QINGFLOW_MCP_IMPORT_JOB_HOME", "import-jobs"),
+            ttl=timedelta(seconds=ttl_seconds),
+        )

package/src/qingflow_mcp/list_type_labels.py

@@ -20,6 +20,18 @@ RECORD_LIST_TYPE_LABELS: dict[int, str] = {
     16: "我发起的-已结束",
 }
 
+SYSTEM_VIEW_DEFINITIONS: tuple[tuple[str, int, str], ...] = (
+    ("system:all", 8, "全部数据"),
+    ("system:initiated", 14, "我发起的"),
+    ("system:todo", 1, "待办"),
+    ("system:done", 2, "已办"),
+    ("system:cc", 12, "抄送我的"),
+)
+
+SYSTEM_VIEW_ID_TO_LIST_TYPE: dict[str, int] = {view_id: list_type for view_id, list_type, _ in SYSTEM_VIEW_DEFINITIONS}
+SYSTEM_VIEW_ID_TO_NAME: dict[str, str] = {view_id: name for view_id, _, name in SYSTEM_VIEW_DEFINITIONS}
+SYSTEM_LIST_TYPE_TO_VIEW_ID: dict[int, str] = {list_type: view_id for view_id, list_type, _ in SYSTEM_VIEW_DEFINITIONS}
+
 TASK_TYPE_LABELS: dict[int, str] = {
     1: "待办",
     2: "我发起的",
@@ -40,6 +52,18 @@ def get_record_list_type_label(list_type: int | None) -> str | None:
     return RECORD_LIST_TYPE_LABELS.get(list_type)
 
 
+def get_system_view_id(list_type: int | None) -> str | None:
+    if list_type is None:
+        return None
+    return SYSTEM_LIST_TYPE_TO_VIEW_ID.get(list_type)
+
+
+def get_system_view_name(view_id: str | None) -> str | None:
+    if view_id is None:
+        return None
+    return SYSTEM_VIEW_ID_TO_NAME.get(view_id)
+
+
 def get_task_type_label(type_value: int | None) -> str | None:
     if type_value is None:
         return None

package/src/qingflow_mcp/server.py

@@ -1,61 +1,176 @@
 from __future__ import annotations
 
+from datetime import date
+
 from mcp.server.fastmcp import FastMCP
 
 from .backend_client import BackendClient
 from .session_store import SessionStore
 from .tools.app_tools import AppTools
 from .tools.auth_tools import AuthTools
+from .tools.feedback_tools import FeedbackTools
 from .tools.file_tools import FileTools
+from .tools.import_tools import ImportTools
 from .tools.package_tools import PackageTools
 from .tools.navigation_tools import NavigationTools
-from .tools.approval_tools import ApprovalTools
 from .tools.directory_tools import DirectoryTools
 from .tools.portal_tools import PortalTools
 from .tools.qingbi_report_tools import QingbiReportTools
 from .tools.record_tools import RecordTools
 from .tools.role_tools import RoleTools
 from .tools.solution_tools import SolutionTools
-from .tools.task_tools import TaskTools
+from .tools.task_context_tools import TaskContextTools
 from .tools.view_tools import ViewTools
 from .tools.workflow_tools import WorkflowTools
 from .tools.workspace_tools import WorkspaceTools
 
 
 def build_server() -> FastMCP:
+    today = date.today()
+    current_year = today.year
     server = FastMCP(
         "Qingflow MCP",
-        instructions=(
-            "Use auth_login first, then workspace_list and workspace_select. "
-            "All resource tools operate with the logged-in user's Qingflow permissions.\n\n"
-            "Task Center (待办/已办) handling:\n"
-            "- Use task_statistics to get counts of pending tasks (todo_count), timeouts, urged, etc.\n"
-            "- Use task_list to query tasks. Type values: 1=todo (待办), 2=initiated (我发起的), 3=cc (抄送), 5=done (已办).\n"
-            "- Use task_list_grouped to get tasks grouped by form/worksheet.\n"
-            "- Use task_mark_read to mark a specific task as read.\n"
-            "- Use task_urge to send an urgent reminder for a pending task.\n"
-            "- Process status values: 1=all, 2=processing, 3=passed, 4=refused, 5=need_supply, 6=urged, 7=timeout, 8=pre_timeout, 9=unread.\n"
-            "- After identifying the exact task node and record, use record_approve, record_reject, record_rollback, record_transfer, record_reassign, or record_countersign as needed."
-        ),
+        instructions=f"""Use this server for Qingflow operational workflows. Current date: `{today.isoformat()}`.
+
+## Authentication
+
+Use `auth_login` first, then `workspace_list` and `workspace_select`.
+All resource tools operate with the logged-in user's Qingflow permissions.
+
+## Shared Helper
+
+`feedback_submit` is always available as a cross-cutting helper.
+
+- Use it when the current MCP capability is unsupported, awkward, or still cannot satisfy the user's need after reasonable use.
+- It does not require Qingflow login or workspace selection.
+- Call it only after the user explicitly confirms submission.
+
+## App Discovery
+
+If `app_key` is unknown, use `app_list` or `app_search` first.
+If the app is known but the data range is not, use `app_get` first and choose from `accessible_views`.
+If an accessible view has `analysis_supported=false`, do not use it for `record_list` or `record_analyze`. `boardView` and `ganttView` are special UI views, not list/analyze targets.
+
+## Schema-First Rule
+
+Call `record_schema_get(schema_mode="applicant")` before `record_write`.
+Call `app_get` first when the data range is unclear, then use `record_schema_get(schema_mode="browse", view_id=...)` before `record_list`, `record_get`, or `record_analyze`.
+
+- All `field_id` values must come from the schema response.
+- Never guess field names or ids.
+
+## Schema Scope
+
+`record_schema_get(schema_mode="applicant")` returns the current user's applicant-node visible fields for write/create.
+`record_schema_get(schema_mode="browse", view_id=...)` returns browse-schema fields for the selected accessible view.
+
+- Hidden fields are omitted.
+- Missing fields mean the field is not visible in the current permission scope.
+- Read `fields` and `suggested_*` from the top level of the schema response.
+
+## Analytics Path
+
+`app_get -> record_schema_get(schema_mode="browse", view_id=...) -> record_analyze`
+
+Prefer `view_id` entries from `accessible_views` where `analysis_supported=true`.
+
+Use this DSL shape:
+
+- `dimensions`: `{{field_id, alias, bucket}}`
+- `metrics`: `{{op, field_id, alias}}`
+- `filters`: `{{field_id, op, value}}`
+- `sort`: `{{by, order}}`
+
+Important key rules:
+
+- Use `op`
+- Do **not** use `type`
+- Do **not** use `agg`
+- Do **not** use `aggregation`
+- Do **not** use `operator`
+
+Analysis answers must include concrete numbers. When applicable, include percentages based on the returned totals.
+
+## Record CRUD Path
+
+`app_get -> record_schema_get(schema_mode="browse", view_id=...) -> record_list / record_get`
+`record_schema_get(schema_mode="applicant") -> record_write`
+
+- Use `columns` as `[{{field_id}}]`
+- Use `where` items as `{{field_id, op, value}}`
+- Use `order_by` items as `{{field_id, direction}}`
+- Legacy forms such as bare integer `field_id`, `fieldId`, `operator`, `values`, or `order` may still parse, but they are compatibility-only and not the canonical DSL
+
+`record_write` uses SQL-like JSON clauses:
+
+- `insert` -> `values`
+- `update` -> `record_id + set`
+- `delete` -> `record_id` or `record_ids`
+
+- Read relation targets from `record_schema_get.target_app_key` / `target_app_name` before preparing relation writes.
+- If a member or department field id is known but candidate ids are not, use `record_member_candidates` or `record_department_candidates` before `record_write`.
+- For default-all member or department fields, prefer those field candidate tools instead of starting with `directory_*`.
+
+## Import Path
+
+`record_import_template_get -> record_import_verify -> (optional authorized record_import_repair_local) -> record_import_start -> record_import_status_get`
+
+- Import must go through `verify -> start`; do not start directly from a raw file path.
+- `record_import_start` requires an explicit `being_enter_auditing` choice. Do not assume a default.
+- Do not modify user-uploaded files unless the user explicitly authorizes repair.
+- If repair is authorized, keep the original file and repair a copy, then run `record_import_verify` again before `record_import_start`.
+
+## Task Workflow Path
+
+`task_list -> task_get -> task_action_execute`
+
+- Use `task_associated_report_detail_get` for associated view or report details.
+- Use `task_workflow_log_get` for full workflow log history.
+- Task actions operate on `app_key + record_id + workflow_node_id`, not `task_id`.
+
+## Time Handling
+
+Normalize relative dates before building DSL.
+
+- If the user says `3月` without a year, use the current year: `{current_year}`
+- Convert month-only phrases into explicit legal date ranges
+- Never send impossible dates such as `2026-02-29`
+
+## Environment
+
+Default to `prod` unless the user explicitly specifies `test`.
+
+## Constraints
+
+Avoid builder-side app or schema changes here.
+
+## Feedback Path
+
+If the current MCP capability is unsupported, the workflow is awkward, or the user's need still cannot be satisfied after reasonable use, offer to submit product feedback.
+
+- First summarize what is still not working
+- Ask the user whether to submit feedback
+- Call `feedback_submit` only after explicit user confirmation""",
     )
     sessions = SessionStore()
     backend = BackendClient()
     AuthTools(sessions, backend).register(server)
+    FeedbackTools(backend, mcp_side="通用").register(server)
     WorkspaceTools(sessions, backend).register(server)
     FileTools(sessions, backend).register(server)
+    ImportTools(sessions, backend).register(server)
     RecordTools(sessions, backend).register(server)
+    TaskContextTools(sessions, backend).register(server)
     RoleTools(sessions, backend).register(server)
     AppTools(sessions, backend).register(server)
     QingbiReportTools(sessions, backend).register(server)
     PackageTools(sessions, backend).register(server)
     NavigationTools(sessions, backend).register(server)
-    ApprovalTools(sessions, backend).register(server)
     PortalTools(sessions, backend).register(server)
     DirectoryTools(sessions, backend).register(server)
     WorkflowTools(sessions, backend).register(server)
     ViewTools(sessions, backend).register(server)
     SolutionTools(sessions, backend).register(server)
-    TaskTools(sessions, backend).register(server)
     return server
 
 

package/src/qingflow_mcp/server_app_builder.py

@@ -7,6 +7,7 @@ from .config import DEFAULT_PROFILE
 from .session_store import SessionStore
 from .tools.ai_builder_tools import AiBuilderTools
 from .tools.auth_tools import AuthTools
+from .tools.feedback_tools import FeedbackTools
 from .tools.file_tools import FileTools
 from .tools.workspace_tools import WorkspaceTools
 
@@ -16,13 +17,18 @@ def build_builder_server() -> FastMCP:
         "Qingflow App Builder MCP",
         instructions=(
             "Use this server for AI-native Qingflow builder workflows. "
-            "Follow the resource path resolve -> summary read -> plan -> apply -> attach -> publish_verify. "
-            "Use package_resolve/package_list and app_resolve to locate resources, "
-            "app_read_summary/app_read_fields/app_read_layout_summary/app_read_views_summary/app_read_flow_summary for compact reads, "
-            "app_schema_plan/app_layout_plan/app_flow_plan/app_views_plan before writes when the target patch is non-trivial, "
-            "then app_schema_apply/app_layout_apply/app_flow_apply/app_views_apply to execute normalized patches; these apply tools publish by default unless publish=false. "
+            "`feedback_submit` is always available as a cross-cutting helper when the current capability is unsupported, awkward, or still cannot satisfy the user's need after reasonable use; it does not require Qingflow login or workspace selection, and it should be called only after explicit user confirmation. "
+            "Follow the resource path resolve -> summary read -> apply -> attach -> publish_verify. "
+            "Use builder_tool_contract when you need a machine-readable contract, aliases, allowed enums, or a minimal valid example for a public builder tool. "
+            "If creating a new package may be appropriate, ask the user to confirm package creation before calling package_create; otherwise use package_resolve/package_list and app_resolve to locate resources, "
+            "app_read_summary/app_read_fields/app_read_layout_summary/app_read_views_summary/app_read_flow_summary/app_read_charts_summary/portal_read_summary for compact reads, "
+            "member_search/role_search/role_create when workflow assignees must come from the directory or role catalog, preferring roles over explicit members unless the user explicitly names members, "
+            "then app_schema_apply/app_layout_apply/app_flow_apply/app_views_apply/app_charts_apply/portal_apply to execute normalized patches; these apply tools perform planning, normalization, and dependency checks internally where applicable. Schema/layout/views noop requests skip publish, charts are immediate-live without publish and resolve targets by chart_id first then exact unique chart name, portal updates are replace-only and publish=false only guarantees draft/base-info updates, and flow should use publish=false whenever you only want draft/precheck behavior. "
             "Use package_attach_app to attach apps to packages, and app_publish_verify for explicit final publish verification. "
-            "Do not handcraft internal solution payloads or rely on build_id/stage/repair."
+            "For workflow edits, keep the public builder surface on stable linear flows only: start/approve/fill/copy/webhook/end. Branch and condition nodes are intentionally disabled because the backend workflow route is not front-end stable for those node types. Declare node assignees and editable fields explicitly. "
+            "If builder writes are blocked by the current user's own edit lock, use app_release_edit_lock_if_mine with the lock owner details from the failed result. "
+            "Do not handcraft internal solution payloads or rely on build_id/stage/repair. "
+            "If the current MCP capability is unsupported, the workflow is awkward, or the user's need still cannot be satisfied after reasonable use, first summarize the gap, ask whether to submit feedback, and call feedback_submit only after explicit user confirmation."
         ),
     )
     sessions = SessionStore()
@@ -31,6 +37,7 @@ def build_builder_server() -> FastMCP:
     workspace = WorkspaceTools(sessions, backend)
     files = FileTools(sessions, backend)
     ai_builder = AiBuilderTools(sessions, backend)
+    feedback = FeedbackTools(backend, mcp_side="App Builder MCP")
 
     @server.tool()
     def auth_login(
@@ -116,6 +123,8 @@ def build_builder_server() -> FastMCP:
             file_related_url=file_related_url,
         )
 
+    feedback.register(server)
+
     @server.tool()
     def package_list(profile: str = DEFAULT_PROFILE, trial_status: str = "all") -> dict:
         return ai_builder.package_list(profile=profile, trial_status=trial_status)
@@ -124,6 +133,57 @@ def build_builder_server() -> FastMCP:
     def package_resolve(profile: str = DEFAULT_PROFILE, package_name: str = "") -> dict:
         return ai_builder.package_resolve(profile=profile, package_name=package_name)
 
+    @server.tool()
+    def builder_tool_contract(tool_name: str = "") -> dict:
+        return ai_builder.builder_tool_contract(tool_name=tool_name)
+
+    @server.tool()
+    def package_create(profile: str = DEFAULT_PROFILE, package_name: str = "") -> dict:
+        return ai_builder.package_create(profile=profile, package_name=package_name)
+
+    @server.tool()
+    def member_search(
+        profile: str = DEFAULT_PROFILE,
+        query: str = "",
+        page_num: int = 1,
+        page_size: int = 20,
+        contain_disable: bool = False,
+    ) -> dict:
+        return ai_builder.member_search(
+            profile=profile,
+            query=query,
+            page_num=page_num,
+            page_size=page_size,
+            contain_disable=contain_disable,
+        )
+
+    @server.tool()
+    def role_search(
+        profile: str = DEFAULT_PROFILE,
+        keyword: str = "",
+        page_num: int = 1,
+        page_size: int = 20,
+    ) -> dict:
+        return ai_builder.role_search(profile=profile, keyword=keyword, page_num=page_num, page_size=page_size)
+
+    @server.tool()
+    def role_create(
+        profile: str = DEFAULT_PROFILE,
+        role_name: str = "",
+        member_uids: list[int] | None = None,
+        member_emails: list[str] | None = None,
+        member_names: list[str] | None = None,
+        role_icon: str = "ex-user-outlined",
+    ) -> dict:
+        return ai_builder.role_create(
+            profile=profile,
+            role_name=role_name,
+            member_uids=member_uids or [],
+            member_emails=member_emails or [],
+            member_names=member_names or [],
+            role_icon=role_icon,
+        )
+
     @server.tool()
     def package_attach_app(
         profile: str = DEFAULT_PROFILE,
@@ -133,6 +193,20 @@ def build_builder_server() -> FastMCP:
     ) -> dict:
         return ai_builder.package_attach_app(profile=profile, tag_id=tag_id, app_key=app_key, app_title=app_title)
 
+    @server.tool()
+    def app_release_edit_lock_if_mine(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        lock_owner_email: str = "",
+        lock_owner_name: str = "",
+    ) -> dict:
+        return ai_builder.app_release_edit_lock_if_mine(
+            profile=profile,
+            app_key=app_key,
+            lock_owner_email=lock_owner_email,
+            lock_owner_name=lock_owner_name,
+        )
+
     @server.tool()
     def app_resolve(
         profile: str = DEFAULT_PROFILE,
@@ -163,76 +237,16 @@ def build_builder_server() -> FastMCP:
         return ai_builder.app_read_flow_summary(profile=profile, app_key=app_key)
 
     @server.tool()
-    def app_schema_plan(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        package_tag_id: int | None = None,
-        app_name: str = "",
-        create_if_missing: bool = False,
-        add_fields: list[dict] | None = None,
-        update_fields: list[dict] | None = None,
-        remove_fields: list[dict] | None = None,
-    ) -> dict:
-        return ai_builder.app_schema_plan(
-            profile=profile,
-            app_key=app_key,
-            package_tag_id=package_tag_id,
-            app_name=app_name,
-            create_if_missing=create_if_missing,
-            add_fields=add_fields or [],
-            update_fields=update_fields or [],
-            remove_fields=remove_fields or [],
-        )
+    def app_read_charts_summary(profile: str = DEFAULT_PROFILE, app_key: str = "") -> dict:
+        return ai_builder.app_read_charts_summary(profile=profile, app_key=app_key)
 
     @server.tool()
-    def app_layout_plan(
+    def portal_read_summary(
         profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        mode: str = "merge",
-        sections: list[dict] | None = None,
-        preset: str | None = None,
+        dash_key: str = "",
+        being_draft: bool = True,
     ) -> dict:
-        return ai_builder.app_layout_plan(
-            profile=profile,
-            app_key=app_key,
-            mode=mode,
-            sections=sections or [],
-            preset=preset,
-        )
-
-    @server.tool()
-    def app_flow_plan(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        mode: str = "replace",
-        nodes: list[dict] | None = None,
-        transitions: list[dict] | None = None,
-        preset: str | None = None,
-    ) -> dict:
-        return ai_builder.app_flow_plan(
-            profile=profile,
-            app_key=app_key,
-            mode=mode,
-            nodes=nodes or [],
-            transitions=transitions or [],
-            preset=preset,
-        )
-
-    @server.tool()
-    def app_views_plan(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        upsert_views: list[dict] | None = None,
-        remove_views: list[str] | None = None,
-        preset: str | None = None,
-    ) -> dict:
-        return ai_builder.app_views_plan(
-            profile=profile,
-            app_key=app_key,
-            upsert_views=upsert_views or [],
-            remove_views=remove_views or [],
-            preset=preset,
-        )
+        return ai_builder.portal_read_summary(profile=profile, dash_key=dash_key, being_draft=being_draft)
 
     @server.tool()
     def app_schema_apply(
@@ -304,6 +318,52 @@ def build_builder_server() -> FastMCP:
             remove_views=remove_views or [],
         )
 
+    @server.tool()
+    def app_charts_apply(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        upsert_charts: list[dict] | None = None,
+        remove_chart_ids: list[str] | None = None,
+        reorder_chart_ids: list[str] | None = None,
+    ) -> dict:
+        return ai_builder.app_charts_apply(
+            profile=profile,
+            app_key=app_key,
+            upsert_charts=upsert_charts or [],
+            remove_chart_ids=remove_chart_ids or [],
+            reorder_chart_ids=reorder_chart_ids or [],
+        )
+
+    @server.tool()
+    def portal_apply(
+        profile: str = DEFAULT_PROFILE,
+        dash_key: str = "",
+        dash_name: str = "",
+        package_tag_id: int | None = None,
+        publish: bool = True,
+        sections: list[dict] | None = None,
+        auth: dict | None = None,
+        icon: str | None = None,
+        color: str | None = None,
+        hide_copyright: bool | None = None,
+        dash_global_config: dict | None = None,
+        config: dict | None = None,
+    ) -> dict:
+        return ai_builder.portal_apply(
+            profile=profile,
+            dash_key=dash_key,
+            dash_name=dash_name,
+            package_tag_id=package_tag_id,
+            publish=publish,
+            sections=sections or [],
+            auth=auth,
+            icon=icon,
+            color=color,
+            hide_copyright=hide_copyright,
+            dash_global_config=dash_global_config,
+            config=config or {},
+        )
+
     @server.tool()
     def app_publish_verify(
         profile: str = DEFAULT_PROFILE,