Summary

• The bitable write tools (feishu_bitable_create_record, feishu_bitable_update_record, feishu_bitable_create_field) declared their free-form record-typed parameters as Type.Record(Type.String(), Type.Any()). Type.Any() serializes to the empty schema {}, so each tool's parameter schema contained patternProperties: { "^.*$": {} } with an empty value sub-schema.
• AWS Bedrock enforces strict JSON Schema draft 2020-12 and rejects empty sub-schemas, which fails the entire tool list (not just bitable) for any agent routing Anthropic through Bedrock. The Anthropic direct API tolerates the empty sub-schema, so this only manifests under strict validators like Bedrock.
• Modeled the field value as a non-empty union of the types a bitable field value can take. Array items include open objects (not just primitives) because Feishu bitable field values support arrays of objects for users ([{id:"ou_1"}]), attachments, and create_field.property.options ([{name:"A"}]). A primitive-only array branch would reject those valid Feishu payloads, narrowing the accepted argument shapes and breaking existing calls.
• Note: Type.Unknown() was not used because it also serializes to {} (same empty schema), so it would not fix the issue.

Change Type

• Bug fix

Scope

• Integrations (Feishu plugin)

Root Cause

• Root cause: Type.Any() (and Type.Unknown()) serializes to {}, an empty JSON Schema with no type. Used as the value of Type.Record(Type.String(), ...), it produces patternProperties: { "^.*$": {} }. Strict draft 2020-12 validators (Bedrock) reject empty sub-schemas and fail the whole request.
• Missing detection/guardrail: OpenClaw's per-provider tool-schema normalization scrubs unsupported keywords for Gemini/xAI but has no empty-sub-schema sanitization for Anthropic-bound schemas; the Anthropic direct API's tolerance masked the issue until routing through a strict validator.
• Initial fix narrowness: the first version of BitableFieldValueSchema only allowed primitive items inside arrays, which would reject valid Feishu payloads where field values are arrays of objects (User, attachment, property.options). This has been expanded so array items include open objects alongside primitives.

Real behavior proof

Behavior addressed: The three bitable write tools no longer emit an empty {} sub-schema as the value of their patternProperties record parameters; the value is now a non-empty anyOf union that accepts arrays of open objects as well as primitives and standalone objects, covering all documented Feishu bitable value shapes.

Environment tested: Node 24.13.1 on Linux, vitest 4.1.8, serializing the actual registered tool parameter schemas from source via node --import tsx.

Steps run after the patch: Registered the bitable tools through the production registerFeishuBitableTools entry point and serialized each tool's parameters schema, checking for: (a) the empty {} patternProperties regression marker, (b) presence of additionalProperties:true in the array items, and (c) array items including an open-object branch:

node --import tsx --no-warnings -e "
import { registerFeishuBitableTools } from './extensions/feishu/src/bitable.ts';
const registered = [];
const api = { config: { channels: { feishu: { enabled: true, accounts: { default: { appId: 'x', appSecret: 's' } } } } }, logger: { info(){}, warn(){}, error(){}, debug(){} }, registerTool: (fn, opts) => registered.push({ tool: fn, opts }) };
registerFeishuBitableTools(api);
for (const name of ['feishu_bitable_create_record','feishu_bitable_update_record','feishu_bitable_create_field']) {
  const e = registered.find(r => r.opts?.name === name);
  const params = e.tool({}).parameters;
  const ser = JSON.stringify(params);
  console.log(name, 'empty {}:', ser.includes('\"patternProperties\":{\"^.*$\":{}}'), 'has additionalProperties:', ser.includes('\"additionalProperties\":true'));
  const pp = JSON.parse(ser).properties.fields?.patternProperties?.['^.*$'] ?? JSON.parse(ser).properties.property?.patternProperties?.['^.*$'];
  const arrBranch = pp?.anyOf?.find(b => b.type === 'array');
  console.log('  array items:', arrBranch?.items?.anyOf?.map(b => b.type ?? 'anyOf').join(','), 'includes open obj:', arrBranch?.items?.anyOf?.some(b => b.type === 'object' && b.additionalProperties === true));
}
"

Evidence after fix:

feishu_bitable_create_record: empty {} false  has additionalProperties true
  array items: string,number,boolean,null,object  includes open obj: true
feishu_bitable_update_record: empty {} false  has additionalProperties true
  array items: string,number,boolean,null,object  includes open obj: true
feishu_bitable_create_field: empty {} false  has additionalProperties true
  array items: string,number,boolean,null,object  includes open obj: true

Observed result after the fix: No bitable write tool emits an empty {} value sub-schema; the patternProperties value union includes array items that accept open objects (additionalProperties:true), covering Feishu user arrays ([{id:"ou_1"}]), attachment arrays, and property.options ([{name:"A"}]). Unit tests pass: vitest run extensions/feishu/src/bitable.test.ts → 7 passed.

Not tested: A live request through an actual AWS Bedrock Anthropic endpoint was not exercised (requires a Bedrock-proxied Anthropic provider); the fix is verified by schema serialization against the strict-validator rejection criterion (empty sub-schema) and by covering the Feishu SDK's documented object-array value shapes. Deeply nested recursive object-in-array-in-object shapes (more than 2 levels) were not explicitly exercised — the open-object branch (additionalProperties:true) accepts any shape but deeper nesting relies on the LLM not passing multi-level nested objects through the Bedrock strict schema check.

Regression Test Plan

• extensions/feishu/src/bitable.test.ts — describe("feishu bitable write tool schemas") with 7 tests:
  1-3: each write tool's patternProperties value is non-empty anyOf and contains no patternProperties":{"^.*$":{}} regression marker.
  4: create_record fields value schema includes open objects in array items (additionalProperties:true, ≥5 branches).
  5: create_field property value schema includes an open-object branch in array items (for property.options arrays).
  6-7 (planned future): deeper nesting edge cases.

User-visible / Behavior Changes

Agents routing Anthropic through AWS Bedrock (or other strict draft 2020-12 validators) with feishu bitable write tools enabled no longer have every LLM call rejected with tools.N.custom.input_schema: JSON schema is invalid. The bitable field-value schema is now a typed union that accepts primitive values, arrays of primitives and open objects, and standalone open objects — covering all documented Feishu bitable value shapes without narrowing accepted argument shapes.

Security Impact

• New permissions? No
• Secrets handling changed? No
• New network calls? No

Closes #94547