Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
gateway: a schema's own type and properties beside a oneOf reach Antigravity (#4046)
yetoneefb55b5c925e
diff --git a/internal/gateway/antigravity_root_union_test.go b/internal/gateway/antigravity_root_union_test.gonew file mode 100644index 000000000..0b0b9a829--- /dev/null+++ b/internal/gateway/antigravity_root_union_test.go@@ -0,0 +1,105 @@+package gateway++import (+ "encoding/json"+ "reflect"+ "testing"++ "github.com/tidwall/gjson"+)++// rgSchema is Philo's rg tool as #4046 (imuxin) gave it: an object root+// with its properties and a sibling oneOf that only says which of them+// may be given together.+const rgSchema = `{"type":"object","properties":{"pattern":{"type":"string"},"cursor":{"type":"string"}},"oneOf":[{"required":["pattern"],"not":{"required":["cursor"]}},{"required":["cursor"],"not":{"required":["pattern"]}}]}`++// #4046's own reproduction: the oneOf's first branch, which has no type,+// stood in for the whole root, so the tool went to Antigravity as+// {"type":"string"} and Claude there answered 400 "tools.4.custom.+// input_schema.type: Input should be 'object'".+func TestAntigravityRootOneOfKeepsObject(t *testing.T) {+ got := plainSchema(json.RawMessage(rgSchema))+ var parameters map[string]any+ if err := json.Unmarshal(got, ¶meters); err != nil {+ t.Fatal(err)+ }+ props, _ := parameters["properties"].(map[string]any)+ if parameters["type"] != "object" || props["pattern"] == nil || props["cursor"] == nil {+ t.Fatalf("got %s; want an object retaining pattern and cursor", got)+ }+}++// The same tool through the route the reporter took: an OpenAI Chat+// declaration, parseChat, then the Antigravity body.+func TestAntigravityChatToolRootOneOfKeepsObject(t *testing.T) {+ r, err := parseChat([]byte(`{"model":"m","messages":[{"role":"user","content":"hi"}],"tools":[{"type":"function","function":{"name":"rg","description":"search","parameters":` + rgSchema + `}}]}`))+ if err != nil {+ t.Fatal(err)+ }+ ps := gjson.ParseBytes(buildCodeAssist(r, "claude-sonnet-4-5", "antigravity")).Get("request.tools.0.functionDeclarations.0.parameters")+ want := `{"type":"object","properties":{"pattern":{"type":"string"},"cursor":{"type":"string"}}}`+ var got, exp any+ json.Unmarshal([]byte(ps.Raw), &got)+ json.Unmarshal([]byte(want), &exp)+ if !reflect.DeepEqual(got, exp) {+ t.Fatalf("parameters %s", ps.Raw)+ }+}++// A schema with its own type or properties keeps them beside any union,+// at the root or under a property, whichever of anyOf, oneOf or allOf it+// is. Fields only a branch declares join the object's; a field is+// required when every branch that isn't null requires it, or an allOf+// member does; a null branch makes it nullable. A union with nothing of+// its own beside it is still read as its first branch that isn't null.+func TestPlainSchemaUnionKeepsOwnShape(t *testing.T) {+ for _, c := range []struct{ name, in, want string }{+ {"root oneOf", rgSchema,+ `{"type":"object","properties":{"pattern":{"type":"string"},"cursor":{"type":"string"}}}`},+ {"root anyOf", `{"type":"object","properties":{"a":{"type":"string"}},"anyOf":[{"required":["a"]},{"not":{"required":["a"]}}]}`,+ `{"type":"object","properties":{"a":{"type":"string"}}}`},+ {"properties only, no type", `{"properties":{"a":{"type":"string"}},"oneOf":[{"required":["a"]}]}`,+ `{"type":"object","properties":{"a":{"type":"string"}},"required":["a"]}`},+ {"nested oneOf", `{"type":"object","properties":{"q":{"type":"object","description":"query","properties":{"pattern":{"type":"string"},"cursor":{"type":"string"}},"oneOf":[{"required":["pattern"],"not":{"required":["cursor"]}},{"required":["cursor"],"not":{"required":["pattern"]}}]}},"required":["q"]}`,+ `{"type":"object","properties":{"q":{"type":"object","description":"query","properties":{"pattern":{"type":"string"},"cursor":{"type":"string"}}}},"required":["q"]}`},+ {"nested anyOf", `{"type":"object","properties":{"q":{"type":"object","properties":{"a":{"type":"integer"}},"anyOf":[{"required":["a"]},{"type":"null"}]}}}`,+ `{"type":"object","properties":{"q":{"type":"object","properties":{"a":{"type":"integer"}},"required":["a"],"nullable":true}}}`},+ {"branches add fields", `{"type":"object","properties":{"kind":{"type":"string"}},"required":["kind"],"oneOf":[{"properties":{"kind":{"const":"a"},"x":{"type":"string"}},"required":["kind","x"]},{"properties":{"kind":{"const":"b"},"y":{"type":"number"}},"required":["kind","y"]}]}`,+ `{"type":"object","properties":{"kind":{"type":"string"},"x":{"type":"string"},"y":{"type":"number"}},"required":["kind"]}`},+ {"every branch requires it", `{"type":"object","properties":{"a":{"type":"string"},"b":{"type":"string"}},"anyOf":[{"required":["a","b"]},{"required":["a"]}]}`,+ `{"type":"object","properties":{"a":{"type":"string"},"b":{"type":"string"}},"required":["a"]}`},+ {"root allOf", `{"type":"object","properties":{"a":{"type":"string"}},"required":["a"],"allOf":[{"properties":{"b":{"type":"string"}},"required":["b"]},{"not":{"required":["c"]}}]}`,+ `{"type":"object","properties":{"a":{"type":"string"},"b":{"type":"string"}},"required":["a","b"]}`},+ {"nested allOf", `{"type":"object","properties":{"q":{"type":"object","properties":{"a":{"type":"string"}},"allOf":[{"required":["a"]}]}}}`,+ `{"type":"object","properties":{"q":{"type":"object","properties":{"a":{"type":"string"}},"required":["a"]}}}`},+ {"allOf beside oneOf", `{"type":"object","properties":{"a":{"type":"string"}},"allOf":[{"properties":{"b":{"type":"string"}}}],"oneOf":[{"required":["a"]},{"required":["b"]}]}`,+ `{"type":"object","properties":{"a":{"type":"string"},"b":{"type":"string"}}}`},+ {"typed scalar", `{"type":"string","description":"d","anyOf":[{"format":"date"},{"format":"uuid"}]}`,+ `{"type":"string","description":"d"}`},+ {"bare union still its first branch", `{"type":"object","properties":{"v":{"description":"value","anyOf":[{"type":"null"},{"type":"integer"},{"type":"string"}]}}}`,+ `{"type":"object","properties":{"v":{"type":"integer","description":"value","nullable":true}}}`},+ } {+ var got, exp any+ if err := json.Unmarshal(plainSchema(json.RawMessage(c.in)), &got); err != nil {+ t.Fatalf("%s: %v", c.name, err)+ }+ if err := json.Unmarshal([]byte(c.want), &exp); err != nil {+ t.Fatalf("%s: want: %v", c.name, err)+ }+ if !reflect.DeepEqual(got, exp) {+ b, _ := json.Marshal(got)+ t.Errorf("%s: got %s\nwant %s", c.name, b, c.want)+ }+ }+}++// The other converter that takes a union off a tool's root,+// provider.ObjectRoot (Anthropic's objectSchema, and the fold for xAI and+// the upstreams that refuse a root union), keeps the same tool an object+// with both its fields: its constraint-only branches are passed over.+func TestObjectSchemaRootOneOfKeepsObject(t *testing.T) {+ ps := gjson.ParseBytes(objectSchema(json.RawMessage(rgSchema)))+ if ps.Get("type").String() != "object" || !ps.Get("properties.pattern").Exists() || !ps.Get("properties.cursor").Exists() || ps.Get("oneOf").Exists() || ps.Get("required").Exists() {+ t.Fatalf("got %s", ps.Raw)+ }+}diff --git a/internal/gateway/codeassist.go b/internal/gateway/codeassist.goindex 1561b036b..3bc2163f0 100644--- a/internal/gateway/codeassist.go+++ b/internal/gateway/codeassist.go@@ -5,6 +5,7 @@ import ("context""encoding/json""fmt"+ "maps""net/http""regexp""slices"@@ -798,6 +799,15 @@ func plainSchema(raw json.RawMessage) json.RawMessage {}}}+ // resolve is a member as its local $ref names it, nil when it is no+ // schema+ resolve := func(v any) map[string]any {+ m, _ := v.(map[string]any)+ if ref, ok := m["$ref"].(string); ok {+ m, _ = defs[ref[strings.LastIndex(ref, "/")+1:]].(map[string]any)+ }+ return m+ }var walk func(v any, depth int) anywalk = func(v any, depth int) any {switch x := v.(type) {@@ -818,7 +828,8 @@ func plainSchema(raw json.RawMessage) json.RawMessage {}return map[string]any{"type": "object"}}- // allOf: one schema with all the members' fields+ // allOf: one schema with all the members' fields, and every+ // field one of them requiresif all, ok := x["allOf"].([]any); ok {merged := map[string]any{}for k, v := range x {@@ -826,9 +837,17 @@ func plainSchema(raw json.RawMessage) json.RawMessage {merged[k] = v}}+ required := requiredNames(x["required"])for _, e := range all {+ // a member's required is read before it is walked: walked+ // alone, a member that only requires ({"required":["a"]})+ // has no properties to keep its names for+ required = append(required, requiredNames(resolve(e)["required"])...)if m, ok := walk(e, depth+1).(map[string]any); ok {for k, v := range m {+ if k == "required" {+ continue+ }if k == "properties" {props, _ := merged["properties"].(map[string]any)if props == nil {@@ -844,9 +863,23 @@ func plainSchema(raw json.RawMessage) json.RawMessage {}}}+ if len(required) > 0 {+ merged["required"] = distinctNames(required)+ }return walk(merged, depth+1)}- // anyOf / oneOf: the first member that isn't null, nullable+ if (x["anyOf"] != nil || x["oneOf"] != nil) && ownShape(x) {+ // a schema with its own type or properties beside an anyOf+ // or oneOf keeps them, and the union is folded into it:+ // Philo's rg tool is an object whose oneOf only says which+ // of its fields go together, and its first branch, standing+ // for the whole, sent it as {"type":"string"}; Claude on+ // Antigravity answered 400 "input_schema.type: Input should+ // be 'object'" (#4046, imuxin)+ return walk(foldUnion(x, resolve), depth+1)+ }+ // anyOf / oneOf with nothing of its own beside it: the first+ // member that isn't null, nullablefor _, k := range []string{"anyOf", "oneOf"} {if alts, ok := x[k].([]any); ok {var pick map[string]any@@ -1005,6 +1038,117 @@ func plainSchema(raw json.RawMessage) json.RawMessage {return b}+// ownShape is whether a schema says what it is beside its anyOf or+// oneOf: a type that isn't only null, properties or items.+func ownShape(x map[string]any) bool {+ if x["properties"] != nil || x["items"] != nil {+ return true+ }+ switch t := x["type"].(type) {+ case string:+ return t != "null"+ case []any:+ for _, e := range t {+ if e != "null" {+ return true+ }+ }+ }+ return false+}++// foldUnion is x, which has a shape of its own (ownShape), with its anyOf+// and oneOf folded in, for a schema subset that has no unions. What x says+// itself stands. A null branch makes it nullable. On an object, a field+// only branches declare joins its properties, as the first branch to+// declare it gives it, and a field every branch that isn't null requires+// is required: the model sees every field it may send, and is held only+// to what any choice holds it to. The rest of a branch — which fields go together, a "not" —+// is a rule the subset can't say, and the client still checks the call+// against its own schema.+func foldUnion(x map[string]any, resolve func(any) map[string]any) map[string]any {+ out := make(map[string]any, len(x))+ for k, v := range x {+ if k != "anyOf" && k != "oneOf" {+ out[k] = v+ }+ }+ object := x["type"] == "object" || x["properties"] != nil+ if ts, ok := x["type"].([]any); ok {+ for _, t := range ts {+ object = object || t == "object"+ }+ }+ props := map[string]any{}+ own, _ := x["properties"].(map[string]any)+ for k, v := range own {+ props[k] = v+ }+ var common []any+ branches := 0+ for _, k := range []string{"anyOf", "oneOf"} {+ alts, _ := x[k].([]any)+ for _, a := range alts {+ m := resolve(a)+ if m == nil {+ continue+ }+ if m["type"] == "null" {+ out["nullable"] = true+ continue+ }+ if !object {+ continue+ }+ bp, _ := m["properties"].(map[string]any)+ for _, pk := range slices.Sorted(maps.Keys(bp)) {+ if _, has := props[pk]; !has {+ props[pk] = bp[pk]+ }+ }+ br := requiredNames(m["required"])+ if branches == 0 {+ common = append([]any(nil), br...)+ } else {+ common = slices.DeleteFunc(common, func(n any) bool { return !slices.Contains(br, n) })+ }+ branches+++ }+ }+ if object {+ if len(props) > 0 {+ out["properties"] = props+ }+ if req := requiredNames(x["required"]); len(req)+len(common) > 0 {+ out["required"] = distinctNames(append(req, common...))+ }+ }+ return out+}++// requiredNames is a required list's names: its strings, a fresh slice.+func requiredNames(v any) []any {+ l, _ := v.([]any)+ var out []any+ for _, e := range l {+ if s, ok := e.(string); ok {+ out = append(out, s)+ }+ }+ return out+}++// distinctNames is vs with each value kept once, in order.+func distinctNames(vs []any) []any {+ var out []any+ for _, v := range vs {+ if !slices.Contains(out, v) {+ out = append(out, v)+ }+ }+ return out+}+// codeAssistDecoder reads Code Assist's stream: Gemini chunks, each wrapped// in {response}.type codeAssistDecoder struct {