Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
gateway: a schema a tool's $ref reaches goes to Kimi with a type
yetone129d8b08a5e3
diff --git a/internal/gateway/gateway.go b/internal/gateway/gateway.goindex 0f7a3f52d..4e3a789e6 100644--- a/internal/gateway/gateway.go+++ b/internal/gateway/gateway.go@@ -3754,6 +3754,7 @@ func (s *Server) forwardOnce(ctx context.Context, p provider.Provider, to providbody = deepseekTokenField(p, to, body)body = toolOneOfAsAnyOf(p, to, body)body = kimiToolEnumTypes(p, to, body)+ body = kimiToolRefTypes(p, to, body)body = kimiLockedSampling(p, to, body)body = clinePin(p, to, body)body = codexImagesFit(p, to, body)diff --git a/internal/gateway/kimi_schema.go b/internal/gateway/kimi_schema.goindex 28880dd36..8d698c323 100644--- a/internal/gateway/kimi_schema.go+++ b/internal/gateway/kimi_schema.go@@ -2,6 +2,8 @@ package gatewayimport ("bytes"+ "net/url"+ "sort""strconv""strings"@@ -16,9 +18,10 @@ import (// defined" (#886, cua-driver's parse_visual_regions, whose kinds' items are// {"enum":["text","icon"]}), and the whole request fails though the tool is// never called. The type is the one every value has — string, integer,-// number or boolean; values of mixed types, or a null among them, are left-// as they were. It is written in place, after the schema's brace, so the-// rest of the body and a cache's prefix stay as they were.+// number or boolean, or that type and "null" when a null is among them, the+// one type array Kimi takes beside an enum; values of other mixed types are+// left as they were. It is written in place, after the schema's brace, so+// the rest of the body and a cache's prefix stay as they were.func kimiToolEnumTypes(p provider.Provider, to provider.Protocol, body []byte) []byte {if !isKimi(p, to) {return body@@ -32,19 +35,29 @@ func kimiToolEnumTypes(p provider.Provider, to provider.Protocol, body []byte) [}var ins []typeInsertcollectUntypedEnums(body, tools, false, &ins)+ return withTypes(body, ins)+}++// withTypes is body with each insert's type written after its schema's+// opening brace; a brace named twice gets it once.+func withTypes(body []byte, ins []typeInsert) []byte {if len(ins) == 0 {return body}- // the walk goes through the body in order, so the inserts ascend+ sort.SliceStable(ins, func(i, j int) bool { return ins[i].at < ins[j].at })var out bytes.Buffer- out.Grow(len(body) + len(ins)*20)- last := 0+ out.Grow(len(body) + len(ins)*24)+ last := -1for _, in := range ins {- out.Write(body[last : in.at+1])- out.WriteString(`"type":"` + in.typ + `",`)- last = in.at + 1+ if in.at == last {+ continue+ }+ start := last + 1+ out.Write(body[start : in.at+1])+ out.WriteString(`"type":` + in.typ + `,`)+ last = in.at}- out.Write(body[last:])+ out.Write(body[last+1:])return out.Bytes()}@@ -59,8 +72,8 @@ func isKimi(p provider.Provider, to provider.Protocol) bool {}type typeInsert struct {- at int // the schema's opening brace- typ string+ at int // the schema's opening brace+ typ string // the type as JSON: "string", or ["string","null"]}// collectUntypedEnums adds, for each schema under node with an enum or a@@ -80,7 +93,7 @@ func collectUntypedEnums(body []byte, node gjson.Result, inSchema bool, ins *[]t} else if c := node.Get("const"); c.Exists() {vals = []gjson.Result{c}}- if t := valuesType(vals); t != "" {+ if t := enumType(vals); t != "" {*ins = append(*ins, typeInsert{node.Index, t})}}@@ -109,6 +122,29 @@ func collectUntypedEnums(body []byte, node gjson.Result, inSchema bool, ins *[]t}}+// enumType is the type, as JSON, an enum or const of vals is written with+// for Kimi: the one all of them have, or it and "null" when a null is among+// them; "" when there are none or other types are mixed.+func enumType(vals []gjson.Result) string {+ var rest []gjson.Result+ null := false+ for _, v := range vals {+ if v.Type == gjson.Null {+ null = true+ continue+ }+ rest = append(rest, v)+ }+ t := valuesType(rest)+ switch {+ case t == "":+ return ""+ case null:+ return `["` + t + `","null"]`+ }+ return `"` + t + `"`+}+// valuesType is the JSON Schema type all of vals have, "" when there are// none or they differ; whole numbers among fractions make them number.func valuesType(vals []gjson.Result) string {@@ -210,3 +246,256 @@ func leadingInt(s string) (int, string) {}return n, s[i:]}++// kimiToolRefTypes is body with a type written into each schema its tools'+// $refs reach that has none, for Kimi and Moonshot. Their validator expands+// a $ref and refuses a target with no type — 400 "not a valid moonshot+// flavored json schema … At path 'properties.b': detected infinite+// recursion without termination condition" — and the whole request fails,+// though the same schema written inline passes. Codex sends such targets:+// its MCP and Codex App tools come as zod's $defs (__schema0, __schema1 …),+// and it types a def with properties or an enum but leaves a oneOf or an+// allOf one as it was (chaosy on Discord, Codex on k3). The type is the+// one the target's keywords or branches say, a type array when they differ,+// and every type when nothing does, which Kimi takes as "any". A target+// that is {}, an anyOf (Kimi refuses a type beside one: "type should be+// defined in anyOf items instead of the parent schema") or only another+// $ref is left as Kimi takes it, as is an enum whose values no one type+// array can hold. Written in place, like kimiToolEnumTypes', after which it+// runs.+func kimiToolRefTypes(p provider.Provider, to provider.Protocol, body []byte) []byte {+ if !isKimi(p, to) || !bytes.Contains(body, []byte(`"$ref"`)) {+ return body+ }+ tools := gjson.GetBytes(body, "tools")+ if !tools.IsArray() || tools.Index <= 0 {+ return body+ }+ var ins []typeInsert+ tools.ForEach(func(_, tool gjson.Result) bool {+ for _, at := range []string{"function.parameters", "parameters", "input_schema"} {+ if root := tool.Get(at); root.IsObject() {+ collectRefTargets(body, root, root, &ins)+ }+ }+ return true+ })+ return withTypes(body, ins)+}++// collectRefTargets adds, for each local $ref under node (a schema of the+// tool schema root) whose target Kimi would refuse untyped, where the+// target opens and the type it is given.+func collectRefTargets(body []byte, root, node gjson.Result, ins *[]typeInsert) {+ walkSchema(node, func(s gjson.Result) {+ ref := s.Get(`\$ref`)+ if ref.Type != gjson.String {+ return+ }+ t, ok := refTarget(root, ref.String())+ if !ok || !t.IsObject() || t.Index <= 0 || t.Index >= len(body) || body[t.Index] != '{' || !untypedForKimi(t) {+ return+ }+ if typ := kimiSchemaType(root, t); typ != "" {+ *ins = append(*ins, typeInsert{t.Index, typ})+ }+ })+}++// walkSchema calls f with node and every schema under it, through the+// keywords that hold schemas.+func walkSchema(node gjson.Result, f func(gjson.Result)) {+ switch {+ case node.IsArray():+ node.ForEach(func(_, v gjson.Result) bool {+ walkSchema(v, f)+ return true+ })+ case node.IsObject():+ f(node)+ node.ForEach(func(key, v gjson.Result) bool {+ switch key.String() {+ case "properties", "$defs", "definitions", "dependentSchemas", "patternProperties":+ v.ForEach(func(_, s gjson.Result) bool {+ walkSchema(s, f)+ return true+ })+ case "items", "additionalProperties", "contains", "propertyNames", "not", "if", "then", "else", "allOf", "anyOf", "oneOf", "prefixItems", "unevaluatedProperties", "unevaluatedItems", "contentSchema":+ walkSchema(v, f)+ }+ return true+ })+ }+}++// refTarget is the schema a local $ref ("#", "#/$defs/x") names in root.+func refTarget(root gjson.Result, ref string) (gjson.Result, bool) {+ if ref != "#" && !strings.HasPrefix(ref, "#/") {+ return gjson.Result{}, false+ }+ cur := root+ for _, tok := range strings.Split(ref, "/")[1:] {+ tok = strings.ReplaceAll(strings.ReplaceAll(tok, "~1", "/"), "~0", "~")+ if u, err := url.PathUnescape(tok); err == nil {+ tok = u+ }+ if !cur.IsObject() && !cur.IsArray() {+ return gjson.Result{}, false+ }+ cur = cur.Get(gjson.Escape(tok))+ if !cur.Exists() {+ return gjson.Result{}, false+ }+ }+ return cur, true+}++// untypedForKimi is whether Kimi refuses s as a $ref's target: it has no+// type, isn't {}, an anyOf, or a $ref with nothing but notes beside it.+func untypedForKimi(s gjson.Result) bool {+ if s.Get("type").Exists() || s.Get("anyOf").Exists() {+ return false+ }+ only := true+ n := 0+ s.ForEach(func(k, _ gjson.Result) bool {+ n+++ switch k.String() {+ case "$ref", "description", "title", "default", "examples", "$comment":+ default:+ only = false+ }+ return true+ })+ if n == 0 {+ return false+ }+ return !(only && s.Get(`\$ref`).Exists())+}++// allKimiTypes is every JSON Schema type, which Kimi takes for a schema+// that may be anything.+const allKimiTypes = `["string","number","integer","boolean","object","array","null"]`++// kimiSchemaType is the type, as JSON, an untyped schema s is given: the+// one (or the ones) its keywords and branches say, every type when they+// say nothing, and "" for an enum no type Kimi takes beside one can hold.+func kimiSchemaType(root, s gjson.Result) string {+ if e := s.Get("enum"); e.IsArray() {+ return enumType(e.Array())+ }+ if c := s.Get("const"); c.Exists() {+ return enumType([]gjson.Result{c})+ }+ ts := schemaTypes(root, s, 0)+ if len(ts) == 0 {+ return allKimiTypes+ }+ if ts["integer"] && ts["number"] {+ delete(ts, "integer")+ }+ var names []string+ for _, t := range []string{"string", "number", "integer", "boolean", "object", "array", "null"} {+ if ts[t] {+ names = append(names, `"`+t+`"`)+ }+ }+ if len(names) == 1 {+ return names[0]+ }+ return "[" + strings.Join(names, ",") + "]"+}++// schemaTypes is the set of types s can have, as its type, its keywords,+// its values or its branches (through their $refs) say; nil when they+// don't say.+func schemaTypes(root, s gjson.Result, depth int) map[string]bool {+ if depth > 16 || !s.IsObject() {+ return nil+ }+ ts := map[string]bool{}+ if t := s.Get("type"); t.Exists() {+ for _, v := range t.Array() {+ ts[v.String()] = true+ }+ return ts+ }+ if ref := s.Get(`\$ref`); ref.Type == gjson.String {+ if t, ok := refTarget(root, ref.String()); ok {+ return schemaTypes(root, t, depth+1)+ }+ return nil+ }+ if e := s.Get("enum"); e.IsArray() || s.Get("const").Exists() {+ vals := e.Array()+ if c := s.Get("const"); c.Exists() {+ vals = []gjson.Result{c}+ }+ for _, v := range vals {+ switch v.Type {+ case gjson.String:+ ts["string"] = true+ case gjson.True, gjson.False:+ ts["boolean"] = true+ case gjson.Null:+ ts["null"] = true+ case gjson.Number:+ if strings.ContainsAny(v.Raw, ".eE") {+ ts["number"] = true+ } else {+ ts["integer"] = true+ }+ default:+ if v.IsArray() {+ ts["array"] = true+ } else {+ ts["object"] = true+ }+ }+ }+ return ts+ }+ // a branch that says nothing makes oneOf and anyOf anything; allOf+ // is what its branches that do say+ for _, k := range []string{"oneOf", "anyOf", "allOf"} {+ bs := s.Get(k)+ if !bs.IsArray() {+ continue+ }+ known := false+ for _, b := range bs.Array() {+ bt := schemaTypes(root, b, depth+1)+ if len(bt) == 0 && k != "allOf" {+ return nil+ }+ for t := range bt {+ ts[t] = true+ known = true+ }+ }+ if known {+ return ts+ }+ }+ has := func(keys ...string) bool {+ for _, k := range keys {+ if s.Get(k).Exists() {+ return true+ }+ }+ return false+ }+ switch {+ case has("properties", "required", "additionalProperties", "patternProperties", "minProperties", "maxProperties", "propertyNames", "dependentRequired", "dependentSchemas", "unevaluatedProperties"):+ ts["object"] = true+ case has("items", "prefixItems", "minItems", "maxItems", "uniqueItems", "contains", "unevaluatedItems"):+ ts["array"] = true+ case has("minLength", "maxLength", "pattern", "format", "contentEncoding", "contentMediaType"):+ ts["string"] = true+ case has("minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf"):+ ts["number"] = true+ default:+ return nil+ }+ return ts+}diff --git a/internal/gateway/kimi_schema_test.go b/internal/gateway/kimi_schema_test.goindex 0eda23d58..56cb91864 100644--- a/internal/gateway/kimi_schema_test.go+++ b/internal/gateway/kimi_schema_test.go@@ -18,7 +18,9 @@ import (// 'properties.options.properties.kinds.anyOf.items': type is not defined"// (#886), and the whole request failed. Values of mixed types, a schema// with a type, a property called enum and the rest of the body are left as-// they were; anyone else is sent the tools unchanged.+// they were; a null among one type's values gives that type and "null",+// the type array Kimi takes beside an enum. Anyone else is sent the tools+// unchanged.func TestKimiToolEnumTypes(t *testing.T) {t.Setenv("XDG_CONFIG_HOME", t.TempDir())t.Setenv("XDG_CACHE_HOME", t.TempDir())@@ -61,6 +63,7 @@ func TestKimiToolEnumTypes(t *testing.T) {`"scale":{"enum"`, `"scale":{"type":"number","enum"`,`"on":{"const"`, `"on":{"type":"boolean","const"`,`"mode":{ "enum"`, `"mode":{"type":"string", "enum"`,+ `"maybe":{"enum"`, `"maybe":{"type":["string","null"],"enum"`,).Replace(tools)b := got["api.kimi.com"]if !strings.Contains(b, want) {@@ -74,6 +77,96 @@ func TestKimiToolEnumTypes(t *testing.T) {}}+// A schema a tool's $ref reaches goes to Kimi with a type: Kimi expands+// the $ref and refuses a target with none, 400 "At path 'properties.b':+// detected infinite recursion without termination condition", and Codex on+// k3 failed outright (chaosy on Discord). Codex sends zod's $defs with a+// oneOf or allOf def untyped, as captured from Codex 0.162.1 (b, c); raw+// clients send defs typed by nothing but their keywords, or by nothing at+// all. Each goes on the chat route, the Anthropic route and from Codex's+// Responses; a {} def, an anyOf (Kimi refuses a type beside one), a typed+// def, an unreferenced one and the rest of the body are left as they were,+// and anyone else is sent the tools unchanged.+func TestKimiToolRefTypes(t *testing.T) {+ t.Setenv("XDG_CONFIG_HOME", t.TempDir())+ t.Setenv("XDG_CACHE_HOME", t.TempDir())+ kimi, err := provider.FromPreset("kimi-code-cn")+ if err != nil {+ t.Fatal(err)+ }+ kimi.ID, kimi.Key, kimi.Models = "kimi", "k", []string{"m"}+ for _, p := range []provider.Provider{kimi,+ {ID: "other", Name: "Other", Key: "k", Chat: "https://other.test/v1", Anthropic: "https://other.test", Models: []string{"m"}},+ } {+ if err := provider.Save(p); err != nil {+ t.Fatal(err)+ }+ }+ got := map[string]string{}+ s := New()+ s.client = &http.Client{Transport: countTransport(func(r *http.Request) (*http.Response, error) {+ b, _ := io.ReadAll(r.Body)+ got[r.URL.Host+r.URL.Path] = string(b)+ return &http.Response{StatusCode: 400, Header: http.Header{"Content-Type": {"application/json"}},+ Body: io.NopCloser(strings.NewReader(`{"error":{"message":"no","type":"invalid_request_error"}}`))}, nil+ })}+ schema := `{"type":"object","properties":{"a":{"$ref":"#/$defs/__schema0"},"b":{"$ref":"#/$defs/__schema1"},` ++ `"c":{"items":{"$ref":"#/$defs/__schema2"},"type":"array"},"d":{"anyOf":[{"$ref":"#/$defs/P"},{"type":"null"}]},` ++ `"e":{"$ref":"#/$defs/M"},"f":{"$ref":"#/definitions/D"},"g":{"$ref":"#/$defs/R"},"h":{"$ref":"#/$defs/U"},"i":{"$ref":"#/$defs/S"}},` ++ `"$defs":{"__schema0":{},"__schema1":{"oneOf":[{"type":"string"},{"type":"number"}]},"__schema2":{"allOf":[{"type":"string"}]},` ++ `"P":{"properties":{"x":{"type":"string"}}},"M":{"minLength":1},"R":{"oneOf":[{"$ref":"#/$defs/P"},{"$ref":"#/definitions/D"}]},` ++ `"U":{"anyOf":[{"type":"string"},{"$ref":"#/$defs/U"}]},"S":{"type":"string","enum":["x"]},"V":{"oneOf":[{"type":"string"}]}},` ++ `"definitions":{"D":{"description":"anything"}}}`+ anything := `["string","number","integer","boolean","object","array","null"]`+ want := strings.NewReplacer(+ `"__schema1":{`, `"__schema1":{"type":["string","number"],`,+ `"__schema2":{`, `"__schema2":{"type":"string",`,+ `"P":{`, `"P":{"type":"object",`,+ `"M":{`, `"M":{"type":"string",`,+ `"R":{`, `"R":{"type":`+anything+`,`,+ `"D":{`, `"D":{"type":`+anything+`,`,+ ).Replace(schema)+ routes := []struct{ path, tools, upstream, otherUp string }{+ {"/v1/chat/completions", `"tools":[{"type":"function","function":{"name":"automation_update","parameters":%s}}]`, "api.kimi.com/coding/v1/chat/completions", "other.test/v1/chat/completions"},+ {"/v1/messages", `"tools":[{"name":"automation_update","input_schema":%s}]`, "api.kimi.com/coding/v1/messages", "other.test/v1/messages"},+ {"/v1/responses", `"tools":[{"type":"function","name":"automation_update","parameters":%s}]`, "api.kimi.com/coding/v1/chat/completions", "other.test/v1/chat/completions"},+ }+ for _, r := range routes {+ for _, id := range []string{"kimi", "other"} {+ clear(got)+ msgs := `"messages":[{"role":"user","content":"hi"}],"max_tokens":16,`+ if r.path == "/v1/responses" {+ msgs = `"input":"hi",`+ }+ body := `{"model":"` + id + `/m",` + msgs + strings.Replace(r.tools, "%s", schema, 1) + `}`+ rec := httptest.NewRecorder()+ s.Handler().ServeHTTP(rec, httptest.NewRequest("POST", r.path, strings.NewReader(body)))+ up := r.upstream+ if id == "other" {+ up = r.otherUp+ }+ b, ok := got[up]+ if !ok {+ t.Fatalf("%s %s: nothing sent to %s, only %v (%d %s)", r.path, id, up, got, rec.Code, rec.Body)+ }+ if !json.Valid([]byte(b)) {+ t.Fatalf("%s %s: invalid JSON sent:\n%s", r.path, id, b)+ }+ sent := gjson.Get(b, "tools.0.function.parameters")+ if !sent.Exists() {+ sent = gjson.Get(b, "tools.0.input_schema")+ }+ w := schema+ if id == "kimi" {+ w = want+ }+ if sent.Raw != w {+ t.Errorf("%s %s was sent:\n%s\nwant:\n%s", r.path, id, sent.Raw, w)+ }+ }+ }+}+// A request to a model whose server locks temperature and top_p — Kimi// Code's kimi-for-coding and k3*, kimi-k2.5 and later on either Kimi// platform — goes without them: the whitelist refuses the ones clients