From 69d49744cf644b1dc7c73bf57167047e4db1e089 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=83=AD=E5=85=B0=E9=91=AB?= <1735612127@qq.com> Date: Sun, 13 Sep 2026 03:57:18 +0800 Subject: [PATCH] fix(antigravity): address code review feedback on schema cleaner - Fix test assertion target location for whereItems prefixItems - Support const keyword normalization to enum and infer scalar type - Infer scalar type for enum-only schema to prevent object reason injection - Recursively clean properties and items after anyOf/oneOf merge - Ensure empty prefixItems is safely deleted --- .../pkg/antigravity/schema_cleaner.go | 77 ++++++++++-- .../pkg/antigravity/schema_cleaner_test.go | 115 +++++++++++++++++- 2 files changed, 180 insertions(+), 12 deletions(-) diff --git a/backend/internal/pkg/antigravity/schema_cleaner.go b/backend/internal/pkg/antigravity/schema_cleaner.go index 8988603ff1..9ac4211e4a 100644 --- a/backend/internal/pkg/antigravity/schema_cleaner.go +++ b/backend/internal/pkg/antigravity/schema_cleaner.go @@ -120,16 +120,21 @@ func cleanJSONSchemaRecursive(value any) any { mergeAllOf(schemaMap) // 0.5 [FIX] 处理 Draft 2020-12 的 prefixItems (元组定义) - if prefixItems, ok := schemaMap["prefixItems"].([]any); ok && len(prefixItems) > 0 { - itemsVal, hasItems := schemaMap["items"] - _, itemsIsBool := itemsVal.(bool) - if !hasItems || itemsVal == nil || itemsIsBool { - best := extractBestSchemaFromUnion(prefixItems) - if best == nil { - best = map[string]any{"type": "string"} + if prefixItemsVal, hasPrefix := schemaMap["prefixItems"]; hasPrefix { + if prefixItems, ok := prefixItemsVal.([]any); ok && len(prefixItems) > 0 { + itemsVal, hasItems := schemaMap["items"] + _, itemsIsBool := itemsVal.(bool) + // 如果没有 items，或者 items 为 nil，或者 items 是布尔值（如 Draft 2020-12 中表示元组闭合的 items: false）， + // 用选出的最佳元组项填充 items，以满足 Gemini 对 array.items 必须为合法 Schema 对象的规范。 + if !hasItems || itemsVal == nil || itemsIsBool { + best := extractBestSchemaFromUnion(prefixItems) + if best == nil { + best = map[string]any{"type": "string"} + } + schemaMap["items"] = best } - schemaMap["items"] = best } + // 无论 prefixItems 是否为空数组，都彻底删除 prefixItems 关键字以防 Gemini 400 delete(schemaMap, "prefixItems") } @@ -219,6 +224,18 @@ func cleanJSONSchemaRecursive(value any) any { schemaMap[k] = deepCopy(v) } } + // 清除已合并的 union 关键字 + delete(schemaMap, "anyOf") + delete(schemaMap, "oneOf") + // 对合并进来的新属性和 items 进行深度递归清洗，确保合并进来的子结构（如 prefixItems）也能被处理 + if props, ok := schemaMap["properties"].(map[string]any); ok { + for _, pv := range props { + cleanJSONSchemaRecursive(pv) + } + } + if items, ok := schemaMap["items"]; ok { + cleanJSONSchemaRecursive(items) + } } } } @@ -228,14 +245,37 @@ func cleanJSONSchemaRecursive(value any) any { hasKey(schemaMap, "properties") || hasKey(schemaMap, "items") || hasKey(schemaMap, "enum") || + hasKey(schemaMap, "const") || hasKey(schemaMap, "anyOf") || hasKey(schemaMap, "oneOf") || hasKey(schemaMap, "allOf") if looksLikeSchema { - // 4. [ROBUST] 约束迁移 + // 4. [ROBUST] 约束迁移与 const 规范化 migrateConstraints(schemaMap) + // 规范化 const 关键字 (Draft 6+ 转换为 Gemini 兼容的 enum: [const]) + if constVal, exists := schemaMap["const"]; exists { + if _, hasEnum := schemaMap["enum"]; !hasEnum { + schemaMap["enum"] = []any{constVal} + } + if _, hasType := schemaMap["type"]; !hasType { + switch constVal.(type) { + case string: + schemaMap["type"] = "string" + case int, int32, int64: + schemaMap["type"] = "integer" + case float32, float64: + schemaMap["type"] = "number" + case bool: + schemaMap["type"] = "boolean" + default: + schemaMap["type"] = "string" + } + } + delete(schemaMap, "const") + } + // 5. [CRITICAL] 白名单过滤 allowedFields := map[string]bool{ "type": true, @@ -283,11 +323,25 @@ func cleanJSONSchemaRecursive(value any) any { } schemaMap["type"] = selectedType } else { - // 如果没有 type，但有 properties/items，推断并补全 + // 如果没有 type，但有 properties/items/enum，推断并补全 if hasKey(schemaMap, "properties") { schemaMap["type"] = "object" } else if hasKey(schemaMap, "items") { schemaMap["type"] = "array" + } else if enumArr, ok := schemaMap["enum"].([]any); ok && len(enumArr) > 0 { + // [FIX] 针对仅含 enum 的 schema，按其元素类型推断标量类型，避免被误判为 object 并注入 reason 属性 + switch enumArr[0].(type) { + case int, int32, int64: + schemaMap["type"] = "integer" + case float32, float64: + schemaMap["type"] = "number" + case bool: + schemaMap["type"] = "boolean" + default: + schemaMap["type"] = "string" + } + } else if hasKey(schemaMap, "enum") { + schemaMap["type"] = "string" } else { schemaMap["type"] = "object" } @@ -525,6 +579,9 @@ func scoreSchemaOption(val any) int { if hasKey(m, "items") || typeStr == "array" { return 2 } + if hasKey(m, "enum") || hasKey(m, "const") { + return 1 + } if typeStr != "" && typeStr != "null" { return 1 } diff --git a/backend/internal/pkg/antigravity/schema_cleaner_test.go b/backend/internal/pkg/antigravity/schema_cleaner_test.go index 516d010c72..0401b670ad 100644 --- a/backend/internal/pkg/antigravity/schema_cleaner_test.go +++ b/backend/internal/pkg/antigravity/schema_cleaner_test.go @@ -41,12 +41,12 @@ func TestCleanJSONSchema_ArrayPrefixItems(t *testing.T) { require.True(t, ok) assert.Equal(t, "array", where["type"]) - // prefixItems 应被移除或替换 - assert.Nil(t, where["prefixItems"]) whereItems, ok := where["items"].(map[string]any) require.True(t, ok, "where.items must be an object") assert.Equal(t, "array", whereItems["type"]) + // prefixItems 应在 whereItems 中被彻底移除 + assert.Nil(t, whereItems["prefixItems"]) // 关键验证：where.items.items 必须存在且有效，不能缺失导致 Gemini 400 innerItems, ok := whereItems["items"].(map[string]any) @@ -108,3 +108,114 @@ func TestCleanJSONSchema_ArrayExistingItemsPreserved(t *testing.T) { items := numbers["items"].(map[string]any) assert.Equal(t, "integer", items["type"]) } + +func TestCleanJSONSchema_EnumOnlySchemaInTuple(t *testing.T) { + // 测试 enum-only schema 不会被误判为 object，也不应被注入 reason 属性 + input := map[string]any{ + "type": "object", + "properties": map[string]any{ + "choice": map[string]any{ + "enum": []any{"option_a", "option_b"}, + }, + "tuple_with_enum": map[string]any{ + "type": "array", + "prefixItems": []any{ + map[string]any{ + "enum": []any{"read", "write"}, + }, + }, + }, + }, + } + + cleaned := CleanJSONSchema(input) + require.NotNil(t, cleaned) + + props := cleaned["properties"].(map[string]any) + choice := props["choice"].(map[string]any) + assert.Equal(t, "string", choice["type"]) + assert.Nil(t, choice["properties"], "enum-only schema must NOT be treated as object with reason property") + assert.Equal(t, []any{"option_a", "option_b"}, choice["enum"]) + + tupleArray := props["tuple_with_enum"].(map[string]any) + tupleItems := tupleArray["items"].(map[string]any) + assert.Equal(t, "string", tupleItems["type"]) + assert.Nil(t, tupleItems["properties"]) + assert.Equal(t, []any{"read", "write"}, tupleItems["enum"]) +} + +func TestCleanJSONSchema_ConstKeywordConversion(t *testing.T) { + // 测试 const 关键字自动转换为 Gemini 兼容的 enum: [const] 且具有合法 type + input := map[string]any{ + "type": "object", + "properties": map[string]any{ + "action": map[string]any{ + "const": "ping", + }, + }, + } + + cleaned := CleanJSONSchema(input) + require.NotNil(t, cleaned) + + props := cleaned["properties"].(map[string]any) + action := props["action"].(map[string]any) + assert.Nil(t, action["const"], "const keyword must be removed") + assert.Equal(t, "string", action["type"]) + assert.Equal(t, []any{"ping"}, action["enum"]) +} + +func TestCleanJSONSchema_AnyOfNestedPrefixItems(t *testing.T) { + // 测试 anyOf 分支合并进来的嵌套 prefixItems 也被完整深度清洗 + input := map[string]any{ + "type": "object", + "properties": map[string]any{ + "status": map[string]any{"type": "string"}, + }, + "anyOf": []any{ + map[string]any{ + "properties": map[string]any{ + "extra_tuple": map[string]any{ + "type": "array", + "prefixItems": []any{ + map[string]any{"type": "integer"}, + }, + }, + }, + }, + }, + } + + cleaned := CleanJSONSchema(input) + require.NotNil(t, cleaned) + + props := cleaned["properties"].(map[string]any) + require.NotNil(t, props["extra_tuple"]) + extraTuple := props["extra_tuple"].(map[string]any) + assert.Nil(t, extraTuple["prefixItems"], "nested prefixItems from anyOf merge must be cleaned") + require.NotNil(t, extraTuple["items"]) + assert.Equal(t, "integer", extraTuple["items"].(map[string]any)["type"]) +} + +func TestCleanJSONSchema_EmptyPrefixItems(t *testing.T) { + // 验证空 prefixItems: [] 也被安全删除，不遗留非法关键字 + input := map[string]any{ + "type": "object", + "properties": map[string]any{ + "empty_tuple": map[string]any{ + "type": "array", + "prefixItems": []any{}, + }, + }, + } + + cleaned := CleanJSONSchema(input) + require.NotNil(t, cleaned) + + props := cleaned["properties"].(map[string]any) + emptyTuple := props["empty_tuple"].(map[string]any) + assert.Nil(t, emptyTuple["prefixItems"], "empty prefixItems array must be removed") + require.NotNil(t, emptyTuple["items"]) + assert.Equal(t, "string", emptyTuple["items"].(map[string]any)["type"]) +} +