@modesto_ma/dsh-channels 0.5.0-beta.2 → 0.5.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modesto_ma/dsh-channels",
-  "version": "0.5.0-beta.2",
+  "version": "0.5.0-beta.3",
   "description": "DeepSeek Harness (DSH) 飞书渠道插件：一个 dsh 实例对应一个飞书机器人，私聊/群聊/话题群 @ 触发会话，话题绑定 session，卡片 2.0 流式回复；Web 设置里提供「飞书渠道」状态与常用配置面板",
   "repository": {
     "type": "git",

package/src/config.ts

@@ -48,6 +48,9 @@ export const DEFAULT_ATTACHMENT_FETCH_MAX_BYTES = 100 * 1024 * 1024
 /** Default whole-call timeout of `feishu_attachment_fetch` (120 s). */
 export const DEFAULT_ATTACHMENT_FETCH_TIMEOUT_MS = 120_000
 
+/** Largest delay Node's `setTimeout` honors (2^31 − 1 ms, about 24.8 days); longer delays fire at once. */
+export const MAX_TIMER_DELAY_MS = 2_147_483_647
+
 /** Default per-image byte cap for trigger-message prefetch (20 MiB). */
 export const DEFAULT_PREFETCH_IMAGE_MAX_BYTES = 20 * 1024 * 1024
 
@@ -265,10 +268,12 @@ export const configSchema = z.object({
    *   fetch (1–50). A message with more attachments is refused with a readable
    *   reason so the model can retry per `file_key`.
    * - `attachmentFetchMaxBytes`: total download budget of one tool call
-   *   (default 100 MiB). Files stream to the native attachment library, so the
-   *   limit is enforced while streaming rather than buffered first.
-   * - `attachmentFetchTimeoutMs`: whole-call timeout (default 120 s). On expiry
-   *   the in-flight download is cancelled and reported per attachment.
+   *   (default 100 MiB, no upper bound). Files stream to the native attachment
+   *   library, so the limit is enforced while streaming rather than buffered
+   *   first, and multi-GiB files need only disk space.
+   * - `attachmentFetchTimeoutMs`: whole-call timeout (default 120 s, at most
+   *   {@link MAX_TIMER_DELAY_MS}). On expiry the in-flight download is
+   *   cancelled and reported per attachment.
    * - `topicMessages` (default on): register `feishu_topic_messages` in
    *   channel sessions so the model can read the quoted message / earlier
    *   topic messages on demand and authorize their attachments for fetch.
@@ -288,14 +293,21 @@ export const configSchema = z.object({
    *   `im:resource` (or `im:resource:upload`) scope; without it a call returns
    *   a readable failure and the turn continues.
    *
-   * - `wikiRead` (default off): register `feishu_wiki_list` and
-   *   `feishu_wiki_read` so the model can browse the wiki nodes under
-   *   `wikiRoots` and read docx documents there. Needs `wiki:wiki` (or
-   *   `wiki:wiki:readonly`) and `docx:document` (or `docx:document:readonly`).
-   * - `wikiWrite` (default off): register `feishu_wiki_create` and
-   *   `feishu_wiki_edit` so the model can create docx documents under
-   *   `wikiRoots` and edit documents this app owns. Needs `wiki:wiki` and
-   *   `docx:document`.
+   * - `wikiRead` (default off): register `feishu_wiki_list`,
+   *   `feishu_wiki_read`, `feishu_wiki_sheet_read`, and
+   *   `feishu_wiki_base_read` so the model can browse the wiki nodes under
+   *   `wikiRoots` and read docx documents, spreadsheets, and Bases there.
+   *   Needs `wiki:wiki` (or `wiki:wiki:readonly`), `docx:document` (or
+   *   `docx:document:readonly`), `sheets:spreadsheet` (or a read-only
+   *   spreadsheet scope), and `bitable:app` (or a read-only Base scope).
+   * - `wikiWrite` (default off): register `feishu_wiki_create`,
+   *   `feishu_wiki_edit`, `feishu_wiki_sheet_edit`, and
+   *   `feishu_wiki_base_edit` so the model can create docx documents,
+   *   spreadsheets, and Bases under `wikiRoots`, edit documents and
+   *   spreadsheets this app owns, and change records of Bases this app owns
+   *   (other Bases accept new records only). Needs `wiki:wiki`,
+   *   `docx:document`, `sheets:spreadsheet`, and `bitable:app` (or the
+   *   matching write-only scopes).
    *
    * The wiki tools act with the app identity and are mounted only while
    * `wikiRoots` is non-empty. Each call is limited to topics whose owner is
@@ -309,9 +321,9 @@ export const configSchema = z.object({
     attachmentFetch: z.boolean().default(true),
     attachmentFetchMaxResources: z.number().int().min(1).max(50)
       .default(DEFAULT_ATTACHMENT_FETCH_MAX_RESOURCES),
-    attachmentFetchMaxBytes: z.number().int().min(1).max(1024 * 1024 * 1024)
+    attachmentFetchMaxBytes: z.number().int().min(1)
       .default(DEFAULT_ATTACHMENT_FETCH_MAX_BYTES),
-    attachmentFetchTimeoutMs: z.number().int().min(1_000).max(600_000)
+    attachmentFetchTimeoutMs: z.number().int().min(1_000).max(MAX_TIMER_DELAY_MS)
       .default(DEFAULT_ATTACHMENT_FETCH_TIMEOUT_MS),
     topicMessages: z.boolean().default(true),
     topicMessagesTimeoutMs: z.number().int().min(1_000).max(120_000)

package/src/feishu/scopes.ts

@@ -91,16 +91,28 @@ const SEND_FILE_REQUIREMENT: ScopeRequirement = {
   anyOf: ['im:resource', 'im:resource:upload'], level: 'optional', purpose: '上传图片/文件，让模型用 feishu_send_file 把生成的文件发给用户',
 }
 
-/** Wiki read needs (`feishu_wiki_list` / `feishu_wiki_read`). */
+/** Spreadsheet and Base read needs, shared by the wiki read and write sets. */
+const SHEET_BASE_READ_REQUIREMENTS: readonly ScopeRequirement[] = [
+  { anyOf: ['sheets:spreadsheet', 'sheets:spreadsheet:readonly', 'sheets:spreadsheet:read'], level: 'optional', purpose: '读取知识库电子表格（feishu_wiki_sheet_read）' },
+  { anyOf: ['bitable:app', 'bitable:app:readonly', 'base:record:read'], level: 'optional', purpose: '读取知识库多维表格（feishu_wiki_base_read）' },
+]
+
+/** Wiki read needs (`feishu_wiki_list` / `feishu_wiki_read` and the sheet/base read tools). */
 const WIKI_READ_REQUIREMENTS: readonly ScopeRequirement[] = [
   { anyOf: ['wiki:wiki', 'wiki:wiki:readonly'], level: 'optional', purpose: '浏览知识库节点（feishu_wiki_list / feishu_wiki_read）' },
   { anyOf: ['docx:document', 'docx:document:readonly'], level: 'optional', purpose: '读取知识库中的文档内容（feishu_wiki_read）' },
+  ...SHEET_BASE_READ_REQUIREMENTS,
 ]
 
 /** Wiki write needs (`feishu_wiki_create` / `feishu_wiki_edit`). */
 const WIKI_WRITE_REQUIREMENTS: readonly ScopeRequirement[] = [
   { anyOf: ['wiki:wiki'], level: 'optional', purpose: '在知识库中新建节点（feishu_wiki_create）' },
   { anyOf: ['docx:document'], level: 'optional', purpose: '写入与修改知识库文档内容（feishu_wiki_create / feishu_wiki_edit）' },
+  { anyOf: ['sheets:spreadsheet', 'sheets:spreadsheet:write_only'], level: 'optional', purpose: '写入知识库电子表格（feishu_wiki_sheet_edit）' },
+  { anyOf: ['bitable:app', 'base:record:create'], level: 'optional', purpose: '新增知识库多维表格记录（feishu_wiki_base_edit）' },
+  { anyOf: ['bitable:app', 'base:record:update'], level: 'optional', purpose: '修改本应用创建的多维表格中的记录（feishu_wiki_base_edit）' },
+  { anyOf: ['bitable:app', 'base:record:delete'], level: 'optional', purpose: '删除本应用创建的多维表格中的记录（feishu_wiki_base_edit）' },
+  ...SHEET_BASE_READ_REQUIREMENTS,
 ]
 
 /** Group receive needs while ordinary group messages require an @ mention. */

package/src/feishu/wiki/a1.ts

@@ -0,0 +1,97 @@
+/**
+ * A1 notation helpers for the wiki sheet tools: column letters, single cells,
+ * and rectangle end rows. Ranges never carry a sheet prefix (`Sheet1!`); the
+ * sub-sheet is selected separately.
+ *
+ * @module dsh-channels/feishu/wiki/a1
+ */
+
+/** Largest column the helpers accept (`ZZZ`). */
+const MAX_COLUMN = 18_278
+
+/** Largest row the helpers accept. */
+const MAX_ROW = 10_000_000
+
+/** One cell position, 1-based. */
+export interface A1Cell {
+  readonly column: number
+  readonly row: number
+}
+
+/**
+ * Column letters to a 1-based index (`A` → 1, `AA` → 27).
+ *
+ * @param letters Column letters, any case.
+ * @returns The index, or undefined when invalid or beyond `ZZZ`.
+ */
+export function columnIndex(letters: string): number | undefined {
+  if (!/^[A-Za-z]{1,3}$/u.test(letters)) return undefined
+  let index = 0
+  for (const char of letters.toUpperCase()) index = index * 26 + (char.charCodeAt(0) - 64)
+  return index <= MAX_COLUMN ? index : undefined
+}
+
+/**
+ * A 1-based column index to letters (1 → `A`, 27 → `AA`).
+ *
+ * @param index Column index, at least 1.
+ * @returns The letters.
+ */
+export function columnLetters(index: number): string {
+  let letters = ''
+  let rest = index
+  while (rest > 0) {
+    const digit = (rest - 1) % 26
+    letters = String.fromCharCode(65 + digit) + letters
+    rest = Math.floor((rest - 1) / 26)
+  }
+  return letters
+}
+
+/**
+ * Parse one cell (`B3`).
+ *
+ * @param value Cell reference.
+ * @returns The position, or undefined when it is not a single valid cell.
+ */
+export function parseCell(value: string): A1Cell | undefined {
+  const match = /^([A-Za-z]{1,3})([1-9]\d{0,7})$/u.exec(value.trim())
+  if (match === null) return undefined
+  const column = columnIndex(match[1] ?? '')
+  const row = Number(match[2])
+  return column === undefined || row > MAX_ROW ? undefined : { column, row }
+}
+
+/**
+ * The rectangle that starts at `start` and spans `rows` × `columns` cells.
+ *
+ * @param start Top-left cell.
+ * @param rows Row count, at least 1.
+ * @param columns Column count, at least 1.
+ * @returns The range (`B3:D10`).
+ */
+export function rectangle(start: A1Cell, rows: number, columns: number): string {
+  return `${columnLetters(start.column)}${start.row}:${columnLetters(start.column + columns - 1)}${start.row + rows - 1}`
+}
+
+/**
+ * Last row of a range (`A1:B5` → 5, `C7` → 7); undefined for whole-column ranges (`A:C`).
+ *
+ * @param range A1 range.
+ * @returns The row, or undefined.
+ */
+export function rangeEndRow(range: string): number | undefined {
+  const end = range.split(':').at(-1) ?? ''
+  const match = /(\d+)$/u.exec(end.trim())
+  return match === null ? undefined : Number(match[1])
+}
+
+/**
+ * Whether a range is plain A1 (`A1`, `A1:F30`, `A:C`, `3:5`) without a sheet prefix.
+ *
+ * @param range Candidate range.
+ * @returns True when acceptable.
+ */
+export function isA1Range(range: string): boolean {
+  return /^(?:[A-Za-z]{1,3}\d{0,8}|\d{1,8})(?::(?:[A-Za-z]{1,3}\d{0,8}|\d{1,8}))?$/u.test(range)
+}

package/src/feishu/wiki/api.ts

@@ -123,13 +123,14 @@ export interface WikiApi {
    */
   listChildren(spaceId: string, parentNodeToken: string | undefined, pageToken?: string): Promise<WikiNodePage>
   /**
-   * Create one empty docx node.
+   * Create one empty docx, spreadsheet, or Base node.
    * @param spaceId Wiki space id.
    * @param parentNodeToken Parent node, or undefined for the space top level.
    * @param title Node title.
+   * @param objType Object kind of the new node.
    * @returns The new node.
    */
-  createDocxNode(spaceId: string, parentNodeToken: string | undefined, title: string): Promise<WikiNode>
+  createNode(spaceId: string, parentNodeToken: string | undefined, title: string, objType: 'docx' | 'sheet' | 'bitable'): Promise<WikiNode>
   /**
    * Current revision of one docx document.
    * @param documentId Docx document id (the node's `objToken`).
@@ -193,7 +194,15 @@ function thrownError(error: unknown): FeishuApiError {
   return new FeishuApiError([code === undefined ? undefined : `code=${code}`, msg].filter(Boolean).join(' '), code)
 }
 
-async function call<T>(request: WikiRawRequest, input: Parameters<WikiRawRequest>[0]): Promise<T> {
+/**
+ * One Feishu OpenAPI call: unwraps `data` and maps a transport error or a
+ * non-zero `code` to {@link FeishuApiError}.
+ *
+ * @param request The SDK's generic request.
+ * @param input Method, URL, query, and body.
+ * @returns The response `data`.
+ */
+export async function call<T>(request: WikiRawRequest, input: Parameters<WikiRawRequest>[0]): Promise<T> {
   let response: FeishuEnvelope<T>
   try {
     response = await request<FeishuEnvelope<T>>(input)
@@ -226,7 +235,13 @@ function wikiNode(raw: RawNode | undefined, where: string): WikiNode {
   }
 }
 
-function segment(value: string): string {
+/**
+ * Encode one URL path segment.
+ *
+ * @param value Raw segment.
+ * @returns The encoded segment.
+ */
+export function segment(value: string): string {
   return encodeURIComponent(value)
 }
 
@@ -265,13 +280,13 @@ export function createWikiApi(request: WikiRawRequest): WikiApi {
         ...(data.has_more === true && data.page_token !== undefined && data.page_token !== '' ? { pageToken: data.page_token } : {}),
       }
     },
-    async createDocxNode(spaceId, parentNodeToken, title) {
+    async createNode(spaceId, parentNodeToken, title, objType) {
       const url = `/open-apis/wiki/v2/spaces/${segment(spaceId)}/nodes`
       const data = await call<{ node?: RawNode }>(request, {
         method: 'POST',
         url,
         data: {
-          obj_type: 'docx',
+          obj_type: objType,
           node_type: 'origin',
           title,
           ...(parentNodeToken === undefined ? {} : { parent_node_token: parentNodeToken }),

package/src/feishu/wiki/base-api.ts

@@ -0,0 +1,267 @@
+/**
+ * Feishu Base (多维表格) calls used by the wiki base tools, made with the app
+ * identity (tenant access token).
+ *
+ * Everything goes through `base/v3/bases/:base_token/...` (the legacy
+ * `bitable/v1` API is not used). Record reads return a column matrix that
+ * this module turns into one field map per record; record writes take flat
+ * maps keyed by field name or field id. Writes carry no precondition, are
+ * applied asynchronously (a read straight after a write may not show it), and
+ * must not run in parallel on one table.
+ *
+ * @module dsh-channels/feishu/wiki/base-api
+ */
+
+import { FeishuApiError } from '../../feishu-channel.ts'
+import { call, segment } from './api.ts'
+import type { WikiRawRequest } from './api.ts'
+
+/** Most records one batch write may carry (Feishu limit). */
+export const BASE_BATCH_MAX_RECORDS = 200
+
+/** One table of a base. */
+export interface BaseTable {
+  readonly tableId: string
+  readonly name: string
+}
+
+/** One field (column) of a table, as Feishu describes it. */
+export interface BaseField {
+  readonly fieldId: string
+  readonly name: string
+  /** `text`, `number`, `select`, `datetime`, `user`, `link`, `checkbox`, … */
+  readonly type: string
+  /** Remaining Feishu field properties (style, options, multiple, …), passed through. */
+  readonly properties: Readonly<Record<string, unknown>>
+}
+
+/** One cell value as Feishu reads or writes it (JSON). */
+export type BaseCellValue = unknown
+
+/** One record: its id and a map from field name to value. */
+export interface BaseRecord {
+  readonly recordId: string
+  readonly fields: Readonly<Record<string, BaseCellValue>>
+}
+
+/** Filter, sort, projection, and paging of a record query. */
+export interface BaseRecordQuery {
+  /** `{logic, conditions: [[field, operator, value?], …]}`. */
+  readonly filter?: object
+  /** `[{field, desc}]`. */
+  readonly sort?: readonly object[]
+  /** Field names or ids to return; all view-visible fields when absent. */
+  readonly fields?: readonly string[]
+  readonly viewId?: string
+  readonly offset: number
+  readonly limit: number
+}
+
+/** A keyword search over some fields. */
+export interface BaseRecordSearch extends BaseRecordQuery {
+  readonly keyword: string
+  readonly searchFields: readonly string[]
+}
+
+/** One page of records. */
+export interface BaseRecordPage {
+  readonly records: readonly BaseRecord[]
+  readonly hasMore: boolean
+  /** Table data snapshot version; changes when the data changes. */
+  readonly rev?: number
+  readonly timezone?: string
+  /** Fields Feishu skipped, with its reason. */
+  readonly ignoredFields: readonly string[]
+}
+
+/** Field values of one record write, keyed by field name or id. */
+export type BaseRecordFields = Readonly<Record<string, BaseCellValue>>
+
+/** The `base/v3` endpoints the wiki base tools consume. */
+export interface BaseApi {
+  /**
+   * Tables of one base.
+   * @param baseToken Base token (the wiki node's `objToken`).
+   * @returns The tables.
+   */
+  listTables(baseToken: string): Promise<readonly BaseTable[]>
+  /**
+   * Fields of one table.
+   * @param baseToken Base token.
+   * @param tableId Table id.
+   * @returns The fields.
+   */
+  listFields(baseToken: string, tableId: string): Promise<readonly BaseField[]>
+  /**
+   * One page of records, filtered and sorted.
+   * @param baseToken Base token.
+   * @param tableId Table id.
+   * @param query Filter, sort, projection, paging.
+   * @returns The page.
+   */
+  listRecords(baseToken: string, tableId: string, query: BaseRecordQuery): Promise<BaseRecordPage>
+  /**
+   * One page of records matching a keyword.
+   * @param baseToken Base token.
+   * @param tableId Table id.
+   * @param search Keyword, searched fields, and query options.
+   * @returns The page.
+   */
+  searchRecords(baseToken: string, tableId: string, search: BaseRecordSearch): Promise<BaseRecordPage>
+  /**
+   * Create records (at most {@link BASE_BATCH_MAX_RECORDS}).
+   * @param baseToken Base token.
+   * @param tableId Table id.
+   * @param records Field maps.
+   * @returns The new record ids, in input order.
+   */
+  createRecords(baseToken: string, tableId: string, records: readonly BaseRecordFields[]): Promise<readonly string[]>
+  /**
+   * Update records (at most {@link BASE_BATCH_MAX_RECORDS}); only the given fields change.
+   * @param baseToken Base token.
+   * @param tableId Table id.
+   * @param updates Record id → changed fields.
+   * @returns Fields Feishu ignored (read-only fields), with its reason.
+   */
+  updateRecords(baseToken: string, tableId: string, updates: Readonly<Record<string, BaseRecordFields>>): Promise<readonly string[]>
+  /**
+   * Delete records (at most {@link BASE_BATCH_MAX_RECORDS}).
+   * @param baseToken Base token.
+   * @param tableId Table id.
+   * @param recordIds Records to delete.
+   */
+  deleteRecords(baseToken: string, tableId: string, recordIds: readonly string[]): Promise<void>
+}
+
+interface RawMatrix {
+  fields?: unknown
+  record_id_list?: unknown
+  data?: unknown
+  has_more?: unknown
+  rev?: unknown
+  timezone?: unknown
+  ignored_fields?: unknown
+}
+
+function stringArray(value: unknown): string[] | undefined {
+  return Array.isArray(value) && value.every(item => typeof item === 'string') ? value as string[] : undefined
+}
+
+function ignoredFieldsOf(value: unknown): string[] {
+  if (!Array.isArray(value)) return []
+  return value.flatMap((item) => {
+    if (typeof item !== 'object' || item === null) return []
+    const { name, id, reason } = item as { name?: unknown; id?: unknown; reason?: unknown }
+    const label = typeof name === 'string' && name !== '' ? name : typeof id === 'string' ? id : '?'
+    return [typeof reason === 'string' && reason !== '' ? `${label}: ${reason}` : label]
+  })
+}
+
+function recordPage(raw: RawMatrix, where: string): BaseRecordPage {
+  const names = stringArray(raw.fields) ?? []
+  const ids = stringArray(raw.record_id_list) ?? []
+  const rows = Array.isArray(raw.data) ? raw.data : []
+  if (rows.length !== ids.length) throw new FeishuApiError(`${where}: record ids and rows differ in length`)
+  const records = ids.map((recordId, index) => {
+    const row: unknown = rows[index]
+    if (!Array.isArray(row) || row.length !== names.length) throw new FeishuApiError(`${where}: row ${index} does not match the field list`)
+    return { recordId, fields: Object.fromEntries(names.map((name, column) => [name, row[column] ?? null])) }
+  })
+  return {
+    records,
+    hasMore: raw.has_more === true,
+    ...(typeof raw.rev === 'number' ? { rev: raw.rev } : {}),
+    ...(typeof raw.timezone === 'string' && raw.timezone !== '' ? { timezone: raw.timezone } : {}),
+    ignoredFields: ignoredFieldsOf(raw.ignored_fields),
+  }
+}
+
+/**
+ * {@link BaseApi} over the SDK's generic authenticated request.
+ *
+ * @param request `Client.request` of the connected SDK client.
+ * @returns The API.
+ */
+export function createBaseApi(request: WikiRawRequest): BaseApi {
+  const tablePath = (baseToken: string, tableId: string): string =>
+    `/open-apis/base/v3/bases/${segment(baseToken)}/tables/${segment(tableId)}`
+  return {
+    async listTables(baseToken) {
+      const data = await call<{ tables?: unknown; items?: unknown }>(request, {
+        method: 'GET',
+        url: `/open-apis/base/v3/bases/${segment(baseToken)}/tables`,
+        params: { offset: 0, limit: 300 },
+      })
+      const raw = Array.isArray(data.tables) ? data.tables : Array.isArray(data.items) ? data.items : []
+      return raw.flatMap((item: unknown) => {
+        if (typeof item !== 'object' || item === null) return []
+        const { id, table_id, name, table_name } = item as Record<string, unknown>
+        const tableId = typeof id === 'string' ? id : typeof table_id === 'string' ? table_id : undefined
+        if (tableId === undefined) return []
+        return [{ tableId, name: typeof name === 'string' ? name : typeof table_name === 'string' ? table_name : '' }]
+      })
+    },
+    async listFields(baseToken, tableId) {
+      const data = await call<{ fields?: unknown; items?: unknown }>(request, {
+        method: 'GET',
+        url: `${tablePath(baseToken, tableId)}/fields`,
+        params: { offset: 0, limit: 300 },
+      })
+      const raw = Array.isArray(data.fields) ? data.fields : Array.isArray(data.items) ? data.items : []
+      return raw.flatMap((item: unknown) => {
+        if (typeof item !== 'object' || item === null) return []
+        const { id, field_id, name, field_name, type, ...properties } = item as Record<string, unknown>
+        const fieldId = typeof id === 'string' ? id : typeof field_id === 'string' ? field_id : undefined
+        if (fieldId === undefined) return []
+        return [{
+          fieldId,
+          name: typeof name === 'string' ? name : typeof field_name === 'string' ? field_name : '',
+          type: typeof type === 'string' ? type : 'not_support',
+          properties,
+        }]
+      })
+    },
+    async listRecords(baseToken, tableId, query) {
+      const url = `${tablePath(baseToken, tableId)}/records`
+      const params = new URLSearchParams({ offset: String(query.offset), limit: String(query.limit) })
+      for (const field of query.fields ?? []) params.append('field_id', field)
+      if (query.viewId !== undefined) params.set('view_id', query.viewId)
+      if (query.filter !== undefined) params.set('filter', JSON.stringify(query.filter))
+      if (query.sort !== undefined) params.set('sort', JSON.stringify(query.sort))
+      const data = await call<RawMatrix>(request, { method: 'GET', url: `${url}?${params.toString()}` })
+      return recordPage(data, url)
+    },
+    async searchRecords(baseToken, tableId, search) {
+      const url = `${tablePath(baseToken, tableId)}/records/search`
+      const data = await call<RawMatrix>(request, {
+        method: 'POST',
+        url,
+        data: {
+          keyword: search.keyword,
+          search_fields: search.searchFields,
+          ...(search.fields === undefined ? {} : { select_fields: search.fields }),
+          ...(search.viewId === undefined ? {} : { view_id: search.viewId }),
+          ...(search.filter === undefined ? {} : { filter: search.filter }),
+          ...(search.sort === undefined ? {} : { sort: search.sort }),
+          offset: search.offset,
+          limit: search.limit,
+        },
+      })
+      return recordPage(data, url)
+    },
+    async createRecords(baseToken, tableId, records) {
+      const url = `${tablePath(baseToken, tableId)}/records/batch_create`
+      const data = await call<{ record_id_list?: unknown }>(request, { method: 'POST', url, data: { create_records: records } })
+      return stringArray(data.record_id_list) ?? []
+    },
+    async updateRecords(baseToken, tableId, updates) {
+      const url = `${tablePath(baseToken, tableId)}/records/batch_update`
+      const data = await call<{ ignored_fields?: unknown }>(request, { method: 'POST', url, data: { update_records: updates } })
+      return ignoredFieldsOf(data.ignored_fields)
+    },
+    async deleteRecords(baseToken, tableId, recordIds) {
+      const url = `${tablePath(baseToken, tableId)}/records/batch_delete`
+      await call<unknown>(request, { method: 'POST', url, data: { record_id_list: recordIds } })
+    },
+  }
+}