@qingflow-tech/qingflow-app-user-mcp 1.0.0

package/src/qingflow_mcp/response_trim.py

@@ -0,0 +1,470 @@
+from __future__ import annotations
+
+import json
+from copy import deepcopy
+from functools import wraps
+from typing import Any, Callable
+
+from .public_surface import (
+    BUILDER_DOMAIN,
+    USER_DOMAIN,
+    cli_trim_key_from_namespace,
+    server_method_map,
+    tool_key,
+)
+
+
+JSONObject = dict[str, Any]
+TransformFn = Callable[[JSONObject], None]
+
+
+COMMON_SUCCESS_DROP_TOP = {
+    "request_route",
+    "profile",
+    "ws_id",
+    "output_profile",
+    "qf_version_source",
+    "persisted",
+    "base_url",
+    "normalized_args",
+    "suggested_next_call",
+    "noop",
+    "allowed_values",
+    "missing_fields",
+    "ok",
+}
+
+COMMON_ERROR_DROP_TOP = {
+    "request_route",
+    "base_url",
+    "normalized_args",
+    "suggested_next_call",
+    "profile",
+    "ws_id",
+    "output_profile",
+    "qf_version_source",
+    "persisted",
+    "allowed_values",
+    "missing_fields",
+    "noop",
+    "ok",
+}
+
+SUCCESS_POLICY_BY_TOOL: dict[str, TransformFn] = {}
+
+
+def trim_public_response(tool_name: str | None, payload: dict[str, Any]) -> dict[str, Any]:
+    if not isinstance(payload, dict):
+        return payload
+    if _looks_like_failure_payload(payload):
+        return _trim_returned_failure(payload)
+    return trim_success_response(tool_name, payload)
+
+
+def trim_success_response(tool_name: str | None, payload: dict[str, Any]) -> dict[str, Any]:
+    if not isinstance(payload, dict):
+        return payload
+    trimmed = deepcopy(payload)
+    _drop_top_keys(trimmed, COMMON_SUCCESS_DROP_TOP)
+    transformer = SUCCESS_POLICY_BY_TOOL.get(tool_name or "")
+    if transformer is not None:
+        transformer(trimmed)
+    _drop_empty_optional_keys(trimmed)
+    return trimmed
+
+
+def trim_error_response(payload: dict[str, Any]) -> dict[str, Any]:
+    if not isinstance(payload, dict):
+        return payload
+    trimmed = deepcopy(payload)
+    _drop_top_keys(trimmed, COMMON_ERROR_DROP_TOP)
+    _drop_deep_keys(trimmed.get("details"), {"request_route", "base_url", "normalized_args", "suggested_next_call", "transport", "response", "body", "raw"})
+    details = trimmed.get("details")
+    if isinstance(details, dict):
+        compact_details = _compact_scalar_dict(details)
+        if compact_details:
+            trimmed["details"] = compact_details
+        else:
+            trimmed.pop("details", None)
+    if trimmed.get("backend_code") is not None:
+        trimmed.pop("http_status", None)
+    _drop_empty_optional_keys(trimmed)
+    return trimmed
+
+
+def wrap_trimmed_methods(instance: object, method_map: dict[str, str]) -> object:
+    for method_name, tool_name in method_map.items():
+        original = getattr(instance, method_name, None)
+        if original is None or not callable(original):
+            continue
+        setattr(instance, method_name, _wrap_callable(original, tool_name))
+    return instance
+
+
+def resolve_cli_tool_name(args: Any) -> str | None:
+    return cli_trim_key_from_namespace(args)
+
+
+USER_SERVER_METHOD_MAP = server_method_map(USER_DOMAIN)
+BUILDER_SERVER_METHOD_MAP = server_method_map(BUILDER_DOMAIN)
+
+
+def _wrap_callable(original: Callable[..., Any], tool_name: str) -> Callable[..., Any]:
+    @wraps(original)
+    def wrapped(*args: Any, **kwargs: Any) -> Any:
+        try:
+            result = original(*args, **kwargs)
+        except RuntimeError as exc:
+            payload = _parse_runtime_error_payload(exc)
+            if payload is None:
+                raise
+            raise RuntimeError(json.dumps(trim_error_response(payload), ensure_ascii=False)) from None
+        return trim_public_response(tool_name, result) if isinstance(result, dict) else result
+
+    return wrapped
+
+
+def _parse_runtime_error_payload(exc: RuntimeError) -> dict[str, Any] | None:
+    raw = str(exc)
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError:
+        return None
+    return payload if isinstance(payload, dict) else None
+
+
+def _looks_like_failure_payload(payload: dict[str, Any]) -> bool:
+    if payload.get("ok") is False:
+        return True
+    status = str(payload.get("status") or "").lower()
+    return status in {"failed", "blocked", "verification_failed"}
+
+
+def _trim_returned_failure(payload: dict[str, Any]) -> dict[str, Any]:
+    trimmed = deepcopy(payload)
+    _drop_top_keys(trimmed, COMMON_ERROR_DROP_TOP)
+    _drop_deep_keys(trimmed.get("details"), {"request_route", "base_url", "normalized_args", "suggested_next_call", "transport", "response", "body", "raw"})
+    details = trimmed.get("details")
+    if isinstance(details, dict):
+        compact_details = _compact_scalar_dict(details)
+        if compact_details:
+            trimmed["details"] = compact_details
+        else:
+            trimmed.pop("details", None)
+    if trimmed.get("backend_code") is not None:
+        trimmed.pop("http_status", None)
+    _drop_empty_optional_keys(trimmed)
+    return trimmed
+
+
+def _drop_top_keys(payload: JSONObject, keys: set[str]) -> None:
+    for key in keys:
+        payload.pop(key, None)
+
+
+def _drop_empty_optional_keys(payload: JSONObject) -> None:
+    for key in ("warnings", "verification", "details"):
+        value = payload.get(key)
+        if value in (None, [], {}, ""):
+            payload.pop(key, None)
+
+
+def _compact_scalar_dict(payload: dict[str, Any]) -> dict[str, Any]:
+    compact: dict[str, Any] = {}
+    for key, value in payload.items():
+        if isinstance(value, (str, int, float, bool)) or value is None:
+            compact[key] = value
+            continue
+        if isinstance(value, dict):
+            nested = {
+                nested_key: nested_value
+                for nested_key, nested_value in value.items()
+                if isinstance(nested_value, (str, int, float, bool)) or nested_value is None
+            }
+            if nested:
+                compact[key] = nested
+    return compact
+
+
+def _trim_item_list(payload: JSONObject, key: str, *, allowed: tuple[str, ...]) -> None:
+    items = payload.get(key)
+    if not isinstance(items, list):
+        return
+    payload[key] = [_pick(item, allowed) for item in items if isinstance(item, dict)]
+
+
+def _trim_nested_item_list(payload: JSONObject, path: tuple[str, ...], *, allowed: tuple[str, ...]) -> None:
+    parent = _nested_dict(payload, path[:-1])
+    if not isinstance(parent, dict):
+        return
+    key = path[-1]
+    items = parent.get(key)
+    if not isinstance(items, list):
+        return
+    parent[key] = [_pick(item, allowed) for item in items if isinstance(item, dict)]
+
+
+def _keep_nested_keys(payload: JSONObject, path: tuple[str, ...], *, allowed: tuple[str, ...]) -> None:
+    parent = _nested_dict(payload, path[:-1])
+    if not isinstance(parent, dict):
+        return
+    node = parent.get(path[-1])
+    if isinstance(node, dict):
+        parent[path[-1]] = _pick(node, allowed)
+
+
+def _drop_nested_keys(payload: JSONObject, path: tuple[str, ...], *, keys: tuple[str, ...]) -> None:
+    parent = _nested_dict(payload, path[:-1])
+    if not isinstance(parent, dict):
+        return
+    node = parent.get(path[-1])
+    if not isinstance(node, dict):
+        return
+    for key in keys:
+        node.pop(key, None)
+
+
+def _drop_deep_keys(payload: Any, keys: set[str]) -> None:
+    if isinstance(payload, dict):
+        for key in list(payload.keys()):
+            if key in keys:
+                payload.pop(key, None)
+                continue
+            _drop_deep_keys(payload.get(key), keys)
+    elif isinstance(payload, list):
+        for item in payload:
+            _drop_deep_keys(item, keys)
+
+
+def _nested_dict(payload: JSONObject, path: tuple[str, ...]) -> JSONObject | None:
+    node: Any = payload
+    for key in path:
+        if not isinstance(node, dict):
+            return None
+        node = node.get(key)
+    return node if isinstance(node, dict) else None
+
+
+def _pick(payload: JSONObject, allowed: tuple[str, ...]) -> JSONObject:
+    return {key: payload.get(key) for key in allowed if key in payload}
+
+
+def _trim_auth_payload(payload: JSONObject) -> None:
+    pass
+
+
+def _trim_auth_logout(payload: JSONObject) -> None:
+    pass
+
+
+def _trim_workspace_list(payload: JSONObject) -> None:
+    page = payload.get("page")
+    if isinstance(page, dict):
+        _trim_item_list(page, "list", allowed=("wsId", "workspaceName", "remark"))
+
+
+def _trim_app_search_like(payload: JSONObject) -> None:
+    payload.pop("apps", None)
+    _trim_item_list(payload, "items", allowed=("app_key", "app_name", "package_name"))
+
+
+def _trim_app_get(payload: JSONObject) -> None:
+    _trim_builder_envelope(payload)
+    _trim_nested_item_list(
+        payload,
+        ("data", "accessible_views"),
+        allowed=("view_id", "name", "analysis_supported", "list_supported", "kind"),
+    )
+
+
+def _trim_file_upload_info(payload: JSONObject) -> None:
+    pass
+
+
+def _trim_file_upload_local(payload: JSONObject) -> None:
+    payload.pop("result", None)
+    payload.pop("upload_result", None)
+
+
+def _trim_import_schema(payload: JSONObject) -> None:
+    pass
+
+
+def _trim_record_schema(payload: JSONObject) -> None:
+    payload.pop("legacy_schema", None)
+
+
+def _trim_record_write(payload: JSONObject) -> None:
+    data = payload.get("data")
+    if not isinstance(data, dict):
+        return
+    data.pop("normalized_payload", None)
+    data.pop("human_review", None)
+    data.pop("action", None)
+
+
+def _trim_record_get(payload: JSONObject) -> None:
+    _keep_nested_keys(payload, ("data", "selection", "view"), allowed=("view_id", "name"))
+    _drop_nested_keys(payload, ("data", "selection"), keys=("columns", "workflow_node_id"))
+
+
+def _trim_record_list(payload: JSONObject) -> None:
+    _keep_nested_keys(payload, ("data", "selection", "view"), allowed=("view_id", "name"))
+    _drop_nested_keys(payload, ("data", "selection"), keys=("columns",))
+
+
+def _trim_record_analyze(payload: JSONObject) -> None:
+    _drop_deep_keys(payload, {"debug"})
+
+
+def _trim_code_block_schema(payload: JSONObject) -> None:
+    payload.pop("legacy_schema", None)
+    _trim_nested_item_list(payload, ("code_block_fields",), allowed=("title", "selector", "bound_output_fields", "configured_aliases"))
+
+
+def _trim_code_block_run(payload: JSONObject) -> None:
+    _drop_deep_keys(payload, {"debug", "request_route"})
+
+
+def _trim_task_list(payload: JSONObject) -> None:
+    _drop_nested_keys(payload, ("data", "selection"), keys=("query",))
+
+
+def _trim_task_get(payload: JSONObject) -> None:
+    _drop_deep_keys(payload, {"request_route", "output_profile"})
+
+
+def _trim_directory(payload: JSONObject) -> None:
+    pass
+
+
+def _trim_feedback(payload: JSONObject) -> None:
+    payload.pop("normalized_payload", None)
+
+
+def _trim_builder_envelope(payload: JSONObject) -> None:
+    if str(payload.get("status") or "").lower() == "success":
+        details = payload.get("details")
+        if isinstance(details, dict):
+            _drop_deep_keys(details, {"request_route", "base_url", "normalized_args", "suggested_next_call", "transport", "response", "body", "raw"})
+            compact = _compact_scalar_dict(details)
+            if compact:
+                payload["details"] = compact
+            else:
+                payload.pop("details", None)
+
+
+def _trim_builder_list_like(payload: JSONObject) -> None:
+    _trim_builder_envelope(payload)
+
+
+def _register_policy(domains: tuple[str, ...], names: tuple[str, ...], transform: TransformFn) -> None:
+    for domain in domains:
+        for name in names:
+            SUCCESS_POLICY_BY_TOOL[tool_key(domain, name)] = transform
+
+
+_register_policy((USER_DOMAIN, BUILDER_DOMAIN), ("auth_use_credential", "auth_whoami"), _trim_auth_payload)
+_register_policy((USER_DOMAIN, BUILDER_DOMAIN), ("auth_logout",), _trim_auth_logout)
+_register_policy((USER_DOMAIN, BUILDER_DOMAIN), ("workspace_list",), _trim_workspace_list)
+_register_policy((USER_DOMAIN,), ("app_list", "app_search"), _trim_app_search_like)
+_register_policy((USER_DOMAIN, BUILDER_DOMAIN), ("app_get",), _trim_app_get)
+_register_policy((BUILDER_DOMAIN,), ("app_repair_code_blocks",), _trim_builder_list_like)
+_register_policy((USER_DOMAIN, BUILDER_DOMAIN), ("portal_list", "portal_get", "view_get", "chart_get"), _trim_builder_list_like)
+_register_policy((USER_DOMAIN,), ("file_get_upload_info",), _trim_file_upload_info)
+_register_policy((USER_DOMAIN, BUILDER_DOMAIN), ("file_upload_local",), _trim_file_upload_local)
+_register_policy(
+    (USER_DOMAIN,),
+    (
+        "record_import_schema_get",
+        "record_import_template_get",
+        "record_import_verify",
+        "record_import_repair_local",
+        "record_import_start",
+        "record_import_status_get",
+    ),
+    _trim_import_schema,
+)
+_register_policy(
+    (USER_DOMAIN,),
+    (
+        "record_schema_get",
+        "record_insert_schema_get",
+        "record_browse_schema_get",
+        "record_update_schema_get",
+        "record_code_block_schema_get",
+    ),
+    _trim_record_schema,
+)
+_register_policy((USER_DOMAIN,), ("record_insert", "record_update"), _trim_record_write)
+_register_policy((USER_DOMAIN,), ("record_get",), _trim_record_get)
+_register_policy((USER_DOMAIN,), ("record_list",), _trim_record_list)
+_register_policy((USER_DOMAIN,), ("record_analyze",), _trim_record_analyze)
+_register_policy((USER_DOMAIN,), ("record_code_block_run",), _trim_code_block_run)
+_register_policy((USER_DOMAIN,), ("task_list",), _trim_task_list)
+_register_policy(
+    (USER_DOMAIN,),
+    (
+        "task_get",
+        "task_action_execute",
+        "task_associated_report_detail_get",
+        "task_workflow_log_get",
+    ),
+    _trim_task_get,
+)
+_register_policy(
+    (USER_DOMAIN,),
+    (
+        "directory_search",
+        "directory_list_internal_users",
+        "directory_list_all_internal_users",
+        "directory_list_internal_departments",
+        "directory_list_all_departments",
+        "directory_list_sub_departments",
+        "directory_list_external_members",
+    ),
+    _trim_directory,
+)
+_register_policy((USER_DOMAIN, BUILDER_DOMAIN), ("feedback_submit",), _trim_feedback)
+_register_policy(
+    (USER_DOMAIN,),
+    (
+        "record_member_candidates",
+        "record_department_candidates",
+        "record_delete",
+    ),
+    _trim_builder_list_like,
+)
+_register_policy(
+    (BUILDER_DOMAIN,),
+    (
+        "builder_tool_contract",
+        "package_get",
+        "package_apply",
+        "solution_install",
+        "member_search",
+        "role_search",
+        "role_create",
+        "app_release_edit_lock_if_mine",
+        "app_resolve",
+        "app_custom_button_list",
+        "app_custom_button_get",
+        "app_custom_button_create",
+        "app_custom_button_update",
+        "app_custom_button_delete",
+        "app_get_fields",
+        "app_repair_code_blocks",
+        "app_get_layout",
+        "app_get_views",
+        "app_get_flow",
+        "app_get_charts",
+        "app_schema_apply",
+        "app_layout_apply",
+        "app_flow_apply",
+        "app_views_apply",
+        "app_charts_apply",
+        "portal_apply",
+        "app_publish_verify",
+    ),
+    _trim_builder_list_like,
+)

