nolo-cli 0.1.39 → 0.1.41

package/ai/tools/table/createTableTool.ts

@@ -0,0 +1,315 @@
+// 文件: ai/tools/table/createTableTool.ts
+
+import { createTable } from "../../../render/table/tableSlice";
+import { SEPARATOR } from "../../../database/keys";
+
+type ColumnType =
+    | "text"
+    | "number"
+    | "boolean"
+    | "date"
+    | "datetime"
+    | "select"
+    | "multi_select";
+
+interface ToolTableColumnInput {
+    name: string;
+    label?: string;
+    type?: ColumnType;
+    description?: string;
+    required?: boolean;
+    options?: string[];
+}
+
+type CreateTableToolArgs = {
+    spaceId?: string;
+    title?: string;
+    description?: string;
+    tags?: string[];
+    categoryId?: string;
+    columns: ToolTableColumnInput[];
+    withDefaultRows?: boolean;
+};
+
+type CreateTableResult = {
+    rawData: any;
+    displayData: string;
+};
+
+/**
+ * 解析 meta dbKey，得到 tenantId / tableId
+ * 约定：meta-{tenantId}-{tableId}
+ */
+const parseMetaKey = (dbKey: string): { tenantId: string; tableId: string } => {
+    const parts = dbKey.split(SEPARATOR);
+    if (parts[0] !== "meta" || parts.length < 3) {
+        return { tenantId: "", tableId: "" };
+    }
+    const tenantId = parts[1];
+    const tableId = parts.slice(2).join(SEPARATOR);
+    return { tenantId, tableId };
+};
+
+const toPreviewJson = (value: unknown, maxLength = 400): string => {
+    try {
+        const json = JSON.stringify(value, null, 2);
+        if (json.length <= maxLength) return json;
+        return `${json.slice(0, maxLength)}\n…(已截断)…`;
+    } catch {
+        return "[无法序列化为 JSON]";
+    }
+};
+
+/**
+ * [Schema] createTable：为当前用户创建一张新表
+ */
+export const createTableFunctionSchema = {
+    name: "createTable",
+    description: [
+        "在当前用户（租户）下创建一张新的结构化数据表。",
+        "根据用户的描述，设计表的标题（title）、用途说明（description）以及字段列表（columns）。",
+        "字段名建议使用简洁的英文或拼音（如 name, desc, status, dueDate），避免空格和特殊符号。",
+    ].join("\n"),
+    parameters: {
+        type: "object",
+        properties: {
+            spaceId: {
+                type: "string",
+                description:
+                    "可选：指定要创建到的 Space ID。不传则使用当前 Space。",
+            },
+            title: {
+                type: "string",
+                description:
+                    "表的显示名称，可以使用中文，例如「任务清单」「客户管理」。",
+            },
+            description: {
+                type: "string",
+                description:
+                    "表用途说明（给人和 AI 看）：建议描述每一行代表什么，以及这张表大致用来干什么。",
+            },
+            tags: {
+                type: "array",
+                items: { type: "string" },
+                description:
+                    "可选：表示该表的关键词标签列表，例如 [\"记账\",\"交易\",\"预算\"]。主要供 AI 选表使用，用户无需手动维护。",
+            },
+            categoryId: {
+                type: "string",
+                description: "可选：Space 内分类 ID。",
+            },
+            columns: {
+                type: "array",
+                description: [
+                    "要创建的字段列表，至少包含 1 个字段。",
+                    "字段顺序会按数组顺序保存。",
+                    "",
+                    "每个字段对象支持：",
+                    "- name: 字段 machine 名（英文/拼音，无空格），必填；",
+                    "- label: 字段显示名，可中文；",
+                    "- type: 字段类型，默认 text，可选：text/number/boolean/date/datetime/select/multi_select；",
+                    "- description: 字段含义说明，给人和 AI 看；",
+                    "- required: 是否必填；",
+                    "- options: 对于 select/multi_select 的可选值列表。",
+                ].join("\n"),
+                minItems: 1,
+                items: {
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description:
+                                "字段名（machine name），例如 name、desc、status、dueDate。必须是单个标识符，不要包含空格。",
+                        },
+                        label: {
+                            type: "string",
+                            description:
+                                "字段显示名，可中文，例如「订单金额」「备注」。不填时前端会回退为 name。",
+                        },
+                        type: {
+                            type: "string",
+                            enum: [
+                                "text",
+                                "number",
+                                "boolean",
+                                "date",
+                                "datetime",
+                                "select",
+                                "multi_select",
+                            ],
+                            description:
+                                "字段类型，默认 text。选择类字段请使用 select 或 multi_select。",
+                        },
+                        description: {
+                            type: "string",
+                            description:
+                                "字段含义说明，既给用户也给 AI 看，例如「订单金额（单位人民币）」。",
+                        },
+                        required: {
+                            type: "boolean",
+                            description: "是否为必填字段。",
+                        },
+                        options: {
+                            type: "array",
+                            items: { type: "string" },
+                            description:
+                                "当 type 为 select 或 multi_select 时可用，表示允许的取值列表，例如 [\"created\",\"paid\",\"done\"]。",
+                        },
+                    },
+                    required: ["name"],
+                },
+            },
+            withDefaultRows: {
+                type: "boolean",
+                description:
+                    "是否自动创建两行示例数据。默认 false（AI 创建的表通常不需要示例行）。",
+            },
+        },
+        required: ["columns"],
+    },
+};
+
+/**
+ * [Executor] 创建一张新表（调用 tableSlice.createTable thunk）
+ */
+export async function createTableFunc(
+    args: CreateTableToolArgs,
+    thunkApi: any
+): Promise<CreateTableResult> {
+    const spaceId =
+        typeof args?.spaceId === "string" && args.spaceId.trim()
+            ? args.spaceId.trim()
+            : undefined;
+    const title =
+        typeof args?.title === "string" && args.title.trim()
+            ? args.title.trim()
+            : undefined;
+    const description =
+        typeof args?.description === "string" && args.description.trim()
+            ? args.description.trim()
+            : undefined;
+    const tags =
+        Array.isArray(args?.tags) && args.tags.length
+            ? args.tags
+                .map((t) => (typeof t === "string" ? t.trim() : ""))
+                .filter(Boolean)
+            : undefined;
+    const categoryId =
+        typeof args?.categoryId === "string" && args.categoryId.trim()
+            ? args.categoryId.trim()
+            : undefined;
+    const withDefaultRows =
+        typeof args?.withDefaultRows === "boolean" ? args.withDefaultRows : false;
+
+    const columnsInput = Array.isArray(args?.columns) ? args.columns : [];
+
+    if (columnsInput.length === 0) {
+        throw new Error(
+            "createTable.columns 至少需要包含一个字段，请根据用户需求设计字段。"
+        );
+    }
+
+    // 1. 清洗字段：去空白、去重
+    const seen = new Set<string>();
+    const sanitizedColumns: ToolTableColumnInput[] = [];
+
+    for (const col of columnsInput) {
+        if (!col || typeof col.name !== "string") continue;
+        const name = col.name.trim();
+        if (!name) continue;
+        if (seen.has(name)) continue;
+        seen.add(name);
+
+        const sanitized: ToolTableColumnInput = { name };
+
+        if (typeof col.label === "string" && col.label.trim()) {
+            sanitized.label = col.label.trim();
+        }
+        if (typeof col.type === "string") {
+            sanitized.type = col.type as ColumnType;
+        }
+        if (typeof col.description === "string" && col.description.trim()) {
+            sanitized.description = col.description.trim();
+        }
+        if (typeof col.required === "boolean") {
+            sanitized.required = col.required;
+        }
+        if (Array.isArray(col.options)) {
+            const opts = col.options
+                .map((opt) => (typeof opt === "string" ? opt.trim() : ""))
+                .filter(Boolean);
+            if (opts.length) sanitized.options = opts;
+        }
+
+        sanitizedColumns.push(sanitized);
+    }
+
+    if (sanitizedColumns.length === 0) {
+        throw new Error(
+            "createTable.columns 中没有任何有效的字段名，请为至少一个字段提供非空的 name。"
+        );
+    }
+
+    // 2. 构造 CreateTableArgs（与 render/table/createTableAction.ts 对齐）
+    const createArgs: any = {
+        spaceId,
+        title,
+        description,
+        tags,
+        categoryId,
+        columns: sanitizedColumns,
+        withDefaultRows,
+    };
+
+    try {
+        const actionResult = await thunkApi.dispatch(createTable(createArgs));
+
+        if (!createTable.fulfilled.match(actionResult)) {
+            const msg =
+                (actionResult.payload as string) ||
+                actionResult.error?.message ||
+                "创建表失败";
+            throw new Error(msg);
+        }
+
+        // createTableAction 返回的是 dbKey（string）
+        const dbKey = actionResult.payload as string;
+
+        // 解析出 tenantId / tableId
+        const { tenantId, tableId } = parseMetaKey(dbKey);
+
+        const finalTitle = title || "新建表格";
+        const colNamesForDisplay = sanitizedColumns.map((c) => c.name).join(", ");
+
+        // 给聊天前端的结构化数据，供 Tool 卡片渲染
+        const tableMetaForUi = {
+            dbKey, // meta-{tenantId}-{tableId}
+            tenantId,
+            tableId,
+            displayName: finalTitle,
+            description,
+            tags,
+            columns: sanitizedColumns, // [{ name, label?, type?, description?, required?, options? }]
+        };
+
+        return {
+            rawData: tableMetaForUi,
+            displayData:
+                `已创建新表「${finalTitle}」（tableId: ${tableId}）。\n` +
+                `字段列表：${colNamesForDisplay}\n\n` +
+                `接下来调用 addTableRow 时，请传入完整结构：\n` +
+                `{\n` +
+                `  "tenantId": "${tenantId}",\n` +
+                `  "tableId": "${tableId}",\n` +
+                `  "values": {\n` +
+                `    "列名": "字段值"\n` +
+                `  }\n` +
+                `}\n\n` +
+                `服务器返回 dbKey：\n${toPreviewJson(dbKey)}`,
+        };
+    } catch (error: any) {
+        throw new Error(
+            `createTable 调用失败：${error?.message ?? "未知错误"}`
+        );
+    }
+}

