@fish-under-sea/magpie-dragonapi 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/LICENSE ADDED
@@ -0,0 +1,21 @@
1
+ MIT License
2
+
3
+ Copyright (c) 2026 Fish-under-sea
4
+
5
+ Permission is hereby granted, free of charge, to any person obtaining a copy
6
+ of this software and associated documentation files (the "Software"), to deal
7
+ in the Software without restriction, including without limitation the rights
8
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
+ copies of the Software, and to permit persons to whom the Software is
10
+ furnished to do so, subject to the following conditions:
11
+
12
+ The above copyright notice and this permission notice shall be included in all
13
+ copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
+ SOFTWARE.
package/README.md CHANGED
@@ -1,3 +1,141 @@
1
- # Temporary Holding Version
1
+ # DragonAPI in Magpie
2
2
 
3
- This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
3
+ 把 [DragonAPI](https://newapi.dragon3api.com/) 接进 magpie:模型广场、余额、用量,外加一个能按分组建钥匙的本地界面。
4
+
5
+ > 当前版本 **0.1.0**(首个可用版本)。只做供应商插件 + 只读看板 + 密钥管理,不做「页面里点充值」。
6
+
7
+ ## 它是什么
8
+
9
+ 一个独立的 magpie 插件包,同时是两样东西:
10
+
11
+ | 身份 | 作用 |
12
+ | --- | --- |
13
+ | **供应商插件** | 把站点 `/api/pricing` 的目录折成 magpie 的模型表;`sk-` 钥匙直接读余额与逐条用量;视频模型走 magpie 的 `/v1/videos` 三件套 |
14
+ | **页面插件 + 本地服务** | magpie 的插件页是 `connect-src 'none'` 的沙箱,页面自己发不出请求。所以插件起一个只监听 `127.0.0.1` 的 HTTP 服务,页面导航过去,界面由服务提供 |
15
+
16
+ ## 为什么不照抄 NearToken
17
+
18
+ NearToken 那套「页面里点充值、点连接」依赖两个本站没有的东西:
19
+
20
+ 1. **设备授权**(`/api/dsh/device/*`)——那是 neartoken.cc 的私有补丁,DragonAPI 没有。本站登录要过人机校验,PAT 只能在浏览器会话里创建,插件代不了。
21
+ 2. **请求头切分组**(`x-neartoken-group`)——DragonAPI 不读这个头。它的分组是**钥匙的属性**:`TokenAuth` 里 `userGroup = tokenGroup`,一把钥匙绑死一个分组。
22
+
23
+ 所以这里的做法是:
24
+
25
+ - **分组 = 账号**。一个分组一把钥匙,magpie 里就是多个账号;每个账号的模型清单只列它那一组的模型,宿主自己会把请求送到对的账号(上游 magpie 的 `AccountServes` 保证)。
26
+ - **登录 = 贴钥匙**,或**用 PAT 让插件替你建钥匙**。
27
+
28
+ ## 三步接入
29
+
30
+ ### 1. 在站点建一把钥匙
31
+
32
+ 到 [控制台 → API 密钥](https://newapi.dragon3api.com/console) 新建,**选好分组**(分组决定能调哪些模型、按什么倍率计费),复制 `sk-` 开头的钥匙。
33
+
34
+ ### 2. 在 magpie 里添加账号
35
+
36
+ 打开供应商列表里的 **DragonAPI**,点「添加账号」,两种方式任选:
37
+
38
+ | 方式 | 做什么 | 适合 |
39
+ | --- | --- | --- |
40
+ | **DragonAPI API Key** | 把 `sk-…` 粘进去 | 最常见;一把钥匙一个分组 |
41
+ | **用访问令牌按分组自动建钥匙** | 插件调站点 API 建一把新钥匙并直接绑成账号 | 想少跑一趟控制台 |
42
+
43
+ 第二种要先在插件页面里填**访问令牌(PAT)**,见下一节。它在 magpie 里表现为第二条登录方式,选完分组就自动建好并绑上。
44
+
45
+ ### 3. 需要多个分组就重复第 2 步
46
+
47
+ 每个分组加一个账号。magpie 的供应商编辑器里会列出多个账号,每个账号只带它那一组的模型。
48
+
49
+ ## 访问令牌(PAT)
50
+
51
+ 建钥匙、看钥匙列表、看账户资料都要 PAT。它**只能在浏览器里创建**:
52
+
53
+ 1. 登录控制台 → 头像 → **安全** → **访问令牌** → 新建;
54
+ 2. 勾选权限:
55
+ - `profile:read` —— 读账户与可用分组(**建钥匙必填**)
56
+ - `api_key:read` —— 读钥匙列表
57
+ - `api_key:write` —— 建钥匙 / 删钥匙
58
+ - `api_key:reveal` —— 看钥匙完整明文
59
+ - `usage:read` —— 读用量流水
60
+ - `wallet:read` —— 读余额与邀请(可选)
61
+ 3. 复制 `nap-` 开头的令牌,粘到插件页面的「访问令牌」页。
62
+
63
+ > 旧版访问令牌已停用(站点返回 `ACCESS_TOKEN_LEGACY_RETIRED`),必须用新的 `nap-` 令牌。
64
+
65
+ **PAT 存在本地**:`<magpie 配置目录>/dragonapi-state.json`,权限 0600。它必须明文存——每次建钥匙都要用。文件里**不存任何 `sk-` 钥匙明文**,那些由 magpie 自己的 `plugin-auth.json` 保管。
66
+
67
+ ## 界面里有什么
68
+
69
+ | 页 | 内容 |
70
+ | --- | --- |
71
+ | **模型广场** | 122 个模型 / 195 行「分组 × 模型」,按分组、类别、关键词筛选。**纯展示,没有启用/停用开关**——本站做不到 NearToken 那种按分组启停,所以这里不给假开关 |
72
+ | **余额与用量** | 每个账号的余额与已用;按天/周/月汇总;逐条流水(模型、token、费用、吞吐、首字延迟) |
73
+ | **密钥** | 列出现有钥匙(打码)、按分组建新钥匙、建完显示一次完整明文并提供复制、删除、查看完整明文 |
74
+ | **访问令牌** | 填入/清除 PAT,说明需要哪些权限 |
75
+
76
+ ## 价格怎么算
77
+
78
+ 站点有两种计费,插件分开处理,**算不准就明说「价格未知」,不编数字**:
79
+
80
+ | 计费方式 | 怎么折 | 可信度 |
81
+ | --- | --- | --- |
82
+ | 倍率计费 | `模型倍率 × 分组倍率 × 2` 美元/百万 token | 准 |
83
+ | 表达式计费(对话) | 从 `billing_expr` 取 `tier(...)` 里的 `p` / `c` / `cr` / `cc` 系数 | 准(多档时标注是哪一档) |
84
+ | 表达式计费(视频) | 取 `u("seconds")` / `u("resolution")` 的单价,给区间 | 区间价,实际以控制台为准 |
85
+ | 解析不出来 | 显示「价格未知」+ 原因 | —— |
86
+
87
+ `auto` 分组**不算单价**——它的费率取决于命中的通道,站点自己也这么说。
88
+
89
+ ## 已知限制
90
+
91
+ | 限制 | 原因 | 影响 |
92
+ | --- | --- | --- |
93
+ | 页面里不能直接绑账号 | 页面跑在沙箱里,写不了 magpie 的账号表 | 绑定只能走 magpie 的「添加账号」;插件用第二条登录方式把「建钥匙 + 绑定」合成一步 |
94
+ | 没有设备授权 | 站点没有这个端点 | 每次都要贴钥匙,或先用 PAT 让插件建 |
95
+ | 一把钥匙一个分组 | 分组是钥匙的属性 | 多分组 = 多账号,账号列表会变长 |
96
+ | 视频按秒计费只能给区间 | 价格随分辨率/规格变 | 实际扣费以控制台为准 |
97
+ | `priceRate` 未验证 | 站点前端还有一个「充值价系数」,拿不到登录态确认不了 | 单价可能整体差一个系数;流水里的实际费用不受影响 |
98
+ | 独立起服务时看不到余额 | 钥匙只在插件进程内存里 | 用 `node serve.mjs` 单独起时,余额显示「—」 |
99
+
100
+ ## 独立启动(插件宿主起不来时)
101
+
102
+ ```powershell
103
+ node serve.mjs
104
+ ```
105
+
106
+ 会在 `127.0.0.1:3517` 起同一个服务,界面可用(余额除外)。如果插件已经在跑,它会提示并退出,不会抢端口。
107
+
108
+ ## 开发
109
+
110
+ ```powershell
111
+ npm test # 122 个用例:价格解析、目录构建、用量解析、源与刷新链路、服务冒烟、插件入口、界面
112
+ ```
113
+
114
+ 测试用站点 2026-11-10 的真实快照([证据-站点定价快照-2026-11-10.json](证据-站点定价快照-2026-11-10.json))当夹具,站点改了写法就会被发现。
115
+
116
+ 目录结构:
117
+
118
+ ```text
119
+ index.mjs 供应商插件入口:config / auth / provider.models + 起本地服务
120
+ lib/site.mjs 站点客户端(sk- 与 PAT 两条通道分开)
121
+ lib/pricing.mjs 两种计费规则的解析与降级
122
+ lib/catalog.mjs /api/pricing → magpie 模型表(分组×模型)
123
+ lib/catalog-source.mjs 目录的唯一所有者:缓存、条件请求、刷新、健康记录
124
+ lib/status-source.mjs 站点参数的唯一所有者:缓存与降级
125
+ lib/usage.mjs 日志解析、汇总、窗口
126
+ lib/store.mjs 本地状态(PAT、账号元数据),原子写 0600
127
+ lib/service.mjs 本地 HTTP 服务 + 全部 API(只管呈现,不缓存)
128
+ page/ 带路页(把自己导航到本地服务)
129
+ ui/ 真正的界面
130
+ serve.mjs 独立启动
131
+ ```
132
+
133
+ ### 两个「源」为什么单独存在
134
+
135
+ 目录和站点参数各有一个 `*-source.mjs`,是因为它们**曾经各被缓存了两份**(插件一份、服务一份),
136
+ 结果页面点「刷新」刷的是另一份缓存,按钮点了没反应。现在只有一处持有缓存,
137
+ `lib/service.mjs` 通过注入拿到它们,`tests/refresh.test.mjs` 钉住这条链路。
138
+
139
+ ## 许可
140
+
141
+ MIT
package/index.mjs ADDED
@@ -0,0 +1,452 @@
1
+ // DragonAPI 的 magpie 宿主部分:一个 OpenCode 形状的 provider 插件。
2
+ //
3
+ // 它不碰 magpie 源码,用的都是 magpie 自己提供的扩展点:
4
+ //
5
+ // config 声明供应商(名字、npm、base)
6
+ // auth.methods 两种登录:贴 sk- 钥匙 / 用 PAT 自动建钥匙
7
+ // auth.usage 余额,按 magpie 的用量卡显示
8
+ // auth.loader 请求带着这把钥匙出去,并把 `分组/模型` 还原成站点的模型名
9
+ // provider.models 模型目录:`分组/模型` 一行,每行属于一个分组
10
+ //
11
+ // 与 NearToken 最大的不同:DragonAPI 不读请求头里的分组,分组是**钥匙的属性**。
12
+ // 所以这里的模型 id 带分组前缀,而「走哪个分组」由 magpie 的账号选择决定——
13
+ // 每个账号(一把钥匙)的 models 清单只列它那一组的模型,宿主就不会把模型发错账号。
14
+ //
15
+ // 另外它起一个只监听 127.0.0.1 的本地服务:magpie 的插件页是 connect-src 'none'
16
+ // 的沙箱,页面自己发不出任何请求,只能把自己导航过去。界面由那个服务提供。
17
+
18
+ import { readFileSync } from 'node:fs'
19
+ import { join } from 'node:path'
20
+
21
+ import { DEFAULT_SITE, currencyOf, readTokenUsage, createKey, revealKey, readKeys } from './lib/site.mjs'
22
+ import { buildCatalog } from './lib/catalog.mjs'
23
+ import { createCatalogSource } from './lib/catalog-source.mjs'
24
+ import { createStatusSource } from './lib/status-source.mjs'
25
+ import { loadState, saveState, maskKey, tailOf } from './lib/store.mjs'
26
+ import { startService } from './lib/service.mjs'
27
+
28
+ /** 供应商 id:一个就好,多账号靠 magpie 自己的账号槽。 */
29
+ const PROVIDER_ID = 'dragonapi'
30
+ /** 站点给这把钥匙起的名字前缀,便于用户在控制台认出来。 */
31
+ const KEY_NAME = 'Magpie'
32
+
33
+ /**
34
+ * 插件状态。全部放在闭包里,一个进程一份。
35
+ *
36
+ * 这里刻意不存钥匙明文到磁盘:钥匙由 magpie 的 plugin-auth.json 保管,
37
+ * 我们只在内存里留一份 `tail → 钥匙` 的映射,供本地服务查余额用。
38
+ * 进程重启后由第一次 models() 调用重新填上。
39
+ *
40
+ * 目录与站点参数不在这里缓存:它们各有自己的源(catalog-source /
41
+ * status-source),插件和本地服务共用同一份,避免两处真相。
42
+ */
43
+ function makeContext(input, options) {
44
+ const dir = String(input?.directory || '.')
45
+ const site = String(options?.site || DEFAULT_SITE).replace(/\/+$/, '')
46
+ const port = Number(options?.port) > 0 ? Number(options.port) : 3517
47
+
48
+ const state = loadState(dir)
49
+ /** 内存里的钥匙:tail → 明文。不落盘。 */
50
+ const secrets = new Map()
51
+ /**
52
+ * 上一次「站点实时」拿到的模型表,用于列表单调不减。
53
+ *
54
+ * 它必须挂在 ctx 上,不能是 makeContext 里的局部变量:provider.models
55
+ * 定义在返回的对象里,闭包看不到 makeContext 的局部变量,直接引用会
56
+ * 抛 ReferenceError——而那个错误被 catch 吞成空表,表现就是「插件一个
57
+ * 模型都没有」,完全查不出原因。
58
+ */
59
+ const memory = { lastGood: null }
60
+
61
+ // catalogStub 只给测试用:注入一份固定目录,不打站点。
62
+ const catalog = createCatalogSource({ site, stub: options?.catalogStub || null })
63
+ const status = createStatusSource({
64
+ site,
65
+ // 冷启动先用上次落盘的值顶上,别让页面等一次网络往返。
66
+ seed: state.status || null,
67
+ onRead: (v) => { state.status = v; saveState(dir, state) },
68
+ })
69
+
70
+ function persist() {
71
+ saveState(dir, state)
72
+ }
73
+
74
+ /** 从一份 auth 里把钥匙记进内存,并把账号元数据补进 state。 */
75
+ function remember(auth) {
76
+ if (!auth) return null
77
+ const secret = String(auth.key || auth.access || '')
78
+ if (!secret) return null
79
+ const tail = tailOf(secret)
80
+ if (tail) secrets.set(tail, secret)
81
+ const md = auth.metadata && typeof auth.metadata === 'object' ? auth.metadata : {}
82
+ const group = String(md.group || '')
83
+ if (tail && group) {
84
+ const had = state.accounts[tail] || {}
85
+ state.accounts[tail] = {
86
+ label: String(md.label || had.label || `${group} · ${maskKey(secret)}`),
87
+ group,
88
+ masked: maskKey(secret),
89
+ tail,
90
+ models: Number(md.models) || had.models || 0,
91
+ boundAt: Number(had.boundAt) || Number(md.boundAt) || Date.now(),
92
+ }
93
+ persist()
94
+ }
95
+ return { secret, tail, group }
96
+ }
97
+
98
+ return {
99
+ dir,
100
+ site,
101
+ port,
102
+ state,
103
+ secrets,
104
+ memory,
105
+ persist,
106
+ remember,
107
+ catalog,
108
+ status,
109
+ noteModelsError: (why) => { state.lastModelsError = why },
110
+ }
111
+ }
112
+
113
+ /** 让本地服务能拿到某个账号的钥匙(按 tail)。 */
114
+ export function keyForTail(ctx, tail) {
115
+ return ctx.secrets.get(String(tail || '')) || ''
116
+ }
117
+
118
+ export default async function dragonapi(input, options) {
119
+ void input
120
+ const ctx = makeContext(input, options)
121
+
122
+ // 先把站点参数与目录拉起来:冷启动时宿主很快就要模型表。
123
+ await Promise.all([ctx.status.get({}), ctx.catalog.get({})])
124
+
125
+ // 本地服务:页面的真正宿主。起不来也不能让供应商消失,所以失败只记一笔。
126
+ let service = null
127
+ const serviceReady = startService({
128
+ port: ctx.port,
129
+ dir: ctx.dir,
130
+ site: ctx.site,
131
+ // 目录与站点参数各有唯一所有者,服务只消费,不自己缓存。
132
+ catalog: ctx.catalog,
133
+ status: ctx.status,
134
+ // 本地服务查余额要用某个账号的钥匙。钥匙只在内存里,按 tail 取。
135
+ keyOf: (tail) => ctx.secrets.get(String(tail || '')) || '',
136
+ getState: async () => ({
137
+ accounts: ctx.state.accounts,
138
+ pat: ctx.state.pat,
139
+ patHint: ctx.state.patHint,
140
+ patScopes: ctx.state.patScopes,
141
+ enabledGroups: ctx.state.enabledGroups || [],
142
+ }),
143
+ setPat: async ({ pat, hint, scopes, user }) => {
144
+ ctx.state.pat = pat
145
+ ctx.state.patHint = hint
146
+ ctx.state.patScopes = scopes
147
+ if (user) ctx.state.user = { id: user.id, name: user.username }
148
+ ctx.persist()
149
+ },
150
+ })
151
+ .then((s) => {
152
+ service = s
153
+ console.log(`[dragonapi] 本地服务已就绪 http://127.0.0.1:${s.port}`)
154
+ return s
155
+ })
156
+ .catch((e) => {
157
+ console.error('[dragonapi] 本地服务起不来:' + (e?.message || e))
158
+ return null
159
+ })
160
+ // 让本地服务能找到钥匙:它不能直接读这个闭包,所以注入一个取值函数。
161
+ void serviceReady
162
+ void service
163
+
164
+ return {
165
+ /**
166
+ * config 声明供应商。任何一步失败都不能让 provider 消失:
167
+ * 宿主拿不到声明就当成没这个供应商。
168
+ */
169
+ async config(cfg) {
170
+ try {
171
+ if (!cfg || typeof cfg !== 'object') return
172
+ cfg.provider ??= {}
173
+ cfg.provider[PROVIDER_ID] ??= {}
174
+ const p = cfg.provider[PROVIDER_ID]
175
+ p.name = 'DragonAPI'
176
+ if (!p.npm) p.npm = '@ai-sdk/openai-compatible'
177
+ if (!p.api) p.api = ctx.site + '/v1'
178
+ // 不要声明 models:空对象会被理解成「这个供应商声明的模型是 0 个」。
179
+ delete p.models
180
+ } catch { /* 声明失败也不能抛 */ }
181
+ },
182
+
183
+ auth: {
184
+ provider: PROVIDER_ID,
185
+ get icon() {
186
+ // 站点图标:包内 svg 编成 data URI。宿主只收 https 与 data:image,
187
+ // 联网抓会在断网时变成灰书页。
188
+ try {
189
+ const svg = readFileSync(join(ctx.dir, 'page', 'icon.svg'))
190
+ return 'data:image/svg+xml;base64,' + svg.toString('base64')
191
+ } catch {
192
+ try {
193
+ const here = new URL('.', import.meta.url).pathname
194
+ const svg = readFileSync(join(here, 'page', 'icon.svg'))
195
+ return 'data:image/svg+xml;base64,' + svg.toString('base64')
196
+ } catch { return '' }
197
+ }
198
+ },
199
+
200
+ get methods() {
201
+ const out = [
202
+ {
203
+ type: 'api',
204
+ label: 'DragonAPI API Key',
205
+ placeholder: 'sk-…',
206
+ // 不写 authorize:宿主直接把用户粘的钥匙存下来,这是最常见也最稳的路。
207
+ },
208
+ ]
209
+ // 有 PAT 才出现第二条:用访问令牌按分组建一把新钥匙,并自动绑成账号。
210
+ // 这是「在插件里建钥匙」真正可用的形态——页面能建钥匙,但页面写不了
211
+ // magpie 的账号表,只有走这里的 authorize 才能既建又绑。
212
+ if (ctx.state.pat) {
213
+ out.push({
214
+ type: 'api',
215
+ keyless: true,
216
+ label: '用访问令牌按分组自动建钥匙',
217
+ placeholder: '',
218
+ async ask(inputs) {
219
+ if (inputs && inputs.group) return null
220
+ const groups = await groupChoices(ctx)
221
+ if (!groups.length) {
222
+ throw new Error('读不到可用的分组:请先在插件页面里设置访问令牌(需要 profile:read 权限)')
223
+ }
224
+ return {
225
+ type: 'select',
226
+ key: 'group',
227
+ message: '这把新钥匙建在哪个分组?分组决定它能调哪些模型、按什么倍率计费',
228
+ options: groups.map((g) => ({ label: `${g}${ratioHint(ctx, g)}`, value: g })),
229
+ }
230
+ },
231
+ async authorize(inputs) {
232
+ const group = String(inputs?.group || '').trim()
233
+ if (!group) throw new Error('没有选分组')
234
+ const pat = ctx.state.pat
235
+ if (!pat) throw new Error('还没有设置访问令牌(PAT)')
236
+ const name = `${KEY_NAME}-${group}`.slice(0, 50)
237
+ try {
238
+ await createKey(ctx.site, pat, { name, group, unlimited: true })
239
+ const keys = await readKeys(ctx.site, pat)
240
+ const made = keys.find((k) => k.name === name && k.group === group)
241
+ if (!made) throw new Error('钥匙建好了,但没能在列表里找到它')
242
+ const secret = await revealKey(ctx.site, pat, made.id)
243
+ const tail = tailOf(secret)
244
+ if (tail) ctx.secrets.set(tail, secret)
245
+ return {
246
+ type: 'success',
247
+ key: secret,
248
+ metadata: {
249
+ group,
250
+ label: `${group} · ${maskKey(secret)}`,
251
+ masked: maskKey(secret),
252
+ tail,
253
+ boundAt: Date.now(),
254
+ },
255
+ }
256
+ } catch (e) {
257
+ throw new Error(`自动建钥匙失败:${String(e?.message || e)}。可以改用「DragonAPI API Key」,到控制台建一把再粘进来。`)
258
+ }
259
+ },
260
+ })
261
+ }
262
+ return out
263
+ },
264
+
265
+ /** 余额:站点给这把钥匙的额度。 */
266
+ async usage(getAuth) {
267
+ try {
268
+ const auth = await getAuth()
269
+ const found = ctx.remember(auth)
270
+ const key = found?.secret
271
+ if (!key) throw new Error('还没有连接 DragonAPI')
272
+ const [st, u] = await Promise.all([ctx.status.get({}), readTokenUsage(ctx.site, key)])
273
+ const cur = currencyOf(st)
274
+ const used = Number(u.used) || 0
275
+ return {
276
+ user: u.name || '',
277
+ balance: fmt(u.available, cur),
278
+ windows: [
279
+ { name: '已用', display: fmt(used, cur) },
280
+ // 钥匙允许查用户额度时才有这个窗口;没有就不给,别编一个 0。
281
+ ...(u.userQuota ? [{ name: '账户余额', display: fmt(u.userQuota.available, cur) }] : []),
282
+ ],
283
+ }
284
+ } catch (e) {
285
+ throw new Error(String(e?.message || e))
286
+ }
287
+ },
288
+
289
+ /** 请求带着这把钥匙出去,并把 `分组/模型` 还原成站点认的模型名。 */
290
+ async loader(getAuth) {
291
+ const auth = await getAuth()
292
+ const found = ctx.remember(auth)
293
+ const key = found?.secret || ''
294
+ return {
295
+ apiKey: key,
296
+ baseURL: ctx.site + '/v1',
297
+ fetch: async (input_, init) => {
298
+ const body = init?.body
299
+ if (typeof body !== 'string') return fetch(input_, init)
300
+ let parsed
301
+ try { parsed = JSON.parse(body) } catch { return fetch(input_, init) }
302
+ const raw = parsed?.model
303
+ if (typeof raw !== 'string' || !raw.includes('/')) return fetch(input_, init)
304
+ // `分组/模型` → `模型`。分组已经由账号选定了,请求里不需要它。
305
+ const bare = raw.slice(raw.indexOf('/') + 1)
306
+ if (!bare) return fetch(input_, init)
307
+ parsed.model = bare
308
+ return fetch(input_, { ...init, body: JSON.stringify(parsed) })
309
+ },
310
+ }
311
+ },
312
+ },
313
+
314
+ provider: {
315
+ id: PROVIDER_ID,
316
+ /**
317
+ * 模型表:`分组/模型` 一行。
318
+ *
319
+ * 宿主会为**每个账号**各调一次,并带上那个账号的 auth(`ctx.auth`)。
320
+ * 所以我们只返回该账号所属分组的模型:宿主的 AccountServes 就会把
321
+ * 请求送到对的账号,不需要任何请求头。
322
+ *
323
+ * 没有任何账号时返回全量目录,让用户先看到「这个供应商有什么」。
324
+ */
325
+ async models(_given, hookCtx) {
326
+ let group = ''
327
+ try {
328
+ const auth = hookCtx?.auth
329
+ const found = ctx.remember(auth)
330
+ group = found?.group || ''
331
+ } catch { /* auth 形状不对就按「无分组」处理 */ }
332
+
333
+ try {
334
+ const cat = await ctx.catalog.get({})
335
+ const st = await ctx.status.get({})
336
+ const cur = currencyOf(st)
337
+ const built = cat.env
338
+ ? buildCatalog(cat.env, { cur, enabledGroups: [], site: ctx.site })
339
+ : { models: {}, rows: [], groups: [] }
340
+
341
+ // 保护 1:列表单调不减。站点偶发少给几个模型时用上一次实时表补齐,
342
+ // 否则宿主会把这些「消失」的模型从用户选择里移除。
343
+ let table = group ? pickGroup(built.models, group) : built.models
344
+ const lastGood = ctx.memory.lastGood
345
+ if (lastGood) {
346
+ for (const id of Object.keys(lastGood)) {
347
+ if (!table[id] && (!group || id.startsWith(group + '/'))) table[id] = lastGood[id]
348
+ }
349
+ }
350
+
351
+ // 保护 2:本次不是实时数据时打标记,宿主看到 magpie.fellBack 就跳过
352
+ // 「谁不见了」的对比,避免把网络抖动当成模型下架。
353
+ if (cat.source !== 'live') {
354
+ try { table[Symbol.for('magpie.fellBack')] = true } catch { /* 标记失败不影响返回 */ }
355
+ } else if (Object.keys(table).length) {
356
+ ctx.memory.lastGood = { ...(lastGood || {}), ...table }
357
+ }
358
+
359
+ // 顺手把这个账号有多少模型记下来,页面要用。
360
+ if (group) {
361
+ const tail = tailOf(String(hookCtx?.auth?.key || hookCtx?.auth?.access || ''))
362
+ if (tail && ctx.state.accounts[tail]) {
363
+ ctx.state.accounts[tail].models = Object.keys(table).length
364
+ ctx.persist()
365
+ }
366
+ }
367
+
368
+ return table
369
+ } catch (error) {
370
+ // 绝不向宿主抛 rejected Promise(抛了宿主就判「没有模型」→ 掉供应商),
371
+ // 但也绝不静默吞掉:空表等于告诉宿主「这个供应商一个模型都没有」,
372
+ // 效果和抛错一样糟,而且完全查不出原因。所以:
373
+ // 1. 把错误打进日志与健康记录,能查;
374
+ // 2. 手上还有上一次的表就把它交出去,最差也要有个表。
375
+ const why = String(error?.message || error)
376
+ console.error('[dragonapi] provider.models 失败:' + why)
377
+ ctx.noteModelsError(why)
378
+ const last = ctx.memory.lastGood
379
+ return last && (!group || Object.keys(last).some((id) => id.startsWith(group + '/')))
380
+ ? pickGroupIf(last, group)
381
+ : {}
382
+ }
383
+ },
384
+ },
385
+
386
+ /**
387
+ * 只给测试用:读上一次 provider.models 的错误。
388
+ *
389
+ * 生产路径里这个错误已经进了 console.error 与状态文件;但单测需要一个
390
+ * 能断言的入口,否则「出错时静默返回空表」这类 bug 又只能靠人眼发现。
391
+ */
392
+ get __lastModelsError() {
393
+ return ctx.state.lastModelsError || ''
394
+ },
395
+
396
+ /**
397
+ * 停掉本地服务。
398
+ *
399
+ * 这个服务的句柄会让进程的事件循环一直活着,所以必须能关——测试里
400
+ * 每建一个插件实例就多一个监听端口,不关的话 `node --test` 永远不退出。
401
+ * 宿主侧也用得上:卸载插件时应当把端口还回去。
402
+ */
403
+ async dispose() {
404
+ const s = await serviceReady
405
+ if (s) await s.close()
406
+ },
407
+ }
408
+ }
409
+
410
+ /** 只留某个分组的模型。 */
411
+ function pickGroup(models, group) {
412
+ const out = {}
413
+ const prefix = group + '/'
414
+ for (const [id, m] of Object.entries(models)) if (id.startsWith(prefix)) out[id] = m
415
+ return out
416
+ }
417
+
418
+ /** pickGroupIf:group 为空时返回整表,否则只留那一组。 */
419
+ function pickGroupIf(models, group) {
420
+ return group ? pickGroup(models, group) : { ...models }
421
+ }
422
+
423
+ /** 金额:读不到站点参数时也不把额度原值当钱。 */
424
+ function fmt(quota, cur) {
425
+ const n = Number(quota)
426
+ if (!Number.isFinite(n)) return '—'
427
+ const base = n / (cur.per > 0 ? cur.per : 1)
428
+ const value = cur.display && cur.rate > 0 ? base * cur.rate : base
429
+ return cur.symbol + value.toFixed(2)
430
+ }
431
+
432
+ /** 可建钥匙的分组。优先问站点(用户实际可用的),失败就退回目录里的分组。 */
433
+ async function groupChoices(ctx) {
434
+ if (ctx.state.pat) {
435
+ try {
436
+ const { readUsableGroups } = await import('./lib/site.mjs')
437
+ const list = await readUsableGroups(ctx.site, ctx.state.pat)
438
+ if (list.length) return list
439
+ } catch { /* 退回目录 */ }
440
+ }
441
+ const cat = ctx.catalog.snapshot()
442
+ const ratios = cat.env?.group_ratio && typeof cat.env.group_ratio === 'object' ? cat.env.group_ratio : {}
443
+ return Object.keys(ratios).filter((g) => g !== 'auto')
444
+ }
445
+
446
+ /** 分组后面跟一个倍率提示,帮用户选。 */
447
+ function ratioHint(ctx, group) {
448
+ const cat = ctx.catalog.snapshot()
449
+ const ratios = cat.env?.group_ratio && typeof cat.env.group_ratio === 'object' ? cat.env.group_ratio : {}
450
+ const r = Number(ratios[group])
451
+ return Number.isFinite(r) && r > 0 ? ` ×${Math.round(r * 10000) / 10000}` : ''
452
+ }