@qingflow-tech/qingflow-cli 1.1.48 → 1.1.50-beta.1

package/src/qingflow_mcp/tools/record_tools.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import csv
 import html
 import mimetypes
 import json
@@ -34,6 +33,7 @@ from ..list_type_labels import (
 )
 from .base import ToolBase
 from .directory_tools import _directory_has_more, _directory_items
+from .csv_export import CsvShardWriter
 
 
 DEFAULT_QUERY_PAGE_SIZE = 50
@@ -442,7 +442,7 @@ class RecordTools(ToolBase):
             description=(
                 "Browse Qingflow records with a schema-first list DSL. "
                 "Use record_browse_schema_get first, then pass field_id-only columns, where, and order_by clauses. "
-                "This route returns up to 10 rows plus total counts for browse, sample inspection, and fuzzy record lookup; it is not for analysis."
+                "This route returns one page (10 rows by default) plus total counts for browse, sample inspection, and fuzzy record lookup; it is not for analysis."
             )
         )
         def record_list(
@@ -1525,6 +1525,7 @@ class RecordTools(ToolBase):
             )
             warnings: list[JSONObject] = []
             scope_source = "static_applicant_scope"
+            backend_pagination: JSONObject = {}
             try:
                 if runtime_lookup:
                     state = self._build_candidate_lookup_state(
@@ -1535,7 +1536,10 @@ class RecordTools(ToolBase):
                         workflow_node_id=workflow_node_id,
                         fields=normalized_fields,
                     )
-                    items = self._resolve_member_candidates_backend(context, field, keyword=keyword, state=state)
+                    items = self._resolve_member_candidates_backend(
+                        context, field, keyword=keyword, state=state,
+                        page_num=page_num, page_size=page_size, pagination=backend_pagination,
+                    )
                     scope_source = "backend_runtime_scope"
                 else:
                     items: list[JSONObject] | None = None
@@ -1548,7 +1552,10 @@ class RecordTools(ToolBase):
                             workflow_node_id=None,
                             fields={},
                         )
-                        items = self._resolve_member_candidates_backend(context, field, keyword=keyword, state=state)
+                        items = self._resolve_member_candidates_backend(
+                            context, field, keyword=keyword, state=state,
+                            page_num=page_num, page_size=page_size, pagination=backend_pagination,
+                        )
                         scope_source = "backend_applicant_scope"
                     if items is None:
                         items = self._resolve_member_candidates(context, field, keyword=keyword)
@@ -1581,7 +1588,7 @@ class RecordTools(ToolBase):
             total = len(items)
             start = (page_num - 1) * page_size
             end = start + page_size
-            page_items = items[start:end]
+            page_items = items if backend_pagination else items[start:end]
             page_amount = (total + page_size - 1) // page_size if total else 0
             return {
                 "profile": profile,
@@ -1598,6 +1605,7 @@ class RecordTools(ToolBase):
                         "returned_items": len(page_items),
                         "reported_total": total,
                         "page_amount": page_amount,
+                        **backend_pagination,
                     },
                     "selection": {
                         "app_key": app_key,
@@ -1668,6 +1676,7 @@ class RecordTools(ToolBase):
             )
             warnings: list[JSONObject] = []
             scope_source = "static_applicant_scope"
+            backend_pagination: JSONObject = {}
             try:
                 if runtime_lookup:
                     state = self._build_candidate_lookup_state(
@@ -1678,7 +1687,10 @@ class RecordTools(ToolBase):
                         workflow_node_id=workflow_node_id,
                         fields=normalized_fields,
                     )
-                    items = self._resolve_department_candidates_backend(context, field, keyword=keyword, state=state)
+                    items = self._resolve_department_candidates_backend(
+                        context, field, keyword=keyword, state=state,
+                        page_num=page_num, page_size=page_size, pagination=backend_pagination,
+                    )
                     scope_source = "backend_runtime_scope"
                 else:
                     items: list[JSONObject] | None = None
@@ -1691,7 +1703,10 @@ class RecordTools(ToolBase):
                             workflow_node_id=None,
                             fields={},
                         )
-                        items = self._resolve_department_candidates_backend(context, field, keyword=keyword, state=state)
+                        items = self._resolve_department_candidates_backend(
+                            context, field, keyword=keyword, state=state,
+                            page_num=page_num, page_size=page_size, pagination=backend_pagination,
+                        )
                         scope_source = "backend_applicant_scope"
                     if items is None:
                         items = self._resolve_department_candidates(context, field, keyword=keyword)
