yetone
ee657c0969
Why it was 0: magpie already counts a subscription's calls at the API list
price (a Claude or Codex account at its maker's, cf6b82f7). A Kimi Code
provider is looked up in its own models.dev catalog first, and models.dev
lists every model of kimi-code-plan-global / kimi-code-plan-cn at $0 (what
the membership charges per token), so k3, k3-256k, kimi-for-coding and
kimi-for-coding-highspeed were all "priced" at $0. The same $0 catalogs
were also among the maker catalogs, so MakerPrice("k3") was $0 too.
What changed (internal/provider/models.go):
- membershipCatalogs (the two Kimi Code plan catalogs) are never read for a
price: ListPrice, MakerPrice and PricedName skip them.
- A provider served at a Kimi Code catalog prices its model as the Kimi API
model it is (kimiCodeAPI), per Kimi Code's docs
(https://www.kimi.com/code/docs/en/, read 2026-10-09): k3 and k3-256k are
K3 -> kimi-k3; kimi-for-coding-highspeed is K2.7 Code HighSpeed ->
kimi-k2.7-code-highspeed. models.dev's canonical_model_id agrees. The
prices come from moonshotai's catalog, which matches Kimi's pricing page
(https://platform.kimi.ai/docs/pricing/chat: kimi-k3 $3 in, $15 out,
$0.30 cached, $3 cache write; kimi-k2.7-code-highspeed $1.90/$8/$0.38).
- kimi-for-coding is K2.8 Preview, which the Kimi API doesn't sell: it has
no API price, so it is now unpriced (the "—" / "no known price" the GUI
already shows) instead of ¥0.000. The user can give it a price with
`magpie model price kimi-code/kimi-for-coding …` or in Names & levels.
- The alias is scoped to Kimi Code providers: a relay's own "k3" keeps its
own catalog price; Moonshot pay-as-you-go's kimi-k3, an OpenCode free
model ($0) and Codex's maker price are unchanged.
- PricedNameFor(provider, model): the Requests list's "API price
reference" names kimi-k3 for a Kimi Code k3 (internal/gui/usage.go).
Docs: reference.md (What a model costs) and providers-accounts.md.
Tests: TestKimiCodeListPrice (internal/provider; fixture
testdata/kimi_code_catalog.json is models.dev's own moonshotai and Kimi Code
plan entries) and TestKimiCodeCost (internal/usage; the reporter's k3 row,
240K in / 78.4K out / 10.0M cached, counted at $4.896 in the ledger and the
summary, kimi-for-coding unpriced, moonshot/kimi-k3 unchanged). Both fail on
the old models.go (every Kimi Code model priced at $0, MakerPrice(k3) $0,
k3 cost=0, unpriced 0); PricedNameFor's check fails with the alias turned
off ("k3-256k").
Run: gofmt -l (empty); go vet -tags nogui, GOOS=linux go vet -tags nogui,
GOOS=windows go vet -tags nogui on internal/provider, internal/usage,
internal/gui; go build, GOOS=linux go build -tags nogui, GOOS=windows go
build; go test -tags nogui -count=1 ./... under a temp HOME with pinned
caches: all ok; -race -count=3 on the new tests ok. No GUI asset changed,
so the Playwright suite wasn't run. Not tried with a real Kimi Code
account or the reporter's usage log.
77 lines
2.4 KiB
Go
77 lines
2.4 KiB
Go
package usage
|
|
|
|
import (
|
|
"math"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/yetone/magpie/internal/catalog"
|
|
"github.com/yetone/magpie/internal/provider"
|
|
)
|
|
|
|
// #1370 (maicent): the Usage page counted a Kimi Code membership's k3 at
|
|
// ≈¥0.000, its plan's models.dev catalog listing every model at $0. A k3
|
|
// call is now counted at Kimi's API price for kimi-k3, kimi-for-coding
|
|
// (K2.8 Preview, which the API doesn't sell) is unpriced rather than free,
|
|
// and a Moonshot pay-as-you-go call is what it was.
|
|
func TestKimiCodeCost(t *testing.T) {
|
|
home := t.TempDir()
|
|
t.Setenv("HOME", home)
|
|
t.Setenv("USERPROFILE", home)
|
|
t.Setenv("XDG_CONFIG_HOME", filepath.Join(home, ".config"))
|
|
t.Setenv("XDG_CACHE_HOME", filepath.Join(home, ".cache"))
|
|
b, err := os.ReadFile(filepath.Join("..", "provider", "testdata", "kimi_code_catalog.json"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
os.MkdirAll(filepath.Dir(catalog.CachePath()), 0o755)
|
|
if err := os.WriteFile(catalog.CachePath(), b, 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
catalog.Reset()
|
|
t.Cleanup(catalog.Reset)
|
|
for _, id := range []string{"kimi-code-cn", "moonshot"} {
|
|
p, err := provider.FromPreset(id)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
p.Key = "sk-test"
|
|
if err := provider.Save(p); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
// the reporter's k3 row: 240K in, 78.4K out, 10.0M cached
|
|
in, out, cached := 240_000, 78_400, 10_000_000
|
|
k3 := (float64(in)*3 + float64(out)*15 + float64(cached)*0.3) / 1e6
|
|
now := time.Now()
|
|
calls := []struct {
|
|
prov, model string
|
|
priced bool
|
|
want float64
|
|
}{
|
|
{"kimi-code-cn", "k3", true, k3},
|
|
{"kimi-code-cn", "kimi-for-coding", false, 0},
|
|
{"moonshot", "kimi-k3", true, k3},
|
|
}
|
|
for i, c := range calls {
|
|
Append(Record{Time: now.Add(-time.Duration(len(calls)-i) * time.Minute), Agent: "claude-code", Provider: c.prov, Model: c.model,
|
|
Input: in, Output: out, CacheRead: cached, Status: 200})
|
|
}
|
|
rows, sum, _ := Ledger(Month, Filter{})
|
|
if len(rows) != len(calls) {
|
|
t.Fatalf("rows %d", len(rows))
|
|
}
|
|
for i, c := range calls {
|
|
r := rows[len(calls)-1-i]
|
|
if r.Model != c.model || r.Priced != c.priced || math.Abs(r.Cost-c.want) > 1e-9 {
|
|
t.Errorf("%s/%s: priced=%v cost=%v, want %v %v", c.prov, c.model, r.Priced, r.Cost, c.priced, c.want)
|
|
}
|
|
}
|
|
s := Summarize(Month)
|
|
if s.Unpriced != 1 || math.Abs(s.Cost-2*k3) > 1e-9 || math.Abs(sum.Cost-2*k3) > 1e-9 {
|
|
t.Fatalf("summary cost %v unpriced %d, ledger %v; want %v and 1", s.Cost, s.Unpriced, sum.Cost, 2*k3)
|
|
}
|
|
}
|