@josephyan/qingflow-app-builder-mcp 0.2.0-beta.7 → 0.2.0-beta.71

package/src/qingflow_mcp/server_app_user.py

@@ -1,34 +1,186 @@
 from __future__ import annotations
 
+import json
+from datetime import date
+
 from mcp.server.fastmcp import FastMCP
 
 from .backend_client import BackendClient
 from .config import DEFAULT_PROFILE
+from .response_trim import USER_SERVER_METHOD_MAP, trim_error_response, trim_public_response, wrap_trimmed_methods
 from .session_store import SessionStore
-from .tools.approval_tools import ApprovalTools
+from .tools.app_tools import AppTools
 from .tools.auth_tools import AuthTools
+from .tools.code_block_tools import CodeBlockTools
 from .tools.directory_tools import DirectoryTools
+from .tools.feedback_tools import FeedbackTools
 from .tools.file_tools import FileTools
-from .tools.record_tools import RecordTools
-from .tools.task_tools import TaskTools
+from .tools.import_tools import ImportTools
+from .tools.task_context_tools import TaskContextTools
 from .tools.workspace_tools import WorkspaceTools
 
 
 def build_user_server() -> FastMCP:
+    today = date.today()
+    current_year = today.year
     server = FastMCP(
         "Qingflow App User MCP",
-        instructions=(
-            "Use this server for Qingflow record queries, record writes, task center operations, "
-            "directory lookups, and approval actions. Avoid builder-side app or schema changes here."
-        ),
+        instructions=f"""Use this server for Qingflow operational workflows. Current date: `{today.isoformat()}`.
+
+## 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.
+
+## 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.
+
+## 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`.
+Inside `optional_fields`, any field with `may_become_required=true` is still writable, but may become required when linked visibility or option-driven runtime rules activate.
+`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()
-    auth = AuthTools(sessions, backend)
-    workspace = WorkspaceTools(sessions, backend)
-    files = FileTools(sessions, backend)
-    approvals = ApprovalTools(sessions, backend)
-    tasks = TaskTools(sessions, backend)
+    auth = wrap_trimmed_methods(AuthTools(sessions, backend), USER_SERVER_METHOD_MAP)
+    apps = wrap_trimmed_methods(AppTools(sessions, backend), USER_SERVER_METHOD_MAP)
+    workspace = wrap_trimmed_methods(WorkspaceTools(sessions, backend), USER_SERVER_METHOD_MAP)
+    file_tools = wrap_trimmed_methods(FileTools(sessions, backend), USER_SERVER_METHOD_MAP)
+    imports = wrap_trimmed_methods(ImportTools(sessions, backend), USER_SERVER_METHOD_MAP)
+    feedback = FeedbackTools(backend, mcp_side="App User MCP")
+    code_block_tools = wrap_trimmed_methods(CodeBlockTools(sessions, backend), USER_SERVER_METHOD_MAP)
+    task_context_tools = wrap_trimmed_methods(TaskContextTools(sessions, backend), USER_SERVER_METHOD_MAP)
+    directory_tools = wrap_trimmed_methods(DirectoryTools(sessions, backend), USER_SERVER_METHOD_MAP)
 
     @server.tool()
     def auth_login(
@@ -92,6 +244,18 @@ def build_user_server() -> FastMCP:
     def workspace_select(profile: str = DEFAULT_PROFILE, ws_id: int = 0) -> dict:
         return workspace.workspace_select(profile=profile, ws_id=ws_id)
 
+    @server.tool()
+    def app_list(profile: str = DEFAULT_PROFILE) -> dict:
+        return apps.app_list(profile=profile)
+
+    @server.tool()
+    def app_search(profile: str = DEFAULT_PROFILE, keyword: str = "", page_num: int = 1, page_size: int = 50) -> dict:
+        return apps.app_search(profile=profile, keyword=keyword, page_num=page_num, page_size=page_size)
+
+    @server.tool()
+    def app_get(profile: str = DEFAULT_PROFILE, app_key: str = "") -> dict:
+        return apps.app_get(profile=profile, app_key=app_key)
+
     @server.tool()
     def file_get_upload_info(
         profile: str = DEFAULT_PROFILE,
@@ -104,7 +268,7 @@ def build_user_server() -> FastMCP:
         path_id: int | None = None,
         file_related_url: str | None = None,
     ) -> dict:
-        return files.file_get_upload_info(
+        return file_tools.file_get_upload_info(
             profile=profile,
             upload_kind=upload_kind,
             file_name=file_name,
@@ -127,7 +291,7 @@ def build_user_server() -> FastMCP:
         path_id: int | None = None,
         file_related_url: str | None = None,
     ) -> dict:
-        return files.file_upload_local(
+        return file_tools.file_upload_local(
             profile=profile,
             upload_kind=upload_kind,
             file_path=file_path,
@@ -138,187 +302,51 @@ def build_user_server() -> FastMCP:
             file_related_url=file_related_url,
         )
 
-    RecordTools(sessions, backend).register(server)
-    DirectoryTools(sessions, backend).register(server)
-
-    @server.tool()
-    def record_comment_add(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        payload: dict | None = None,
-    ) -> dict:
-        return approvals.record_comment_add(profile=profile, app_key=app_key, apply_id=apply_id, payload=payload or {})
-
-    @server.tool()
-    def record_comment_list(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        page_size: int = 20,
-        list_type: int | None = None,
-        page_num: int | None = 1,
-    ) -> dict:
-        return approvals.record_comment_list(
-            profile=profile,
-            app_key=app_key,
-            apply_id=apply_id,
-            page_size=page_size,
-            list_type=list_type,
-            page_num=page_num,
-        )
+    imports.register(server)
 
     @server.tool()
-    def record_comment_mention_candidates(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        page_size: int = 20,
-        page_num: int = 1,
-        list_type: int | None = None,
-        keyword: str | None = None,
-    ) -> dict:
-        return approvals.record_comment_mention_candidates(
-            profile=profile,
-            app_key=app_key,
-            apply_id=apply_id,
-            page_size=page_size,
-            page_num=page_num,
-            list_type=list_type,
-            keyword=keyword,
-        )
-
-    @server.tool()
-    def record_comment_mark_read(profile: str = DEFAULT_PROFILE, app_key: str = "", apply_id: int = 0) -> dict:
-        return approvals.record_comment_mark_read(profile=profile, app_key=app_key, apply_id=apply_id)
-
-    @server.tool()
-    def record_comment_stats(profile: str = DEFAULT_PROFILE, app_key: str = "", apply_id: int = 0) -> dict:
-        return approvals.record_comment_stats(profile=profile, app_key=app_key, apply_id=apply_id)
-
-    @server.tool()
-    def task_list(
-        profile: str = DEFAULT_PROFILE,
-        type: int = 1,
-        process_status: int = 1,
-        app_key: str | None = None,
-        node_id: int | None = None,
-        search_key: str | None = None,
-        page_num: int = 1,
-        page_size: int = 20,
-        create_time_asc: bool | None = None,
-    ) -> dict:
-        return tasks.task_list(
-            profile=profile,
-            type=type,
-            process_status=process_status,
-            app_key=app_key,
-            node_id=node_id,
-            search_key=search_key,
-            page_num=page_num,
-            page_size=page_size,
-            create_time_asc=create_time_asc,
-        )
-
-    @server.tool()
-    def task_list_grouped(
-        profile: str = DEFAULT_PROFILE,
-        type: int = 1,
-        process_status: int = 1,
+    def feedback_submit(
+        category: str = "",
+        title: str = "",
+        description: str = "",
+        expected_behavior: str | None = None,
+        actual_behavior: str | None = None,
+        impact_scope: str | None = None,
+        tool_name: str | None = None,
         app_key: str | None = None,
-        node_id: int | None = None,
-        search_key: str | None = None,
-        page_num: int = 1,
-        page_size: int = 20,
-    ) -> dict:
-        return tasks.task_list_grouped(
-            profile=profile,
-            type=type,
-            process_status=process_status,
-            app_key=app_key,
-            node_id=node_id,
-            search_key=search_key,
-            page_num=page_num,
-            page_size=page_size,
-        )
-
-    @server.tool()
-    def task_statistics(profile: str = DEFAULT_PROFILE, app_key: str | None = None) -> dict:
-        return tasks.task_statistics(profile=profile, app_key=app_key)
-
-    @server.tool()
-    def task_urge(profile: str = DEFAULT_PROFILE, app_key: str = "", row_record_id: int = 0) -> dict:
-        return tasks.task_urge(profile=profile, app_key=app_key, row_record_id=row_record_id)
-
-    @server.tool(description=approvals._high_risk_tool_description(operation="approve", target="workflow task"))
-    def task_approve(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        payload: dict | None = None,
-    ) -> dict:
-        return approvals.record_approve(profile=profile, app_key=app_key, apply_id=apply_id, payload=payload or {})
-
-    @server.tool(description=approvals._high_risk_tool_description(operation="reject", target="workflow task"))
-    def task_reject(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        payload: dict | None = None,
-    ) -> dict:
-        return approvals.record_reject(profile=profile, app_key=app_key, apply_id=apply_id, payload=payload or {})
-
-    @server.tool()
-    def task_rollback_candidates(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        audit_node_id: int = 0,
-    ) -> dict:
-        return approvals.record_rollback_candidates(
-            profile=profile,
-            app_key=app_key,
-            apply_id=apply_id,
-            audit_node_id=audit_node_id,
-        )
-
-    @server.tool()
-    def task_rollback(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        payload: dict | None = None,
-    ) -> dict:
-        return approvals.record_rollback(profile=profile, app_key=app_key, apply_id=apply_id, payload=payload or {})
-
-    @server.tool()
-    def task_transfer_candidates(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        page_size: int = 20,
-        page_num: int = 1,
-        audit_node_id: int = 0,
-        keyword: str | None = None,
-    ) -> dict:
-        return approvals.record_transfer_candidates(
-            profile=profile,
-            app_key=app_key,
-            apply_id=apply_id,
-            page_size=page_size,
-            page_num=page_num,
-            audit_node_id=audit_node_id,
-            keyword=keyword,
-        )
-
-    @server.tool()
-    def task_transfer(
-        profile: str = DEFAULT_PROFILE,
-        app_key: str = "",
-        apply_id: int = 0,
-        payload: dict | None = None,
+        record_id: str | int | None = None,
+        workflow_node_id: str | int | None = None,
+        note: str | None = None,
     ) -> dict:
-        return approvals.record_transfer(profile=profile, app_key=app_key, apply_id=apply_id, payload=payload or {})
+        try:
+            return trim_public_response(
+                "feedback_submit",
+                feedback.feedback_submit(
+                    category=category,
+                    title=title,
+                    description=description,
+                    expected_behavior=expected_behavior,
+                    actual_behavior=actual_behavior,
+                    impact_scope=impact_scope,
+                    tool_name=tool_name,
+                    app_key=app_key,
+                    record_id=record_id,
+                    workflow_node_id=workflow_node_id,
+                    note=note,
+                ),
+            )
+        except RuntimeError as exc:
+            try:
+                payload = json.loads(str(exc))
+            except json.JSONDecodeError:
+                raise
+            if isinstance(payload, dict):
+                raise RuntimeError(json.dumps(trim_error_response(payload), ensure_ascii=False)) from None
+            raise
+
+    code_block_tools.register(server)
+    task_context_tools.register(server)
+    directory_tools.register(server)
 
     return server
 

package/src/qingflow_mcp/session_store.py

@@ -15,6 +15,7 @@ from .json_types import JSONObject, KeyringBackend
 
 
 KEYRING_SERVICE_NAME = "qingflow-mcp"
+_UNSET = object()
 
 
 def _utcnow() -> str:
@@ -136,9 +137,13 @@ class SessionStore:
         if profile in self._logged_out_profiles:
             return None
         memory_session = self._memory_sessions.get(profile)
+        session_profile = self.get_profile(profile)
         if memory_session:
+            if session_profile is not None:
+                memory_session.base_url = session_profile.base_url
+                memory_session.qf_version = session_profile.qf_version
+                memory_session.qf_version_source = session_profile.qf_version_source
             return memory_session
-        session_profile = self.get_profile(profile)
         if not session_profile or not session_profile.persisted:
             return None
         token = self._get_secret(self._token_key(profile))
@@ -179,6 +184,41 @@ class SessionStore:
             backend_session.qf_version_source = session_profile.qf_version_source
         return session_profile
 
+    def update_profile_metadata(
+        self,
+        profile: str,
+        *,
+        uid: int | object = _UNSET,
+        email: str | None | object = _UNSET,
+        nick_name: str | None | object = _UNSET,
+        selected_ws_id: int | None | object = _UNSET,
+        selected_ws_name: str | None | object = _UNSET,
+    ) -> SessionProfile:
+        session_profile = self.get_profile(profile)
+        if session_profile is None:
+            raise KeyError(profile)
+        if uid is not _UNSET:
+            session_profile.uid = int(uid)
+        if email is not _UNSET:
+            session_profile.email = email if isinstance(email, str) or email is None else session_profile.email
+        if nick_name is not _UNSET:
+            session_profile.nick_name = nick_name if isinstance(nick_name, str) or nick_name is None else session_profile.nick_name
+        if selected_ws_id is not _UNSET:
+            session_profile.selected_ws_id = (
+                int(selected_ws_id)
+                if isinstance(selected_ws_id, int) and not isinstance(selected_ws_id, bool)
+                else None
+            )
+        if selected_ws_name is not _UNSET:
+            session_profile.selected_ws_name = (
+                selected_ws_name
+                if isinstance(selected_ws_name, str) or selected_ws_name is None
+                else session_profile.selected_ws_name
+            )
+        session_profile.updated_at = _utcnow()
+        self._upsert_profile(session_profile)
+        return session_profile
+
     def logout(self, profile: str, forget_persisted: bool = False) -> None:
         self._memory_sessions.pop(profile, None)
         if forget_persisted:

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

@@ -23,6 +23,8 @@ QUESTION_TYPE_MAP = {
     FieldType.address: 21,
     FieldType.attachment: 13,
     FieldType.boolean: 10,
+    FieldType.q_linker: 20,
+    FieldType.code_block: 26,
     FieldType.relation: 25,
     FieldType.subtable: 18,
 }
@@ -243,13 +245,40 @@ def build_question(field: dict[str, Any], temp_id: int) -> tuple[dict[str, Any],
                 "queDefaultType": 2,
             }
         )
+    if field_type == FieldType.code_block:
+        question.update(
+            {
+                "minOpts": -1,
+                "maxOpts": -1,
+                "codeBlockConfig": {
+                    "configMode": int(config.get("config_mode") or 1),
+                    "codeContent": str(config.get("code_content") or ""),
+                    "resultAliasPath": deepcopy(config.get("result_alias_path") or []),
+                    "beingHideOnForm": bool(config.get("being_hide_on_form", False)),
+                },
+                "autoTrigger": bool(config.get("auto_trigger", False)),
+                "customBtnTextStatus": bool(config.get("custom_button_text_enabled", False)),
+                "customBtnText": str(config.get("custom_button_text") or ""),
+            }
+        )
+    if field_type == FieldType.q_linker:
+        question.update(
+            {
+                "minOpts": -1,
+                "maxOpts": -1,
+                "remoteLookupConfig": deepcopy(config.get("remote_lookup_config") or config),
+                "autoTrigger": bool(config.get("auto_trigger", False)),
+                "customBtnTextStatus": bool(config.get("custom_button_text_enabled", False)),
+                "customBtnText": str(config.get("custom_button_text") or ""),
+            }
+        )
     if field_type == FieldType.subtable:
         sub_questions: list[dict[str, Any]] = []
         for subfield in field.get("subfields", []):
             sub_question, next_temp_id = build_question(subfield, next_temp_id)
             sub_questions.append(sub_question)
         question["subQuestions"] = sub_questions
-        question["innerQuestions"] = deepcopy(sub_questions)
+        question["innerQuestions"] = [deepcopy(sub_questions)]
         question["queDefaultValues"] = {"queId": temp_id, "queTitle": field["label"], "queType": que_type, "values": [], "tableValues": []}
     return question, next_temp_id
 
@@ -257,13 +286,16 @@ def build_question(field: dict[str, Any], temp_id: int) -> tuple[dict[str, Any],
 def build_reference_config(field: dict[str, Any], temp_id: int) -> dict[str, Any]:
     config = field.get("config") or {}
     display_field_id = field.get("target_field_id") or "title"
+    display_field_que_id = field.get("target_field_que_id") or config.get("target_field_que_id") or 0
     display_field_label = config.get("target_field_label") or "__TARGET_FIELD_LABEL__"
     refer_field_ids = list(config.get("refer_field_ids") or [display_field_id])
+    refer_field_que_ids = list(config.get("refer_field_que_ids") or [])
     refer_field_labels = config.get("refer_field_labels") or [display_field_label]
     refer_field_types = config.get("refer_field_types")
     refer_questions = []
     for ordinal, field_id in enumerate(refer_field_ids, start=1):
         label = refer_field_labels[ordinal - 1] if ordinal - 1 < len(refer_field_labels) else field_id
+        que_id = refer_field_que_ids[ordinal - 1] if ordinal - 1 < len(refer_field_que_ids) else 0
         raw_type = _reference_field_type_value(
             refer_field_types,
             field_id=field_id,
@@ -272,7 +304,7 @@ def build_reference_config(field: dict[str, Any], temp_id: int) -> dict[str, Any
         )
         refer_questions.append(
             {
-                "queId": 0,
+                "queId": que_id,
                 "queTitle": label,
                 "queType": _normalize_reference_que_type(raw_type) or "2",
                 "queAuth": 1,
@@ -282,15 +314,22 @@ def build_reference_config(field: dict[str, Any], temp_id: int) -> dict[str, Any
             }
         )
     auth_field_ids = list(config.get("auth_field_ids") or refer_field_ids)
+    auth_field_que_ids = list(config.get("auth_field_que_ids") or [])
+    auth_ques = deepcopy(config.get("refer_auth_ques") or [])
+    if not auth_ques:
+        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})
     return {
         "referAppKey": "__TARGET_APP_KEY__",
-        "referQueId": 0,
+        "referQueId": display_field_que_id,
         "customButtonText": config.get("custom_button_text") or "选择数据",
         "beingTableSource": False,
         "referQuestions": refer_questions,
         "referMatchRules": deepcopy(config.get("refer_match_rules") or []),
         "referFillRules": deepcopy(config.get("refer_fill_rules") or []),
-        "referAuthQues": deepcopy(config.get("refer_auth_ques") or [{"queId": 0, "queAuth": 1, "_field_id": field_id} for field_id in auth_field_ids]),
+        "referAuthQues": auth_ques,
         "canAddData": bool(config.get("can_add_data", False)),
         "dataAdditionButtonText": config.get("data_addition_button_text") or "新增数据",
         "canViewProcessLog": bool(config.get("can_view_process_log", True)),