@@ -1710,7 +1725,10 @@ class RecordTools(ToolBase):
                                 workflow_node_id=None,
                                 fields={},
                             )
-                            items = self._resolve_department_candidates_backend(context, field, keyword=keyword, state=state)
+                            items = self._resolve_department_candidates_backend(
+                                context, field, keyword=keyword, state=state,
+                                page_num=page_num, page_size=page_size, pagination=backend_pagination,
+                            )
                             scope_source = "backend_applicant_scope"
                     warnings.append(
                         {
@@ -1741,7 +1759,7 @@ class RecordTools(ToolBase):
             total = len(items)
             start = (page_num - 1) * page_size
             end = start + page_size
-            page_items = items[start:end]
+            page_items = items if backend_pagination else items[start:end]
             page_amount = (total + page_size - 1) // page_size if total else 0
             return {
                 "profile": profile,
@@ -1758,6 +1776,7 @@ class RecordTools(ToolBase):
                         "returned_items": len(page_items),
                         "reported_total": total,
                         "page_amount": page_amount,
+                        **backend_pagination,
                     },
                     "selection": {
                         "app_key": app_key,
@@ -1888,7 +1907,7 @@ class RecordTools(ToolBase):
         query_fields: list[JSONObject | int] | None = None,
         where: list[JSONObject],
         order_by: list[JSONObject],
-        limit: int = DEFAULT_RECORD_LIST_RETURN_LIMIT,
+        limit: int | None = None,
         page: int = 1,
         page_size: int = DEFAULT_RECORD_LIST_RETURN_LIMIT,
         view_id: str | None = None,
@@ -1905,12 +1924,14 @@ class RecordTools(ToolBase):
         normalized_columns = _normalize_public_column_selectors(columns)
         normalized_query = _normalize_optional_text(query)
         normalized_query_field_selectors = _normalize_public_query_field_selectors(query_fields or [])
-        if limit <= 0:
+        if limit is not None and limit <= 0:
             raise_tool_error(QingflowApiError.config_error("limit must be positive"))
         if page <= 0:
             raise_tool_error(QingflowApiError.config_error("page must be positive"))
         if page_size <= 0:
             raise_tool_error(QingflowApiError.config_error("page_size must be positive"))
+        if limit is not None:
+            page_size = min(limit, page_size)
         if not (
             _normalize_optional_text(view_id)
             or list_type is not None
@@ -1989,7 +2010,7 @@ class RecordTools(ToolBase):
                 search_que_ids=resolved_query_fields or None,
                 match_rules=match_rules,
                 sort_rules=sort_rules,
-                max_rows=min(limit, page_size),
+                max_rows=page_size,
                 selected_fields=selected_fields,
                 output_profile="verbose" if normalized_output_profile in {"verbose", "normalized"} else DEFAULT_OUTPUT_PROFILE,
             )
@@ -2263,57 +2284,22 @@ class RecordTools(ToolBase):
                 }
 
             run_dir = _record_access_run_dir()
-            run_dir.mkdir(parents=True, exist_ok=True)
             header = ["record_id"] + [str(field["column_name"]) for field in fields_payload]
-            files: list[JSONObject] = []
-            shard_part = 0
-            shard_rows = 0
-            row_count = 0
-            file_handle: Any | None = None
-            writer: Any | None = None
-
-            def close_shard() -> None:
-                nonlocal file_handle, writer, shard_rows
-                if file_handle is None:
-                    return
-                path = Path(file_handle.name)
-                file_handle.close()
-                files.append(
-                    {
-                        "local_path": str(path),
-                        "row_count": shard_rows,
-                        "part": len(files) + 1,
-                    }
-                )
-                file_handle = None
-                writer = None
-                shard_rows = 0
-
-            def ensure_writer() -> Any:
-                nonlocal file_handle, writer, shard_part
-                if writer is not None:
-                    return writer
-                shard_part += 1
-                path = run_dir / f"records-{shard_part:04d}.csv"
-                file_handle = path.open("w", newline="", encoding="utf-8-sig")
-                writer = csv.writer(file_handle)
-                writer.writerow(header)
-                return writer
+            shard_writer = CsvShardWriter(
+                output_dir=run_dir,
+                file_prefix="records",
+                header=header,
+                shard_rows=DEFAULT_RECORD_ACCESS_SHARD_ROWS,
+            )
 
             def write_record(apply_id: int | None, answer_list: list[JSONValue]) -> None:
-                nonlocal row_count, shard_rows
                 if apply_id is None:
                     return
-                if shard_rows >= DEFAULT_RECORD_ACCESS_SHARD_ROWS:
-                    close_shard()
-                csv_writer = ensure_writer()
                 values: list[str] = [_public_record_id_text(apply_id) or ""]
                 for field in selected_fields:
                     answer = _find_answer_for_field(answer_list, field)
                     values.append(_record_access_csv_cell(_normalize_answer_field_value_for_output(answer, field)))
-                csv_writer.writerow(values)
-                row_count += 1
-                shard_rows += 1
+                shard_writer.write(values)
 
             current_page = 1
             has_more = False
@@ -2353,7 +2339,7 @@ class RecordTools(ToolBase):
                         break
                     page = fetch_page(current_page, BACKEND_RECORD_ACCESS_PAGE_SIZE)
             finally:
-                close_shard()
+                shard_writer.close_shard()
 
             if stopped_reason == "TIME_BUDGET_EXCEEDED":
                 warnings.append(_record_access_time_budget_warning(reported_total=reported_total, fetched_pages=fetched_pages))
@@ -2378,11 +2364,11 @@ class RecordTools(ToolBase):
                 "view_id": view_route.view_id,
                 "format": "csv",
                 "local_dir": str(run_dir),
-                "row_count": row_count,
+                "row_count": shard_writer.row_count,
                 "complete": complete,
                 "truncated": not complete,
                 "safe_for_final_conclusion": safe_for_final_conclusion,
-                "files": files,
+                "files": shard_writer.files,
                 "fields": fields_payload,
                 "warnings": warnings,
                 "verification": verification_payload,
@@ -13314,6 +13300,9 @@ class RecordTools(ToolBase):
         *,
         keyword: str,
         state: LookupResolutionState,
+        page_num: int = 1,
+        page_size: int = LOOKUP_RELATION_FILTER_PAGE_SIZE,
+        pagination: JSONObject | None = None,
     ) -> list[JSONObject]:
         """执行内部辅助逻辑。"""
         scope = field.member_select_scope if isinstance(field.member_select_scope, dict) else {}
@@ -13321,7 +13310,9 @@ class RecordTools(ToolBase):
             isinstance(scope.get("externalMemberList"), list) and scope.get("externalMemberList")
             or isinstance(scope.get("externalDepartList"), list) and scope.get("externalDepartList")
         )
