fix(feishu): expand bitable value schema to accept object arrays (User/attachment/options)

ZOOWH · ZOOWH · commit dc17189a1bf7 · 2026-06-19T00:10:27.000+08:00
The previous BitableFieldValueSchema only allowed primitive items inside arrays, rejecting valid Feishu payloads where field values are arrays of objects — User=[{id:"ou_1"}], attachment arrays, and create_field property.options=[{name:"A"}]. This narrowed the accepted argument shapes and would break existing Feishu bitable calls under provider/runtime schema validation. Expand the array items union to include open objects (additionalProperties: true) alongside primitives, preserving the no-empty-patternProperties property while covering all documented Feishu bitable value shapes. Add regression tests for User field arrays and create_field property options arrays to guard against future narrowing. Closes #94547
diff --git a/extensions/feishu/src/bitable.test.ts b/extensions/feishu/src/bitable.test.ts
@@ -223,4 +223,48 @@ describe("feishu bitable write tool schemas", () => {
     expect(valueSchema).toMatchObject({ anyOf: expect.any(Array) });
     expect(JSON.stringify(parameters)).not.toContain('"patternProperties":{"^.*$":{}}');
   });
+
+  it("accepts Feishu user field value (array of objects)", () => {
+    // Feishu bitable user fields are arrays of objects: [{id:"ou_xxx"}].
+    // The value schema must accept open objects inside arrays, not just
+    // primitives, to avoid rejecting valid Feishu payloads.
+    const { api, resolveTool } = createToolFactoryHarness(createConfig());
+    registerFeishuBitableTools(api);
+    const tool = resolveTool("feishu_bitable_create_record");
+    const parameters = (tool as unknown as { parameters?: unknown }).parameters;
+    const serialized = JSON.stringify(parameters);
+
+    // The array branch items must include an open-object option
+    // (additionalProperties: true), not just primitive types.
+    expect(serialized).toContain('"additionalProperties":true');
+    // Verify the array items union has at least 5 branches (primitives + open object)
+    const valueSchema = recordValueSchema(parameters, "fields");
+    const anyOf = (valueSchema as { anyOf?: unknown[] })?.anyOf;
+    const arrayBranch = anyOf?.find(
+      (b) => (b as { type?: string })?.type === "array",
+    ) as { items?: { anyOf?: unknown[] } } | undefined;
+    expect(arrayBranch?.items?.anyOf?.length).toBeGreaterThanOrEqual(5);
+  });
+
+  it("accepts Feishu create_field property.options (array of option objects)", () => {
+    // property.options for SingleSelect/MultiSelect fields is [{name:"A"}].
+    // The value schema must allow arrays containing objects.
+    const { api, resolveTool } = createToolFactoryHarness(createConfig());
+    registerFeishuBitableTools(api);
+    const tool = resolveTool("feishu_bitable_create_field");
+    const parameters = (tool as unknown as { parameters?: unknown }).parameters;
+    const valueSchema = recordValueSchema(parameters, "property");
+
+    const anyOf = (valueSchema as { anyOf?: unknown[] })?.anyOf;
+    const arrayBranch = anyOf?.find(
+      (b) => (b as { type?: string })?.type === "array",
+    ) as { items?: { anyOf?: unknown[] } } | undefined;
+    // Array items must include an open-object branch for option objects
+    const objectBranch = arrayBranch?.items?.anyOf?.find(
+      (b) =>
+        (b as { type?: string })?.type === "object" &&
+        (b as { additionalProperties?: unknown })?.additionalProperties === true,
+    );
+    expect(objectBranch).toBeDefined();
+  });
 });
diff --git a/extensions/feishu/src/bitable.ts b/extensions/feishu/src/bitable.ts
@@ -498,12 +498,26 @@ async function updateRecord(
 // Strict JSON Schema (draft 2020-12) validators such as AWS Bedrock reject empty
 // sub-schemas, which fails the entire tool list. Every branch below serializes to
 // a non-empty schema (no bare `{}`).
+//
+// Array items include open objects (not just primitives) because Feishu bitable
+// field values already support arrays of objects for users ([{id:"ou_xxx"}]),
+// 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.
 const BitableFieldValueSchema = Type.Union([
   Type.String(),
   Type.Number(),
   Type.Boolean(),
   Type.Null(),
-  Type.Array(Type.Union([Type.String(), Type.Number(), Type.Boolean(), Type.Null()])),
+  Type.Array(
+    Type.Union([
+      Type.String(),
+      Type.Number(),
+      Type.Boolean(),
+      Type.Null(),
+      Type.Object({}, { additionalProperties: true }),
+    ]),
+  ),
   Type.Object({}, { additionalProperties: true }),
 ]);
 
