Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
package provider
import (
"context"
"encoding/json"
"io"
"net/http"
"net/http/httptest"
"path/filepath"
"strconv"
"strings"
"sync"
"testing"
"time"
"github.com/yetone/magpie/internal/agentenv"
)
// The signature is the one Tencent Cloud's signing doc (api/213/30654)
// works through: DescribeInstances on cvm.tencentcloudapi.com at
// 1551113065, its payload byte for byte.
func TestTC3SignMatchesDoc(t *testing.T) {
// the doc sends the name as JSON escapes (a backslash and u672a…), not UTF-8
esc := strings.ReplaceAll("#u672a#u547d#u540d", "#", `\`)
payload := []byte(`{"Limit": 1, "Filters": [{"Values": ["` + esc + `"], "Name": "instance-name"}]}`)
if got := volcHex(payload); got != "35e9c5b0e3ae67532d3c9f17ead6c90222632e5b1ff7f6e89887f1398934f064" {
t.Fatalf("payload hash %s", got)
}
id, key := "AKID"+strings.Repeat("*", 32), strings.Repeat("*", 32)
got := tc3Sign(id, key, "cvm", "cvm.tencentcloudapi.com", "DescribeInstances", payload, time.Unix(1551113065, 0))
want := "TC3-HMAC-SHA256 Credential=" + id + "/2019-02-25/cvm/tc3_request, SignedHeaders=content-type;host;x-tc-action, Signature=10b1a37a7301a02ca19a647ad722d5e43b4b3cff309d421d85b46093f6ab6c4f"
if got != want {
t.Fatalf("\n got %s\nwant %s", got, want)
}
// a time in another zone signs with the UTC date
cst := time.Unix(1551113065, 0).In(time.FixedZone("CST", 8*3600))
if tc3Sign(id, key, "cvm", "cvm.tencentcloudapi.com", "DescribeInstances", payload, cst) != want {
t.Error("CST time signed differently")
}
}
// Only the enterprise plan's endpoints take an access key: /plan on
// TokenHub's hosts. Its pay as you go, the personal plan, another vendor
// and an account don't; Volcengine's stay Volcengine's.
func TestTencentPlanRegion(t *testing.T) {
for _, c := range []struct {
p Provider
region string
}{
{Provider{Chat: "https://tokenhub.tencentmaas.com/plan/v3"}, "ap-guangzhou"},
{Provider{Anthropic: "https://tokenhub.tencentmaas.com/plan/anthropic"}, "ap-guangzhou"},
{Provider{Responses: "https://TokenHub-Intl.tencentmaas.com/plan/v3/"}, "ap-singapore"},
{Provider{Chat: "https://tokenhub.tencentmaas.com/v1"}, ""},
{Provider{Chat: "https://api.lkeap.cloud.tencent.com/plan/v3"}, ""},
{Provider{Chat: "https://relay.example.com/plan/v3"}, ""},
{Provider{Chat: "https://tokenhub.tencentmaas.com/planx/v3"}, ""},
{Provider{Chat: "https://tokenhub.tencentmaas.com/plan/v3", Account: &Account{}}, ""},
} {
region, ok := tencentPlanRegion(c.p)
if region != c.region || ok != (c.region != "") || TakesTencentAccessKey(c.p) != ok {
t.Errorf("%+v: %q %v", c.p, region, ok)
}
}
for _, c := range []struct {
p Provider
vendor string
}{
{Provider{Chat: "https://tokenhub.tencentmaas.com/plan/v3"}, "tencent"},
{Provider{Chat: "https://ark.cn-beijing.volces.com/api/coding/v3"}, "volcengine"},
{Provider{Chat: "https://api.lkeap.cloud.tencent.com/plan/v3"}, ""},
} {
if got := AccessKeyVendor(c.p); got != c.vendor {
t.Errorf("AccessKeyVendor(%s) = %q", c.p.Chat, got)
}
}
}
// The docs' PackageInfo (quotas as strings) and TokenSummary: used of the
// cycle's quota, credits for 专业套餐 and tokens for 轻享套餐, resetting at
// the cycle's end; with no TokenSummary the cycle is counted from the
// package's start, never past its expiry; no quota is no window.
func TestTencentPlanWindow(t *testing.T) {
var p tencentPlan
if err := json.Unmarshal([]byte(`{"TeamId":"team-a1b2c3d4","ProductType":"enterprise",
"PackageInfo":{"TotalQuota":"1000000","TotalUsed":"100000","TotalCycles":1,"CycleUnit":"month","StartTime":"2026-04-01T00:00:00Z","ExpireTime":"2027-04-01T00:00:00Z",
"ExclusiveAllocated":"500000","ExclusiveUsed":"100000","SharedPool":"500000","SharedUsed":"50000","CycleQuota":"1000000","CurrentCycle":1,"RemainCycles":0},
"TokenSummary":{"CycleSeq":1,"CycleStartTime":"2026-04-01T00:00:00+08:00","CycleEndTime":"2026-05-01T00:00:00+08:00",
"BillingItems":[{"BillingItem":"input","TotalQty":"60000"},{"BillingItem":"output","TotalQty":"40000"}]}}`), &p); err != nil {
t.Fatal(err)
}
now := time.Date(2026, 4, 10, 0, 0, 0, 0, time.UTC)
w, ok := p.window(now)
if !ok || w.Name != "Month" || w.Used != 10 || w.Amount != 100000 || w.Limit != 1000000 || w.Unit != "credits" ||
w.ResetsAt == nil || !w.ResetsAt.Equal(time.Date(2026, 4, 30, 16, 0, 0, 0, time.UTC)) || w.Span != 30*24*time.Hour {
t.Fatalf("%+v %v", w, ok)
}
p.ProductType = "enterprise-auto"
if w, _ := p.window(now); w.Unit != "tokens" {
t.Errorf("轻享套餐 unit %q", w.Unit)
}
// no TokenSummary: month 1 from StartTime, and on past it as time goes
p.TokenSummary = nil
if w, _ := p.window(now); w.ResetsAt == nil || !w.ResetsAt.Equal(time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC)) {
t.Errorf("from StartTime: %+v", w.ResetsAt)
}
if w, _ := p.window(time.Date(2026, 7, 15, 0, 0, 0, 0, time.UTC)); w.ResetsAt == nil || !w.ResetsAt.Equal(time.Date(2026, 8, 1, 0, 0, 0, 0, time.UTC)) {
t.Errorf("July: %+v", w.ResetsAt)
}
p.PackageInfo.ExpireTime = "2026-07-20T00:00:00Z"
if w, _ := p.window(time.Date(2026, 7, 15, 0, 0, 0, 0, time.UTC)); w.ResetsAt == nil || !w.ResetsAt.Equal(time.Date(2026, 7, 20, 0, 0, 0, 0, time.UTC)) {
t.Errorf("capped at expiry: %+v", w.ResetsAt)
}
// no cycle quota: the total's; used past it shows full
p.PackageInfo.CycleQuota, p.PackageInfo.TotalUsed = nil, 2000000.0
if w, ok := p.window(now); !ok || w.Limit != 1000000 || w.Used != 100 {
t.Errorf("TotalQuota: %+v", w)
}
for _, pk := range []string{`{}`, `{"TotalQuota":"0","TotalUsed":"1"}`, `{"TotalQuota":"10"}`} {
var q tencentPlan
json.Unmarshal([]byte(`{"PackageInfo":`+pk+`}`), &q)
if _, ok := q.window(now); ok {
t.Errorf("%s gave a window", pk)
}
}
if _, ok := (tencentPlan{}).window(now); ok {
t.Error("no PackageInfo gave a window")
}
}
// The Usage page has a card for each team plan the SecretId can see, read
// from tokenhub.tencentcloudapi.com only, each request signed as TC3 with
// the SecretKey and never with the plan's own key; a refused key says
// what to check, an account with no plan says so, and the personal plan,
// a provider with no SecretKey and one switched off have none.
func TestTencentPlanQuotas(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("PATH", h)
for _, v := range agentenv.Vars {
t.Setenv(v, "")
}
secrets := map[string]string{"AKIDone": "SK1", "AKIDtwo": "SK2", "AKIDnone": "SK4", "AKIDbad": "wrong"}
var mu sync.Mutex
asked := map[string]int{}
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
body, _ := io.ReadAll(r.Body)
action := r.Header.Get("X-TC-Action")
if r.Header.Get("X-Host") != tcAPIHost || r.Method != http.MethodPost || r.URL.Path != "/" ||
r.Header.Get("X-TC-Version") != "2026-03-22" || r.Header.Get("Content-Type") != tcContentType {
t.Errorf("asked %s %s%s %s %v", r.Method, r.Header.Get("X-Host"), r.URL, action, r.Header)
w.WriteHeader(http.StatusNotFound)
return
}
auth := r.Header.Get("Authorization")
if strings.Contains(auth, "sk-tp") || strings.Contains(string(body), "sk-tp") {
t.Errorf("the plan's key was sent: %s %s", auth, body)
}
cred, _, _ := strings.Cut(strings.TrimPrefix(auth, "TC3-HMAC-SHA256 Credential="), "/")
ts, _ := strconv.ParseInt(r.Header.Get("X-TC-Timestamp"), 10, 64)
region := r.Header.Get("X-TC-Region")
if want := tc3Sign(cred, secrets[cred], "tokenhub", tcAPIHost, action, body, time.Unix(ts, 0)); cred == "AKIDbad" || auth != want {
io.WriteString(w, `{"Response":{"Error":{"Code":"AuthFailure.SignatureFailure","Message":"The provided credentials could not be validated."},"RequestId":"e1"}}`)
return
}
mu.Lock()
asked[cred+" "+region+" "+action]++
mu.Unlock()
var params map[string]any
json.Unmarshal(body, ¶ms)
switch {
case action == "DescribeTokenPlanList" && cred == "AKIDnone":
io.WriteString(w, `{"Response":{"RequestId":"r0","TokenPlanSet":[],"TotalCount":0}}`)
case action == "DescribeTokenPlanList" && cred == "AKIDone":
// the docs' example
io.WriteString(w, `{"Response":{"RequestId":"be515245-e05f-4334-9f9d-6d55db1aa8b5","TokenPlanSet":[{"ApiKeyMax":10000,"AppId":"176623905","CreatedAt":"2026-04-05T21:06:09+08:00","Creator":"176623905","Name":"my-team-test-1","PrepayResourceID":"pre-123456","Status":"enable","StopReason":"","TeamId":"team-a1b2c3d4","Uin":"214508345","UpdatedAt":"2026-04-07T23:26:01+08:00","ProductType":"enterprise"}],"TotalCount":1}}`)
case action == "DescribeTokenPlanList" && cred == "AKIDtwo":
io.WriteString(w, `{"Response":{"RequestId":"r2","TokenPlanSet":[
{"Name":"alpha","Status":"enable","TeamId":"team-a","ProductType":"enterprise-auto","PackageInfo":{"TotalQuota":"5000000","TotalUsed":"1250000","CycleQuota":"5000000","StartTime":"2026-04-01T00:00:00Z","ExpireTime":"2027-04-01T00:00:00Z","CurrentCycle":1}},
{"Name":"beta","Status":"isolate","StopReason":"arrears","TeamId":"team-b","ProductType":"enterprise"}],"TotalCount":2}}`)
case action == "DescribeTokenPlan" && params["TeamId"] == "team-a1b2c3d4":
io.WriteString(w, `{"Response":{"ApiKeyCount":10,"ApiKeyMax":10000,"Name":"my-team-test-1","Status":"enable","TeamId":"team-a1b2c3d4","RequestId":"45b1f117",
"PackageInfo":{"TotalQuota":"1000000","TotalUsed":"100000","CycleUnit":"month","StartTime":"2026-04-01T00:00:00Z","ExpireTime":"2027-04-01T00:00:00Z","CycleQuota":"1000000","CurrentCycle":1},
"TokenSummary":{"CycleSeq":1,"CycleStartTime":"2026-04-01T00:00:00+08:00","CycleEndTime":"2026-05-01T00:00:00+08:00","BillingItems":[]}}}`)
case action == "DescribeTokenPlan" && params["TeamId"] == "team-a":
// the docs' own example: no PackageInfo, the list's is kept
io.WriteString(w, `{"Response":{"ApiKeyCount":1,"Name":"alpha","Status":"enable","TeamId":"team-a","RequestId":"45b1f117"}}`)
case action == "DescribeTokenPlan" && params["TeamId"] == "team-b":
io.WriteString(w, `{"Response":{"Name":"beta","Status":"isolate","StopReason":"arrears","TeamId":"team-b","RequestId":"r3"}}`)
default:
t.Errorf("action %q %s by %s", action, body, cred)
}
}))
defer srv.Close()
old := http.DefaultClient.Transport
http.DefaultClient.Transport = rewrite{srv}
t.Cleanup(func() { http.DefaultClient.Transport = old })
forgetPlanQuotas()
t.Cleanup(forgetPlanQuotas)
ent, intl := "https://tokenhub.tencentmaas.com/plan/v3", "https://tokenhub-intl.tencentmaas.com/plan/v3"
for _, p := range []Provider{
{ID: "tencent-cloud", Name: "Tencent Cloud", Chat: ent, Anthropic: "https://tokenhub.tencentmaas.com/plan/anthropic", Key: "sk-tp-1", AccessKeyID: "AKIDone", SecretAccessKey: "SK1"},
// the same key and region again: asked once
{ID: "tc-copy", Name: "Tencent copy", Chat: ent, Key: "sk-tp-1", AccessKeyID: "AKIDone", SecretAccessKey: "SK1"},
{ID: "tc-intl", Name: "Tencent intl", Chat: intl, Key: "sk-tp-2", AccessKeyID: "AKIDtwo", SecretAccessKey: "SK2"},
{ID: "tc-none", Name: "Tencent none", Chat: ent, Key: "sk-tp-3", AccessKeyID: "AKIDnone", SecretAccessKey: "SK4"},
{ID: "tc-bad", Name: "Tencent bad", Chat: ent, Key: "sk-tp-4", AccessKeyID: "AKIDbad", SecretAccessKey: "wrong"},
{ID: "tc-personal", Name: "Tencent personal", Chat: "https://api.lkeap.cloud.tencent.com/plan/v3", Key: "sk-tp-5", AccessKeyID: "AKIDone", SecretAccessKey: "SK1"},
{ID: "tc-nosecret", Name: "Tencent half", Chat: ent, Key: "sk-tp-6", AccessKeyID: "AKIDhalf"},
{ID: "tc-off", Name: "Tencent off", Chat: ent, Key: "sk-tp-7", AccessKeyID: "AKIDoff", SecretAccessKey: "SKoff", Off: true},
} {
if err := Save(p); err != nil {
t.Fatal(err)
}
}
var cards []SubscriptionQuota
for _, q := range PlanQuotas(context.Background()) {
if q.Plan != "" && (strings.HasPrefix(q.Provider, "tc-") || q.Provider == "tencent-cloud") {
cards = append(cards, q)
}
}
by := map[string]SubscriptionQuota{}
for _, q := range cards {
by[q.Provider+"|"+q.User] = q
}
if len(cards) != 5 || len(by) != 5 {
t.Fatalf("cards: %+v", cards)
}
one, ok := by["tencent-cloud|"]
if !ok {
one = by["tc-copy|"]
}
if one.Plan != "Token Plan Enterprise" || one.Error != "" || len(one.Windows) != 1 || one.Windows[0].Used != 10 || one.Windows[0].Unit != "credits" ||
one.Windows[0].ResetsAt == nil || !one.Windows[0].ResetsAt.Equal(time.Date(2026, 4, 30, 16, 0, 0, 0, time.UTC)) {
t.Errorf("one plan: %+v", one)
}
alpha := by["tc-intl|alpha"]
if alpha.Error != "" || len(alpha.Windows) != 1 || alpha.Windows[0].Used != 25 || alpha.Windows[0].Unit != "tokens" || alpha.Windows[0].ResetsAt == nil {
t.Errorf("alpha: %+v", alpha)
}
beta := by["tc-intl|beta"]
if beta.Plan != "Token Plan Enterprise · isolate, arrears" || !strings.Contains(beta.Error, "told no quota") {
t.Errorf("beta: %+v", beta)
}
if q := by["tc-none|"]; !strings.Contains(q.Error, "no Token Plan Enterprise in ap-guangzhou") {
t.Errorf("no plan: %+v", q)
}
if q := by["tc-bad|"]; !strings.Contains(q.Error, "AuthFailure.SignatureFailure") || !strings.Contains(q.Error, "SecretId and SecretKey") {
t.Errorf("refused: %+v", q)
}
mu.Lock()
defer mu.Unlock()
for k, want := range map[string]int{
"AKIDone ap-guangzhou DescribeTokenPlanList": 1, "AKIDone ap-guangzhou DescribeTokenPlan": 1,
"AKIDtwo ap-singapore DescribeTokenPlanList": 1, "AKIDtwo ap-singapore DescribeTokenPlan": 2,
"AKIDnone ap-guangzhou DescribeTokenPlanList": 1,
} {
if asked[k] != want {
t.Errorf("%s asked %d times, want %d (%v)", k, asked[k], want, asked)
}
}
if len(asked) != 5 {
t.Errorf("asked %v", asked)
}
}