-        payload = self._build_lookup_scope_payload(state, keyword=keyword, que_id=field.que_id)
+        payload = self._build_lookup_scope_payload(
+            state, keyword=keyword, que_id=field.que_id, page_num=page_num, page_size=page_size,
+        )
         route = f"/data/que/{field.que_id}/external/memberSelectScope" if use_external else f"/data/que/{field.que_id}/memberSelectScope"
         try:
             result = self.backend.request("POST", context, route, json_body=payload)
@@ -13334,7 +13325,10 @@ class RecordTools(ToolBase):
                     details={"field": _field_ref_payload(field), "received_value": keyword, "candidate_error": exc.to_dict()},
                 )
             self._raise_candidate_lookup_failed(kind="member", field=field, value=keyword, error=exc)
-        return self._normalize_backend_member_candidates(result, external=use_external)
+        items = self._normalize_backend_member_candidates(result, external=use_external)
+        if pagination is not None:
+            pagination.update(_candidate_page_metadata(result, page_num=page_num, page_size=page_size, returned_items=len(items)))
+        return items
 
     def _member_confirmation_candidates(self, candidates: list[JSONObject]) -> list[JSONObject]:
         """执行内部辅助逻辑。"""
@@ -13603,16 +13597,24 @@ class RecordTools(ToolBase):
         *,
         keyword: str,
         state: LookupResolutionState,
