magic-agent 2.4.2 → 2.6.0

package/internal/agent/credits.go

@@ -0,0 +1,713 @@
+package agent
+
+// credits.go - codebuddy 系账号的「剩余积分」查询（`--engines` 的 credit_left 字段）。
+//
+// 剩余积分只存在于账单接口（CLI 本地缓存里只有各模型倍率，没有余额）：
+//
+//	POST https://<auth.domain>/billing/meter/get-user-resource-summary
+//	Authorization: Bearer <auth.accessToken>
+//	X-User-Id: <account.uid>   X-Domain: <auth.domain>   Accept-Language: zh
+//
+// 返回 data.TotalCredits（credits，小数）或 data.Packages[].CycleRemainCapacity。
+// 企业账号走 /billing/meter/get-enterprise-user-usage（X-Enterprise-Id），
+// 返回 limit_num / used_num（limit_num=-1 表示不限量，此时不给数字）。
+//
+// 票据就在本机 auth/<id>.info；桌面 App 那几份（workbuddy-desktop*.info）的
+// token 是 $wbEncrypted（受管密钥），独立进程读不了 —— 解析时自然跳过。
+//
+// 约束：只读票据 + 只发这一条只读请求；任何失败都返回 ""，--engines 因此不带该字段，
+// 绝不影响引擎列表本身。
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// CreditLister 能报告账号当前剩余积分（仅 codebuddy / codebuddy-ai 实现）。
+//
+// 返回十进制字符串（如 "5939.2"，已去掉多余的 0）；未登录 / 无票据 / 查询失败
+// 返回空串 —— 调用方据此省略字段，而不是显示 0。
+type CreditLister interface {
+	CreditLeft(ctx context.Context) string
+}
+
+// LoginChecker 多账号引擎的**槽位**是否已登录（`--engines` 的 logged_in 字段）。
+//
+// codebuddy / codebuddy-ai 是两个独立账号槽位（各自票据目录），没登录的那个
+// 不该出现在引擎选择器里 —— 「登录了几个账号就显示几个」，而不是固定两行。
+// 判定只看票据文件是否存在且可读（App 的 $wbEncrypted 票据不算），不发网络请求。
+type LoginChecker interface {
+	LoggedIn() bool
+}
+
+// LoggedIn 实现 LoginChecker：codebuddy 主账号。
+func (e *CodeBuddyEngine) LoggedIn() bool {
+	_, ok := readCodebuddyTicket(codebuddyAuthDir(userHomeDir()), codebuddyAuthID)
+	return ok
+}
+
+// LoggedIn 实现 LoginChecker：codebuddy-ai 的隔离账号。
+func (e *CodeBuddyAIEngine) LoggedIn() bool {
+	_, ok := readCodebuddyTicket(codebuddyAuthDir(codebuddyAIDir()), codebuddyAIAuthID)
+	return ok
+}
+
+// AccountLister 多账号引擎的**账号昵称**（`--engines` / `--quotas` 的 account 字段）。
+//
+// 两个 codebuddy 槽位在选择器里只差一个引擎名，用户看不出「这行是哪个号」——
+// 昵称来自票据里的 account.nickname（登录时写进去的），只读文件、不发网络。
+// 未登录 / 票据里没有昵称时返回空串（调用方省略该字段）。
+type AccountLister interface {
+	AccountName() string
+}
+
+// AccountName 实现 AccountLister：codebuddy 主账号。
+func (e *CodeBuddyEngine) AccountName() string {
+	t, ok := readCodebuddyTicket(codebuddyAuthDir(userHomeDir()), codebuddyAuthID)
+	if !ok {
+		return ""
+	}
+	return t.Nickname
+}
+
+// AccountName 实现 AccountLister：codebuddy-ai 的隔离账号。
+func (e *CodeBuddyAIEngine) AccountName() string {
+	t, ok := readCodebuddyTicket(codebuddyAuthDir(codebuddyAIDir()), codebuddyAIAuthID)
+	if !ok {
+		return ""
+	}
+	return t.Nickname
+}
+
+// CreditLeft 实现 CreditLister：codebuddy 主账号（真实 homedir + ~/.codebuddy）。
+func (e *CodeBuddyEngine) CreditLeft(ctx context.Context) string {
+	return codebuddyCreditLeft(ctx, userHomeDir(), codebuddyAuthID)
+}
+
+// CreditLeft 实现 CreditLister：codebuddy-ai 的隔离账号（homedir = ~/.codebuddy-ai）。
+func (e *CodeBuddyAIEngine) CreditLeft(ctx context.Context) string {
+	return codebuddyCreditLeft(ctx, codebuddyAIDir(), codebuddyAIAuthID)
+}
+
+// userHomeDir 当前用户家目录（与 CLI 的 os.homedir() 同源：Windows 读 USERPROFILE）。
+func userHomeDir() string {
+	home, err := os.UserHomeDir()
+	if err != nil || home == "" {
+		home = os.Getenv("HOME")
+	}
+	return home
+}
+
+// codebuddyAuthDir 票据目录。与 CLI 的 FilePathService 同构：
+//
+//	<home>/AppData/Local/CodeBuddyExtension/Data/Public/auth        (win32)
+//	<home>/Library/Application Support/CodeBuddyExtension/.../auth  (darwin)
+//	<home>/.local/share/CodeBuddyExtension/Data/Public/auth         (linux)
+//
+// codebuddy-ai 传自己的隔离 home（~/.codebuddy-ai），因此票据天然与主引擎分开。
+func codebuddyAuthDir(home string) string {
+	switch runtime.GOOS {
+	case "windows":
+		return filepath.Join(home, "AppData", "Local", "CodeBuddyExtension", "Data", "Public", "auth")
+	case "darwin":
+		return filepath.Join(home, "Library", "Application Support", "CodeBuddyExtension", "Data", "Public", "auth")
+	default:
+		return filepath.Join(home, ".local", "share", "CodeBuddyExtension", "Data", "Public", "auth")
+	}
+}
+
+// codebuddyTicket 一张可用的 CLI 票据（只取查余额 / 展示账号需要的字段）。
+type codebuddyTicket struct {
+	UID          string
+	Nickname     string
+	EnterpriseID string
+	Token        string
+	Domain       string
+}
+
+// baseProductAuthID CLI 包内 product.json 的 authentication.id —— 新版 CLI 有时会把
+// 票据写到这个名字上（见 codebuddy.go 的账号隔离说明），故作为第二候选。
+const baseProductAuthID = "Tencent-Cloud.coding-copilot"
+
+// readCodebuddyTicket 在 auth 目录里挑一张可读的票据。
+// 顺序：本引擎 id → base product id → 其余 *.info 按 mtime 新到旧（跳过 $wbEncrypted）。
+func readCodebuddyTicket(authDir, authID string) (codebuddyTicket, bool) {
+	preferred := []string{
+		filepath.Join(authDir, authID+".info"),
+		filepath.Join(authDir, baseProductAuthID+".info"),
+	}
+	seen := map[string]bool{}
+	for _, p := range preferred {
+		seen[p] = true
+	}
+	type cand struct {
+		path string
+		mod  time.Time
+	}
+	var rest []cand
+	entries, err := os.ReadDir(authDir)
+	if err != nil {
+		return codebuddyTicket{}, false
+	}
+	for _, e := range entries {
+		if e.IsDir() || !strings.HasSuffix(e.Name(), ".info") {
+			continue
+		}
+		p := filepath.Join(authDir, e.Name())
+		if seen[p] {
+			continue
+		}
+		if st, statErr := e.Info(); statErr == nil {
+			rest = append(rest, cand{p, st.ModTime()})
+		}
+	}
+	sort.Slice(rest, func(i, j int) bool { return rest[i].mod.After(rest[j].mod) })
+
+	for _, p := range preferred {
+		if t, ok := parseCodebuddyTicket(p); ok {
+			return t, true
+		}
+	}
+	for _, c := range rest {
+		if t, ok := parseCodebuddyTicket(c.path); ok {
+			return t, true
+		}
+	}
+	return codebuddyTicket{}, false
+}
+
+// parseCodebuddyTicket 解析一张票据；App 的加密 token（对象形态）直接判不可用。
+func parseCodebuddyTicket(path string) (codebuddyTicket, bool) {
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		return codebuddyTicket{}, false
+	}
+	var doc struct {
+		Account struct {
+			UID          string `json:"uid"`
+			Nickname     string `json:"nickname"`
+			EnterpriseID string `json:"enterpriseId"`
+		} `json:"account"`
+		Auth struct {
+			AccessToken json.RawMessage `json:"accessToken"`
+			Domain      string          `json:"domain"`
+		} `json:"auth"`
+	}
+	if json.Unmarshal(raw, &doc) != nil {
+		return codebuddyTicket{}, false
+	}
+	var tok string
+	// $wbEncrypted 是对象；独立 CLI 解不开，跳过。
+	if len(doc.Auth.AccessToken) == 0 || json.Unmarshal(doc.Auth.AccessToken, &tok) != nil || tok == "" {
+		return codebuddyTicket{}, false
+	}
+	if doc.Auth.Domain == "" {
+		return codebuddyTicket{}, false
+	}
+	return codebuddyTicket{
+		UID:          doc.Account.UID,
+		Nickname:     strings.TrimSpace(doc.Account.Nickname),
+		EnterpriseID: doc.Account.EnterpriseID,
+		Token:        tok,
+		Domain:       doc.Auth.Domain,
+	}, true
+}
+
+// codebuddyCreditLeft 查一张票据对应的剩余积分；失败返回 ""。
+func codebuddyCreditLeft(ctx context.Context, home, authID string) string {
+	t, ok := readCodebuddyTicket(codebuddyAuthDir(home), authID)
+	if !ok {
+		return ""
+	}
+	ctx, cancel := context.WithTimeout(ctx, 8*time.Second)
+	defer cancel()
+	if t.EnterpriseID != "" {
+		return fetchEnterpriseCreditLeft(ctx, t)
+	}
+	return fetchPersonalCreditLeft(ctx, t)
+}
+
+// codebuddyBillingPost 发一次只读账单请求，返回响应体；非 200 / 网络错误返回 false。
+func codebuddyBillingPost(ctx context.Context, t codebuddyTicket, path string, extraHeaders map[string]string) ([]byte, bool) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost,
+		"https://"+t.Domain+path, strings.NewReader("{}"))
+	if err != nil {
+		return nil, false
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept-Language", "zh")
+	req.Header.Set("Authorization", "Bearer "+t.Token)
+	req.Header.Set("X-Domain", t.Domain)
+	if t.UID != "" {
+		req.Header.Set("X-User-Id", t.UID)
+	}
+	for k, v := range extraHeaders {
+		req.Header.Set(k, v)
+	}
+	client := &http.Client{Timeout: 8 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, false
+	}
+	defer resp.Body.Close()
+	/* 不按 HTTP 状态码直接判失败：领取接口在「今天已领」这类业务失败时会返回
+	   非 200 + JSON（code/msg）—— 那份正文才是给用户看的原因。解析交给调用方。 */
+	body, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
+	if err != nil || len(body) == 0 {
+		return nil, false
+	}
+	return body, true
+}
+
+// fetchPersonalCreditLeft 个人账号：优先 data.TotalCredits，缺失时累加各包剩余。
+func fetchPersonalCreditLeft(ctx context.Context, t codebuddyTicket) string {
+	body, ok := codebuddyBillingPost(ctx, t, "/billing/meter/get-user-resource-summary", nil)
+	if !ok {
+		return ""
+	}
+	return personalCreditLeftFromJSON(body)
+}
+
+// personalCreditLeftFromJSON 解析 get-user-resource-summary 的响应（抽出来便于单测）。
+func personalCreditLeftFromJSON(body []byte) string {
+	var doc struct {
+		Code int `json:"code"`
+		Data struct {
+			TotalCredits json.RawMessage `json:"TotalCredits"`
+			Packages     []struct {
+				CycleRemainCapacity json.RawMessage `json:"CycleRemainCapacity"`
+			} `json:"Packages"`
+		} `json:"data"`
+	}
+	if json.Unmarshal(body, &doc) != nil || doc.Code != 0 {
+		return ""
+	}
+	if v, ok := creditFloat(doc.Data.TotalCredits); ok {
+		return formatCredit(v)
+	}
+	var sum float64
+	found := false
+	for _, p := range doc.Data.Packages {
+		if v, ok := creditFloat(p.CycleRemainCapacity); ok {
+			sum += v
+			found = true
+		}
+	}
+	if !found {
+		return ""
+	}
+	return formatCredit(sum)
+}
+
+// fetchEnterpriseCreditLeft 企业账号：limit_num - used_num（-1 = 不限量，不给数字）。
+func fetchEnterpriseCreditLeft(ctx context.Context, t codebuddyTicket) string {
+	body, ok := codebuddyBillingPost(ctx, t, "/billing/meter/get-enterprise-user-usage",
+		map[string]string{"X-Enterprise-Id": t.EnterpriseID})
+	if !ok {
+		return ""
+	}
+	return enterpriseCreditLeftFromJSON(body)
+}
+
+// enterpriseCreditLeftFromJSON 解析 get-enterprise-user-usage 的响应。
+func enterpriseCreditLeftFromJSON(body []byte) string {
+	var doc struct {
+		Code int `json:"code"`
+		Data struct {
+			LimitNum json.RawMessage `json:"limit_num"`
+			UsedNum  json.RawMessage `json:"used_num"`
+		} `json:"data"`
+	}
+	if json.Unmarshal(body, &doc) != nil || doc.Code != 0 {
+		return ""
+	}
+	limit, ok := creditFloat(doc.Data.LimitNum)
+	if !ok || limit < 0 {
+		return ""
+	}
+	used, _ := creditFloat(doc.Data.UsedNum)
+	if left := limit - used; left > 0 {
+		return formatCredit(left)
+	}
+	return "0"
+}
+
+// creditFloat 解析「数字或字符串形式的数字」（接口里两种形态都出现过）。
+func creditFloat(raw json.RawMessage) (float64, bool) {
+	if len(raw) == 0 {
+		return 0, false
+	}
+	s := string(raw)
+	var quoted string
+	if json.Unmarshal(raw, &quoted) == nil {
+		s = quoted
+	}
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return 0, false
+	}
+	f, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return 0, false
+	}
+	return f, true
+}
+
+// formatCredit 归一化成最多两位小数、去掉多余的 0（5939.20000022 → "5939.2"）。
+func formatCredit(f float64) string {
+	s := strconv.FormatFloat(f, 'f', 2, 64)
+	s = strings.TrimRight(s, "0")
+	s = strings.TrimRight(s, ".")
+	if s == "" || s == "-0" {
+		return "0"
+	}
+	return s
+}
+
+// ── 每日积分签到 ──────────────────────────────────────────────
+//
+//	状态：POST https://<domain>/billing/meter/checkin-activity-status
+//	领取：POST https://<domain>/billing/meter/daily-checkin
+//
+// ⚠️ 别用旧的 /billing/meter/checkin-status：实测返回 active=false 全 0，
+// 活动接口是 checkin-activity-status（字段 today_checked_in / daily_credit / streak_days）。
+
+// CheckinInfo 每日签到状态 / 领取结果。
+type CheckinInfo struct {
+	// CheckedToday 今天是否已领。
+	CheckedToday bool
+	// DailyCredit 今日可领积分（十进制字符串，可能为空）。
+	DailyCredit string
+	// Credit 本次实际到账积分（仅领取成功时有）。
+	Credit string
+	// StreakDays 连续签到天数。
+	StreakDays int
+	// Message 业务失败原因（如「今天已经领过了」）。
+	Message string
+}
+
+// Checkiner 每日积分签到（仅 codebuddy / codebuddy-ai 实现）。
+type Checkiner interface {
+	// CheckinStatus 返回签到状态；第二个返回值 false = 拿不到（未登录 / 活动未开 / 网络失败）。
+	CheckinStatus(ctx context.Context) (CheckinInfo, bool)
+	// ClaimCheckin 领取每日积分；业务失败返回 error（Message 里是服务端原因）。
+	ClaimCheckin(ctx context.Context) (CheckinInfo, error)
+}
+
+// CheckinStatus 实现 Checkiner：codebuddy 主账号。
+func (e *CodeBuddyEngine) CheckinStatus(ctx context.Context) (CheckinInfo, bool) {
+	return codebuddyCheckinStatus(ctx, userHomeDir(), codebuddyAuthID)
+}
+
+// CheckinStatus 实现 Checkiner：codebuddy-ai 的隔离账号。
+func (e *CodeBuddyAIEngine) CheckinStatus(ctx context.Context) (CheckinInfo, bool) {
+	return codebuddyCheckinStatus(ctx, codebuddyAIDir(), codebuddyAIAuthID)
+}
+
+// ClaimCheckin 实现 Checkiner：codebuddy 主账号。
+func (e *CodeBuddyEngine) ClaimCheckin(ctx context.Context) (CheckinInfo, error) {
+	return codebuddyClaimCheckin(ctx, userHomeDir(), codebuddyAuthID)
+}
+
+// ClaimCheckin 实现 Checkiner：codebuddy-ai 的隔离账号。
+func (e *CodeBuddyAIEngine) ClaimCheckin(ctx context.Context) (CheckinInfo, error) {
+	return codebuddyClaimCheckin(ctx, codebuddyAIDir(), codebuddyAIAuthID)
+}
+
+// codebuddyCheckinStatus 查签到状态；拿不到返回 false（--engines 因此省略 checkin_today）。
+func codebuddyCheckinStatus(ctx context.Context, home, authID string) (CheckinInfo, bool) {
+	t, ok := readCodebuddyTicket(codebuddyAuthDir(home), authID)
+	if !ok {
+		return CheckinInfo{}, false
+	}
+	ctx, cancel := context.WithTimeout(ctx, 8*time.Second)
+	defer cancel()
+	body, ok := codebuddyBillingPost(ctx, t, "/billing/meter/checkin-activity-status", nil)
+	if !ok {
+		return CheckinInfo{}, false
+	}
+	return checkinStatusFromJSON(body)
+}
+
+// checkinStatusFromJSON 解析 checkin-activity-status（抽出来便于单测）。
+func checkinStatusFromJSON(body []byte) (CheckinInfo, bool) {
+	var doc struct {
+		Code int `json:"code"`
+		Data struct {
+			Active         bool            `json:"active"`
+			TodayCheckedIn bool            `json:"today_checked_in"`
+			DailyCredit    json.RawMessage `json:"daily_credit"`
+			StreakDays     int             `json:"streak_days"`
+		} `json:"data"`
+	}
+	if json.Unmarshal(body, &doc) != nil || doc.Code != 0 || !doc.Data.Active {
+		return CheckinInfo{}, false
+	}
+	daily := ""
+	if v, ok := creditFloat(doc.Data.DailyCredit); ok {
+		daily = formatCredit(v)
+	}
+	return CheckinInfo{
+		CheckedToday: doc.Data.TodayCheckedIn,
+		DailyCredit:  daily,
+		StreakDays:   doc.Data.StreakDays,
+	}, true
+}
+
+// codebuddyClaimCheckin 领取每日积分（重复领取会返回业务错误，不会重复加）。
+//
+// 无论成功还是业务失败（今天已签），都**回查一次状态**：领取接口的失败响应不带
+// 「今天是否已领」，不回查的话客户端领完一次（或发现已领）后仍会显示「领取」按钮。
+func codebuddyClaimCheckin(ctx context.Context, home, authID string) (CheckinInfo, error) {
+	t, ok := readCodebuddyTicket(codebuddyAuthDir(home), authID)
+	if !ok {
+		return CheckinInfo{}, fmt.Errorf("没有可用的登录票据（先 magic-agent --login %s）", authID)
+	}
+	ctx, cancel := context.WithTimeout(ctx, 12*time.Second)
+	defer cancel()
+	body, ok := codebuddyBillingPost(ctx, t, "/billing/meter/daily-checkin", nil)
+	if !ok {
+		return CheckinInfo{}, fmt.Errorf("领取请求失败（网络或服务端错误）")
+	}
+	info, claimErr := claimCheckinFromJSON(body)
+	if st, ok := codebuddyCheckinStatus(ctx, home, authID); ok {
+		st.Credit = info.Credit
+		if info.Message != "" {
+			st.Message = info.Message
+		}
+		return st, claimErr
+	}
+	return info, claimErr
+}
+
+// claimCheckinFromJSON 解析 daily-checkin 的响应。成功时 credit/streak_days 可能在
+// 顶层或 data 里，两处都认。
+func claimCheckinFromJSON(body []byte) (CheckinInfo, error) {
+	var doc struct {
+		Code       int             `json:"code"`
+		Msg        string          `json:"msg"`
+		Credit     json.RawMessage `json:"credit"`
+		StreakDays int             `json:"streak_days"`
+		Data       struct {
+			Credit         json.RawMessage `json:"credit"`
+			StreakDays     int             `json:"streak_days"`
+			TodayCheckedIn bool            `json:"today_checked_in"`
+		} `json:"data"`
+	}
+	if json.Unmarshal(body, &doc) != nil {
+		return CheckinInfo{}, fmt.Errorf("领取响应解析失败")
+	}
+	if doc.Code != 0 {
+		msg := strings.TrimSpace(doc.Msg)
+		if msg == "" {
+			msg = fmt.Sprintf("领取失败（code=%d）", doc.Code)
+		}
+		return CheckinInfo{Message: msg}, fmt.Errorf("%s", msg)
+	}
+	raw := doc.Credit
+	if len(raw) == 0 {
+		raw = doc.Data.Credit
+	}
+	credit := ""
+	if v, ok := creditFloat(raw); ok {
+		credit = formatCredit(v)
+	}
+	streak := doc.StreakDays
+	if streak == 0 {
+		streak = doc.Data.StreakDays
+	}
+	return CheckinInfo{
+		CheckedToday: true,
+		Credit:       credit,
+		StreakDays:   streak,
+	}, nil
+}
+
+// ── llm 引擎：MiniMax 套餐（Token Plan / Coding Plan）剩余额度 ──────────────
+//
+// 额度在套餐用量接口（只读，Bearer <API Key>）：
+//
+//	GET https://www.minimaxi.com/v1/api/openplatform/coding_plan/remains
+//	GET https://www.minimaxi.com/v1/token_plan/remains
+//
+// 返回 model_remains[]，取 model_name=general 的两个窗口：
+//   current_interval_remaining_percent  5 小时窗口剩余百分比
+//   current_weekly_remaining_percent    本周剩余百分比
+//（同一份票据两个接口当前返回一致，先试 coding_plan 再退 token_plan）。
+// key 从 ~/.magic-agent/models.json 里带 minimax 域名的条目取（sk-cp-… 是 Coding Plan）。
+//
+// 额度按**模型**挂（ModelQuota），不挂引擎行：llm 下还有火山等别的供应商模型。
+// 任何失败都不给该字段，不影响引擎列表。
+
+// CreditUnitLister 可选接口：说明 CreditLeft / ModelQuota 的单位（缺省按「积分」展示）。
+// MiniMax 套餐给的是百分比，客户端据此把「剩余 53」显示成「剩余 53%」。
+type CreditUnitLister interface {
+	CreditUnit() string
+}
+
+// QuotaWindows 套餐在「5 小时窗口 / 本周」两个维度的剩余百分比（已格式化的数字串，
+// 如 "98" / "53"）。空串 = 该窗口没有数据。
+type QuotaWindows struct {
+	IntervalLeft string `json:"interval_left,omitempty"`
+	WeeklyLeft   string `json:"weekly_left,omitempty"`
+}
+
+// ModelQuotaLister 可选：按**模型**报告套餐额度快照（model id → 两个窗口的剩余百分比）。
+// llm 用它把 MiniMax 套餐额度挂到真正走 MiniMax 端点的模型上 —— 不挂在引擎行，
+// 因为同一个 llm 引擎下还有别的供应商模型（ark-glm 等），引擎级额度会张冠李戴。
+type ModelQuotaLister interface {
+	ModelQuota(ctx context.Context) map[string]QuotaWindows
+}
+
+// ModelQuota 实现 ModelQuotaLister：models.json 里 URL 指向 minimax 的模型**各用各的
+// API Key** 查额度 —— 不同 key 是不同账号/套餐，额度当然不同；只有共用同一把 key
+// 的模型才共享同一份额度。
+func (e *LLMEngine) ModelQuota(ctx context.Context) map[string]QuotaWindows {
+	list, err := LoadLLMConfigModels()
+	if err != nil {
+		return nil
+	}
+	return modelQuotaMap(ctx, list, minimaxQuota)
+}
+
+// CreditUnit 实现 CreditUnitLister：MiniMax 额度是百分比，不是积分。
+func (e *LLMEngine) CreditUnit() string { return "%" }
+
+// CLIModelQuotas 给 codebuddy 系用：按它自己 models.json 里**自定义模型**的
+// (端点, key) 查 MiniMax 套餐额度，映射到展示 id（有别名用别名，与清单同形）。
+//
+// 为什么挂到 codebuddy：用户在 models.json 里接的 MiniMax 自定义端点（custom-local:*）
+// 与 llm 下的是同一类 token plan，额度也应该在选择器里显示；官方 minimax-* 走平台
+// 账号、没有用户侧的 key，查不到自然不显示。
+func CLIModelQuotas(ctx context.Context, configDir string) map[string]QuotaWindows {
+	customs := CLICustomModels(configDir)
+	if len(customs) == 0 {
+		return nil
+	}
+	list := make([]LLMConfigModel, 0, len(customs))
+	for _, m := range customs {
+		if m.URL == "" || m.APIKey == "" {
+			continue
+		}
+		list = append(list, LLMConfigModel{ID: m.ID, URL: m.URL, APIKey: m.APIKey})
+	}
+	if len(list) == 0 {
+		return nil
+	}
+	return modelQuotaMap(ctx, list, minimaxQuota)
+}
+
+// modelQuotaMap 按 (站点, key) 去重查额度，再映射回各自的模型 id。
+// 同一把 key 只查一次；查不到的模型不给字段（不是复用别人的额度）。
+func modelQuotaMap(ctx context.Context, list []LLMConfigModel,
+	query func(context.Context, string, string) (QuotaWindows, bool)) map[string]QuotaWindows {
+	type res struct {
+		q  QuotaWindows
+		ok bool
+	}
+	cache := make(map[string]res)
+	out := make(map[string]QuotaWindows)
+	for _, m := range list {
+		host := minimaxHost(m.URL)
+		id := strings.TrimSpace(m.ID)
+		key := strings.TrimSpace(m.APIKey)
+		if host == "" || id == "" || key == "" {
+			continue
+		}
+		ck := host + "\x00" + key
+		r, hit := cache[ck]
+		if !hit {
+			r.q, r.ok = query(ctx, host, key)
+			cache[ck] = r
+		}
+		if !r.ok || (r.q.IntervalLeft == "" && r.q.WeeklyLeft == "") {
+			continue
+		}
+		out[id] = r.q
+	}
+	if len(out) == 0 {
+		return nil
+	}
+	return out
+}
+
+// minimaxHost 返回该 URL 对应套餐用量接口的站点根；不是 MiniMax 端点返回 ""。
+func minimaxHost(rawURL string) string {
+	u := strings.ToLower(strings.TrimSpace(rawURL))
+	switch {
+	case strings.Contains(u, "minimax.io"):
+		return "https://www.minimax.io"
+	case strings.Contains(u, "minimaxi.com"):
+		return "https://www.minimaxi.com"
+	}
+	return ""
+}
+
+// minimaxQuota 依次试 coding_plan / token_plan 两个用量接口。
+func minimaxQuota(ctx context.Context, host, key string) (QuotaWindows, bool) {
+	ctx, cancel := context.WithTimeout(ctx, 8*time.Second)
+	defer cancel()
+	for _, p := range []string{
+		"/v1/api/openplatform/coding_plan/remains",
+		"/v1/token_plan/remains",
+	} {
+		if q, ok := minimaxQuotaAt(ctx, host+p, key); ok {
+			return q, true
+		}
+	}
+	return QuotaWindows{}, false
+}
+
+// minimaxQuotaAt 查一次套餐用量，取 general 模型的「5 小时 / 本周」剩余百分比。
+func minimaxQuotaAt(ctx context.Context, url, key string) (QuotaWindows, bool) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return QuotaWindows{}, false
+	}
+	req.Header.Set("Authorization", "Bearer "+key)
+	req.Header.Set("Accept", "application/json")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return QuotaWindows{}, false
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return QuotaWindows{}, false
+	}
+	body, err := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
+	if err != nil {
+		return QuotaWindows{}, false
+	}
+	var doc struct {
+		ModelRemains []struct {
+			ModelName     string  `json:"model_name"`
+			IntervalPct   float64 `json:"current_interval_remaining_percent"`
+			WeeklyPercent float64 `json:"current_weekly_remaining_percent"`
+		} `json:"model_remains"`
+		BaseResp struct {
+			StatusCode int `json:"status_code"`
+		} `json:"base_resp"`
+	}
+	if json.Unmarshal(body, &doc) != nil || doc.BaseResp.StatusCode != 0 {
+		return QuotaWindows{}, false
+	}
+	for _, m := range doc.ModelRemains {
+		if m.ModelName == "general" {
+			return QuotaWindows{
+				IntervalLeft: formatCredit(m.IntervalPct),
+				WeeklyLeft:   formatCredit(m.WeeklyPercent),
+			}, true
+		}
+	}
+	return QuotaWindows{}, false
+}