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

package/src/qingflow_mcp/response_trim.py

@@ -0,0 +1,668 @@
+from __future__ import annotations
+
+import json
+from copy import deepcopy
+from functools import wraps
+from typing import Any, Callable
+
+
+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:
+    command = getattr(args, "command", None)
+    if command == "auth":
+        return {
+            "login": "auth_login",
+            "use-token": "auth_use_token",
+            "whoami": "auth_whoami",
+            "logout": "auth_logout",
+        }.get(getattr(args, "auth_command", None))
+    if command == "workspace":
+        return {
+            "list": "workspace_list",
+            "select": "workspace_select",
+        }.get(getattr(args, "workspace_command", None))
+    if command == "app":
+        return {
+            "list": "app_list",
+            "search": "app_search",
+            "get": "app_get",
+        }.get(getattr(args, "app_command", None))
+    if command == "record":
+        record_command = getattr(args, "record_command", None)
+        if record_command == "schema":
+            return {
+                "applicant": "record_schema_get",
+                "browse": "record_browse_schema_get",
+                "insert": "record_insert_schema_get",
+                "update": "record_update_schema_get",
+                "import": "record_import_schema_get",
+                "code-block": "record_code_block_schema_get",
+            }.get(getattr(args, "record_schema_command", None))
+        return {
+            "list": "record_list",
+            "get": "record_get",
+            "insert": "record_insert",
+            "update": "record_update",
+            "delete": "record_delete",
+            "analyze": "record_analyze",
+            "code-block-run": "record_code_block_run",
+        }.get(record_command)
+    if command == "import":
+        return {
+            "template": "record_import_template_get",
+            "verify": "record_import_verify",
+            "repair": "record_import_repair_local",
+            "start": "record_import_start",
+            "status": "record_import_status_get",
+        }.get(getattr(args, "import_command", None))
+    if command == "task":
+        return {
+            "list": "task_list",
+            "get": "task_get",
+            "action": "task_action_execute",
+            "log": "task_workflow_log_get",
+        }.get(getattr(args, "task_command", None))
+    if command not in {"builder", "build"}:
+        return None
+    builder_command = getattr(args, "builder_command", None)
+    if builder_command == "contract":
+        return "builder_tool_contract"
+    if builder_command == "member":
+        return {
+            "search": "member_search",
+        }.get(getattr(args, "builder_member_command", None))
+    if builder_command == "role":
+        return {
+            "search": "role_search",
+            "create": "role_create",
+        }.get(getattr(args, "builder_role_command", None))
+    if builder_command == "package":
+        return {
+            "list": "package_list",
+            "resolve": "package_resolve",
+            "create": "package_create",
+            "attach-app": "package_attach_app",
+        }.get(getattr(args, "builder_package_command", None))
+    if builder_command == "app":
+        return {
+            "resolve": "app_resolve",
+            "release-edit-lock-if-mine": "app_release_edit_lock_if_mine",
+            "read-summary": "app_read_summary",
+            "read-fields": "app_read_fields",
+            "read-layout": "app_read_layout_summary",
+            "read-views": "app_read_views_summary",
+            "read-flow": "app_read_flow_summary",
+            "read-charts": "app_read_charts_summary",
+        }.get(getattr(args, "builder_app_command", None))
+    if builder_command == "button":
+        return {
+            "list": "app_custom_button_list",
+            "get": "app_custom_button_get",
+            "create": "app_custom_button_create",
+            "update": "app_custom_button_update",
+            "delete": "app_custom_button_delete",
+        }.get(getattr(args, "builder_button_command", None))
+    if builder_command == "portal":
+        return {
+            "list": "portal_list",
+            "get": "portal_get",
+            "read-summary": "portal_read_summary",
+            "apply": "portal_apply",
+        }.get(getattr(args, "builder_portal_command", None))
+    if builder_command == "view":
+        return {
+            "get": "view_get",
+        }.get(getattr(args, "builder_view_command", None))
+    if builder_command == "chart":
+        return {
+            "get": "chart_get",
+        }.get(getattr(args, "builder_chart_command", None))
+    if builder_command == "schema":
+        return {"apply": "app_schema_apply"}.get(getattr(args, "builder_schema_command", None))
+    if builder_command == "layout":
+        return {"apply": "app_layout_apply"}.get(getattr(args, "builder_layout_command", None))
+    if builder_command == "views":
+        return {"apply": "app_views_apply"}.get(getattr(args, "builder_views_command", None))
+    if builder_command == "flow":
+        return {"apply": "app_flow_apply"}.get(getattr(args, "builder_flow_command", None))
+    if builder_command == "charts":
+        return {"apply": "app_charts_apply"}.get(getattr(args, "builder_charts_command", None))
+    if builder_command == "publish":
+        return {"verify": "app_publish_verify"}.get(getattr(args, "builder_publish_command", None))
+    return None
+
+
+USER_SERVER_METHOD_MAP = {
+    "auth_login": "auth_login",
+    "auth_use_token": "auth_use_token",
+    "auth_whoami": "auth_whoami",
+    "auth_logout": "auth_logout",
+    "workspace_list": "workspace_list",
+    "workspace_select": "workspace_select",
+    "app_list": "app_list",
+    "app_search": "app_search",
+    "app_get": "app_get",
+    "file_get_upload_info": "file_get_upload_info",
+    "file_upload_local": "file_upload_local",
+    "feedback_submit": "feedback_submit",
+    "record_import_schema_get": "record_import_schema_get",
+    "record_import_template_get": "record_import_template_get",
+    "record_import_verify": "record_import_verify",
+    "record_import_repair_local": "record_import_repair_local",
+    "record_import_start": "record_import_start",
+    "record_import_status_get": "record_import_status_get",
+    "record_insert_schema_get_public": "record_insert_schema_get",
+    "record_member_candidates": "record_member_candidates",
+    "record_department_candidates": "record_department_candidates",
+    "record_analyze": "record_analyze",
+    "record_list": "record_list",
+    "record_get_public": "record_get",
+    "record_browse_schema_get_public": "record_browse_schema_get",
+    "record_update_schema_get_public": "record_update_schema_get",
+    "record_insert_public": "record_insert",
+    "record_update_public": "record_update",
+    "record_delete_public": "record_delete",
+    "record_code_block_schema_get_public": "record_code_block_schema_get",
+    "record_code_block_run": "record_code_block_run",
+    "task_list": "task_list",
+    "task_get": "task_get",
+    "task_action_execute": "task_action_execute",
+    "task_associated_report_detail_get": "task_associated_report_detail_get",
+    "task_workflow_log_get": "task_workflow_log_get",
+    "directory_search": "directory_search",
+    "directory_list_internal_users": "directory_list_internal_users",
+    "directory_list_all_internal_users": "directory_list_all_internal_users",
+    "directory_list_internal_departments": "directory_list_internal_departments",
+    "directory_list_all_departments": "directory_list_all_departments",
+    "directory_list_sub_departments": "directory_list_sub_departments",
+    "directory_list_external_members": "directory_list_external_members",
+}
+
+BUILDER_SERVER_METHOD_MAP = {
+    "auth_login": "auth_login",
+    "auth_use_token": "auth_use_token",
+    "auth_whoami": "auth_whoami",
+    "auth_logout": "auth_logout",
+    "workspace_list": "workspace_list",
+    "workspace_select": "workspace_select",
+    "file_upload_local": "file_upload_local",
+    "feedback_submit": "feedback_submit",
+    "package_list": "package_list",
+    "package_resolve": "package_resolve",
+    "builder_tool_contract": "builder_tool_contract",
+    "package_create": "package_create",
+    "member_search": "member_search",
+    "role_search": "role_search",
+    "role_create": "role_create",
+    "package_attach_app": "package_attach_app",
+    "app_release_edit_lock_if_mine": "app_release_edit_lock_if_mine",
+    "app_resolve": "app_resolve",
+    "app_custom_button_list": "app_custom_button_list",
+    "app_custom_button_get": "app_custom_button_get",
+    "app_custom_button_create": "app_custom_button_create",
+    "app_custom_button_update": "app_custom_button_update",
+    "app_custom_button_delete": "app_custom_button_delete",
+    "app_read_summary": "app_read_summary",
+    "app_read_fields": "app_read_fields",
+    "app_read_layout_summary": "app_read_layout_summary",
+    "app_read_views_summary": "app_read_views_summary",
+    "app_read_flow_summary": "app_read_flow_summary",
+    "app_read_charts_summary": "app_read_charts_summary",
+    "portal_list": "portal_list",
+    "portal_get": "portal_get",
+    "portal_read_summary": "portal_read_summary",
+    "view_get": "view_get",
+    "chart_get": "chart_get",
+    "app_schema_apply": "app_schema_apply",
+    "app_layout_apply": "app_layout_apply",
+    "app_flow_apply": "app_flow_apply",
+    "app_views_apply": "app_views_apply",
+    "app_charts_apply": "app_charts_apply",
+    "portal_apply": "portal_apply",
+    "app_publish_verify": "app_publish_verify",
+}
+
+
+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_workspace_select(payload: JSONObject) -> None:
+    workspace = payload.get("workspace")
+    if isinstance(workspace, dict):
+        payload["workspace"] = _pick(workspace, ("wsId", "workspaceName"))
+
+
+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_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(names: tuple[str, ...], transform: TransformFn) -> None:
+    for name in names:
+        SUCCESS_POLICY_BY_TOOL[name] = transform
+
+
+_register_policy(("auth_login", "auth_use_token", "auth_whoami"), _trim_auth_payload)
+_register_policy(("auth_logout",), _trim_auth_logout)
+_register_policy(("workspace_list",), _trim_workspace_list)
+_register_policy(("workspace_select",), _trim_workspace_select)
+_register_policy(("app_list", "app_search"), _trim_app_search_like)
+_register_policy(("app_get",), _trim_app_get)
+_register_policy(("file_get_upload_info",), _trim_file_upload_info)
+_register_policy(("file_upload_local",), _trim_file_upload_local)
+_register_policy(
+    (
+        "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(
+    (
+        "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(("record_insert", "record_update"), _trim_record_write)
+_register_policy(("record_get",), _trim_record_get)
+_register_policy(("record_list",), _trim_record_list)
+_register_policy(("record_analyze",), _trim_record_analyze)
+_register_policy(("record_code_block_run",), _trim_code_block_run)
+_register_policy(("task_list",), _trim_task_list)
+_register_policy(
+    (
+        "task_get",
+        "task_action_execute",
+        "task_associated_report_detail_get",
+        "task_workflow_log_get",
+    ),
+    _trim_task_get,
+)
+_register_policy(
+    (
+        "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(("feedback_submit",), _trim_feedback)
+_register_policy(
+    (
+        "record_member_candidates",
+        "record_department_candidates",
+        "record_delete",
+        "package_list",
+        "package_resolve",
+        "builder_tool_contract",
+        "package_create",
+        "member_search",
+        "role_search",
+        "role_create",
+        "package_attach_app",
+        "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_read_summary",
+        "app_read_fields",
+        "app_read_layout_summary",
+        "app_read_views_summary",
+        "app_read_flow_summary",
+        "app_read_charts_summary",
+        "portal_list",
+        "portal_get",
+        "portal_read_summary",
+        "view_get",
+        "chart_get",
+        "app_schema_apply",
+        "app_layout_apply",
+        "app_flow_apply",
+        "app_views_apply",
+        "app_charts_apply",
+        "portal_apply",
+        "app_publish_verify",
+    ),
+    _trim_builder_list_like,
+)