Skip to content

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.go
new file mode 100644
index 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, &parameters); 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.go
index 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) any
walk = 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 requires
if 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, nullable
for _, 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 {