+        page_num: int = 1,
+        page_size: int = LOOKUP_RELATION_FILTER_PAGE_SIZE,
+        pagination: JSONObject | None = None,
     ) -> list[JSONObject]:
         """执行内部辅助逻辑。"""
         scope = field.dept_select_scope if isinstance(field.dept_select_scope, dict) else {}
         external = bool(
             isinstance(scope.get("externalDepartList"), list) and scope.get("externalDepartList")
         )
-        payload = self._build_lookup_scope_payload(state, keyword=keyword, que_id=field.que_id)
+        payload = self._build_lookup_scope_payload(
+            state, keyword=keyword, que_id=field.que_id, page_num=page_num, page_size=page_size,
+        )
         payload["deptScope"] = "EXTERNAL" if external else "INTERNAL"
         result = self.backend.request("POST", context, "/data/deptSelectScope/search", json_body=payload)
-        return self._normalize_backend_department_candidates(result, external=external)
+        items = self._normalize_backend_department_candidates(result, external=external)
+        if pagination is not None:
+            pagination.update(_candidate_page_metadata(result, page_num=page_num, page_size=page_size, returned_items=len(items)))
+        return items
 
     def _department_confirmation_candidates(self, candidates: list[JSONObject]) -> list[JSONObject]:
         """执行内部辅助逻辑。"""
@@ -17881,6 +17883,28 @@ def _normalize_public_record_rows(rows: list[JSONValue]) -> list[JSONObject]:
     return normalized_rows
 
 
+def _candidate_page_metadata(
+    payload: JSONValue, *, page_num: int, page_size: int, returned_items: int,
+) -> JSONObject:
+    page = payload if isinstance(payload, dict) else {}
+    total = _coerce_count(page.get("total"))
+    page_amount = _coerce_count(page.get("pageAmount"))
+    # Some member-scope endpoints return rows without a total. A full page is not a total.
+    if total is None and returned_items < page_size and (page_num == 1 or returned_items > 0):
+        total = (page_num - 1) * page_size + returned_items
+    if page_amount is None and total is not None:
+        page_amount = (total + page_size - 1) // page_size
+    has_more = page_num < page_amount if page_amount is not None else returned_items >= page_size
+    return {
+        "page": page_num,
+        "page_size": page_size,
+        "returned_items": returned_items,
+        "reported_total": total,
+        "page_amount": page_amount,
+        "has_more": has_more,
+    }
+
+
 def _build_record_list_lookup_payload(
     *,
     query: str | None,

package/src/qingflow_mcp/tools/resource_read_tools.py

@@ -6,6 +6,7 @@ from typing import Any
 from ..errors import QingflowApiError, backend_code_int, is_auth_like_error, raise_tool_error
 from ..json_types import JSONObject
 from ..list_type_labels import SYSTEM_VIEW_DEFINITIONS
+from ..resource_uri import try_build_resource_uri
 from ..solution.compiler.icon_utils import workspace_icon_config
 from .app_tools import _analysis_supported_for_view_type
 from .base import ToolBase
@@ -227,6 +228,17 @@ class ResourceReadTools(ToolBase):
                             "message": f"view_get supports exporting `{view_id}`, but the export call still needs an explicit `app_key` from the parent app context.",
                         }
                     )
+            uri = None
+            if resolved_app_key:
+                uri, uri_warning = try_build_resource_uri(
+                    ws_id=session_profile.selected_ws_id,
+                    resource_type="view",
+                    app_key=resolved_app_key,
+                    view_kind="custom",
+                    view_key=view_key,
+                )
+                if uri_warning:
+                    warnings.append(uri_warning)
             return {
                 "profile": profile,
                 "ws_id": session_profile.selected_ws_id,
@@ -249,6 +261,7 @@ class ResourceReadTools(ToolBase):
                     ],
                     "analysis_supported": _analysis_supported_for_view_type(raw_view_type or None),
                     "export_capability": export_capability,
+                    **({"uri": uri} if uri else {}),
                 },
             }
 

package/src/qingflow_mcp/tools/task_context_tools.py

@@ -201,7 +201,15 @@ class TaskContextTools(ToolBase):
         items = response["items"] if isinstance(response.get("items"), list) else []
         page_amount = response.get("page_amount")
         reported_total = response.get("reported_total")
