@josephyan/qingflow-app-builder-mcp 0.2.0-beta.1008 → 0.2.0-beta.1011

package/README.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-builder-mcp",
-  "version": "0.2.0-beta.1008",
+  "version": "0.2.0-beta.1011",
   "description": "Builder MCP for Qingflow app/package/system design and staged solution workflows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qingflow-mcp"
-version = "0.2.0b1008"
+version = "0.2.0b1011"
 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.0b1008"
+_FALLBACK_VERSION = "0.2.0b1011"
 
 
 def _resolve_local_pyproject_version() -> str | None:

package/src/qingflow_mcp/backend_client.py

@@ -474,6 +474,115 @@ class BackendClient:
                 pass
         return import_result
 
+    def start_socket_record_export(
+        self,
+        context: BackendRequestContext,
+        *,
+        app_key: str,
+        view_id: str,
+        filter_bean: JSONObject,
+        export_config: JSONObject,
+        view_key: str | None = None,
+        result_amount: int = 0,
+        ack_timeout_seconds: float = 8.0,
+    ) -> dict[str, Any]:
+        try:
+            import socketio  # type: ignore[import-not-found]
+        except ImportError as exc:
+            raise QingflowApiError(
+                category="config",
+                message=f"socket.io client dependency is missing: {exc}",
+            )
+
+        socket_base_url = self._build_socket_base_url(context.base_url)
+        export_result: dict[str, Any] = {
+            "backend_export_id": None,
+            "warnings": [],
+        }
+        sio = socketio.Client(reconnection=False, logger=False, engineio_logger=False)
+        event_name = "excelViewgraph" if view_key else "excel"
+        event_args: tuple[Any, ...]
+        if view_key:
+            event_args = (
+                context.token,
+                None,
+                view_key,
+                filter_bean,
+                export_config,
+                int(result_amount),
+            )
+        else:
+            event_args = (
+                context.token,
+                app_key,
+                filter_bean,
+                export_config,
+                int(result_amount),
+            )
+        try:
+            sio.connect(
+                socket_base_url,
+                transports=["websocket"],
+                socketio_path="socket.io",
+                headers=self._base_headers(
+                    context.token,
+                    context.ws_id,
+                    qf_version=context.qf_version,
+                ),
+                wait_timeout=ack_timeout_seconds,
+            )
+            sio.emit("token", context.token)
+            sleep(0.2)
+            ack = sio.call(
+                event_name,
+                event_args,
+                timeout=ack_timeout_seconds,
+            )
+            ack_payload = ack[0] if isinstance(ack, list) and ack else ack
+            export_id: Any = ack_payload
+            if isinstance(ack_payload, dict):
+                error_code = ack_payload.get("error")
+                ack_message = ack_payload.get("message")
+                export_id = ack_payload.get("data")
+                if isinstance(export_id, dict):
+                    export_id = (
+                        export_id.get("exportId")
+                        or export_id.get("export_id")
+                        or export_id.get("id")
+                    )
+                if error_code not in (None, 0):
+                    raise QingflowApiError(
+                        category="backend",
+                        message=str(ack_message or f"socket export rejected with error {error_code}"),
+                        details={
+                            "socket_error_code": error_code,
+                            "app_key": app_key,
+                            "view_id": view_id,
+                            "view_key": view_key,
+                        },
+                    )
+            if not export_id:
+                raise QingflowApiError(category="backend", message="socket export ack did not return export_id")
+            export_result["backend_export_id"] = str(export_id)
+        except Exception as exc:
+            message = str(exc)
+            if "timeout" in message.lower():
+                raise QingflowApiError(
+                    category="network",
+                    message="socket export ack timed out",
+                    details={"error_code": "EXPORT_SOCKET_ACK_TIMEOUT"},
+                )
+            if isinstance(exc, QingflowApiError):
+                raise
+            raise QingflowApiError(category="network", message=message or "socket export failed")
+        finally:
+            try:
+                if sio.connected:
+                    sio.disconnect()
+            except Exception:
+                pass
+        return export_result
+
     def _request_with_meta(
         self,
         method: str,

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

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import argparse
 
-from . import app, auth, builder, chart, imports, portal, record, task, view, workspace
+from . import app, auth, builder, chart, exports, imports, portal, record, task, view, workspace
 
 
 def register_all_commands(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
@@ -14,5 +14,6 @@ def register_all_commands(subparsers: argparse._SubParsersAction[argparse.Argume
     chart.register(subparsers)
     record.register(subparsers)
     imports.register(subparsers)
+    exports.register(subparsers)
     task.register(subparsers)
     builder.register(subparsers)

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

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import argparse
+
+from ..context import CliContext
+from .common import load_list_arg
+
+
+def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    parser = subparsers.add_parser("export", help="导出")
+    export_subparsers = parser.add_subparsers(dest="export_command", required=True)
+
+    start = export_subparsers.add_parser("start", help="启动导出")
+    start.add_argument("--app-key", required=True)
+    start.add_argument("--view-id", default="system:all")
+    start.add_argument("--column", dest="columns", action="append", type=int, default=[], help="只导出这些 field_id；不传时导出当前视图全部字段")
+    start.add_argument("--columns-file", help="JSON/YAML list，内容与 --column 语义一致")
+    start.add_argument("--record-id", dest="record_ids", action="append", default=[], help="只导出这些 record_id；不传时导出当前视图全部数据")
+    start.add_argument("--record-ids-file", help="JSON/YAML list，内容与 --record-id 语义一致")
+    start.add_argument("--include-workflow-log", action=argparse.BooleanOptionalAction, default=False, help="是否同时导出流程日志")
+    start.set_defaults(handler=_handle_start, format_hint="export_start")
+
+    status = export_subparsers.add_parser("status", help="查询导出状态")
+    status.add_argument("--export-handle", required=True)
+    status.set_defaults(handler=_handle_status, format_hint="export_status")
+
+    get = export_subparsers.add_parser("get", help="获取导出结果")
+    get.add_argument("--export-handle", required=True)
+    get.add_argument("--download-to-path")
+    get.set_defaults(handler=_handle_get, format_hint="export_get")
+
+    direct = export_subparsers.add_parser("direct", help="直接导出并下载")
+    direct.add_argument("--app-key", required=True)
+    direct.add_argument("--view-id", default="system:all")
+    direct.add_argument("--column", dest="columns", action="append", type=int, default=[], help="只导出这些 field_id；不传时导出当前视图全部字段")
+    direct.add_argument("--columns-file", help="JSON/YAML list，内容与 --column 语义一致")
+    direct.add_argument("--record-id", dest="record_ids", action="append", default=[], help="只导出这些 record_id；不传时导出当前视图全部数据")
+    direct.add_argument("--record-ids-file", help="JSON/YAML list，内容与 --record-id 语义一致")
+    direct.add_argument("--include-workflow-log", action=argparse.BooleanOptionalAction, default=False, help="是否同时导出流程日志")
+    direct.add_argument("--download-to-path")
+    direct.add_argument("--wait-timeout-seconds", type=float)
+    direct.set_defaults(handler=_handle_direct, format_hint="export_direct")
+
+
+def _columns(args: argparse.Namespace) -> list[int | dict]:
+    columns: list[int | dict] = list(args.columns or [])
+    if args.columns_file:
+        columns.extend(load_list_arg(args.columns_file, option_name="--columns-file"))
+    return columns
+
+
+def _record_ids(args: argparse.Namespace) -> list[str | int]:
+    record_ids: list[str | int] = list(args.record_ids or [])
+    if args.record_ids_file:
+        record_ids.extend(load_list_arg(args.record_ids_file, option_name="--record-ids-file"))
+    return record_ids
+
+
+def _handle_start(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.exports.record_export_start(
+        profile=args.profile,
+        app_key=args.app_key,
+        view_id=args.view_id,
+        columns=_columns(args),
+        record_ids=_record_ids(args),
+        include_workflow_log=args.include_workflow_log,
+    )
+
+
+def _handle_status(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.exports.record_export_status_get(
+        profile=args.profile,
+        export_handle=args.export_handle,
+    )
+
+
+def _handle_get(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.exports.record_export_get(
+        profile=args.profile,
+        export_handle=args.export_handle,
+        download_to_path=args.download_to_path,
+    )
+
+
+def _handle_direct(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.exports.record_export_direct(
+        profile=args.profile,
+        app_key=args.app_key,
+        view_id=args.view_id,
+        columns=_columns(args),
+        record_ids=_record_ids(args),
+        include_workflow_log=args.include_workflow_log,
+        download_to_path=args.download_to_path,
+        wait_timeout_seconds=args.wait_timeout_seconds,
+    )

package/src/qingflow_mcp/cli/context.py

@@ -8,6 +8,7 @@ from ..tools.ai_builder_tools import AiBuilderTools
 from ..tools.app_tools import AppTools
 from ..tools.auth_tools import AuthTools
 from ..tools.code_block_tools import CodeBlockTools
+from ..tools.export_tools import ExportTools
 from ..tools.feedback_tools import FeedbackTools
 from ..tools.file_tools import FileTools
 from ..tools.import_tools import ImportTools
@@ -29,6 +30,7 @@ class CliContext:
     record: RecordTools
     code_block: CodeBlockTools
     imports: ImportTools
+    exports: ExportTools
     task: TaskContextTools
     files: FileTools
     builder_feedback: FeedbackTools
@@ -52,6 +54,7 @@ def build_cli_context() -> CliContext:
         record=RecordTools(sessions, backend),
         code_block=CodeBlockTools(sessions, backend),
         imports=ImportTools(sessions, backend),
+        exports=ExportTools(sessions, backend),
         task=TaskContextTools(sessions, backend),
         files=FileTools(sessions, backend),
         builder_feedback=FeedbackTools(backend, mcp_side="App Builder MCP"),

package/src/qingflow_mcp/cli/formatters.py

@@ -412,6 +412,73 @@ def _format_import_status(result: dict[str, Any]) -> str:
     return "\n".join(lines) + "\n"
 
 
+def _format_export_common(result: dict[str, Any], *, title: str | None = None) -> str:
+    lines: list[str] = []
+    if title:
+        lines.append(title)
+    lines.extend(
+        [
+            f"Status: {result.get('status') or '-'}",
+            f"Export Handle: {result.get('export_handle') or '-'}",
+            f"App Key: {result.get('app_key') or '-'}",
+            f"View ID: {result.get('view_id') or '-'}",
+            f"Process Status: {result.get('process_status') or '-'}",
+            f"Rows: {result.get('num') if result.get('num') is not None else '-'}",
+        ]
+    )
+    row_scope = result.get("row_scope")
+    if row_scope not in (None, ""):
+        lines.append(f"Row Scope: {row_scope}")
+    selected_record_count = result.get("selected_record_count")
+    if selected_record_count not in (None, ""):
+        lines.append(f"Selected Rows: {selected_record_count}")
+    field_scope = result.get("field_scope")
+    if field_scope not in (None, ""):
+        lines.append(f"Field Scope: {field_scope}")
+    selected_field_count = result.get("selected_field_count")
+    if selected_field_count not in (None, ""):
+        lines.append(f"Selected Fields: {selected_field_count}")
+    include_workflow_log = result.get("include_workflow_log")
+    if include_workflow_log not in (None, ""):
+        lines.append(f"Include Workflow Log: {include_workflow_log}")
+    file_names = result.get("file_names") if isinstance(result.get("file_names"), list) else []
+    file_urls = result.get("file_urls") if isinstance(result.get("file_urls"), list) else []
+    if file_names or file_urls:
+        lines.append("Remote Files:")
+        max_items = max(len(file_names), len(file_urls))
+        for index in range(max_items):
+            name = file_names[index] if index < len(file_names) else "-"
+            url = file_urls[index] if index < len(file_urls) else "-"
+            lines.append(f"- {name}: {url}")
+    downloaded_files = result.get("downloaded_files") if isinstance(result.get("downloaded_files"), list) else []
+    if downloaded_files:
+        lines.append("Downloaded Files:")
+        for item in downloaded_files:
+            if isinstance(item, dict):
+                lines.append(f"- {item.get('file_name') or '-'}: {item.get('path') or '-'}")
+            else:
+                lines.append(f"- {item}")
+    _append_warnings(lines, result.get("warnings"))
+    _append_verification(lines, result.get("verification"))
+    return "\n".join(lines) + "\n"
+
+
+def _format_export_start(result: dict[str, Any]) -> str:
+    return _format_export_common(result, title="Export Accepted")
+
+
+def _format_export_status(result: dict[str, Any]) -> str:
+    return _format_export_common(result, title="Export Status")
+
+
+def _format_export_get(result: dict[str, Any]) -> str:
+    return _format_export_common(result, title="Export Result")
+
+
+def _format_export_direct(result: dict[str, Any]) -> str:
+    return _format_export_common(result, title="Export Direct")
+
+
 def _format_builder_summary(result: dict[str, Any]) -> str:
     lines = []
     if "status" in result:
@@ -626,5 +693,9 @@ _FORMATTERS = {
     "task_associated_report_detail_get": _format_task_associated_report_detail,
     "import_verify": _format_import_verify,
     "import_status": _format_import_status,
+    "export_start": _format_export_start,
+    "export_status": _format_export_status,
+    "export_get": _format_export_get,
+    "export_direct": _format_export_direct,
     "builder_summary": _format_builder_summary,
 }

package/src/qingflow_mcp/export_store.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from datetime import timedelta
+from pathlib import Path
+
+from .import_store import _JsonEntryStore, _store_dir
+
+
+class ExportJobStore(_JsonEntryStore):
+    def __init__(self, base_dir: Path | None = None, *, ttl_seconds: int = 24 * 3600) -> None:
+        super().__init__(
+            base_dir=base_dir or _store_dir("QINGFLOW_MCP_EXPORT_JOB_HOME", "export-jobs"),
+            ttl=timedelta(seconds=ttl_seconds),
+        )

package/src/qingflow_mcp/public_surface.py

@@ -91,6 +91,10 @@ USER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(USER_DOMAIN, "record_import_repair_local", ("record_import_repair_local",), ("import", "repair")),
     PublicToolSpec(USER_DOMAIN, "record_import_start", ("record_import_start",), ("import", "start")),
     PublicToolSpec(USER_DOMAIN, "record_import_status_get", ("record_import_status_get",), ("import", "status")),
+    PublicToolSpec(USER_DOMAIN, "record_export_start", ("record_export_start",), ("export", "start"), cli_show_effective_context=True),
+    PublicToolSpec(USER_DOMAIN, "record_export_status_get", ("record_export_status_get",), ("export", "status"), cli_show_effective_context=True),
+    PublicToolSpec(USER_DOMAIN, "record_export_get", ("record_export_get",), ("export", "get"), cli_show_effective_context=True),
+    PublicToolSpec(USER_DOMAIN, "record_export_direct", ("record_export_direct",), ("export", "direct"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "record_code_block_run", ("record_code_block_run",), ("record", "code-block-run"), cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(USER_DOMAIN, "task_list", ("task_list",), ("task", "list"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "task_get", ("task_get",), ("task", "get"), cli_show_effective_context=True),

package/src/qingflow_mcp/response_trim.py

@@ -674,6 +674,10 @@ def _trim_import_status_payload(payload: JSONObject) -> None:
         payload.pop(key, None)
 
 
+def _trim_export_payload(payload: JSONObject) -> None:
+    payload.pop("backend_export_id", None)
+
+
 def _summarize_import_issues(issues: list[Any]) -> dict[str, Any]:
     total = 0
     error_count = 0
@@ -756,6 +760,16 @@ _register_policy(
     ),
     _trim_import_schema,
 )
+_register_policy(
+    (USER_DOMAIN,),
+    (
+        "record_export_start",
+        "record_export_status_get",
+        "record_export_get",
+        "record_export_direct",
+    ),
+    _trim_export_payload,
+)
 _register_policy(
     (USER_DOMAIN,),
     (

package/src/qingflow_mcp/server.py

@@ -10,6 +10,7 @@ from .tools.app_tools import AppTools
 from .tools.auth_tools import AuthTools
 from .tools.code_block_tools import CodeBlockTools
 from .tools.feedback_tools import FeedbackTools
+from .tools.export_tools import ExportTools
 from .tools.file_tools import FileTools
 from .tools.import_tools import ImportTools
 from .tools.package_tools import PackageTools
@@ -50,6 +51,7 @@ All resource tools operate with the logged-in user's Qingflow permissions.
 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.
+`view_get(view_id=...)` also returns `export_capability`; it only means there is a supported export route, not that export permission has been verified.
 
 ## Schema-First Rule
 
@@ -147,6 +149,20 @@ Use `record_code_block_run` when the user wants to execute a form code-block fie
 - 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`.
 
+## Export Path
+
+`view_get -> record_export_start -> record_export_status_get -> record_export_get`
+
+- `record_export_direct` is the one-shot export path that starts the export, waits for completion, downloads locally, and still returns remote download links.
+- Export v1 supports record views only and follows the same public `view_id` semantics as `record_list` (`system:*` and `custom:*`).
+- `record_export_start` / `record_export_direct` support frontend-like row selection:
+  - omit `record_ids` to export all rows in the selected view
+  - pass `record_ids` to export selected rows only
+- `record_export_start` / `record_export_direct` also support frontend-like column selection:
+  - omit `columns` to export all current-view fields
+  - pass `columns` to export only selected fields, preserving the provided order
+- `include_workflow_log=true` maps to the native workflow-log export switch.
+
 ## Task Workflow Path
 
 `task_list -> task_get -> task_action_execute`
@@ -190,6 +206,7 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
     WorkspaceTools(sessions, backend).register(server)
     FileTools(sessions, backend).register(server)
     ImportTools(sessions, backend).register(server)
+    ExportTools(sessions, backend).register(server)
     CodeBlockTools(sessions, backend).register(server)
     TaskContextTools(sessions, backend).register(server)
     RoleTools(sessions, backend).register(server)

package/src/qingflow_mcp/server_app_user.py

@@ -13,6 +13,7 @@ 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.export_tools import ExportTools
 from .tools.feedback_tools import FeedbackTools
 from .tools.file_tools import FileTools
 from .tools.import_tools import ImportTools
@@ -33,6 +34,7 @@ def build_user_server() -> FastMCP:
 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.
+`view_get(view_id=...)` also returns `export_capability`; it only means there is a supported export route, not that export permission has been verified.
 
 ## Shared Helper
 
@@ -142,6 +144,20 @@ Use `record_code_block_run` when the user wants to execute a form code-block fie
 - 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`.
 
+## Export Path
+
+`view_get -> record_export_start -> record_export_status_get -> record_export_get`
+
+- `record_export_direct` is the one-shot path that starts export, waits, downloads locally, and still returns remote download links.
+- Export v1 supports record views only and follows the same public `view_id` semantics as `record_list`.
+- `record_export_start` / `record_export_direct` support frontend-like row selection:
+  - omit `record_ids` to export all rows in the selected view
+  - pass `record_ids` to export selected rows only
+- `record_export_start` / `record_export_direct` also support frontend-like column selection:
+  - omit `columns` to export all current-view fields
+  - pass `columns` to export only selected fields, preserving the provided order
+- `include_workflow_log=true` maps to the native workflow-log export switch.
+
 ## Task Workflow Path
 
 `task_list -> task_get -> task_action_execute`
@@ -188,6 +204,7 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
     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)
+    exports = wrap_trimmed_methods(ExportTools(sessions, backend), USER_SERVER_METHOD_MAP)
     resources = wrap_trimmed_methods(ResourceReadTools(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)
@@ -218,6 +235,65 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
     def auth_logout(profile: str = DEFAULT_PROFILE, forget_persisted: bool = False) -> dict:
         return auth.auth_logout(profile=profile, forget_persisted=forget_persisted)
 
+    @server.tool()
+    def record_export_start(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        view_id: str = "system:all",
+        columns: list[dict | int] | None = None,
+        record_ids: list[str | int] | None = None,
+        include_workflow_log: bool = False,
+    ) -> dict:
+        return exports.record_export_start(
+            profile=profile,
+            app_key=app_key,
+            view_id=view_id,
+            columns=columns or [],
+            record_ids=record_ids or [],
+            include_workflow_log=include_workflow_log,
+        )
+
+    @server.tool()
+    def record_export_status_get(
+        profile: str = DEFAULT_PROFILE,
+        export_handle: str = "",
+    ) -> dict:
+        return exports.record_export_status_get(profile=profile, export_handle=export_handle)
+
+    @server.tool()
+    def record_export_get(
+        profile: str = DEFAULT_PROFILE,
+        export_handle: str = "",
+        download_to_path: str | None = None,
+    ) -> dict:
+        return exports.record_export_get(
+            profile=profile,
+            export_handle=export_handle,
+            download_to_path=download_to_path,
+        )
+
+    @server.tool()
+    def record_export_direct(
+        profile: str = DEFAULT_PROFILE,
+        app_key: str = "",
+        view_id: str = "system:all",
+        columns: list[dict | int] | None = None,
+        record_ids: list[str | int] | None = None,
+        include_workflow_log: bool = False,
+        download_to_path: str | None = None,
+        wait_timeout_seconds: float | None = None,
+    ) -> dict:
+        return exports.record_export_direct(
+            profile=profile,
+            app_key=app_key,
+            view_id=view_id,
+            columns=columns or [],
+            record_ids=record_ids or [],
+            include_workflow_log=include_workflow_log,
+            download_to_path=download_to_path,
+            wait_timeout_seconds=wait_timeout_seconds,
+        )
+
     @server.tool()
     def workspace_list(
         profile: str = DEFAULT_PROFILE,