package/ai/tools/table/rowTools.ts

@@ -0,0 +1,386 @@
+import type { RootState } from "../../../app/store";
+import { buildNoloTableQueryRequest } from "../../../agent-runtime/noloWorkspaceTools";
+import {
+  applyRowFilters,
+  formatKnownColumns,
+  normalizeRowValues,
+  pickRowColumns,
+  sortRows,
+  type RowFilters,
+} from "../../../render/table/toolValueUtils";
+import { buildNewRow, ensureRowsLoaded, loadTableMetaOrThrow, patchRecord, resolveRowOrThrow, resolveTableIdentity, writeRow } from "./toolShared";
+
+const toPreviewJson = (value: unknown, maxLength = 600): string => {
+  try {
+    const json = JSON.stringify(value, null, 2);
+    if (json.length <= maxLength) return json;
+    return `${json.slice(0, maxLength)}\n…(已截断)…`;
+  } catch {
+    return "[无法序列化为 JSON]";
+  }
+};
+
+const selectCurrentUserId = (state: RootState) =>
+  typeof state.auth?.currentUser?.userId === "string"
+    ? state.auth.currentUser.userId
+    : undefined;
+
+const normalizeTableQueryArgs = (args: any, thunkApi: any) => {
+  const state = thunkApi.getState() as RootState;
+  return buildNoloTableQueryRequest(args ?? {}, selectCurrentUserId(state)) ?? args;
+};
+
+const requireTableIdentity = (args: { tenantId?: string; tableId?: string }, thunkApi: any) => {
+  const state = thunkApi.getState() as RootState;
+  const { tenantId, tableId } = resolveTableIdentity(args, state);
+  if (!tenantId || !tableId) {
+    throw new Error("需要显式提供 tenantId 和 tableId，或在已打开的表页面中调用。");
+  }
+  return { tenantId, tableId };
+};
+
+export const queryTableRowsFunctionSchema = {
+  name: "queryTableRows",
+  description: "查询指定表中的行，支持简单字段过滤、排序、分页和返回指定列。",
+  parameters: {
+    type: "object",
+    properties: {
+      tenantId: { type: "string", description: "租户 ID。聊天场景中必须显式传入。" },
+      tableId: { type: "string", description: "表 ID。聊天场景中必须显式传入。" },
+      table: { type: "string", description: "表 ID 或 meta-tenantId-tableId；兼容 Nolo CLI 参数。" },
+      metaKey: { type: "string", description: "表 meta key；兼容 table。" },
+      row: { type: "string", description: "可选 rowId 或 row-* dbKey，只查一行。" },
+      filters: {
+        type: "object",
+        description: "按列名做精确匹配过滤，例如 {\"status\":\"todo\"}。",
+      },
+      columns: {
+        type: "array",
+        items: { type: "string" },
+        description: "可选：只返回这些列。",
+      },
+      limit: { type: "number", description: "最多返回多少行，默认 20，最大 200。" },
+      offset: { type: "number", description: "从第几行开始返回，默认 0。" },
+      includeBaseFields: {
+        type: "boolean",
+        description: "配合 columns 使用。设为 false 时不额外返回 dbKey/rowId/tenantId/tableId/createdAt/updatedAt，适合任务表概览。",
+      },
+      sortBy: { type: "string", description: "排序字段，默认 updatedAt。" },
+      sortOrder: {
+        type: "string",
+        enum: ["asc", "desc"],
+        description: "排序方向，默认 desc。",
+      },
+    },
+  },
+};
+
+export async function queryTableRowsFunc(args: any, thunkApi: any) {
+  args = normalizeTableQueryArgs(args, thunkApi);
+  const { tenantId, tableId } = requireTableIdentity(args, thunkApi);
+  const tableMeta = await loadTableMetaOrThrow(thunkApi, tenantId, tableId);
+  const rows = await ensureRowsLoaded(thunkApi, tenantId, tableId);
+  const filters = (args?.filters ?? {}) as RowFilters;
+  const limit = Math.min(Math.max(Number(args?.limit ?? 20), 1), 200);
+  const offset = Math.max(Number(args?.offset ?? 0), 0);
+  const sortBy = typeof args?.sortBy === "string" && args.sortBy.trim() ? args.sortBy.trim() : "updatedAt";
+  const sortOrder = args?.sortOrder === "asc" ? "asc" : "desc";
+  const columns = Array.isArray(args?.columns)
+    ? args.columns.filter((value: unknown): value is string => typeof value === "string" && value.trim().length > 0)
+    : undefined;
+  const includeBaseFields = args?.includeBaseFields !== false;
+
+  const filtered = applyRowFilters(rows, filters);
+  const sorted = sortRows(filtered, sortBy, sortOrder);
+  const page = sorted.slice(offset, offset + limit);
+  const items = columns ? page.map((row) => pickRowColumns(row, columns, { includeBaseFields })) : page;
+
+  return {
+    rawData: {
+      tenantId,
+      tableId,
+      total: filtered.length,
+      limit,
+      offset,
+      items,
+    },
+    displayData:
+      `在表「${tableMeta.displayName || tableId}」中查询到 ${filtered.length} 行，当前返回 ${items.length} 行。\n` +
+      `字段：${formatKnownColumns(tableMeta)}\n\n` +
+      `${toPreviewJson(items)}`,
+  };
+}
+
+export const updateTableRowFunctionSchema = {
+  name: "updateTableRow",
+  description: "按 rowId 或 dbKey 更新指定表中的一行数据，只修改 changes 中提供的字段。",
+  parameters: {
+    type: "object",
+    properties: {
+      tenantId: { type: "string" },
+      tableId: { type: "string" },
+      rowId: { type: "string", description: "要更新的行 ID。" },
+      dbKey: { type: "string", description: "要更新的行 dbKey。rowId 与 dbKey 二选一即可。" },
+      changes: {
+        type: "object",
+        description: "要修改的字段集合，例如 {\"status\":\"done\"}。",
+      },
+    },
+    required: ["changes"],
+  },
+};
+
+export async function updateTableRowFunc(args: any, thunkApi: any) {
+  const { tenantId, tableId } = requireTableIdentity(args, thunkApi);
+  const tableMeta = await loadTableMetaOrThrow(thunkApi, tenantId, tableId);
+  const targetRow = await resolveRowOrThrow(thunkApi, { tenantId, tableId, rowId: args?.rowId, dbKey: args?.dbKey });
+  const changes = args?.changes;
+
+  if (!changes || typeof changes !== "object" || Array.isArray(changes)) {
+    throw new Error("updateTableRow.changes 必须是对象。");
+  }
+
+  const normalized = normalizeRowValues(tableMeta.columns, changes, { mode: "update" });
+  if (normalized.errors.length > 0) {
+    throw new Error(normalized.errors.join("\n"));
+  }
+  if (Object.keys(normalized.sanitizedValues).length === 0) {
+    throw new Error(
+      `updateTableRow 没有可更新的有效字段。已知字段：${formatKnownColumns(tableMeta)}`
+    );
+  }
+
+  const updatedAt = new Date().toISOString();
+  const updated = await patchRecord(thunkApi, targetRow.dbKey, {
+    ...normalized.sanitizedValues,
+    updatedAt,
+  });
+
+  const ignoredInfo =
+    normalized.ignoredColumns.length > 0
+      ? `\n\n注意：以下字段已忽略：${normalized.ignoredColumns.join(", ")}`
+      : "";
+
+  return {
+    rawData: updated,
+    displayData:
+      `已更新表「${tableMeta.displayName || tableId}」中的行 ${targetRow.rowId}。${ignoredInfo}\n\n` +
+      `${toPreviewJson(updated)}`,
+  };
+}
+
+export const deleteTableRowFunctionSchema = {
+  name: "deleteTableRow",
+  description: "删除指定表中的一行数据（软删除）。",
+  parameters: {
+    type: "object",
+    properties: {
+      tenantId: { type: "string" },
+      tableId: { type: "string" },
+      rowId: { type: "string" },
+      dbKey: { type: "string" },
+    },
+  },
+};
+
+export async function deleteTableRowFunc(args: any, thunkApi: any) {
+  const { tenantId, tableId } = requireTableIdentity(args, thunkApi);
+  const tableMeta = await loadTableMetaOrThrow(thunkApi, tenantId, tableId);
+  const targetRow = await resolveRowOrThrow(thunkApi, { tenantId, tableId, rowId: args?.rowId, dbKey: args?.dbKey });
+  const updatedAt = new Date().toISOString();
+  const deleted = await patchRecord(thunkApi, targetRow.dbKey, {
+    deletedAt: updatedAt,
+    updatedAt,
+  });
+
+  return {
+    rawData: deleted,
+    displayData: `已从表「${tableMeta.displayName || tableId}」中删除行 ${targetRow.rowId}。`,
+  };
+}
+
+export const addTableRowsFunctionSchema = {
+  name: "addTableRows",
+  description: "批量向指定表中新增多行数据。",
+  parameters: {
+    type: "object",
+    properties: {
+      tenantId: { type: "string" },
+      tableId: { type: "string" },
+      rows: {
+        type: "array",
+        items: { type: "object" },
+        description: "每一项都是一行数据对象，key 必须是表中的列名。",
+      },
+    },
+    required: ["rows"],
+  },
+};
+
+export async function addTableRowsFunc(args: any, thunkApi: any) {
+  const { tenantId, tableId } = requireTableIdentity(args, thunkApi);
+  const tableMeta = await loadTableMetaOrThrow(thunkApi, tenantId, tableId);
+  const rows = Array.isArray(args?.rows) ? args.rows : [];
+  if (rows.length === 0) {
+    throw new Error("addTableRows.rows 至少需要包含一行。");
+  }
+
+  const createdRows: any[] = [];
+  const ignoredColumns = new Set<string>();
+  for (const row of rows) {
+    if (!row || typeof row !== "object" || Array.isArray(row)) {
+      throw new Error("addTableRows.rows 中的每一项都必须是对象。");
+    }
+    const normalized = normalizeRowValues(tableMeta.columns, row, { mode: "create" });
+    if (normalized.errors.length > 0) {
+      throw new Error(normalized.errors.join("\n"));
+    }
+    if (Object.keys(normalized.sanitizedValues).length === 0) {
+      throw new Error(`存在一行没有任何有效字段。已知字段：${formatKnownColumns(tableMeta)}`);
+    }
+    normalized.ignoredColumns.forEach((column) => ignoredColumns.add(column));
+    const created = buildNewRow(tenantId, tableId, normalized.sanitizedValues);
+    await writeRow(thunkApi, created);
+    createdRows.push(created);
+  }
+
+  const ignoredInfo =
+    ignoredColumns.size > 0 ? `\n\n注意：以下字段已忽略：${Array.from(ignoredColumns).join(", ")}` : "";
+
+  return {
+    rawData: {
+      count: createdRows.length,
+      items: createdRows,
+    },
+    displayData:
+      `已向表「${tableMeta.displayName || tableId}」批量新增 ${createdRows.length} 行。${ignoredInfo}\n\n` +
+      `${toPreviewJson(createdRows.slice(0, 10))}`,
+  };
+}
+
+export const updateTableRowsFunctionSchema = {
+  name: "updateTableRows",
+  description: "批量更新多行数据。每项都需要 rowId 或 dbKey，以及 changes。",
+  parameters: {
+    type: "object",
+    properties: {
+      tenantId: { type: "string" },
+      tableId: { type: "string" },
+      updates: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            rowId: { type: "string" },
+            dbKey: { type: "string" },
+            changes: { type: "object" },
+          },
+        },
+      },
+    },
+    required: ["updates"],
+  },
+};
+
+export async function updateTableRowsFunc(args: any, thunkApi: any) {
+  const { tenantId, tableId } = requireTableIdentity(args, thunkApi);
+  const tableMeta = await loadTableMetaOrThrow(thunkApi, tenantId, tableId);
+  const updates = Array.isArray(args?.updates) ? args.updates : [];
+  if (updates.length === 0) {
+    throw new Error("updateTableRows.updates 至少需要包含一项。");
+  }
+
+  const results: any[] = [];
+  const ignoredColumns = new Set<string>();
+  for (const item of updates) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      throw new Error("updateTableRows.updates 中的每一项都必须是对象。");
+    }
+    const targetRow = await resolveRowOrThrow(thunkApi, {
+      tenantId,
+      tableId,
+      rowId: item.rowId,
+      dbKey: item.dbKey,
+    });
+    const normalized = normalizeRowValues(tableMeta.columns, item.changes ?? {}, { mode: "update" });
+    if (normalized.errors.length > 0) {
+      throw new Error(normalized.errors.join("\n"));
+    }
+    if (Object.keys(normalized.sanitizedValues).length === 0) {
+      throw new Error(`行 ${targetRow.rowId} 没有可更新的有效字段。`);
+    }
+    normalized.ignoredColumns.forEach((column) => ignoredColumns.add(column));
+    const updated = await patchRecord(thunkApi, targetRow.dbKey, {
+      ...normalized.sanitizedValues,
+      updatedAt: new Date().toISOString(),
+    });
+    results.push(updated);
+  }
+
+  const ignoredInfo =
+    ignoredColumns.size > 0 ? `\n\n注意：以下字段已忽略：${Array.from(ignoredColumns).join(", ")}` : "";
+
+  return {
+    rawData: {
+      count: results.length,
+      items: results,
+    },
+    displayData:
+      `已批量更新表「${tableMeta.displayName || tableId}」中的 ${results.length} 行。${ignoredInfo}`,
+  };
+}
+
+export const deleteTableRowsFunctionSchema = {
+  name: "deleteTableRows",
+  description: "批量删除多行数据（软删除）。",
+  parameters: {
+    type: "object",
+    properties: {
+      tenantId: { type: "string" },
+      tableId: { type: "string" },
+      rowIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "要删除的 rowId 列表。",
+      },
+      dbKeys: {
+        type: "array",
+        items: { type: "string" },
+        description: "要删除的 dbKey 列表。",
+      },
+    },
+  },
+};
+
+export async function deleteTableRowsFunc(args: any, thunkApi: any) {
+  const { tenantId, tableId } = requireTableIdentity(args, thunkApi);
+  const tableMeta = await loadTableMetaOrThrow(thunkApi, tenantId, tableId);
+  const rowIds = Array.isArray(args?.rowIds) ? args.rowIds : [];
+  const dbKeys = Array.isArray(args?.dbKeys) ? args.dbKeys : [];
+  const targets = [
+    ...rowIds.map((rowId: string) => ({ rowId })),
+    ...dbKeys.map((dbKey: string) => ({ dbKey })),
+  ];
+
+  if (targets.length === 0) {
+    throw new Error("deleteTableRows 需要至少提供一个 rowId 或 dbKey。");
+  }
+
+  const results = [];
+  for (const target of targets) {
+    const row = await resolveRowOrThrow(thunkApi, { tenantId, tableId, rowId: target.rowId, dbKey: target.dbKey });
+    const deleted = await patchRecord(thunkApi, row.dbKey, {
+      deletedAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+    results.push(deleted);
+  }
+
+  return {
+    rawData: {
+      count: results.length,
+      items: results,
+    },
+    displayData: `已从表「${tableMeta.displayName || tableId}」中批量删除 ${results.length} 行。`,
+  };
+}