-        if query and not items:
+        search_has_no_matches = not items and not (_coerce_count(reported_total) or 0)
+        if query and search_has_no_matches and page > 1:
+            first_page = self._list_normalized_task_items(
+                profile=profile, task_box=task_box, flow_status=flow_status,
+                app_key=app_key, workflow_node_id=workflow_node_id,
+                query=query, page=1, page_size=page_size,
+            )
+            search_has_no_matches = not first_page["items"] and not (_coerce_count(first_page.get("reported_total")) or 0)
+        if query and search_has_no_matches:
             fallback = self._task_list_local_query_fallback(
                 profile=profile,
                 task_box=task_box,
@@ -1238,6 +1246,7 @@ class TaskContextTools(ToolBase):
         scan_page = 1
         page_amount: int | None = None
         matched_items: list[dict[str, Any]] = []
+        scanned_items = 0
         while True:
             response = self._list_normalized_task_items(
                 profile=profile,
@@ -1250,14 +1259,22 @@ class TaskContextTools(ToolBase):
                 page_size=scan_page_size,
             )
             normalized_items = response.get("items") if isinstance(response.get("items"), list) else []
+            scanned_items += len(normalized_items)
             matched_items.extend(item for item in normalized_items if self._task_item_matches_query(item, query))
             if page_amount is None:
                 coerced_page_amount = _coerce_count(response.get("page_amount"))
                 if coerced_page_amount is not None and coerced_page_amount > 0:
                     page_amount = coerced_page_amount
-            if page_amount is not None and scan_page >= page_amount:
+            if not normalized_items:
                 break
-            if not normalized_items or len(normalized_items) < scan_page_size:
+            reported_total = _coerce_count(response.get("reported_total"))
+            if page_amount is not None:
+                if scan_page >= page_amount:
+                    break
+            elif reported_total is not None:
+                if scanned_items >= reported_total:
+                    break
+            elif len(normalized_items) < scan_page_size:
                 break
             scan_page += 1
         if not matched_items:
@@ -1527,7 +1544,7 @@ class TaskContextTools(ToolBase):
             if report_item.get("graph_type") == "view":
                 viewgraph_key = str(report_item.get("chart_key") or "")
                 body = {
-                    "filter": {},
+                    "filter": {"pageNum": page, "pageSize": page_size},
                     "viewgraphKey": viewgraph_key,
                     "equipmentType": 0,
                     "associationQuery": association_query,

package/src/qingflow_mcp/tools/workspace_tools.py

@@ -94,8 +94,13 @@ class WorkspaceTools(ToolBase):
             normalized = result if isinstance(result, dict) else {"list": result if isinstance(result, list) else []}
             workspace_list = normalized.get("list") if isinstance(normalized.get("list"), list) else []
             selected_ws_id = _.selected_ws_id if _ is not None else None
+            selected_in_page = bool(
+                selected_ws_id
+                and any(isinstance(item, dict) and item.get("wsId") == selected_ws_id for item in workspace_list)
+            )
             warnings: list[dict[str, Any]] = []
-            if selected_ws_id and not any(isinstance(item, dict) and item.get("wsId") == selected_ws_id for item in workspace_list):
+            selected_workspace = None
+            if page_num == 1 and selected_ws_id and not selected_in_page:
                 try:
                     selected_workspace = self.backend.request("GET", context, f"/user/workspace/{selected_ws_id}")
                 except QingflowApiError as exc:
@@ -106,23 +111,15 @@ class WorkspaceTools(ToolBase):
                         "wsId": selected_ws_id,
                         "workspaceName": _.selected_ws_name if _ is not None else None,
                     }
-                if isinstance(selected_workspace, dict):
-                    workspace_list.append(selected_workspace)
-                    normalized["list"] = workspace_list
-                    total = normalized.get("total")
-                    if isinstance(total, int):
-                        normalized["total"] = total + 1
             return {
                 "profile": profile,
                 "include_external": include_external,
                 "page": normalized,
+                "selected_workspace": selected_workspace,
                 "warnings": warnings,
                 "verification": {
-                    "selected_workspace_detail_verified": not warnings,
-                    "selected_workspace_included": bool(
-                        selected_ws_id
-                        and any(isinstance(item, dict) and item.get("wsId") == selected_ws_id for item in workspace_list)
-                    ),
+                    "selected_workspace_detail_verified": not warnings and (selected_in_page or isinstance(selected_workspace, dict)),
+                    "selected_workspace_included": selected_in_page,
                 },
             }