Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
provider: Kimi Code's month read however /usages tells it, on every route
yetonecf3a2cc8384c
diff --git a/internal/provider/planquota.go b/internal/provider/planquota.goindex b3e18d2ff..d62689370 100644--- a/internal/provider/planquota.go+++ b/internal/provider/planquota.go@@ -413,9 +413,14 @@ func KimiCodeSearch(p Provider) string {// "usages":{"limit_5h":{"used_ratio":0.4372,"reset_time":"…"},// "limit_7d":{…},"limit_month_total":{…},"limit_month_code":{…}}//-// limit_month_total is the month's allowance; limit_month_code is the-// share of it code has used, no allowance of its own, so it isn't shown.-// A window told both ways is taken from usages, as kimi-code does.+// limit_month_total is the month's allowance. limit_month_code is code's+// share of it (kimi-code) or, on the membership of 2026-09, the coding+// allowance itself with no total beside it (GCMP's kimiUsage.ts), so it+// is the month only when limit_month_total isn't there. A window told+// both ways is taken from usages, as kimi-code does. Each share is read+// under its camelCase name too, a reset as text or epoch seconds or+// milliseconds (EchoBird's fixture), and a limits[] window counted in+// weeks or months by its length.func readKimiCode(b []byte) (string, []QuotaWindow, error) {type row map[string]anyvar r struct {@@ -439,6 +444,25 @@ func readKimiCode(b []byte) (string, []QuotaWindow, error) {}return 0, false}+ // a reset as RFC 3339 text or as epoch seconds or milliseconds, under+ // either spelling of its name+ resetOf := func(d row) *time.Time {+ for _, k := range []string{"resetTime", "resetAt", "reset_at", "reset_time"} {+ if s, _ := d[k].(string); s != "" {+ if t, err := time.Parse(time.RFC3339Nano, s); err == nil {+ return &t+ }+ }+ if n, ok := num(d[k]); ok && n > 0 {+ t := time.Unix(int64(n), 0)+ if n > 1e11 {+ t = time.UnixMilli(int64(n))+ }+ return &t+ }+ }+ return nil+ }window := func(d row, name string, span time.Duration) (QuotaWindow, bool) {limit, ok := num(d["limit"])if !ok || limit <= 0 {@@ -453,14 +477,7 @@ func readKimiCode(b []byte) (string, []QuotaWindow, error) {used = limit - left}w := QuotaWindow{Name: name, Span: span, Used: max(0, min(100, used/limit*100))}- for _, k := range []string{"resetTime", "resetAt", "reset_at", "reset_time"} {- if s, _ := d[k].(string); s != "" {- if t, err := time.Parse(time.RFC3339Nano, s); err == nil {- w.ResetsAt = &t- break- }- }- }+ w.ResetsAt = resetOf(d)return w, true}out := []QuotaWindow{}@@ -479,9 +496,15 @@ func readKimiCode(b []byte) (string, []QuotaWindow, error) {span = time.Duration(n) * time.Hourcase strings.Contains(unit, "DAY"):span = time.Duration(n) * 24 * time.Hour+ case strings.Contains(unit, "WEEK"):+ span = time.Duration(n) * 7 * 24 * time.Hour+ case strings.Contains(unit, "MONTH"):+ span = time.Duration(n) * 30 * 24 * time.Hour}name := "Allowance"switch {+ case span == 30*24*time.Hour:+ name = "Month"case span > 24*time.Hour && span%(24*time.Hour) == 0:name = fmt.Sprintf("%d days", span/(24*time.Hour))case span >= time.Hour && span%time.Hour == 0:@@ -500,19 +523,21 @@ func readKimiCode(b []byte) (string, []QuotaWindow, error) {for _, k := range []struct {key, name stringspan time.Duration- }{{"limit_5h", "5 hours", 5 * time.Hour}, {"limit_7d", "7 days", 7 * 24 * time.Hour}, {"limit_month_total", "Month", 30 * 24 * time.Hour}} {+ }{{"limit_5h", "5 hours", 5 * time.Hour}, {"limit_7d", "7 days", 7 * 24 * time.Hour},+ {"limit_month_total", "Month", 30 * 24 * time.Hour}, {"limit_month_code", "Month", 30 * 24 * time.Hour}} {d := r.Usages[k.key]+ if d == nil {+ d = r.Usages[camel(k.key)]+ }ratio, ok := num(d["used_ratio"])- if d == nil || !ok || math.IsNaN(ratio) || math.IsInf(ratio, 0) {- continue+ if !ok {+ ratio, ok = num(d["usedRatio"])}- w := QuotaWindow{Name: k.name, Span: k.span, Used: max(0, min(100, ratio*100))}- if s, _ := d["reset_time"].(string); s != "" {- if t, err := time.Parse(time.RFC3339Nano, s); err == nil {- w.ResetsAt = &t- }+ if d == nil || !ok || math.IsNaN(ratio) || math.IsInf(ratio, 0) ||+ slices.ContainsFunc(shares, func(s QuotaWindow) bool { return s.Span == k.span }) {+ continue}- shares = append(shares, w)+ shares = append(shares, QuotaWindow{Name: k.name, Span: k.span, Used: max(0, min(100, ratio*100)), ResetsAt: resetOf(d)})}if len(shares) > 0 {out = slices.DeleteFunc(out, func(w QuotaWindow) bool {@@ -898,3 +923,15 @@ func zhipuKeyTeamAt(ctx context.Context, root, quotaURL, key string, team *Zhipu_, ws, err := readZhipuPlan(b)return "GLM Coding Team", ws, err}++// camel spells a snake_case name in camelCase: limit_month_total is+// limitMonthTotal.+func camel(s string) string {+ parts := strings.Split(s, "_")+ for i := 1; i < len(parts); i++ {+ if parts[i] != "" {+ parts[i] = strings.ToUpper(parts[i][:1]) + parts[i][1:]+ }+ }+ return strings.Join(parts, "")+}diff --git a/internal/provider/planquota_test.go b/internal/provider/planquota_test.goindex b01c8e9b5..32c5495e7 100644--- a/internal/provider/planquota_test.go+++ b/internal/provider/planquota_test.go@@ -6,6 +6,7 @@ import ("math""net/http""net/http/httptest"+ "os""path/filepath""strings""sync/atomic"@@ -438,7 +439,7 @@ func TestReadKimiCode(t *testing.T) {// body is a live reply of 2026-09-23 (narumiruna/pi-extensions#1390): no// weekly usage, the 5h window told both ways. The second has every// window kimi-code reads (managed-usage.ts); each is taken from usages,-// limit_month_code shown not at all.+// limit_month_code not shown beside limit_month_total.func TestReadKimiCodeMonth(t *testing.T) {_, ws, err := readKimiCode([]byte(`{"limits": [@@ -482,6 +483,104 @@ func TestReadKimiCodeMonth(t *testing.T) {}}+// The month however Kimi tells it (lidazi2016 on Discord, still no month+// on v0.1.2023 with a Kimi Code China key): the membership of 2026-09+// sends limit_5h and limit_month_code with no total (GCMP's+// kimiUsage.ts), a share may come in camelCase with its reset in epoch+// milliseconds (EchoBird's fixture), and a counted window may be a+// month or a week long.+func TestReadKimiCodeMonthEveryWay(t *testing.T) {+ for _, c := range []struct{ name, body string }{+ {"code share only", `{"usages":{"limit_5h":{"used_ratio":0.25,"reset_time":"2026-10-29T11:25:00Z"},+ "limit_month_code":{"used_ratio":0.5,"reset_time":"2026-11-17T00:00:00Z"}}}`},+ {"camelCase", `{"usages":{"limit5h":{"usedRatio":0.25,"resetTime":"2026-10-29T11:25:00Z"},+ "limitMonthTotal":{"usedRatio":"0.5","resetTime":1794873600000}}}`},+ {"counted", `{"limits":[{"window":{"duration":300,"timeUnit":"TIME_UNIT_MINUTE"},"detail":{"limit":"100","used":"25","resetTime":"2026-10-29T11:25:00Z"}},+ {"window":{"duration":1,"timeUnit":"TIME_UNIT_MONTH"},"detail":{"limit":"100","remaining":"50","resetTime":1794873600}}]}`},+ } {+ _, ws, err := readKimiCode([]byte(c.body))+ if err != nil || len(ws) != 2 || ws[0].Name != "5 hours" || ws[0].Used != 25 || ws[0].ResetsAt == nil ||+ ws[1].Name != "Month" || ws[1].Used != 50 || ws[1].Span != 30*24*time.Hour ||+ ws[1].ResetsAt == nil || ws[1].ResetsAt.UTC().Day() != 17 || ws[1].ResetsAt.UTC().Month() != time.November {+ t.Errorf("%s: %+v %v", c.name, ws, err)+ }+ }+ // a counted week is the week, beside the month the shares tell+ _, ws, err := readKimiCode([]byte(`{"limits":[{"window":{"duration":1,"timeUnit":"TIME_UNIT_WEEK"},"detail":{"limit":10,"used":4}}],+ "usages":{"limit_month_total":{"used_ratio":0.1},"limit_month_code":{"used_ratio":0.05}}}`))+ if err != nil || len(ws) != 2 || ws[0].Name != "7 days" || ws[0].Used != 40 || ws[1].Name != "Month" || math.Abs(ws[1].Used-10) > 1e-9 {+ t.Errorf("week and month: %+v %v", ws, err)+ }+}++// Every way a Kimi Code key is added shows the month Kimi tells: the+// China and global presets, a provider of its own at the Anthropic base+// alone, and a key imported from OpenCode's auth.json. Each card is read+// from /usages on its own host with its own key.+func TestPlanQuotasKimiCodeMonthEveryRoute(t *testing.T) {+ isolate(t)+ h := t.TempDir()+ t.Setenv("HOME", h)+ t.Setenv("USERPROFILE", h)+ t.Setenv("XDG_CONFIG_HOME", filepath.Join(h, ".config"))+ t.Setenv("XDG_CACHE_HOME", filepath.Join(h, ".cache"))+ t.Setenv("XDG_DATA_HOME", filepath.Join(h, ".local", "share"))+ t.Setenv("PATH", h)+ for _, v := range agentenv.Vars {+ t.Setenv(v, "")+ }+ month := `{"limits":[{"window":{"duration":300,"timeUnit":"TIME_UNIT_MINUTE"},"detail":{"limit":"100","used":"11","resetTime":"2026-10-29T11:25:00Z"}}],+ "usages":{"limit_5h":{"used_ratio":0.11,"reset_time":"2026-10-29T11:25:00Z"},"limit_month_code":{"used_ratio":0.3,"reset_time":"2026-11-17T00:00:00Z"}}}`+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ switch r.Header.Get("X-Host") + r.URL.Path + " " + r.Header.Get("Authorization") {+ case "api.kimi.com/coding/v1/usages Bearer sk-kimi-cn",+ "api.kimi.ai/coding/v1/usages Bearer sk-kimi-global",+ "api.kimi.com/coding/v1/usages Bearer sk-kimi-own",+ "api.kimi.com/coding/v1/usages Bearer sk-kimi-oc":+ w.Write([]byte(month))+ default:+ t.Errorf("asked %s%s with %q", r.Header.Get("X-Host"), r.URL.Path, r.Header.Get("Authorization"))+ w.WriteHeader(http.StatusUnauthorized)+ }+ }))+ defer srv.Close()+ old := http.DefaultClient.Transport+ http.DefaultClient.Transport = rewrite{srv}+ t.Cleanup(func() { http.DefaultClient.Transport = old })++ auth := filepath.Join(h, "auth.json")+ if err := os.WriteFile(auth, []byte(`{"kimi-code-plan-cn":{"type":"api","key":"sk-kimi-oc"}}`), 0o600); err != nil {+ t.Fatal(err)+ }+ items, err := readOpenCodeAuth(auth)+ if err != nil || len(items) != 1 || items[0].Skip != "" {+ t.Fatalf("OpenCode import: %+v %v", items, err)+ }+ oc := items[0].Provider+ oc.ID = "kimi-oc"+ for _, p := range []Provider{+ FromPresetKey(t, "kimi-code-cn", "sk-kimi-cn"),+ FromPresetKey(t, "kimi-code", "sk-kimi-global"),+ {ID: "kimi-own", Name: "My Kimi", Anthropic: "https://api.kimi.com/coding/", Key: "sk-kimi-own"},+ oc,+ } {+ if err := Save(p); err != nil {+ t.Fatal(err)+ }+ }+ got := map[string]SubscriptionQuota{}+ for _, q := range PlanQuotas(context.Background()) {+ got[q.Provider] = q+ }+ for _, id := range []string{"kimi-code-cn", "kimi-code", "kimi-own", "kimi-oc"} {+ q := got[id]+ if len(q.Windows) != 2 || q.Windows[0].Name != "5 hours" || q.Windows[1].Name != "Month" ||+ math.Abs(q.Windows[1].Used-30) > 1e-9 || q.Windows[1].ResetsAt == nil {+ t.Errorf("%s: %+v", id, q)+ }+ }+}+// An OpenCode Go key whose windows can't be read says why, with the way// out (sakulalalalalal on X: three Go keys, each "Allowance unavailable"// and nothing more). The bodies are OpenCode's own, as zen/go/v1/usage