package/src/qingflow_mcp/server.py

@@ -0,0 +1,212 @@
+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.code_block_tools import CodeBlockTools
+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.directory_tools import DirectoryTools
+from .tools.portal_tools import PortalTools
+from .tools.qingbi_report_tools import QingbiReportTools
+from .tools.role_tools import RoleTools
+from .tools.solution_tools import SolutionTools
+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=f"""Use this server for Qingflow operational workflows. Current date: `{today.isoformat()}`.
+
+## Authentication
+
+Use `auth_use_credential` first when a local host such as createClaw can provide a credential. Treat the returned `wsId` and `qfVersion` as authoritative for the local session.
+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_insert_schema_get` before `record_insert`.
+Call `record_update_schema_get` before `record_update`.
+Call `record_code_block_schema_get` before `record_code_block_run`.
+Call `app_get` first when the data range is unclear, then use `record_browse_schema_get(view_id=...)` before `record_list`, `record_get`, or `record_analyze`.
+Call `record_import_schema_get` when the import field mapping is unclear before template download or verify.
+
+- All `field_id` values must come from the schema response.
+- Never guess field names or ids.
+
+## Schema Scope
+
+`record_insert_schema_get` returns the current user's insert-ready applicant schema; read `required_fields`, `optional_fields`, `runtime_linked_required_fields`, and `payload_template`.
+`record_update_schema_get` returns the current record's overall update-ready writable field set across matched accessible views; read `writable_fields` and `payload_template`.
+`record_browse_schema_get(view_id=...)` returns browse-schema fields for the selected accessible view.
+`record_code_block_schema_get` returns code-block-ready schema for exact code block field selection.
+`record_import_schema_get` returns import-ready column metadata.
+
+- Hidden fields are omitted.
+- Missing fields mean the field is not visible in the current permission scope.
+- Read the top-level schema payload directly; do not guess missing writable fields.
+
+## Analytics Path
+
+`app_get -> record_browse_schema_get(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_browse_schema_get(view_id=...) -> record_list / record_get`
+`record_insert_schema_get -> record_insert`
+`record_update_schema_get -> record_update`
+`record_list / record_get -> record_delete`
+`record_code_block_schema_get -> record_code_block_run`
+
+- 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_insert` uses an applicant-node `fields` map keyed by field title.
+- `record_update` uses a field-title keyed `fields` map and internally selects the first accessible view that can execute the current payload.
+- For insert, `runtime_linked_required_fields` means required-but-not-directly-writable fields that are usually supplied by runtime linkage or upstream context.
+- For insert, fields marked `may_become_required=true` stay in `optional_fields`; they are still directly writable, but linked visibility or option-driven rules can make them required at runtime.
+- Read field-level `linkage` whenever present on `record_insert_schema_get` or `record_update_schema_get`; it is the static hint for linked visibility, reference-driven auto fill, and formula/default auto-fill behavior.
+- `linkage.sources` lists upstream field titles that influence the current field; `linkage.affects_fields` lists downstream fields that may change when the current field changes.
+- `linkage.kind=logic_visibility` means linked visibility or option-driven rules are involved; `linkage.kind=reference_fill` means reference/default matching logic is involved; `linkage.kind=formula_fill` means formula/default auto-fill logic is involved.
+- `record_update_schema_get` exposes the overall writable field set for the record, but not every field combination is guaranteed; `record_update` still needs one single matched accessible view that can cover the payload.
+- `record_delete` deletes by `record_id` or `record_ids`.
+- When readback shape matters after insert or update, prefer `record_get(..., output_profile="normalized")` or `record_list(..., output_profile="normalized")`.
+
+- Read relation targets from `record_insert_schema_get` / `record_update_schema_get` relation metadata before preparing relation writes.
+- Member and department fields may be written with natural strings directly on `record_insert` / `record_update`; only fall back to `record_member_candidates` or `record_department_candidates` when the user wants explicit candidate browsing or the write returns ambiguity that needs confirmation.
+- If explicit candidate browsing is needed for default-all member or department fields, prefer those field candidate tools instead of starting with `directory_*`.
+
+## Code Block Path
+
+Use `record_code_block_run` when the user wants to execute a form code-block field against an existing record.
+
+- Always resolve the exact code-block field from `record_code_block_schema_get` first.
+- Treat code-block execution as write-capable, not read-only.
+- If the code block is bound to relation outputs, Qingflow may calculate target answers and write them back automatically.
+- For safe debugging, pass `apply_writeback=false` and inspect the parsed alias results plus `relation.calculated_answers_preview` before allowing any writeback.
+- In workflow context, pass `role=3` and the exact `workflow_node_id`.
+- After execution, inspect `outputs.configured_aliases`, `outputs.alias_results`, `outputs.alias_map`, `relation.target_fields`, and `writeback.verification` before claiming success.
+
+## Import Path
+
+`app_get -> record_import_schema_get -> record_import_template_get -> record_import_verify -> (optional authorized record_import_repair_local) -> record_import_start -> record_import_status_get`
+
+- Check `app_get.data.import_capability` before doing import work.
+- If `import_capability.can_import=false`, stop before template download, file repair, or import start.
+- 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)
+    CodeBlockTools(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)
+    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)
+    return server
+
+
+mcp = build_server()
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()