@josephyan/qingflow-app-user-mcp 0.2.0-beta.986 → 0.2.0-beta.987

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-app-user-mcp@0.2.0-beta.986
+npm install @josephyan/qingflow-app-user-mcp@0.2.0-beta.987
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-app-user-mcp@0.2.0-beta.986 qingflow-app-user-mcp
+npx -y -p @josephyan/qingflow-app-user-mcp@0.2.0-beta.987 qingflow-app-user-mcp
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-user-mcp",
-  "version": "0.2.0-beta.986",
+  "version": "0.2.0-beta.987",
   "description": "Operational end-user MCP for Qingflow records, tasks, comments, and directory workflows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qingflow-mcp"
-version = "0.2.0b986"
+version = "0.2.0b987"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/__init__.py

@@ -5,7 +5,7 @@ from pathlib import Path
 
 __all__ = ["__version__"]
 
-_FALLBACK_VERSION = "0.2.0b986"
+_FALLBACK_VERSION = "0.2.0b987"
 
 
 def _resolve_local_pyproject_version() -> str | None:

package/src/qingflow_mcp/builder_facade/service.py

@@ -9811,6 +9811,15 @@ def _apply_relation_target_selection(
     config["refer_field_types"] = [item.get("type") for item in normalized_visible]
     config["auth_field_ids"] = [item.get("field_id") or item.get("name") for item in normalized_visible]
     config["auth_field_que_ids"] = [_coerce_positive_int(item.get("que_id")) or 0 for item in normalized_visible]
+    config["refer_auth_ques"] = [
+        {
+            "queId": _coerce_positive_int(item.get("que_id")) or 0,
+            "queAuth": _REFERENCE_FIELD_VISIBLE_AUTH,
+            "_field_id": item.get("field_id") or item.get("name"),
+        }
+        for item in normalized_visible
+        if (_coerce_positive_int(item.get("que_id")) or 0) > 0
+    ]
     config["field_name_show"] = bool(field.get("field_name_show", True))
     field["target_field_id"] = display_field.get("field_id") or display_field.get("name")
     field["target_field_que_id"] = _coerce_positive_int(display_field.get("que_id")) or 0
@@ -10071,17 +10080,32 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
         field["target_app_key"] = reference.get("referAppKey")
         field["relation_mode"] = _relation_mode_from_optional_data_num(reference.get("optionalDataNum"))
         refer_questions = reference.get("referQuestions") if isinstance(reference.get("referQuestions"), list) else []
+        refer_auth_questions = reference.get("referAuthQues") if isinstance(reference.get("referAuthQues"), list) else []
+        refer_auth_by_que_id: dict[int, int] = {}
+        for raw_item in refer_auth_questions:
+            if not isinstance(raw_item, dict):
+                continue
+            que_id = _coerce_nonnegative_int(raw_item.get("queId"))
+            que_auth = _coerce_nonnegative_int(raw_item.get("queAuth"))
+            if que_id is None or que_auth is None or que_id in refer_auth_by_que_id:
+                continue
+            refer_auth_by_que_id[que_id] = que_auth
         visible_fields: list[dict[str, Any]] = []
         display_field_que_id = _coerce_nonnegative_int(reference.get("referQueId"))
         display_field_name: str | None = None
         for item in refer_questions:
             if not isinstance(item, dict):
                 continue
+            que_id = _coerce_nonnegative_int(item.get("queId"))
+            que_auth = _coerce_nonnegative_int(item.get("queAuth"))
+            if que_auth is None and que_id is not None:
+                que_auth = refer_auth_by_que_id.get(que_id)
             selector = {
-                "que_id": _coerce_nonnegative_int(item.get("queId")),
+                "que_id": que_id,
                 "name": str(item.get("queTitle") or "").strip() or None,
             }
-            visible_fields.append(selector)
+            if que_auth != _REFERENCE_FIELD_HIDDEN_AUTH:
+                visible_fields.append(selector)
             if display_field_que_id is not None and selector["que_id"] == display_field_que_id:
                 display_field_name = selector["name"]
         if display_field_name is None and visible_fields:
@@ -13275,6 +13299,333 @@ def _normalize_reference_auth_question_for_save(value: Any) -> dict[str, Any] |
     return payload
 
 
+def _dedupe_reference_auth_questions(auth_questions: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    deduped: list[dict[str, Any]] = []
+    seen_que_ids: set[int] = set()
+    for item in auth_questions:
+        normalized_item = _normalize_reference_auth_question_for_save(item)
+        if normalized_item is None:
+            continue
+        que_id = _coerce_any_int(normalized_item.get("queId"))
+        if que_id is None or que_id in seen_que_ids:
+            continue
+        seen_que_ids.add(que_id)
+        deduped.append(normalized_item)
+    return deduped
+
+
+_REFERENCE_FIELD_HIDDEN_AUTH = 2
+_REFERENCE_FIELD_VISIBLE_AUTH = 3
+
+
+def _synthesize_reference_auth_questions_for_save(
+    *,
+    source: dict[str, Any],
+    field: dict[str, Any],
+) -> list[dict[str, Any]]:
+    config = field.get("config") if isinstance(field.get("config"), dict) else {}
+    synthesized: list[dict[str, Any]] = []
+
+    if isinstance(config.get("refer_auth_ques"), list):
+        synthesized.extend(cast(list[dict[str, Any]], config.get("refer_auth_ques") or []))
+    if synthesized:
+        return _dedupe_reference_auth_questions(synthesized)
+
+    refer_question_ids_by_name: dict[str, int] = {}
+    for raw_item in cast(list[Any], source.get("referQuestions") or []):
+        if not isinstance(raw_item, dict):
+            continue
+        que_id = _coerce_any_int(raw_item.get("queId"))
+        name = str(raw_item.get("queTitle") or "").strip()
+        if que_id is None or not name or name in refer_question_ids_by_name:
+            continue
+        refer_question_ids_by_name[name] = que_id
+
+    visible_fields = cast(list[dict[str, Any]], field.get("visible_fields") or [])
+    for item in visible_fields:
+        if not isinstance(item, dict):
+            continue
+        que_id = _coerce_any_int(item.get("que_id"))
+        if que_id is None:
+            name = str(item.get("name") or "").strip()
+            que_id = refer_question_ids_by_name.get(name)
+        if que_id is None:
+            continue
+        synthesized.append({"queId": que_id, "queAuth": _REFERENCE_FIELD_VISIBLE_AUTH})
+    if synthesized:
+        return _dedupe_reference_auth_questions(synthesized)
+
+    auth_field_que_ids = cast(list[Any], config.get("auth_field_que_ids") or [])
+    for raw_que_id in auth_field_que_ids:
+        que_id = _coerce_any_int(raw_que_id)
+        if que_id is None:
+            continue
+        synthesized.append({"queId": que_id, "queAuth": _REFERENCE_FIELD_VISIBLE_AUTH})
+    if synthesized:
+        return _dedupe_reference_auth_questions(synthesized)
+
+    for raw_item in cast(list[Any], source.get("referQuestions") or []):
+        if not isinstance(raw_item, dict):
+            continue
+        que_id = _coerce_any_int(raw_item.get("queId"))
+        if que_id is None:
+            continue
+        synthesized.append(
+            {
+                "queId": que_id,
+                "queAuth": _REFERENCE_FIELD_VISIBLE_AUTH,
+            }
+        )
+    if synthesized:
+        return _dedupe_reference_auth_questions(synthesized)
+
+    fallback_que_id = _coerce_any_int(field.get("target_field_que_id"))
+    if fallback_que_id is not None:
+        synthesized.append({"queId": fallback_que_id, "queAuth": _REFERENCE_FIELD_VISIBLE_AUTH})
+    return _dedupe_reference_auth_questions(synthesized)
+
+
+def _reference_question_auth_overrides_for_save(
+    *,
+    source: dict[str, Any],
+    field: dict[str, Any],
+) -> dict[int, int]:
+    overrides: dict[int, int] = {}
+    visible_que_ids: set[int] = set()
+
+    for item in cast(list[Any], field.get("visible_fields") or []):
+        if not isinstance(item, dict):
+            continue
+        que_id = _coerce_any_int(item.get("que_id"))
+        if que_id is not None:
+            visible_que_ids.add(que_id)
+
+    if not visible_que_ids:
+        refer_auth_ques = _synthesize_reference_auth_questions_for_save(source=source, field=field)
+        for item in refer_auth_ques:
+            que_id = _coerce_any_int(item.get("queId"))
+            que_auth = _coerce_nonnegative_int(item.get("queAuth"))
+            if que_id is None or que_auth is None:
+                continue
+            overrides[que_id] = que_auth
+        if overrides:
+            return overrides
+
+    for raw_item in cast(list[Any], source.get("referQuestions") or []):
+        if not isinstance(raw_item, dict):
+            continue
+        que_id = _coerce_any_int(raw_item.get("queId"))
+        if que_id is None:
+            continue
+        overrides[que_id] = (
+            _REFERENCE_FIELD_VISIBLE_AUTH if que_id in visible_que_ids else _REFERENCE_FIELD_HIDDEN_AUTH
+        )
+    return overrides
+
+
+def _reference_question_matches_visible_selector(question: dict[str, Any], selector: dict[str, Any]) -> bool:
+    question_que_id = _coerce_any_int(question.get("queId"))
+    selector_que_id = _coerce_any_int(selector.get("que_id"))
+    if question_que_id is not None and selector_que_id is not None and question_que_id == selector_que_id:
+        return True
+    question_name = str(question.get("queTitle") or "").strip()
+    selector_name = str(selector.get("name") or "").strip()
+    return bool(question_name and selector_name and question_name == selector_name)
+
+
+def _build_reference_question_from_visible_selector(
+    selector: dict[str, Any],
+    *,
+    ordinal: int,
+) -> dict[str, Any] | None:
+    return _normalize_reference_question_for_save(
+        {
+            "queId": _coerce_any_int(selector.get("que_id")),
+            "queTitle": str(selector.get("name") or "").strip() or None,
+            "queType": str(selector.get("type") or "2"),
+            "ordinal": ordinal,
+        },
+        ordinal=ordinal,
+    )
+
+
+def _canonicalize_reference_questions_for_save(
+    *,
+    source: dict[str, Any],
+    field: dict[str, Any],
+) -> list[dict[str, Any]]:
+    normalized_source_questions = [
+        item
+        for item in (
+            _normalize_reference_question_for_save(raw_item, ordinal=index)
+            for index, raw_item in enumerate(cast(list[Any], source.get("referQuestions") or []), start=1)
+        )
+        if item is not None
+    ]
+
+    display_field = field.get("display_field") if isinstance(field.get("display_field"), dict) else None
+    visible_fields = [item for item in cast(list[Any], field.get("visible_fields") or []) if isinstance(item, dict)]
+    ordered_visible_selectors: list[dict[str, Any]] = []
+    if display_field is not None:
+        ordered_visible_selectors.append(display_field)
+    for item in visible_fields:
+        if any(_relation_target_field_matches(existing, item) for existing in ordered_visible_selectors):
+            continue
+        ordered_visible_selectors.append(item)
+
+    if not ordered_visible_selectors:
+        return normalized_source_questions
+
+    canonical_questions: list[dict[str, Any]] = []
+    used_source_indexes: set[int] = set()
+
+    for ordinal, selector in enumerate(ordered_visible_selectors, start=1):
+        matched_index: int | None = None
+        matched_item: dict[str, Any] | None = None
+        for index, item in enumerate(normalized_source_questions):
+            if index in used_source_indexes:
+                continue
+            if _reference_question_matches_visible_selector(item, selector):
+                matched_index = index
+                matched_item = deepcopy(item)
+                break
+        if matched_item is None:
+            matched_item = _build_reference_question_from_visible_selector(selector, ordinal=ordinal)
+        if matched_item is None:
+            continue
+        matched_item["ordinal"] = ordinal
+        canonical_questions.append(matched_item)
+        if matched_index is not None:
+            used_source_indexes.add(matched_index)
+
+    next_ordinal = len(canonical_questions) + 1
+    for index, item in enumerate(normalized_source_questions):
+        if index in used_source_indexes:
+            continue
+        remaining_item = deepcopy(item)
+        remaining_item["ordinal"] = next_ordinal
+        next_ordinal += 1
+        canonical_questions.append(remaining_item)
+
+    return canonical_questions
+
+
+def _canonicalize_reference_auth_questions_for_save(
+    *,
+    source: dict[str, Any],
+    refer_questions: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    source_auth_questions = [
+        item
+        for item in (
+            _normalize_reference_auth_question_for_save(raw_item)
+            for raw_item in cast(list[Any], source.get("referAuthQues") or [])
+        )
+        if item is not None
+    ]
+    source_auth_by_que_id: dict[int, dict[str, Any]] = {}
+    for item in source_auth_questions:
+        que_id = _coerce_any_int(item.get("queId"))
+        if que_id is None or que_id in source_auth_by_que_id:
+            continue
+        source_auth_by_que_id[que_id] = item
+
+    auth_questions: list[dict[str, Any]] = []
+    for item in refer_questions:
+        que_id = _coerce_any_int(item.get("queId"))
+        que_auth = _coerce_nonnegative_int(item.get("queAuth"))
+        if que_id is None or que_auth is None:
+            continue
+        payload = deepcopy(source_auth_by_que_id.get(que_id) or {"queId": que_id})
+        payload["queId"] = que_id
+        payload["queAuth"] = que_auth
+        auth_questions.append(payload)
+    return _dedupe_reference_auth_questions(auth_questions)
+
+
+def _enforce_reference_config_consistency_for_save(
+    payload: dict[str, Any],
+    *,
+    field: dict[str, Any],
+) -> dict[str, Any]:
+    refer_questions = [
+        item
+        for item in (
+            _normalize_reference_question_for_save(raw_item, ordinal=index)
+            for index, raw_item in enumerate(cast(list[Any], payload.get("referQuestions") or []), start=1)
+        )
+        if item is not None
+    ]
+    if not refer_questions:
+        return payload
+
+    refer_auth_ques = _dedupe_reference_auth_questions(
+        [
+            item
+            for item in (
+                _normalize_reference_auth_question_for_save(raw_item)
+                for raw_item in cast(list[Any], payload.get("referAuthQues") or [])
+            )
+            if item is not None
+        ]
+    )
+    refer_auth_by_que_id: dict[int, int] = {}
+    for item in refer_auth_ques:
+        que_id = _coerce_any_int(item.get("queId"))
+        que_auth = _coerce_nonnegative_int(item.get("queAuth"))
+        if que_id is None or que_auth is None or que_id in refer_auth_by_que_id:
+            continue
+        refer_auth_by_que_id[que_id] = que_auth
+
+    display_field_que_id = _coerce_any_int(payload.get("referQueId"))
+    if display_field_que_id is None:
+        display_field_que_id = _coerce_any_int(field.get("target_field_que_id"))
+        if display_field_que_id is not None:
+            payload["referQueId"] = display_field_que_id
+
+    if display_field_que_id is not None and not any(
+        _coerce_any_int(item.get("queId")) == display_field_que_id for item in refer_questions
+    ):
+        display_selector = field.get("display_field") if isinstance(field.get("display_field"), dict) else None
+        display_question = (
+            _build_reference_question_from_visible_selector(display_selector, ordinal=1)
+            if display_selector is not None
+            else None
+        )
+        if display_question is not None:
+            display_question["queId"] = display_field_que_id
+            display_question["queAuth"] = _REFERENCE_FIELD_VISIBLE_AUTH
+            refer_questions = [display_question, *refer_questions]
+
+    if display_field_que_id is not None:
+        display_questions = [
+            item for item in refer_questions if _coerce_any_int(item.get("queId")) == display_field_que_id
+        ]
+        trailing_questions = [
+            item for item in refer_questions if _coerce_any_int(item.get("queId")) != display_field_que_id
+        ]
+        refer_questions = [*display_questions, *trailing_questions]
+
+    for ordinal, item in enumerate(refer_questions, start=1):
+        que_id = _coerce_any_int(item.get("queId"))
+        if que_id is None:
+            continue
+        item["ordinal"] = ordinal
+        item["queAuth"] = refer_auth_by_que_id.get(
+            que_id,
+            _coerce_nonnegative_int(item.get("queAuth")) or _REFERENCE_FIELD_VISIBLE_AUTH,
+        )
+        if display_field_que_id is not None and que_id == display_field_que_id:
+            item["queAuth"] = _REFERENCE_FIELD_VISIBLE_AUTH
+
+    payload["referQuestions"] = refer_questions
+    payload["referAuthQues"] = _canonicalize_reference_auth_questions_for_save(
+        source={"referAuthQues": refer_auth_ques},
+        refer_questions=refer_questions,
+    )
+    return payload
+
+
 def _normalize_reference_config_for_save(
     reference: Any,
     *,
@@ -13289,11 +13640,13 @@ def _normalize_reference_config_for_save(
     if field.get("field_name_show") is not None:
         payload["fieldNameShow"] = bool(field.get("field_name_show"))
 
-    refer_questions: list[dict[str, Any]] = []
-    for index, raw_item in enumerate(cast(list[Any], source.get("referQuestions") or []), start=1):
-        normalized_item = _normalize_reference_question_for_save(raw_item, ordinal=index)
-        if normalized_item is not None:
-            refer_questions.append(normalized_item)
+    refer_question_auth_overrides = _reference_question_auth_overrides_for_save(source=source, field=field)
+    refer_questions = _canonicalize_reference_questions_for_save(source=source, field=field)
+    for index, normalized_item in enumerate(refer_questions, start=1):
+        que_id = _coerce_any_int(normalized_item.get("queId"))
+        if que_id is not None and que_id in refer_question_auth_overrides:
+            normalized_item["queAuth"] = refer_question_auth_overrides[que_id]
+        normalized_item["ordinal"] = index
     if refer_questions or "referQuestions" in source:
         payload["referQuestions"] = refer_questions
 
@@ -13308,18 +13661,13 @@ def _normalize_reference_config_for_save(
     if refer_fill_rules or "referFillRules" in source:
         payload["referFillRules"] = refer_fill_rules
 
-    refer_auth_ques = [
-        item
-        for item in (
-            _normalize_reference_auth_question_for_save(raw_item)
-            for raw_item in cast(list[Any], source.get("referAuthQues") or [])
-        )
-        if item is not None
-    ]
+    refer_auth_ques = _canonicalize_reference_auth_questions_for_save(source=source, refer_questions=refer_questions)
+    if not refer_auth_ques:
+        refer_auth_ques = _synthesize_reference_auth_questions_for_save(source=source, field=field)
     if refer_auth_ques or "referAuthQues" in source:
         payload["referAuthQues"] = refer_auth_ques
 
-    return payload
+    return _enforce_reference_config_consistency_for_save(payload, field=field)
 
 
 def _normalize_relation_question_for_save(question: dict[str, Any], *, field: dict[str, Any]) -> dict[str, Any]:
@@ -13550,9 +13898,16 @@ def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]
             preserved_reference["referAppKey"] = field.get("target_app_key")
             question["referenceConfig"] = preserved_reference
         else:
+            existing_reference = (
+                deepcopy(relation_question_template.get("referenceConfig"))
+                if relation_question_template is not None and isinstance(relation_question_template.get("referenceConfig"), dict)
+                else deepcopy(question.get("referenceConfig"))
+                if isinstance(question.get("referenceConfig"), dict)
+                else {}
+            )
             reference = (
-                deepcopy(built_question.get("referenceConfig"))
-                if relation_config_explicit and isinstance(built_question.get("referenceConfig"), dict)
+                existing_reference
+                if relation_config_explicit
                 else deepcopy(question.get("referenceConfig"))
                 if isinstance(question.get("referenceConfig"), dict)
                 else {}
@@ -13573,6 +13928,8 @@ def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]
                 "fieldNameShow",
                 "_targetFieldId",
             ):
+                if relation_config_explicit and key in {"referQuestions", "referAuthQues"}:
+                    continue
                 if key in built_reference:
                     reference[key] = deepcopy(built_reference[key])
             reference["referAppKey"] = field.get("target_app_key")

package/src/qingflow_mcp/cli/commands/workspace.py

@@ -15,6 +15,10 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     list_parser.add_argument("--include-external", action="store_true")
     list_parser.set_defaults(handler=_handle_list, format_hint="workspace_list")
 
+    get_parser = workspace_subparsers.add_parser("get", help="读取工作区详情")
+    get_parser.add_argument("--ws-id", type=int, default=0)
+    get_parser.set_defaults(handler=_handle_get, format_hint="workspace_get")
+
 
 def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
     return context.workspace.workspace_list(
@@ -23,3 +27,10 @@ def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
         page_size=args.page_size,
         include_external=bool(args.include_external),
     )
+
+
+def _handle_get(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.workspace.workspace_get(
+        profile=args.profile,
+        ws_id=args.ws_id if int(args.ws_id or 0) > 0 else None,
+    )

package/src/qingflow_mcp/cli/formatters.py

@@ -38,8 +38,12 @@ def _format_whoami(result: dict[str, Any]) -> str:
         f"User: {result.get('nick_name') or '-'} ({result.get('email') or '-'})",
         f"UID: {result.get('uid')}",
         f"Workspace: {result.get('selected_ws_name') or '-'} ({result.get('selected_ws_id') or '-'})",
-        f"QF Version: {result.get('qf_version') or '-'}",
+        f"Workspace QF Version: {result.get('qf_version') or '-'}",
     ]
+    request_route = result.get("request_route") if isinstance(result.get("request_route"), dict) else {}
+    route_qf_version = request_route.get("qf_version")
+    if route_qf_version and route_qf_version != result.get("qf_version"):
+        lines.append(f"Request Route QF Version: {route_qf_version}")
     lines.append(f"Permission Level: {result.get('permission_level') or '-'}")
     departments = result.get("departments") if isinstance(result.get("departments"), list) else []
     roles = result.get("roles") if isinstance(result.get("roles"), list) else []
@@ -82,6 +86,19 @@ def _format_workspace_list(result: dict[str, Any]) -> str:
     return _render_titled_table("Workspaces", ["ws_id", "name", "remark"], rows)
 
 
+def _format_workspace_get(result: dict[str, Any]) -> str:
+    workspace = result.get("workspace") if isinstance(result.get("workspace"), dict) else {}
+    lines = [
+        f"Workspace: {workspace.get('workspaceName') or workspace.get('wsName') or '-'} ({workspace.get('wsId') or result.get('ws_id') or '-'})",
+        f"QF Version: {result.get('qf_version') or workspace.get('systemVersion') or '-'}",
+        f"Identity: {workspace.get('identity') or '-'}",
+        f"Auth: {workspace.get('auth') if workspace.get('auth') is not None else '-'}",
+        f"State: {workspace.get('state') if workspace.get('state') is not None else '-'}",
+    ]
+    _append_warnings(lines, result.get("warnings"))
+    return "\n".join(lines) + "\n"
+
+
 def _format_app_items(result: dict[str, Any]) -> str:
     items = result.get("items")
     if not isinstance(items, list):
@@ -344,6 +361,7 @@ def _first_present(payload: dict[str, Any], *keys: str) -> Any:
 _FORMATTERS = {
     "auth_whoami": _format_whoami,
     "workspace_list": _format_workspace_list,
+    "workspace_get": _format_workspace_get,
     "app_list": _format_app_items,
     "app_search": _format_app_items,
     "app_get": _format_app_get,

package/src/qingflow_mcp/public_surface.py

@@ -34,6 +34,7 @@ USER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(USER_DOMAIN, "auth_whoami", ("auth_whoami",), ("auth", "whoami")),
     PublicToolSpec(USER_DOMAIN, "auth_logout", ("auth_logout",), ("auth", "logout")),
     PublicToolSpec(USER_DOMAIN, "workspace_list", ("workspace_list",), ("workspace", "list")),
+    PublicToolSpec(USER_DOMAIN, "workspace_get", ("workspace_get",), ("workspace", "get")),
     PublicToolSpec(USER_DOMAIN, "app_list", ("app_list",), ("app", "list"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "app_search", ("app_search",), ("app", "search"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "app_get", ("app_get",), ("app", "get"), cli_show_effective_context=True),
@@ -109,6 +110,7 @@ BUILDER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(BUILDER_DOMAIN, "auth_whoami", ("auth_whoami",), ("builder", "auth", "whoami"), cli_public=False),
     PublicToolSpec(BUILDER_DOMAIN, "auth_logout", ("auth_logout",), ("builder", "auth", "logout"), cli_public=False),
     PublicToolSpec(BUILDER_DOMAIN, "workspace_list", ("workspace_list",), ("builder", "workspace", "list"), cli_public=False),
+    PublicToolSpec(BUILDER_DOMAIN, "workspace_get", ("workspace_get",), ("builder", "workspace", "get"), cli_public=False),
     PublicToolSpec(BUILDER_DOMAIN, "file_upload_local", ("file_upload_local",), ("builder", "file", "upload-local"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "feedback_submit", ("feedback_submit",), ("builder", "feedback", "submit"), has_contract=True),
     PublicToolSpec(BUILDER_DOMAIN, "builder_tool_contract", ("builder_tool_contract",), ("builder", "contract"), has_contract=False),

package/src/qingflow_mcp/solution/compiler/form_compiler.py

@@ -307,7 +307,7 @@ def build_reference_config(field: dict[str, Any], temp_id: int) -> dict[str, Any
                 "queId": que_id,
                 "queTitle": label,
                 "queType": _normalize_reference_que_type(raw_type) or "2",
-                "queAuth": 1,
+                "queAuth": 3,
                 "ordinal": ordinal,
                 "quoteId": temp_id,
                 "_field_id": field_id,
@@ -320,7 +320,7 @@ def build_reference_config(field: dict[str, Any], temp_id: int) -> dict[str, Any
         auth_ques = []
         for ordinal, field_id in enumerate(auth_field_ids, start=1):
             que_id = auth_field_que_ids[ordinal - 1] if ordinal - 1 < len(auth_field_que_ids) else 0
-            auth_ques.append({"queId": que_id, "queAuth": 1, "_field_id": field_id})
+            auth_ques.append({"queId": que_id, "queAuth": 3, "_field_id": field_id})
     return {
         "referAppKey": "__TARGET_APP_KEY__",
         "referQueId": display_field_que_id,

package/src/qingflow_mcp/solution/executor.py

@@ -857,12 +857,12 @@ class SolutionExecutor:
                 if refer_que_id is None:
                     continue
                 resolved["queId"] = refer_que_id
-                resolved["queAuth"] = int(resolved.get("queAuth", 1))
+                resolved["queAuth"] = int(resolved.get("queAuth", 3))
                 auth_ques.append(resolved)
             if not auth_ques:
                 fallback_que_id = target_meta.get("by_field_id", {}).get(target_field_id)
                 if fallback_que_id is not None:
-                    auth_ques.append({"queId": fallback_que_id, "queAuth": 1})
+                    auth_ques.append({"queId": fallback_que_id, "queAuth": 3})
             reference_config["referAuthQues"] = auth_ques
             reference_config["fieldNameShow"] = bool(reference_config.get("fieldNameShow", True))
             fill_rules = []

package/src/qingflow_mcp/tools/auth_tools.py

@@ -212,6 +212,36 @@ class AuthTools(ToolBase):
             backend_session,  # type: ignore[no-untyped-def]
             context: BackendRequestContext,
         ) -> dict[str, Any]:
+            workspace, workspace_qf_version = self._selected_workspace_snapshot(
+                session_profile=session_profile,
+                backend_session=backend_session,
+            )
+            resolved_qf_version = workspace_qf_version or session_profile.qf_version
+            resolved_qf_version_source = (
+                "workspace_system_version"
+                if workspace_qf_version is not None
+                else session_profile.qf_version_source
+            )
+            if (
+                workspace_qf_version is not None
+                and (
+                    workspace_qf_version != session_profile.qf_version
+                    or session_profile.qf_version_source != "workspace_system_version"
+                )
+            ):
+                session_profile = self.sessions.update_route(
+                    profile,
+                    qf_version=workspace_qf_version,
+                    qf_version_source="workspace_system_version",
+                )
+                backend_session = self.sessions.get_backend_session(profile) or backend_session
+                context = BackendRequestContext(
+                    base_url=backend_session.base_url,
+                    token=backend_session.token,
+                    ws_id=session_profile.selected_ws_id,
+                    qf_version=backend_session.qf_version,
+                    qf_version_source=backend_session.qf_version_source,
+                )
             if self._should_refresh_identity_metadata(session_profile):
                 refreshed_profile = self._refresh_identity_metadata(
                     profile=profile,
@@ -224,8 +254,8 @@ class AuthTools(ToolBase):
             response = {
                 "profile": session_profile.profile,
                 "base_url": session_profile.base_url,
-                "qf_version": session_profile.qf_version,
-                "qf_version_source": session_profile.qf_version_source,
+                "qf_version": resolved_qf_version,
+                "qf_version_source": resolved_qf_version_source,
                 "uid": session_profile.uid,
                 "email": session_profile.email,
                 "nick_name": session_profile.nick_name,
@@ -512,6 +542,24 @@ class AuthTools(ToolBase):
             raise_tool_error(QingflowApiError(category="workspace", message=f"Workspace {ws_id} is not accessible"))
         return workspace
 
+    def _selected_workspace_snapshot(
+        self,
+        *,
+        session_profile,  # type: ignore[no-untyped-def]
+        backend_session,  # type: ignore[no-untyped-def]
+    ) -> tuple[dict[str, Any] | None, str | None]:
+        ws_id = session_profile.selected_ws_id
+        if ws_id is None:
+            return None, None
+        workspace = self._fetch_workspace_with_name_fallback(
+            session_profile.base_url,
+            backend_session.token,
+            ws_id,
+            qf_version=session_profile.qf_version,
+            qf_version_source=session_profile.qf_version_source,
+        )
+        return workspace, self._workspace_system_version(workspace)
+
     def _request_route_payload(self, context: BackendRequestContext) -> dict[str, Any]:
         """执行内部辅助逻辑。"""
         describe_route = getattr(self.backend, "describe_route", None)

package/src/qingflow_mcp/tools/workspace_tools.py

@@ -35,6 +35,16 @@ class WorkspaceTools(ToolBase):
                 include_external=include_external,
             )
 
+        @mcp.tool()
+        def workspace_get(
+            profile: str = DEFAULT_PROFILE,
+            ws_id: int = 0,
+        ) -> dict[str, Any]:
+            return self.workspace_get(
+                profile=profile,
+                ws_id=ws_id if ws_id > 0 else None,
+            )
+
         @mcp.tool()
         def workspace_set_plugin_status(
             profile: str = DEFAULT_PROFILE,
@@ -93,6 +103,31 @@ class WorkspaceTools(ToolBase):
 
         return self._run(profile, runner, require_workspace=False)
 
+    @tool_cn_name("工作区详情")
+    def workspace_get(
+        self,
+        *,
+        profile: str = DEFAULT_PROFILE,
+        ws_id: int | None = None,
+    ) -> dict[str, Any]:
+        """读取单个工作区详情，并尽量补齐真实 systemVersion。"""
+
+        def runner(session_profile, context):
+            target_ws_id = ws_id or (session_profile.selected_ws_id if session_profile is not None else None)
+            if target_ws_id is None or target_ws_id <= 0:
+                raise_tool_error(QingflowApiError.workspace_not_selected(profile))
+            workspace = self._fetch_workspace_with_fallback(context, ws_id=target_ws_id)
+            system_version = self._workspace_system_version(workspace)
+            return {
+                "profile": profile,
+                "ws_id": target_ws_id,
+                "qf_version": system_version,
+                "qf_version_source": "workspace_system_version" if system_version else "unverified",
+                "workspace": workspace,
+            }
+
+        return self._run(profile, runner, require_workspace=False)
+
     @tool_cn_name("设置工作区插件状态")
     def workspace_set_plugin_status(
         self,
@@ -123,3 +158,62 @@ class WorkspaceTools(ToolBase):
             }
 
         return self._run(profile, runner)
+
+    def _fetch_workspace_with_fallback(
+        self,
+        context: BackendRequestContext,
+        *,
+        ws_id: int,
+    ) -> dict[str, Any]:
+        workspace = self.backend.request("GET", context, f"/user/workspace/{ws_id}")
+        if not isinstance(workspace, dict):
+            raise_tool_error(QingflowApiError(category="workspace", message=f"Workspace {ws_id} is not accessible"))
+        if self._workspace_needs_list_fallback(workspace):
+            fallback = self._fetch_workspace_from_list(context, ws_id=ws_id)
+            if isinstance(fallback, dict):
+                merged = dict(workspace)
+                for key, value in fallback.items():
+                    if merged.get(key) in (None, "") and value not in (None, ""):
+                        merged[key] = value
+                workspace = merged
+        return workspace
+
+    def _fetch_workspace_from_list(self, context: BackendRequestContext, *, ws_id: int) -> dict[str, Any] | None:
+        payload = self.backend.request(
+            "POST",
+            BackendRequestContext(
+                base_url=context.base_url,
+                token=context.token,
+                ws_id=None,
+                qf_version=context.qf_version,
+                qf_version_source=context.qf_version_source,
+            ),
+            "/user/workspaceList/pageQuery",
+            json_body={"pageNum": 1, "pageSize": 100, "authList": [0, 1, 2, 3]},
+        )
+        workspaces = payload.get("list") if isinstance(payload, dict) else []
+        if not isinstance(workspaces, list):
+            return None
+        found = next(
+            (
+                item
+                for item in workspaces
+                if isinstance(item, dict) and item.get("wsId") == ws_id
+            ),
+            None,
+        )
+        return found if isinstance(found, dict) else None
+
+    def _workspace_needs_list_fallback(self, workspace: dict[str, Any]) -> bool:
+        workspace_name = str(workspace.get("workspaceName") or workspace.get("wsName") or "").strip()
+        system_version = self._workspace_system_version(workspace)
+        return not workspace_name or system_version is None
+
+    def _workspace_system_version(self, workspace: Any) -> str | None:
+        if not isinstance(workspace, dict):
+            return None
+        value = workspace.get("systemVersion")
+        if value is None:
+            return None
+        normalized = str(value).strip()
+        return normalized or None