@tool-bridge/server 0.21.1 → 0.22.1

package/dist/airtable-ML2GIGCH.js

@@ -0,0 +1,790 @@
+import {
+  createAuthedClient
+} from "./chunk-RTW5VRTK.js";
+import "./chunk-BNMLA2RC.js";
+import {
+  asJsonObject,
+  booleanValue,
+  compactDefined,
+  integerValue,
+  trimmedText
+} from "./chunk-JXHMDBAY.js";
+import {
+  createProviderPlugin,
+  upstreamError
+} from "./chunk-X7ZUTKHR.js";
+import "./chunk-7ISGFRC6.js";
+import "./chunk-UY6ANCOY.js";
+import {
+  TBError
+} from "./chunk-HA4BGL6C.js";
+import "./chunk-U67V476Y.js";
+
+// ../plugins/src/airtable/api.ts
+var SERVICE = "airtable";
+var API_BASE = "https://api.airtable.com";
+var BASES_PATH = "/v0/meta/bases";
+var GET_URL_LENGTH_SOFT_LIMIT = 15e3;
+function requireText(value, field) {
+  const result = trimmedText(value);
+  if (result === void 0) throw new TBError("invalid_argument", `${field} is required`);
+  return result;
+}
+function requireObject(value, label) {
+  const fields = asJsonObject(value);
+  if (fields === void 0) throw upstreamError(502, `${label} must be a plain object`);
+  return fields;
+}
+function objectArray(value, label) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item, index) => requireObject(item, `${label}[${index}]`));
+}
+function inputObject(value, label) {
+  const fields = asJsonObject(value);
+  if (fields === void 0) throw new TBError("invalid_argument", `${label} must be an object`);
+  return fields;
+}
+function buildUrl(path, query) {
+  const url = new URL(path, API_BASE);
+  for (const [key, value] of query ?? []) url.searchParams.append(key, value);
+  return url.toString();
+}
+function errorMessage(payload, status) {
+  if (typeof payload === "string" && payload !== "") return payload;
+  const error = asJsonObject(asJsonObject(payload)?.error);
+  const message = trimmedText(error?.message);
+  const type = trimmedText(error?.type);
+  if (message !== void 0 && type !== void 0) return `${message} (${type})`;
+  return message ?? type ?? `airtable request failed with ${status}`;
+}
+function responsePayload(result) {
+  const contentType = result.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    if (result.bodyKind === "json") return result.data;
+    if (result.bodyKind === "empty" && (result.status === 204 || result.status === 205)) return null;
+    throw upstreamError(502, "airtable response parsing failed: invalid JSON");
+  }
+  if (result.bodyKind === "empty") return null;
+  if (result.bodyKind === "text") {
+    try {
+      return JSON.parse(String(result.data));
+    } catch {
+      return result.data;
+    }
+  }
+  return result.data;
+}
+function mapAirtableError(context) {
+  try {
+    return upstreamError(context.status, errorMessage(responsePayload(context), context.status));
+  } catch {
+    return upstreamError(502, "airtable response parsing failed: invalid JSON");
+  }
+}
+var http = createAuthedClient({
+  baseUrl: API_BASE,
+  service: SERVICE,
+  auth: { kind: "bearer" },
+  headers: { accept: "application/json" },
+  mapError: mapAirtableError,
+  mapTransportError: ({ message }) => upstreamError(
+    502,
+    `airtable request failed: ${message ?? "unknown request error"}`
+  )
+});
+async function request(ctx, input) {
+  const result = await http.request(ctx, {
+    path: input.path,
+    method: input.method ?? "GET",
+    query: input.query,
+    ...input.body === void 0 ? {} : { json: input.body },
+    invalidJson: "text",
+    responseType: "auto"
+  });
+  return responsePayload(result);
+}
+function recordCollectionPath(input) {
+  const baseId = encodeURIComponent(requireText(input.baseId, "baseId"));
+  const table = encodeURIComponent(requireText(input.tableIdOrName, "tableIdOrName"));
+  return `/v0/${baseId}/${table}`;
+}
+function includeQuery(include) {
+  return (include ?? []).map((item) => ["include[]", requireText(item, "include item")]);
+}
+function commonReadQuery(input) {
+  const query = [];
+  for (const field of input.fields ?? []) query.push(["fields[]", requireText(field, "fields item")]);
+  const cellFormat = trimmedText(input.cellFormat);
+  const timeZone = trimmedText(input.timeZone);
+  const userLocale = trimmedText(input.userLocale);
+  const returnFieldsByFieldId = booleanValue(input.returnFieldsByFieldId);
+  const includeDateDependencyMetadata = booleanValue(input.includeDateDependencyMetadata);
+  if (cellFormat !== void 0) query.push(["cellFormat", cellFormat]);
+  if (timeZone !== void 0) query.push(["timeZone", timeZone]);
+  if (userLocale !== void 0) query.push(["userLocale", userLocale]);
+  if (returnFieldsByFieldId !== void 0) query.push(["returnFieldsByFieldId", String(returnFieldsByFieldId)]);
+  if (includeDateDependencyMetadata !== void 0) {
+    query.push(["includeDateDependencyMetadata", String(includeDateDependencyMetadata)]);
+  }
+  return query;
+}
+function listRecordsQuery(input) {
+  const query = commonReadQuery(input);
+  const offset = trimmedText(input.offset);
+  const pageSize = integerValue(input.pageSize);
+  const maxRecords = integerValue(input.maxRecords);
+  const view = trimmedText(input.view);
+  const filterByFormula = trimmedText(input.filterByFormula);
+  if (offset !== void 0) query.push(["offset", offset]);
+  if (pageSize !== void 0) query.push(["pageSize", String(pageSize)]);
+  if (maxRecords !== void 0) query.push(["maxRecords", String(maxRecords)]);
+  if (view !== void 0) query.push(["view", view]);
+  if (filterByFormula !== void 0) query.push(["filterByFormula", filterByFormula]);
+  for (const [index, item] of (input.sort ?? []).entries()) {
+    const rule = inputObject(item, `sort[${index}]`);
+    query.push([`sort[${index}][field]`, requireText(rule.field, `sort[${index}].field`)]);
+    const direction = trimmedText(rule.direction);
+    if (direction !== void 0) query.push([`sort[${index}][direction]`, direction]);
+  }
+  for (const item of input.recordMetadata ?? []) {
+    query.push(["recordMetadata[]", requireText(item, "recordMetadata item")]);
+  }
+  return query;
+}
+function listRecordsPostBody(input) {
+  return compactDefined({
+    view: trimmedText(input.view),
+    fields: input.fields === void 0 ? void 0 : input.fields.map((field) => requireText(field, "fields item")),
+    sort: input.sort === void 0 ? void 0 : input.sort.map((item, index) => {
+      const rule = inputObject(item, `sort[${index}]`);
+      return compactDefined({
+        field: requireText(rule.field, `sort[${index}].field`),
+        direction: trimmedText(rule.direction)
+      });
+    }),
+    filterByFormula: trimmedText(input.filterByFormula),
+    maxRecords: integerValue(input.maxRecords),
+    pageSize: integerValue(input.pageSize),
+    offset: trimmedText(input.offset),
+    cellFormat: trimmedText(input.cellFormat),
+    timeZone: trimmedText(input.timeZone),
+    userLocale: trimmedText(input.userLocale),
+    returnFieldsByFieldId: booleanValue(input.returnFieldsByFieldId),
+    includeDateDependencyMetadata: booleanValue(input.includeDateDependencyMetadata),
+    recordMetadata: input.recordMetadata === void 0 ? void 0 : input.recordMetadata.map((item) => requireText(item, "recordMetadata item"))
+  });
+}
+function fieldConfig(value, label) {
+  const field = { ...inputObject(value, label) };
+  delete field.baseId;
+  delete field.tableId;
+  delete field.columnId;
+  return compactDefined({
+    ...field,
+    name: requireText(field.name, `${label}.name`),
+    type: requireText(field.type, `${label}.type`),
+    description: trimmedText(field.description),
+    options: asJsonObject(field.options)
+  });
+}
+function fieldConfigs(value, label) {
+  const fields = Array.isArray(value) ? value : [];
+  if (fields.length === 0) throw new TBError("invalid_argument", `${label} is required`);
+  return fields.map((field, index) => fieldConfig(field, `${label}[${index}]`));
+}
+function tableConfigs(value) {
+  const tables = Array.isArray(value) ? value : [];
+  if (tables.length === 0) throw new TBError("invalid_argument", "tables is required");
+  return tables.map((table, index) => {
+    const config = inputObject(table, `tables[${index}]`);
+    return compactDefined({
+      ...config,
+      name: requireText(config.name, `tables[${index}].name`),
+      description: trimmedText(config.description),
+      fields: fieldConfigs(config.fields, `tables[${index}].fields`)
+    });
+  });
+}
+function recordFields(value, label) {
+  const fields = asJsonObject(value);
+  if (fields === void 0) throw new TBError("invalid_argument", `${label} must be an object`);
+  return fields;
+}
+async function listBases(input, ctx) {
+  const offset = trimmedText(input.offset);
+  const payload = requireObject(
+    await request(ctx, { path: BASES_PATH, query: offset === void 0 ? [] : [["offset", offset]] }),
+    "airtable list bases response"
+  );
+  return {
+    bases: objectArray(payload.bases, "bases"),
+    // 翻页靠它:没有下一页时给 null,压成 undefined 会让调用方分不清"到底了"。
+    offset: trimmedText(payload.offset) ?? null
+  };
+}
+async function getBaseCollaborators(input, ctx) {
+  const payload = await request(ctx, {
+    path: `${BASES_PATH}/${encodeURIComponent(requireText(input.baseId, "baseId"))}`,
+    query: includeQuery(input.include)
+  });
+  return { base: requireObject(payload, "airtable get base collaborators response") };
+}
+async function getBaseSchema(input, ctx) {
+  const payload = requireObject(
+    await request(ctx, {
+      path: `${BASES_PATH}/${encodeURIComponent(requireText(input.baseId, "baseId"))}/tables`,
+      query: includeQuery(input.include)
+    }),
+    "airtable get base schema response"
+  );
+  return { tables: Array.isArray(payload.tables) ? payload.tables : [] };
+}
+async function createBase(input, ctx) {
+  const payload = await request(ctx, {
+    method: "POST",
+    path: BASES_PATH,
+    body: {
+      name: requireText(input.name, "name"),
+      workspaceId: requireText(input.workspaceId, "workspaceId"),
+      tables: tableConfigs(input.tables)
+    }
+  });
+  return requireObject(payload, "airtable create base response");
+}
+async function deleteBase(input, ctx) {
+  const payload = await request(ctx, {
+    method: "DELETE",
+    path: `${BASES_PATH}/${encodeURIComponent(requireText(input.baseId, "baseId"))}`
+  });
+  return requireObject(payload, "airtable delete base response");
+}
+async function createTable(input, ctx) {
+  const payload = await request(ctx, {
+    method: "POST",
+    path: `${BASES_PATH}/${encodeURIComponent(requireText(input.baseId, "baseId"))}/tables`,
+    body: compactDefined({
+      name: requireText(input.name, "name"),
+      description: trimmedText(input.description),
+      fields: fieldConfigs(input.fields, "fields")
+    })
+  });
+  return requireObject(payload, "airtable create table response");
+}
+async function updateTable(input, ctx) {
+  const baseId = encodeURIComponent(requireText(input.baseId, "baseId"));
+  const table = encodeURIComponent(requireText(input.tableIdOrName, "tableIdOrName"));
+  const payload = await request(ctx, {
+    method: "PATCH",
+    path: `${BASES_PATH}/${baseId}/tables/${table}`,
+    body: compactDefined({
+      name: trimmedText(input.name),
+      description: trimmedText(input.description),
+      dateDependencySettings: asJsonObject(input.dateDependencySettings)
+    })
+  });
+  return requireObject(payload, "airtable update table response");
+}
+async function createField(input, ctx) {
+  const baseId = encodeURIComponent(requireText(input.baseId, "baseId"));
+  const tableId = encodeURIComponent(requireText(input.tableId, "tableId"));
+  const payload = await request(ctx, {
+    method: "POST",
+    path: `${BASES_PATH}/${baseId}/tables/${tableId}/fields`,
+    body: fieldConfig(input, "field")
+  });
+  return requireObject(payload, "airtable create field response");
+}
+async function updateField(input, ctx) {
+  const baseId = encodeURIComponent(requireText(input.baseId, "baseId"));
+  const tableId = encodeURIComponent(requireText(input.tableId, "tableId"));
+  const columnId = encodeURIComponent(requireText(input.columnId, "columnId"));
+  const payload = await request(ctx, {
+    method: "PATCH",
+    path: `${BASES_PATH}/${baseId}/tables/${tableId}/fields/${columnId}`,
+    body: compactDefined({
+      name: trimmedText(input.name),
+      description: trimmedText(input.description),
+      options: asJsonObject(input.options)
+    })
+  });
+  return requireObject(payload, "airtable update field response");
+}
+async function listRecords(input, ctx) {
+  const path = recordCollectionPath(input);
+  const query = listRecordsQuery(input);
+  const usePost = buildUrl(path, query).length >= GET_URL_LENGTH_SOFT_LIMIT;
+  const payload = requireObject(
+    await request(ctx, usePost ? { method: "POST", path: `${path}/listRecords`, body: listRecordsPostBody(input) } : { path, query }),
+    "airtable list records response"
+  );
+  return {
+    records: objectArray(payload.records, "records"),
+    offset: trimmedText(payload.offset) ?? null
+  };
+}
+async function getRecord(input, ctx) {
+  const payload = await request(ctx, {
+    path: `${recordCollectionPath(input)}/${encodeURIComponent(requireText(input.recordId, "recordId"))}`,
+    query: commonReadQuery(input)
+  });
+  return { record: requireObject(payload, "airtable get record response") };
+}
+async function createRecords(input, ctx) {
+  const records = Array.isArray(input.records) ? input.records : [];
+  if (records.length === 0) throw new TBError("invalid_argument", "records is required");
+  const payload = requireObject(
+    await request(ctx, {
+      method: "POST",
+      path: recordCollectionPath(input),
+      body: compactDefined({
+        // 创建时只发 fields:带上 id 会被 Airtable 当成非法字段。
+        records: records.map((item, index) => ({
+          fields: recordFields(inputObject(item, `records[${index}]`).fields, `records[${index}].fields`)
+        })),
+        typecast: booleanValue(input.typecast),
+        returnFieldsByFieldId: booleanValue(input.returnFieldsByFieldId)
+      })
+    }),
+    "airtable create records response"
+  );
+  return { records: objectArray(payload.records, "records") };
+}
+async function updateRecords(input, ctx) {
+  const records = Array.isArray(input.records) ? input.records : [];
+  if (records.length === 0) throw new TBError("invalid_argument", "records is required");
+  const payload = requireObject(
+    await request(ctx, {
+      method: "PATCH",
+      path: recordCollectionPath(input),
+      body: compactDefined({
+        records: records.map((item, index) => {
+          const entry = inputObject(item, `records[${index}]`);
+          return {
+            id: requireText(entry.id, `records[${index}].id`),
+            fields: recordFields(entry.fields, `records[${index}].fields`)
+          };
+        }),
+        typecast: booleanValue(input.typecast),
+        returnFieldsByFieldId: booleanValue(input.returnFieldsByFieldId)
+      })
+    }),
+    "airtable update records response"
+  );
+  return { records: objectArray(payload.records, "records") };
+}
+async function deleteRecords(input, ctx) {
+  const recordIds = Array.isArray(input.recordIds) ? input.recordIds : [];
+  if (recordIds.length === 0) throw new TBError("invalid_argument", "recordIds is required");
+  const payload = requireObject(
+    await request(ctx, {
+      method: "DELETE",
+      path: recordCollectionPath(input),
+      // 删除的 id 走 query 的重复 `records[]`,不是请求体。
+      query: recordIds.map((id) => ["records[]", requireText(id, "recordIds item")])
+    }),
+    "airtable delete records response"
+  );
+  return { records: objectArray(payload.records, "records") };
+}
+
+// ../plugins/src/airtable/schema.ts
+import { z } from "zod/v4";
+var listBasesInput = z.strictObject({
+  offset: z.string().min(1).describe("Opaque pagination cursor returned by a previous Airtable response.").optional()
+}).describe("The input payload for this action.");
+var listBasesOutput = z.strictObject({
+  bases: z.array(z.strictObject({
+    id: z.string().describe("Base ID."),
+    name: z.string().describe("Base name."),
+    permissionLevel: z.string().describe("Permission level reported by Airtable for this base.")
+  }).describe("Airtable base summary.")).describe("Bases returned by Airtable."),
+  offset: z.string().describe("Pagination cursor for the next page of bases, or null when unavailable.").nullable()
+}).describe("Airtable action output.");
+var getBaseCollaboratorsInput = z.strictObject({
+  baseId: z.string().min(1).describe("Base ID in the format appXXXXXXXXXXXXXX."),
+  include: z.array(z.enum(["collaborators", "inviteLinks", "interfaces", "packages"])).min(1).describe("Optional Airtable base collaboration details to include.").optional()
+}).describe("The input payload for this action.");
+var getBaseCollaboratorsOutput = z.strictObject({
+  base: z.looseObject({
+    id: z.string().describe("Base ID."),
+    createdTime: z.string().describe("Base creation timestamp returned by Airtable."),
+    permissionLevel: z.string().describe("Permission level reported by Airtable for the authenticated user."),
+    workspaceId: z.string().min(1).describe("Workspace ID in the format wspXXXXXXXXXXXXXX."),
+    name: z.string().describe("Base name."),
+    interfaces: z.looseObject({}).describe("Interface metadata returned by Airtable.").optional(),
+    collaborators: z.looseObject({}).describe("Deprecated collaborator metadata returned by Airtable.").optional(),
+    groupCollaborators: z.looseObject({}).describe("Group collaborator metadata returned by Airtable.").optional(),
+    individualCollaborators: z.looseObject({}).describe("Individual collaborator metadata returned by Airtable.").optional(),
+    inviteLinks: z.looseObject({}).describe("Invite link metadata returned by Airtable.").optional(),
+    packages: z.looseObject({}).describe("Package metadata returned by Airtable.").optional()
+  }).describe("Airtable base details response.")
+}).describe("Airtable action output.");
+var getBaseSchemaInput = z.strictObject({
+  baseId: z.string().min(1).describe("Base ID in the format appXXXXXXXXXXXXXX."),
+  include: z.array(z.literal("visibleFieldIds")).min(1).max(1).describe("Optional Airtable schema details to include in table views.").optional()
+}).describe("The input payload for this action.");
+var getBaseSchemaOutput = z.strictObject({
+  tables: z.array(z.looseObject({
+    id: z.string().describe("Table ID."),
+    name: z.string().describe("Table name."),
+    description: z.string().describe("Table description when Airtable returns one.").optional(),
+    primaryFieldId: z.string().describe("Primary field ID configured for the table.").optional(),
+    dateDependencySettings: z.looseObject({}).describe("Date dependency settings returned by Airtable for the table.").optional(),
+    fields: z.array(z.looseObject({
+      id: z.string().describe("Field ID."),
+      name: z.string().describe("Field name."),
+      type: z.string().describe("Field type reported by Airtable."),
+      description: z.string().describe("Field description when Airtable returns one.").optional(),
+      options: z.looseObject({}).describe("Field options reported by Airtable.").optional()
+    }).describe("Airtable field definition.")).describe("Fields defined on the Airtable table."),
+    views: z.array(z.looseObject({
+      id: z.string().describe("View ID."),
+      name: z.string().describe("View name."),
+      type: z.string().describe("View type reported by Airtable.").optional(),
+      visibleFieldIds: z.array(z.string()).describe("Field IDs visible in the Airtable view.").optional()
+    }).describe("Airtable view definition.")).describe("Views defined on the Airtable table.").optional()
+  }).describe("Airtable table definition.")).describe("Tables returned by Airtable for the base.")
+}).describe("Airtable action output.");
+var createBaseInput = z.strictObject({
+  name: z.string().min(1).describe("Name for the Airtable base."),
+  workspaceId: z.string().min(1).describe("Workspace ID in the format wspXXXXXXXXXXXXXX."),
+  tables: z.array(z.looseObject({
+    name: z.string().min(1).describe("Name for the Airtable table."),
+    description: z.string().max(2e4).describe("Optional Airtable description, up to 20,000 characters.").optional(),
+    fields: z.array(z.looseObject({
+      name: z.string().min(1).describe("Name for the Airtable field."),
+      type: z.string().min(1).describe("Airtable field type, such as singleLineText."),
+      description: z.string().max(2e4).describe("Optional Airtable description, up to 20,000 characters.").optional(),
+      options: z.looseObject({}).describe("Type-specific Airtable field options.").optional()
+    }).describe("Airtable field configuration accepted by metadata write endpoints.")).min(1).describe("Field configurations to create in the Airtable table.")
+  }).describe("Airtable table configuration accepted when creating a base or table.")).min(1).describe("Tables to create along with the new Airtable base.")
+}).describe("The input payload for this action.");
+var createBaseOutput = z.strictObject({
+  id: z.string().describe("Base ID."),
+  tables: z.array(z.looseObject({
+    id: z.string().describe("Table ID."),
+    name: z.string().describe("Table name."),
+    description: z.string().describe("Table description when Airtable returns one.").optional(),
+    primaryFieldId: z.string().describe("Primary field ID configured for the table.").optional(),
+    dateDependencySettings: z.looseObject({}).describe("Date dependency settings returned by Airtable for the table.").optional(),
+    fields: z.array(z.looseObject({
+      id: z.string().describe("Field ID."),
+      name: z.string().describe("Field name."),
+      type: z.string().describe("Field type reported by Airtable."),
+      description: z.string().describe("Field description when Airtable returns one.").optional(),
+      options: z.looseObject({}).describe("Field options reported by Airtable.").optional()
+    }).describe("Airtable field definition.")).describe("Fields defined on the Airtable table."),
+    views: z.array(z.looseObject({
+      id: z.string().describe("View ID."),
+      name: z.string().describe("View name."),
+      type: z.string().describe("View type reported by Airtable.").optional(),
+      visibleFieldIds: z.array(z.string()).describe("Field IDs visible in the Airtable view.").optional()
+    }).describe("Airtable view definition.")).describe("Views defined on the Airtable table.").optional()
+  }).describe("Airtable table definition.")).describe("Tables created with the Airtable base.")
+}).describe("Airtable create base response.");
+var deleteBaseInput = z.strictObject({
+  baseId: z.string().min(1).describe("Base ID in the format appXXXXXXXXXXXXXX.")
+}).describe("The input payload for this action.");
+var deleteBaseOutput = z.strictObject({
+  id: z.string().describe("Base ID."),
+  deleted: z.literal(true).describe("Whether Airtable reports the base as deleted.")
+}).describe("Airtable deleted-base acknowledgement.");
+var createTableInput = z.strictObject({
+  baseId: z.string().min(1).describe("Base ID in the format appXXXXXXXXXXXXXX."),
+  name: z.string().min(1).describe("Name for the Airtable table."),
+  description: z.string().max(2e4).describe("Optional Airtable description, up to 20,000 characters.").optional(),
+  fields: z.array(z.looseObject({
+    name: z.string().min(1).describe("Name for the Airtable field."),
+    type: z.string().min(1).describe("Airtable field type, such as singleLineText."),
+    description: z.string().max(2e4).describe("Optional Airtable description, up to 20,000 characters.").optional(),
+    options: z.looseObject({}).describe("Type-specific Airtable field options.").optional()
+  }).describe("Airtable field configuration accepted by metadata write endpoints.")).min(1).describe("Field configurations to create in the Airtable table.")
+}).describe("The input payload for this action.");
+var createTableOutput = z.looseObject({
+  id: z.string().describe("Table ID."),
+  name: z.string().describe("Table name."),
+  description: z.string().describe("Table description when Airtable returns one.").optional(),
+  primaryFieldId: z.string().describe("Primary field ID configured for the table.").optional(),
+  dateDependencySettings: z.looseObject({}).describe("Date dependency settings returned by Airtable for the table.").optional(),
+  fields: z.array(z.looseObject({
+    id: z.string().describe("Field ID."),
+    name: z.string().describe("Field name."),
+    type: z.string().describe("Field type reported by Airtable."),
+    description: z.string().describe("Field description when Airtable returns one.").optional(),
+    options: z.looseObject({}).describe("Field options reported by Airtable.").optional()
+  }).describe("Airtable field definition.")).describe("Fields defined on the Airtable table."),
+  views: z.array(z.looseObject({
+    id: z.string().describe("View ID."),
+    name: z.string().describe("View name."),
+    type: z.string().describe("View type reported by Airtable.").optional(),
+    visibleFieldIds: z.array(z.string()).describe("Field IDs visible in the Airtable view.").optional()
+  }).describe("Airtable view definition.")).describe("Views defined on the Airtable table.").optional()
+}).describe("Airtable table definition.");
+var updateTableInput = z.strictObject({
+  baseId: z.string().min(1).describe("Base ID in the format appXXXXXXXXXXXXXX."),
+  tableIdOrName: z.string().min(1).describe("Table ID or table name accepted by the Airtable path parameter."),
+  name: z.string().min(1).describe("Name for the Airtable table.").optional(),
+  description: z.string().max(2e4).describe("Optional Airtable description, up to 20,000 characters.").optional(),
+  dateDependencySettings: z.looseObject({}).describe("Airtable date dependency settings for a table.").optional()
+}).describe("The input payload for this action.");
+var updateTableOutput = z.looseObject({
+  id: z.string().describe("Table ID."),
+  name: z.string().describe("Table name."),
+  description: z.string().describe("Table description when Airtable returns one.").optional(),
+  primaryFieldId: z.string().describe("Primary field ID configured for the table.").optional(),
+  dateDependencySettings: z.looseObject({}).describe("Date dependency settings returned by Airtable for the table.").optional(),
+  fields: z.array(z.looseObject({
+    id: z.string().describe("Field ID."),
+    name: z.string().describe("Field name."),
+    type: z.string().describe("Field type reported by Airtable."),
+    description: z.string().describe("Field description when Airtable returns one.").optional(),
+    options: z.looseObject({}).describe("Field options reported by Airtable.").optional()
+  }).describe("Airtable field definition.")).describe("Fields defined on the Airtable table."),
+  views: z.array(z.looseObject({
+    id: z.string().describe("View ID."),
+    name: z.string().describe("View name."),
+    type: z.string().describe("View type reported by Airtable.").optional(),
+    visibleFieldIds: z.array(z.string()).describe("Field IDs visible in the Airtable view.").optional()
+  }).describe("Airtable view definition.")).describe("Views defined on the Airtable table.").optional()
+}).describe("Airtable table definition.");
+var createFieldInput = z.strictObject({
+  baseId: z.string().min(1).describe("Base ID in the format appXXXXXXXXXXXXXX."),
+  tableId: z.string().min(1).describe("Table ID in the format tblXXXXXXXXXXXXXX."),
+  name: z.string().min(1).describe("Name for the Airtable field."),
+  type: z.string().min(1).describe("Airtable field type, such as singleLineText."),
+  description: z.string().max(2e4).describe("Optional Airtable description, up to 20,000 characters.").optional(),
+  options: z.looseObject({}).describe("Type-specific Airtable field options.").optional()
+}).describe("The input payload for this action.");
+var createFieldOutput = z.looseObject({
+  id: z.string().describe("Field ID."),
+  name: z.string().describe("Field name."),
+  type: z.string().describe("Field type reported by Airtable."),
+  description: z.string().describe("Field description when Airtable returns one.").optional(),
+  options: z.looseObject({}).describe("Field options reported by Airtable.").optional()
+}).describe("Airtable field definition.");
+var updateFieldInput = z.strictObject({
+  baseId: z.string().min(1).describe("Base ID in the format appXXXXXXXXXXXXXX."),
+  tableId: z.string().min(1).describe("Table ID in the format tblXXXXXXXXXXXXXX."),
+  columnId: z.string().min(1).describe("Field ID in the format fldXXXXXXXXXXXXXX."),
+  name: z.string().min(1).describe("Name for the Airtable field.").optional(),
+  description: z.string().max(2e4).describe("Optional Airtable description, up to 20,000 characters.").optional(),
+  options: z.looseObject({}).describe("Type-specific Airtable field options.").optional()
+}).describe("The input payload for this action.");
+var updateFieldOutput = z.looseObject({
+  id: z.string().describe("Field ID."),
+  name: z.string().describe("Field name."),
+  type: z.string().describe("Field type reported by Airtable."),
+  description: z.string().describe("Field description when Airtable returns one.").optional(),
+  options: z.looseObject({}).describe("Field options reported by Airtable.").optional()
+}).describe("Airtable field definition.");
+var listRecordsInput = z.strictObject({
+  baseId: z.string().min(1).describe("Base ID in the format appXXXXXXXXXXXXXX."),
+  tableIdOrName: z.string().min(1).describe("Table ID or table name accepted by the Airtable path parameter."),
+  cellFormat: z.enum(["json", "string"]).describe("Cell format accepted by Airtable for read operations.").optional(),
+  timeZone: z.string().min(1).describe("Timezone string sent to Airtable when cellFormat is string.").optional(),
+  userLocale: z.string().min(1).describe("User locale sent to Airtable when cellFormat is string.").optional(),
+  returnFieldsByFieldId: z.boolean().describe("Whether Airtable should return field IDs instead of field names in record objects.").optional(),
+  includeDateDependencyMetadata: z.boolean().describe("Whether Airtable should return date dependency metadata for linked record fields.").optional(),
+  view: z.string().min(1).describe("View name or view ID used by Airtable to filter and sort results.").optional(),
+  fields: z.array(z.string().min(1)).min(1).describe("Field names or field IDs to include in the Airtable response.").optional(),
+  sort: z.array(z.strictObject({
+    field: z.string().min(1).describe("Field name or field ID used by Airtable for sorting."),
+    direction: z.enum(["asc", "desc"]).describe("Sort direction accepted by Airtable.").optional()
+  }).describe("Sort rule accepted by the Airtable list records endpoint.")).min(1).describe("Sort rules applied by Airtable in order.").optional(),
+  filterByFormula: z.string().min(1).describe("Formula string evaluated by Airtable to filter matching records.").optional(),
+  maxRecords: z.int().min(1).describe("Maximum total number of records to return before Airtable stops pagination.").optional(),
+  pageSize: z.int().min(1).max(100).describe("Number of records to return per page.").optional(),
+  offset: z.string().min(1).describe("Opaque pagination cursor returned by a previous Airtable response.").optional(),
+  recordMetadata: z.array(z.literal("commentCount")).min(1).describe("Record metadata fields to include in Airtable list records responses.").optional()
+}).describe("The input payload for this action.");
+var listRecordsOutput = z.strictObject({
+  records: z.array(z.looseObject({
+    id: z.string().describe("Record ID."),
+    createdTime: z.string().describe("Record creation timestamp returned by Airtable.").optional(),
+    fields: z.looseObject({}).describe("Record fields keyed by field name or field ID."),
+    commentCount: z.int().describe("Comment count returned by Airtable when enabled on the endpoint.").optional()
+  }).describe("Airtable record.")).describe("Records returned by Airtable."),
+  offset: z.string().describe("Pagination cursor for the next page of records, or null when unavailable.").nullable()
+}).describe("Airtable action output.");
+var getRecordInput = z.strictObject({
+  baseId: z.string().min(1).describe("Base ID in the format appXXXXXXXXXXXXXX."),
+  tableIdOrName: z.string().min(1).describe("Table ID or table name accepted by the Airtable path parameter."),
+  cellFormat: z.enum(["json", "string"]).describe("Cell format accepted by Airtable for read operations.").optional(),
+  timeZone: z.string().min(1).describe("Timezone string sent to Airtable when cellFormat is string.").optional(),
+  userLocale: z.string().min(1).describe("User locale sent to Airtable when cellFormat is string.").optional(),
+  returnFieldsByFieldId: z.boolean().describe("Whether Airtable should return field IDs instead of field names in record objects.").optional(),
+  includeDateDependencyMetadata: z.boolean().describe("Whether Airtable should return date dependency metadata for linked record fields.").optional(),
+  recordId: z.string().min(1).describe("Record ID in the format recXXXXXXXXXXXXXX.")
+}).describe("The input payload for this action.");
+var getRecordOutput = z.strictObject({
+  record: z.looseObject({
+    id: z.string().describe("Record ID."),
+    createdTime: z.string().describe("Record creation timestamp returned by Airtable.").optional(),
+    fields: z.looseObject({}).describe("Record fields keyed by field name or field ID."),
+    commentCount: z.int().describe("Comment count returned by Airtable when enabled on the endpoint.").optional()
+  }).describe("Airtable record.")
+}).describe("Airtable action output.");
+var createRecordsInput = z.strictObject({
+  baseId: z.string().min(1).describe("Base ID in the format appXXXXXXXXXXXXXX."),
+  tableIdOrName: z.string().min(1).describe("Table ID or table name accepted by the Airtable path parameter."),
+  records: z.array(z.strictObject({
+    fields: z.looseObject({}).describe("Record fields keyed by field name or field ID.")
+  }).describe("Record payload used when creating Airtable records.")).min(1).max(10).describe("Records to create in the Airtable table."),
+  typecast: z.boolean().describe("Whether Airtable should coerce incoming values to compatible field types.").optional(),
+  returnFieldsByFieldId: z.boolean().describe("Whether Airtable should return field IDs instead of field names in record objects.").optional()
+}).describe("The input payload for this action.");
+var createRecordsOutput = z.strictObject({
+  records: z.array(z.looseObject({
+    id: z.string().describe("Record ID."),
+    createdTime: z.string().describe("Record creation timestamp returned by Airtable.").optional(),
+    fields: z.looseObject({}).describe("Record fields keyed by field name or field ID."),
+    commentCount: z.int().describe("Comment count returned by Airtable when enabled on the endpoint.").optional()
+  }).describe("Airtable record.")).describe("Records created by Airtable.")
+}).describe("Airtable action output.");
+var updateRecordsInput = z.strictObject({
+  baseId: z.string().min(1).describe("Base ID in the format appXXXXXXXXXXXXXX."),
+  tableIdOrName: z.string().min(1).describe("Table ID or table name accepted by the Airtable path parameter."),
+  records: z.array(z.strictObject({
+    id: z.string().min(1).describe("Record ID in the format recXXXXXXXXXXXXXX."),
+    fields: z.looseObject({}).describe("Record fields keyed by field name or field ID.")
+  }).describe("Record payload used when updating Airtable records.")).min(1).max(10).describe("Records to update in the Airtable table."),
+  typecast: z.boolean().describe("Whether Airtable should coerce incoming values to compatible field types.").optional(),
+  returnFieldsByFieldId: z.boolean().describe("Whether Airtable should return field IDs instead of field names in record objects.").optional()
+}).describe("The input payload for this action.");
+var updateRecordsOutput = z.strictObject({
+  records: z.array(z.looseObject({
+    id: z.string().describe("Record ID."),
+    createdTime: z.string().describe("Record creation timestamp returned by Airtable.").optional(),
+    fields: z.looseObject({}).describe("Record fields keyed by field name or field ID."),
+    commentCount: z.int().describe("Comment count returned by Airtable when enabled on the endpoint.").optional()
+  }).describe("Airtable record.")).describe("Records returned by Airtable after update.")
+}).describe("Airtable action output.");
+var deleteRecordsInput = z.strictObject({
+  baseId: z.string().min(1).describe("Base ID in the format appXXXXXXXXXXXXXX."),
+  tableIdOrName: z.string().min(1).describe("Table ID or table name accepted by the Airtable path parameter."),
+  recordIds: z.array(z.string().min(1).describe("Record ID in the format recXXXXXXXXXXXXXX.")).min(1).max(10).describe("Record IDs to delete from the Airtable table.")
+}).describe("The input payload for this action.");
+var deleteRecordsOutput = z.strictObject({
+  records: z.array(z.strictObject({
+    id: z.string().describe("Record ID."),
+    deleted: z.boolean().describe("Whether Airtable reports the record as deleted.")
+  }).describe("Airtable deleted-record acknowledgement.")).describe("Deleted-record acknowledgements returned by Airtable.")
+}).describe("Airtable action output.");
+var airtableActions = {
+  list_bases: {
+    description: "List Airtable bases accessible to the authenticated personal access token.",
+    effect: "read",
+    inputSchema: listBasesInput,
+    outputSchema: z.toJSONSchema(listBasesOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_base_collaborators: {
+    description: "Read Airtable base metadata, including workspaceId and optional collaborator details.",
+    effect: "read",
+    inputSchema: getBaseCollaboratorsInput,
+    outputSchema: z.toJSONSchema(getBaseCollaboratorsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_base_schema: {
+    description: "Read Airtable table, field, and view schema for a specific base.",
+    effect: "read",
+    inputSchema: getBaseSchemaInput,
+    outputSchema: z.toJSONSchema(getBaseSchemaOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_base: {
+    description: "Create an Airtable base in a workspace with the provided initial table and field schema.",
+    effect: "write",
+    inputSchema: createBaseInput,
+    outputSchema: z.toJSONSchema(createBaseOutput, { io: "output", unrepresentable: "any" })
+  },
+  delete_base: {
+    description: "Delete an Airtable base. Airtable restricts this endpoint to enterprise admins.",
+    effect: "destructive",
+    inputSchema: deleteBaseInput,
+    outputSchema: z.toJSONSchema(deleteBaseOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_table: {
+    description: "Create a table in an Airtable base with the provided field schema.",
+    effect: "write",
+    inputSchema: createTableInput,
+    outputSchema: z.toJSONSchema(createTableOutput, { io: "output", unrepresentable: "any" })
+  },
+  update_table: {
+    description: "Update an Airtable table name, description, or date dependency settings.",
+    effect: "write",
+    inputSchema: updateTableInput,
+    outputSchema: z.toJSONSchema(updateTableOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_field: {
+    description: "Create a field in an Airtable table.",
+    effect: "write",
+    inputSchema: createFieldInput,
+    outputSchema: z.toJSONSchema(createFieldOutput, { io: "output", unrepresentable: "any" })
+  },
+  update_field: {
+    description: "Update an Airtable field name, description, or type-specific options.",
+    effect: "write",
+    inputSchema: updateFieldInput,
+    outputSchema: z.toJSONSchema(updateFieldOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_records: {
+    description: "List Airtable records from a table with optional fields, sorting, view filters, formula filters, and pagination.",
+    effect: "read",
+    inputSchema: listRecordsInput,
+    outputSchema: z.toJSONSchema(listRecordsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_record: {
+    description: "Read a single Airtable record by record ID.",
+    effect: "read",
+    inputSchema: getRecordInput,
+    outputSchema: z.toJSONSchema(getRecordOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_records: {
+    description: "Create one or more Airtable records in a table.",
+    effect: "write",
+    inputSchema: createRecordsInput,
+    outputSchema: z.toJSONSchema(createRecordsOutput, { io: "output", unrepresentable: "any" })
+  },
+  update_records: {
+    description: "Update one or more existing Airtable records by record ID.",
+    effect: "write",
+    inputSchema: updateRecordsInput,
+    outputSchema: z.toJSONSchema(updateRecordsOutput, { io: "output", unrepresentable: "any" })
+  },
+  delete_records: {
+    description: "Delete one or more Airtable records by record ID.",
+    effect: "destructive",
+    inputSchema: deleteRecordsInput,
+    outputSchema: z.toJSONSchema(deleteRecordsOutput, { io: "output", unrepresentable: "any" })
+  }
+};
+
+// ../plugins/src/airtable/index.ts
+function createAirtablePlugin() {
+  return createProviderPlugin({
+    description: "Airtable",
+    actions: airtableActions,
+    // 上游 credentialValidators 也打 /v0/meta/bases —— 只读、无必填入参,
+    // 正好当挂载时的凭证探针。
+    credentialProbe: "list_bases",
+    handlers: {
+      list_bases: listBases,
+      get_base_collaborators: getBaseCollaborators,
+      get_base_schema: getBaseSchema,
+      create_base: createBase,
+      delete_base: deleteBase,
+      create_table: createTable,
+      update_table: updateTable,
+      create_field: createField,
+      update_field: updateField,
+      list_records: listRecords,
+      get_record: getRecord,
+      create_records: createRecords,
+      update_records: updateRecords,
+      delete_records: deleteRecords
+    }
+  });
+}
+var airtable_default = createAirtablePlugin();
+export {
+  createAirtablePlugin,
+  airtable_default as default
+};